clang/unittests/Rename/RenameClassTest.cpp

   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