1 //===-- RenameClassTest.cpp - unit tests for renaming classes -------------===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "ClangRenameTest.h"
10 
11 namespace clang {
12 namespace clang_rename {
13 namespace test {
14 namespace {
15 
16 class RenameClassTest : public ClangRenameTest {
17 public:
18   RenameClassTest() {
19     AppendToHeader(R"(
20       namespace a {
21         class Foo {
22           public:
23             struct Nested {
24               enum NestedEnum {E1, E2};
25             };
26             void func() {}
27           static int Constant;
28         };
29         class Goo {
30           public:
31             struct Nested {
32               enum NestedEnum {E1, E2};
33             };
34         };
35         int Foo::Constant = 1;
36       } // namespace a
37       namespace b {
38       class Foo {};
39       } // namespace b
40 
41       #define MACRO(x) x
42 
43       template<typename T> class ptr {};
44     )");
45   }
46 };
47 
48 INSTANTIATE_TEST_SUITE_P(
49     RenameClassTests, RenameClassTest,
50     testing::ValuesIn(std::vector<Case>({
51         // basic classes
52         {"a::Foo f;", "b::Bar f;", "", ""},
53         {"::a::Foo f;", "::b::Bar f;", "", ""},
54         {"void f(a::Foo f) {}", "void f(b::Bar f) {}", "", ""},
55         {"void f(a::Foo *f) {}", "void f(b::Bar *f) {}", "", ""},
56         {"a::Foo f() { return a::Foo(); }", "b::Bar f() { return b::Bar(); }",
57          "", ""},
58         {"namespace a {a::Foo f() { return Foo(); }}",
59          "namespace a {b::Bar f() { return b::Bar(); }}", "", ""},
60         {"void f(const a::Foo& a1) {}", "void f(const b::Bar& a1) {}", "", ""},
61         {"void f(const a::Foo* a1) {}", "void f(const b::Bar* a1) {}", "", ""},
62         {"namespace a { void f(Foo a1) {} }",
63          "namespace a { void f(b::Bar a1) {} }", "", ""},
64         {"void f(MACRO(a::Foo) a1) {}", "void f(MACRO(b::Bar) a1) {}", "", ""},
65         {"void f(MACRO(a::Foo a1)) {}", "void f(MACRO(b::Bar a1)) {}", "", ""},
66         {"a::Foo::Nested ns;", "b::Bar::Nested ns;", "", ""},
67         {"auto t = a::Foo::Constant;", "auto t = b::Bar::Constant;", "", ""},
68         {"a::Foo::Nested ns;", "a::Foo::Nested2 ns;", "a::Foo::Nested",
69          "a::Foo::Nested2"},
70 
71         // use namespace and typedefs
72         {"using a::Foo; Foo gA;", "using b::Bar; b::Bar gA;", "", ""},
73         {"using a::Foo; void f(Foo gA) {}", "using b::Bar; void f(Bar gA) {}",
74          "", ""},
75         {"using a::Foo; namespace x { Foo gA; }",
76          "using b::Bar; namespace x { Bar gA; }", "", ""},
77         {"struct S { using T = a::Foo; T a_; };",
78          "struct S { using T = b::Bar; T a_; };", "", ""},
79         {"using T = a::Foo; T gA;", "using T = b::Bar; T gA;", "", ""},
80         {"typedef a::Foo T; T gA;", "typedef b::Bar T; T gA;", "", ""},
81         {"typedef MACRO(a::Foo) T; T gA;", "typedef MACRO(b::Bar) T; T gA;", "",
82          ""},
83 
84         // struct members and other oddities
85         {"struct S : public a::Foo {};", "struct S : public b::Bar {};", "",
86          ""},
87         {"struct F { void f(a::Foo a1) {} };",
88          "struct F { void f(b::Bar a1) {} };", "", ""},
89         {"struct F { a::Foo a_; };", "struct F { b::Bar a_; };", "", ""},
90         {"struct F { ptr<a::Foo> a_; };", "struct F { ptr<b::Bar> a_; };", "",
91          ""},
92 
93         {"void f() { a::Foo::Nested ne; }", "void f() { b::Bar::Nested ne; }",
94          "", ""},
95         {"void f() { a::Goo::Nested ne; }", "void f() { a::Goo::Nested ne; }",
96          "", ""},
97         {"void f() { a::Foo::Nested::NestedEnum e; }",
98          "void f() { b::Bar::Nested::NestedEnum e; }", "", ""},
99         {"void f() { auto e = a::Foo::Nested::NestedEnum::E1; }",
100          "void f() { auto e = b::Bar::Nested::NestedEnum::E1; }", "", ""},
101         {"void f() { auto e = a::Foo::Nested::E1; }",
102          "void f() { auto e = b::Bar::Nested::E1; }", "", ""},
103 
104         // templates
105         {"template <typename T> struct Foo { T t; };\n"
106          "void f() { Foo<a::Foo> foo; }",
107          "template <typename T> struct Foo { T t; };\n"
108          "void f() { Foo<b::Bar> foo; }",
109          "", ""},
110         {"template <typename T> struct Foo { a::Foo a; };",
111          "template <typename T> struct Foo { b::Bar a; };", "", ""},
112         {"template <typename T> void f(T t) {}\n"
113          "void g() { f<a::Foo>(a::Foo()); }",
114          "template <typename T> void f(T t) {}\n"
115          "void g() { f<b::Bar>(b::Bar()); }",
116          "", ""},
117         {"template <typename T> int f() { return 1; }\n"
118          "template <> int f<a::Foo>() { return 2; }\n"
119          "int g() { return f<a::Foo>(); }",
120          "template <typename T> int f() { return 1; }\n"
121          "template <> int f<b::Bar>() { return 2; }\n"
122          "int g() { return f<b::Bar>(); }",
123          "", ""},
124         {"struct Foo { template <typename T> T foo(); };\n"
125          "void g() { Foo f;  auto a = f.template foo<a::Foo>(); }",
126          "struct Foo { template <typename T> T foo(); };\n"
127          "void g() { Foo f;  auto a = f.template foo<b::Bar>(); }",
128          "", ""},
129 
130         // The following two templates are distilled from regressions found in
131         // unique_ptr<> and type_traits.h
132         {"template <typename T> struct outer {\n"
133          "     typedef T type;\n"
134          "     type Baz();\n"
135          "    };\n"
136          "    outer<a::Foo> g_A;",
137          "template <typename T> struct outer {\n"
138          "      typedef T type;\n"
139          "      type Baz();\n"
140          "    };\n"
141          "    outer<b::Bar> g_A;",
142          "", ""},
143         {"template <typename T> struct nested { typedef T type; };\n"
144          "template <typename T> struct outer { typename nested<T>::type Foo(); "
145          "};\n"
146          "outer<a::Foo> g_A;",
147          "template <typename T> struct nested { typedef T type; };\n"
148          "template <typename T> struct outer { typename nested<T>::type Foo(); "
149          "};\n"
150          "outer<b::Bar> g_A;",
151          "", ""},
152 
153         // macros
154         {"#define FOO(T, t) T t\n"
155          "void f() { FOO(a::Foo, a1); FOO(a::Foo, a2); }",
156          "#define FOO(T, t) T t\n"
157          "void f() { FOO(b::Bar, a1); FOO(b::Bar, a2); }",
158          "", ""},
159         {"#define FOO(n) a::Foo n\n"
160          " void f() { FOO(a1); FOO(a2); }",
161          "#define FOO(n) b::Bar n\n"
162          " void f() { FOO(a1); FOO(a2); }",
163          "", ""},
164 
165         // Pointer to member functions
166         {"auto gA = &a::Foo::func;", "auto gA = &b::Bar::func;", "", ""},
167         {"using a::Foo; auto gA = &Foo::func;",
168          "using b::Bar; auto gA = &b::Bar::func;", "", ""},
169         {"using a::Foo; namespace x { auto gA = &Foo::func; }",
170          "using b::Bar; namespace x { auto gA = &Bar::func; }", "", ""},
171         {"typedef a::Foo T; auto gA = &T::func;",
172          "typedef b::Bar T; auto gA = &T::func;", "", ""},
173         {"auto gA = &MACRO(a::Foo)::func;", "auto gA = &MACRO(b::Bar)::func;",
174          "", ""},
175 
176         // Short match inside a namespace
177         {"namespace a { void f(Foo a1) {} }",
178          "namespace a { void f(b::Bar a1) {} }", "", ""},
179 
180         // Correct match.
181         {"using a::Foo; struct F { ptr<Foo> a_; };",
182          "using b::Bar; struct F { ptr<Bar> a_; };", "", ""},
183 
184         // avoid false positives
185         {"void f(b::Foo a) {}", "void f(b::Foo a) {}", "", ""},
186         {"namespace b { void f(Foo a) {} }", "namespace b { void f(Foo a) {} }",
187          "", ""},
188 
189         // friends, everyone needs friends.
190         {"class Foo { int i; friend class a::Foo; };",
191          "class Foo { int i; friend class b::Bar; };", "", ""},
192     })) );
193 
194 TEST_P(RenameClassTest, RenameClasses) {
195   auto Param = GetParam();
196   std::string OldName = Param.OldName.empty() ? "a::Foo" : Param.OldName;
197   std::string NewName = Param.NewName.empty() ? "b::Bar" : Param.NewName;
198   std::string Actual = runClangRenameOnCode(Param.Before, OldName, NewName);
199   CompareSnippets(Param.After, Actual);
200 }
201 
202 class NamespaceDetectionTest : public ClangRenameTest {
203 protected:
204   NamespaceDetectionTest() {
205     AppendToHeader(R"(
206          class Old {};
207          namespace o1 {
208          class Old {};
209          namespace o2 {
210          class Old {};
211          namespace o3 {
212          class Old {};
213          }  // namespace o3
214          }  // namespace o2
215          }  // namespace o1
216      )");
217   }
218 };
219 
220 INSTANTIATE_TEST_SUITE_P(
221     RenameClassTest, NamespaceDetectionTest,
222     ::testing::ValuesIn(std::vector<Case>({
223         // Test old and new namespace overlap.
224         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
225          "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
226          "o1::o2::o3::Old", "o1::o2::o3::New"},
227         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
228          "namespace o1 { namespace o2 { namespace o3 { n3::New moo; } } }",
229          "o1::o2::o3::Old", "o1::o2::n3::New"},
230         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
231          "namespace o1 { namespace o2 { namespace o3 { n2::n3::New moo; } } }",
232          "o1::o2::o3::Old", "o1::n2::n3::New"},
233         {"namespace o1 { namespace o2 { Old moo; } }",
234          "namespace o1 { namespace o2 { New moo; } }", "::o1::o2::Old",
235          "::o1::o2::New"},
236         {"namespace o1 { namespace o2 { Old moo; } }",
237          "namespace o1 { namespace o2 { n2::New moo; } }", "::o1::o2::Old",
238          "::o1::n2::New"},
239         {"namespace o1 { namespace o2 { Old moo; } }",
240          "namespace o1 { namespace o2 { ::n1::n2::New moo; } }",
241          "::o1::o2::Old", "::n1::n2::New"},
242         {"namespace o1 { namespace o2 { Old moo; } }",
243          "namespace o1 { namespace o2 { n1::n2::New moo; } }", "::o1::o2::Old",
244          "n1::n2::New"},
245 
246         // Test old and new namespace with differing depths.
247         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
248          "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
249          "o1::o2::o3::Old", "::o1::New"},
250         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
251          "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
252          "o1::o2::o3::Old", "::o1::o2::New"},
253         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
254          "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
255          "o1::o2::o3::Old", "o1::New"},
256         {"namespace o1 { namespace o2 { namespace o3 { Old moo; } } }",
257          "namespace o1 { namespace o2 { namespace o3 { New moo; } } }",
258          "o1::o2::o3::Old", "o1::o2::New"},
259         {"Old moo;", "o1::New moo;", "::Old", "o1::New"},
260         {"Old moo;", "o1::New moo;", "Old", "o1::New"},
261         {"namespace o1 { ::Old moo; }", "namespace o1 { New moo; }", "Old",
262          "o1::New"},
263         {"namespace o1 { namespace o2 {  Old moo; } }",
264          "namespace o1 { namespace o2 {  ::New moo; } }", "::o1::o2::Old",
265          "::New"},
266         {"namespace o1 { namespace o2 {  Old moo; } }",
267          "namespace o1 { namespace o2 {  New moo; } }", "::o1::o2::Old", "New"},
268 
269         // Test moving into the new namespace at different levels.
270         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
271          "namespace n1 { namespace n2 { New moo; } }", "::o1::o2::Old",
272          "::n1::n2::New"},
273         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
274          "namespace n1 { namespace n2 { New moo; } }", "::o1::o2::Old",
275          "n1::n2::New"},
276         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
277          "namespace n1 { namespace n2 { o2::New moo; } }", "::o1::o2::Old",
278          "::n1::o2::New"},
279         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
280          "namespace n1 { namespace n2 { o2::New moo; } }", "::o1::o2::Old",
281          "n1::o2::New"},
282         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
283          "namespace n1 { namespace n2 { ::o1::o2::New moo; } }",
284          "::o1::o2::Old", "::o1::o2::New"},
285         {"namespace n1 { namespace n2 { o1::o2::Old moo; } }",
286          "namespace n1 { namespace n2 { o1::o2::New moo; } }", "::o1::o2::Old",
287          "o1::o2::New"},
288 
289         // Test friends declarations.
290         {"class Foo { friend class o1::Old; };",
291          "class Foo { friend class o1::New; };", "o1::Old", "o1::New"},
292         {"class Foo { int i; friend class o1::Old; };",
293          "class Foo { int i; friend class ::o1::New; };", "::o1::Old",
294          "::o1::New"},
295         {"namespace o1 { class Foo { int i; friend class Old; }; }",
296          "namespace o1 { class Foo { int i; friend class New; }; }", "o1::Old",
297          "o1::New"},
298         {"namespace o1 { class Foo { int i; friend class Old; }; }",
299          "namespace o1 { class Foo { int i; friend class New; }; }",
300          "::o1::Old", "::o1::New"},
301     })) );
302 
303 TEST_P(NamespaceDetectionTest, RenameClasses) {
304   auto Param = GetParam();
305   std::string Actual =
306       runClangRenameOnCode(Param.Before, Param.OldName, Param.NewName);
307   CompareSnippets(Param.After, Actual);
308 }
309 
310 class TemplatedClassRenameTest : public ClangRenameTest {
311 protected:
312   TemplatedClassRenameTest() {
313     AppendToHeader(R"(
314            template <typename T> struct Old {
315              T t_;
316              T f() { return T(); };
317              static T s(T t) { return t; }
318            };
319            namespace ns {
320            template <typename T> struct Old {
321              T t_;
322              T f() { return T(); };
323              static T s(T t) { return t; }
324            };
325            }  // namespace ns
326 
327            namespace o1 {
328            namespace o2 {
329            namespace o3 {
330            template <typename T> struct Old {
331              T t_;
332              T f() { return T(); };
333              static T s(T t) { return t; }
334            };
335            }  // namespace o3
336            }  // namespace o2
337            }  // namespace o1
338        )");
339   }
340 };
341 
342 INSTANTIATE_TEST_SUITE_P(
343     RenameClassTests, TemplatedClassRenameTest,
344     ::testing::ValuesIn(std::vector<Case>({
345         {"Old<int> gI; Old<bool> gB;", "New<int> gI; New<bool> gB;", "Old",
346          "New"},
347         {"ns::Old<int> gI; ns::Old<bool> gB;",
348          "ns::New<int> gI; ns::New<bool> gB;", "ns::Old", "ns::New"},
349         {"auto gI = &Old<int>::f; auto gB = &Old<bool>::f;",
350          "auto gI = &New<int>::f; auto gB = &New<bool>::f;", "Old", "New"},
351         {"auto gI = &ns::Old<int>::f;", "auto gI = &ns::New<int>::f;",
352          "ns::Old", "ns::New"},
353 
354         {"int gI = Old<int>::s(0); bool gB = Old<bool>::s(false);",
355          "int gI = New<int>::s(0); bool gB = New<bool>::s(false);", "Old",
356          "New"},
357         {"int gI = ns::Old<int>::s(0); bool gB = ns::Old<bool>::s(false);",
358          "int gI = ns::New<int>::s(0); bool gB = ns::New<bool>::s(false);",
359          "ns::Old", "ns::New"},
360 
361         {"struct S { Old<int*> o_; };", "struct S { New<int*> o_; };", "Old",
362          "New"},
363         {"struct S { ns::Old<int*> o_; };", "struct S { ns::New<int*> o_; };",
364          "ns::Old", "ns::New"},
365 
366         {"auto a = reinterpret_cast<Old<int>*>(new Old<int>);",
367          "auto a = reinterpret_cast<New<int>*>(new New<int>);", "Old", "New"},
368         {"auto a = reinterpret_cast<ns::Old<int>*>(new ns::Old<int>);",
369          "auto a = reinterpret_cast<ns::New<int>*>(new ns::New<int>);",
370          "ns::Old", "ns::New"},
371         {"auto a = reinterpret_cast<const Old<int>*>(new Old<int>);",
372          "auto a = reinterpret_cast<const New<int>*>(new New<int>);", "Old",
373          "New"},
374         {"auto a = reinterpret_cast<const ns::Old<int>*>(new ns::Old<int>);",
375          "auto a = reinterpret_cast<const ns::New<int>*>(new ns::New<int>);",
376          "ns::Old", "ns::New"},
377 
378         {"Old<bool>& foo();", "New<bool>& foo();", "Old", "New"},
379         {"ns::Old<bool>& foo();", "ns::New<bool>& foo();", "ns::Old",
380          "ns::New"},
381         {"o1::o2::o3::Old<bool>& foo();", "o1::o2::o3::New<bool>& foo();",
382          "o1::o2::o3::Old", "o1::o2::o3::New"},
383         {"namespace ns { Old<bool>& foo(); }",
384          "namespace ns { New<bool>& foo(); }", "ns::Old", "ns::New"},
385         {"const Old<bool>& foo();", "const New<bool>& foo();", "Old", "New"},
386         {"const ns::Old<bool>& foo();", "const ns::New<bool>& foo();",
387          "ns::Old", "ns::New"},
388 
389         // FIXME: figure out why this only works when Moo gets
390         // specialized at some point.
391         {"template <typename T> struct Moo { Old<T> o_; }; Moo<int> m;",
392          "template <typename T> struct Moo { New<T> o_; }; Moo<int> m;", "Old",
393          "New"},
394         {"template <typename T> struct Moo { ns::Old<T> o_; }; Moo<int> m;",
395          "template <typename T> struct Moo { ns::New<T> o_; }; Moo<int> m;",
396          "ns::Old", "ns::New"},
397     })) );
398 
399 TEST_P(TemplatedClassRenameTest, RenameTemplateClasses) {
400   auto Param = GetParam();
401   std::string Actual =
402       runClangRenameOnCode(Param.Before, Param.OldName, Param.NewName);
403   CompareSnippets(Param.After, Actual);
404 }
405 
406 TEST_F(ClangRenameTest, RenameClassWithOutOfLineMembers) {
407   std::string Before = R"(
408       class Old {
409        public:
410         Old();
411         ~Old();
412 
413         Old* next();
414 
415        private:
416         Old* next_;
417       };
418 
419       Old::Old() {}
420       Old::~Old() {}
421       Old* Old::next() { return next_; }
422     )";
423   std::string Expected = R"(
424       class New {
425        public:
426         New();
427         ~New();
428 
429         New* next();
430 
431        private:
432         New* next_;
433       };
434 
435       New::New() {}
436       New::~New() {}
437       New* New::next() { return next_; }
438     )";
439   std::string After = runClangRenameOnCode(Before, "Old", "New");
440   CompareSnippets(Expected, After);
441 }
442 
443 TEST_F(ClangRenameTest, RenameClassWithInlineMembers) {
444   std::string Before = R"(
445       class Old {
446        public:
447         Old() {}
448         ~Old() {}
449 
450         Old* next() { return next_; }
451 
452        private:
453         Old* next_;
454       };
455     )";
456   std::string Expected = R"(
457       class New {
458        public:
459         New() {}
460         ~New() {}
461 
462         New* next() { return next_; }
463 
464        private:
465         New* next_;
466       };
467     )";
468   std::string After = runClangRenameOnCode(Before, "Old", "New");
469   CompareSnippets(Expected, After);
470 }
471 
472 TEST_F(ClangRenameTest, RenameClassWithNamespaceWithInlineMembers) {
473   std::string Before = R"(
474       namespace ns {
475       class Old {
476        public:
477         Old() {}
478         ~Old() {}
479 
480         Old* next() { return next_; }
481 
482        private:
483         Old* next_;
484       };
485       }  // namespace ns
486     )";
487   std::string Expected = R"(
488       namespace ns {
489       class New {
490        public:
491         New() {}
492         ~New() {}
493 
494         New* next() { return next_; }
495 
496        private:
497         New* next_;
498       };
499       }  // namespace ns
500     )";
501   std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
502   CompareSnippets(Expected, After);
503 }
504 
505 TEST_F(ClangRenameTest, RenameClassWithNamespaceWithOutOfInlineMembers) {
506   std::string Before = R"(
507       namespace ns {
508       class Old {
509        public:
510         Old();
511         ~Old();
512 
513         Old* next();
514 
515        private:
516         Old* next_;
517       };
518 
519       Old::Old() {}
520       Old::~Old() {}
521       Old* Old::next() { return next_; }
522       }  // namespace ns
523     )";
524   std::string Expected = R"(
525       namespace ns {
526       class New {
527        public:
528         New();
529         ~New();
530 
531         New* next();
532 
533        private:
534         New* next_;
535       };
536 
537       New::New() {}
538       New::~New() {}
539       New* New::next() { return next_; }
540       }  // namespace ns
541     )";
542   std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
543   CompareSnippets(Expected, After);
544 }
545 
546 TEST_F(ClangRenameTest, RenameClassInInheritedConstructor) {
547   // `using Base::Base;` will generate an implicit constructor containing usage
548   // of `::ns::Old` which should not be matched.
549   std::string Before = R"(
550       namespace ns {
551       class Old;
552       class Old {
553         int x;
554       };
555       class Base {
556        protected:
557         Old *moo_;
558        public:
559         Base(Old *moo) : moo_(moo) {}
560       };
561       class Derived : public Base {
562        public:
563          using Base::Base;
564       };
565       }  // namespace ns
566       int main() {
567         ::ns::Old foo;
568         ::ns::Derived d(&foo);
569         return 0;
570       })";
571   std::string Expected = R"(
572       namespace ns {
573       class New;
574       class New {
575         int x;
576       };
577       class Base {
578        protected:
579         New *moo_;
580        public:
581         Base(New *moo) : moo_(moo) {}
582       };
583       class Derived : public Base {
584        public:
585          using Base::Base;
586       };
587       }  // namespace ns
588       int main() {
589         ::ns::New foo;
590         ::ns::Derived d(&foo);
591         return 0;
592       })";
593   std::string After = runClangRenameOnCode(Before, "ns::Old", "ns::New");
594   CompareSnippets(Expected, After);
595 }
596 
597 TEST_F(ClangRenameTest, DontRenameReferencesInImplicitFunction) {
598   std::string Before = R"(
599       namespace ns {
600       class Old {
601       };
602       } // namespace ns
603       struct S {
604         int y;
605         ns::Old old;
606       };
607       void f() {
608         S s1, s2, s3;
609         // This causes an implicit assignment operator to be created.
610         s1 = s2 = s3;
611       }
612       )";
613   std::string Expected = R"(
614       namespace ns {
615       class New {
616       };
617       } // namespace ns
618       struct S {
619         int y;
620         ::new_ns::New old;
621       };
622       void f() {
623         S s1, s2, s3;
624         // This causes an implicit assignment operator to be created.
625         s1 = s2 = s3;
626       }
627       )";
628   std::string After = runClangRenameOnCode(Before, "ns::Old", "::new_ns::New");
629   CompareSnippets(Expected, After);
630 }
631 
632 TEST_F(ClangRenameTest, ReferencesInLambdaFunctionParameters) {
633   std::string Before = R"(
634       template <class T>
635       class function;
636       template <class R, class... ArgTypes>
637       class function<R(ArgTypes...)> {
638       public:
639         template <typename Functor>
640         function(Functor f) {}
641 
642         function() {}
643 
644         R operator()(ArgTypes...) const {}
645       };
646 
647       namespace ns {
648       class Old {};
649       void f() {
650         function<void(Old)> func;
651       }
652       }  // namespace ns)";
653   std::string Expected = R"(
654       template <class T>
655       class function;
656       template <class R, class... ArgTypes>
657       class function<R(ArgTypes...)> {
658       public:
659         template <typename Functor>
660         function(Functor f) {}
661 
662         function() {}
663 
664         R operator()(ArgTypes...) const {}
665       };
666 
667       namespace ns {
668       class New {};
669       void f() {
670         function<void(::new_ns::New)> func;
671       }
672       }  // namespace ns)";
673   std::string After = runClangRenameOnCode(Before, "ns::Old", "::new_ns::New");
674   CompareSnippets(Expected, After);
675 }
676 
677 TEST_F(ClangRenameTest, DontChangeIfSameName) {
678   std::string Before = R"(
679       namespace foo {
680       class Old {
681        public:
682          static void foo() {}
683       };
684       }
685 
686       void f(foo::Old * x) {
687         foo::Old::foo() ;
688       }
689       using foo::Old;)";
690   std::string Expected = R"(
691       namespace foo {
692       class Old {
693        public:
694          static void foo() {}
695       };
696       }
697 
698       void f(foo::Old * x) {
699         foo::Old::foo() ;
700       }
701       using foo::Old;)";
702   std::string After = runClangRenameOnCode(Before, "foo::Old", "foo::Old");
703   CompareSnippets(Expected, After);
704 }
705 
706 TEST_F(ClangRenameTest, ChangeIfNewNameWithLeadingDotDot) {
707   std::string Before = R"(
708       namespace foo {
709       class Old {
710        public:
711          static void foo() {}
712       };
713       }
714 
715       void f(foo::Old * x) {
716         foo::Old::foo() ;
717       }
718       using foo::Old;)";
719   std::string Expected = R"(
720       namespace foo {
721       class Old {
722        public:
723          static void foo() {}
724       };
725       }
726 
727       void f(::foo::Old * x) {
728         ::foo::Old::foo() ;
729       }
730       using ::foo::Old;)";
731   std::string After = runClangRenameOnCode(Before, "foo::Old", "::foo::Old");
732   CompareSnippets(Expected, After);
733 }
734 
735 TEST_F(ClangRenameTest, ChangeIfSameNameWithLeadingDotDot) {
736   std::string Before = R"(
737       namespace foo {
738       class Old {
739        public:
740          static void foo() {}
741       };
742       }
743 
744       void f(foo::Old * x) {
745         foo::Old::foo() ;
746       }
747       using foo::Old;)";
748   std::string Expected = R"(
749       namespace foo {
750       class Old {
751        public:
752          static void foo() {}
753       };
754       }
755 
756       void f(::foo::Old * x) {
757         ::foo::Old::foo() ;
758       }
759       using ::foo::Old;)";
760   std::string After = runClangRenameOnCode(Before, "::foo::Old", "::foo::Old");
761   CompareSnippets(Expected, After);
762 }
763 
764 TEST_F(RenameClassTest, UsingAlias) {
765   std::string Before = R"(
766       namespace a { struct A {}; }
767 
768       namespace foo {
769       using Alias = a::A;
770       Alias a;
771       })";
772   std::string Expected = R"(
773       namespace a { struct B {}; }
774 
775       namespace foo {
776       using Alias = b::B;
777       Alias a;
778       })";
779   std::string After = runClangRenameOnCode(Before, "a::A", "b::B");
780   CompareSnippets(Expected, After);
781 }
782 
783 TEST_F(ClangRenameTest, FieldDesignatedInitializers) {
784   std::string Before = R"(
785       struct S {
786         int a;
787       };
788       void foo() {
789         S s = { .a = 10 };
790         s.a = 20;
791       })";
792   std::string Expected = R"(
793       struct S {
794         int b;
795       };
796       void foo() {
797         S s = { .b = 10 };
798         s.b = 20;
799       })";
800   std::string After = runClangRenameOnCode(Before, "S::a", "S::b");
801   CompareSnippets(Expected, After);
802 }
803 
804 // FIXME: investigate why the test fails when adding a new USR to the USRSet.
805 TEST_F(ClangRenameTest, DISABLED_NestedTemplates) {
806   std::string Before = R"(
807       namespace a { template <typename T> struct A {}; }
808       a::A<a::A<int>> foo;)";
809   std::string Expected = R"(
810       namespace a { template <typename T> struct B {}; }
811       b::B<b::B<int>> foo;)";
812   std::string After = runClangRenameOnCode(Before, "a::A", "b::B");
813   CompareSnippets(Expected, After);
814 }
815 
816 
817 } // anonymous namespace
818 } // namespace test
819 } // namespace clang_rename
820 } // namesdpace clang
821