[change-namespace] consider typedef/using alias decls in the moved namespace.

[ioeric]

Summary

If a TypeLoc refers to a type alias defined in the moved namespace, we do not need to update its specifier since the type alias decl will be moved along with the type reference.

[ioeric]

• Added implementation.

[ioeric]

• Make namespace prefix end with ::

[hokein]

looks good.

unittests/change-namespace/ChangeNamespaceTests.cpp

829–830

Any reason to change the existing test case?

[ioeric]

unittests/change-namespace/ChangeNamespaceTests.cpp

829–830

This was a typo that I found when manually running unit tests (instead of using check clang-tools-extra). In the old code, using na::CA; does not compile, so I figure I might just fix here as well.

[ioeric]

Test comment.

change-namespace/ChangeNamespace.h

private:
   // A class forward declaration is not moved, so it will be deleted from the
   // moved code block and inserted back into the old namespace. The insertion
   // will be done after removing the code from the old namespace and before
   // inserting it to the new namespace.
   std::map<std::string, std::vector<InsertForwardDeclaration>> InsertFwdDecls;
   // Records all using declarations, which can be used to shorten namespace
   // specifiers.
   llvm::SmallPtrSet<const UsingDecl *, 8> UsingDecls;
+  // Records all type alias declarations, which can be used to shorten namespace
+  // specifiers.
+  llvm::SmallPtrSet<const TypeAliasDecl *, 8> TypeAliasDecls;
   // Records all using namespace declarations, which can be used to shorten
   // namespace specifiers.
   llvm::SmallPtrSet<const UsingDirectiveDecl *, 8> UsingNamespaceDecls;
 };
 
 } // namespace change_namespace
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CHANGE_NAMESPACE_CHANGENAMESPACE_H

change-namespace/ChangeNamespace.cpp

auto IsInMovedNs =
             isExpansionInFileMatching(FilePattern));
   auto IsVisibleInNewNs = anyOf(
       IsInMovedNs, unless(hasAncestor(namespaceDecl(hasName(Prefix)))));
   // Match using declarations.
   Finder->addMatcher(
       usingDecl(isExpansionInFileMatching(FilePattern), IsVisibleInNewNs)
           .bind("using"),
       this);
+  // Match using declarations.
+  Finder->addMatcher(
+      typeAliasDecl(isExpansionInFileMatching(FilePattern), IsVisibleInNewNs)
+          .bind("type_alias"),
+      this);
   // Match using namespace declarations.
   Finder->addMatcher(usingDirectiveDecl(isExpansionInFileMatching(FilePattern),
                                         IsVisibleInNewNs)
                          .bind("using_namespace"),
                      this);
 
   // Match old namespace blocks.
   Finder->addMatcher(
Finder->addMatcher(declRefExpr(IsInMovedNs, hasAncestor(decl().bind("dc")),
                          .bind("var_ref"),
                      this);
 }
 
 void ChangeNamespaceTool::run(
     const ast_matchers::MatchFinder::MatchResult &Result) {
   if (const auto *Using = Result.Nodes.getNodeAs<UsingDecl>("using")) {
     UsingDecls.insert(Using);
+  } else if (const auto *AliasDecl =
+                 Result.Nodes.getNodeAs<TypeAliasDecl>("type_alias")) {
+    TypeAliasDecls.insert(AliasDecl);
   } else if (const auto *UsingNamespace =
                  Result.Nodes.getNodeAs<UsingDirectiveDecl>(
                      "using_namespace")) {
     UsingNamespaceDecls.insert(UsingNamespace);
   } else if (const auto *NsDecl =
                  Result.Nodes.getNodeAs<NamespaceDecl>("old_ns")) {
     moveOldNamespace(Result, NsDecl);
   } else if (const auto *FwdDecl =

unittests/change-namespace/ChangeNamespaceTests.cpp

std::string Expected = "namespace glob {\n"
                          "  Glob g;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, UsingShadowDeclInClass) {
-  std::string Code = "namespace na { class C_A {};\n }\n"
+  std::string Code = "namespace na { class C_A {}; }\n"
                      "namespace na {\n"
                      "namespace nb {\n"
                      "void f() {\n"
-                     "  using na::CA;\n"
-                     "  CA ca;\n"
+                     "  using ::na::C_A;\n"
+                     "  C_A ca;\n"
                      "}\n"
                      "} // namespace nb\n"
                      "} // namespace na\n";
-  std::string Expected = "namespace na { class C_A {};\n }\n"
+  std::string Expected = "namespace na { class C_A {}; }\n"
                          "\n"
                          "namespace x {\n"
                          "namespace y {\n"
                          "void f() {\n"
-                         "  using na::CA;\n"
-                         "  CA ca;\n"
+                         "  using ::na::C_A;\n"
+                         "  C_A ca;\n"
                          "}\n"
                          "} // namespace y\n"
                          "} // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
 TEST_F(ChangeNamespaceTest, UsingDeclInMovedNamespace) {
   std::string Code = "namespace nx { void f(); }\n"
std::string Expected = "namespace na { class A {}; }\n"
                          "\n"
                          "namespace nd {\n"
                          "void d() { A a; }\n"
                          "} // namespace nd\n"
                          "} // nb\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
+TEST_F(ChangeNamespaceTest, UsingAliasDecl) {
+  std::string Code =
+      "namespace nx { namespace ny { class X {}; } }\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "using Y = nx::ny::X;\n"
+      "void f() { Y y; }\n"
+      "} // namespace nb\n"
+      "} // namespace na\n";
+
+  std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
+                         "\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "using Y = nx::ny::X;\n"
+                         "void f() { Y y; }\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+/*
+TEST_F(ChangeNamespaceTest, ClassWithConstructors) {
+  std::string Code = "namespace na {\n"
+                     "namespace nb {\n"
+                     "class A {"
+         "public:\n"
+         "  A() {}\n"
+         "  A(int i);\n"
+         "};\n"
+         "A::A(int i) {}\n"
+                     "} // namespace nb\n"
+                     "} // namespace na\n";
+  std::string Expected = "\n\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "class A {"
+                         "public:\n"
+                         "  A() {}\n"
+                         "  A(int i);\n"
+                         "};\n"
+                         "A::A(int i) {}\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, DerivedClassWithConstructors) {
+  std::string Code =
+      "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "class A : public nx::ny::X {"
+      "public:\n"
+      "  A() : nx::ny::X::X(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : nx::ny::X::X(i) {}\n"
+      "} // namespace nb\n"
+      "} // namespace na\n";
+  std::string Expected =
+      "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
+      "\n\n"
+      "namespace x {\n"
+      "namespace y {\n"
+      "class A : public nx::ny::X {"
+      "public:\n"
+      "  A() : nx::ny::X::X(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : nx::ny::X::X(i) {}\n"
+      "} // namespace y\n"
+      "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, DerivedClassWithConstructorsAndUsingDecl) {
+  std::string Code =
+      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "using nx::XYZ;\n"
+      "class A : public XYZ {"
+      "public:\n"
+      "  A() : XYZ::XYZ(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : XYZ::XYZ(i) {}\n"
+      "} // namespace nb\n"
+      "} // namespace na\n";
+  std::string Expected =
+      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
+      "\n\n"
+      "namespace x {\n"
+      "namespace y {\n"
+      "using ::nx::XYZ;\n"
+      "class A : public XYZ {"
+      "public:\n"
+      "  A() : XYZ::XYZ(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : XYZ::XYZ(i) {}\n"
+      "} // namespace y\n"
+      "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+TEST_F(ChangeNamespaceTest, ConstructorsAndUsingDeclInAnonymous) {
+  std::string Code =
+      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "using nx::XYZ;\n"
+      "namespace {\n"
+      "class A : public XYZ {"
+      "public:\n"
+      "  A() : XYZ::XYZ(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : XYZ::XYZ(i) {}\n"
+      "} // namespace\n"
+      "} // namespace nb\n"
+      "} // namespace na\n";
+  std::string Expected =
+      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
+      "\n\n"
+      "namespace x {\n"
+      "namespace y {\n"
+      "using ::nx::XYZ;\n"
+      "namespace {\n"
+      "class A : public XYZ {"
+      "public:\n"
+      "  A() : XYZ::XYZ(0) {}\n"
+      "  A(int i);\n"
+      "};\n"
+      "A::A(int i) : XYZ::XYZ(i) {}\n"
+      "} // namespace\n"
+      "} // namespace y\n"
+      "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+*/
+
 } // anonymous namespace
 } // namespace change_namespace
 } // namespace clang