[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 ↗

(On Diff #77792)

Any reason to change the existing test case?

[ioeric]

unittests/change-namespace/ChangeNamespaceTests.cpp

829 ↗

(On Diff #77792)

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.

clang-tools-extra/trunk/change-namespace/ChangeNamespace.cpp

void ChangeNamespaceTool::fixTypeLoc(
     SourceLocation End, TypeLoc Type) {
   // FIXME: do not rename template parameter.
   if (Start.isInvalid() || End.isInvalid())
     return;
   // The declaration which this TypeLoc refers to.
   const auto *FromDecl = Result.Nodes.getNodeAs<NamedDecl>("from_decl");
   // `hasDeclaration` gives underlying declaration, but if the type is
   // a typedef type, we need to use the typedef type instead.
-  if (auto *Typedef = Type.getType()->getAs<TypedefType>())
+  if (auto *Typedef = Type.getType()->getAs<TypedefType>()) {
     FromDecl = Typedef->getDecl();
+    auto IsInMovedNs = [&](const NamedDecl *D) {
+      if (!llvm::StringRef(D->getQualifiedNameAsString())
+               .startswith(OldNamespace + "::"))
+        return false;
+      auto ExpansionLoc =
+          Result.SourceManager->getExpansionLoc(D->getLocStart());
+      if (ExpansionLoc.isInvalid())
+        return false;
+      llvm::StringRef Filename =
+          Result.SourceManager->getFilename(ExpansionLoc);
+      llvm::Regex RE(FilePattern);
+      return RE.match(Filename);
+    };
+    // Don't fix the \p Type if it refers to a type alias decl in the moved
+    // namespace since the alias decl will be moved along with the type
+    // reference.
+    if (IsInMovedNs(FromDecl))
+      return;
+  }
 
   const Decl *DeclCtx = Result.Nodes.getNodeAs<Decl>("dc");
   assert(DeclCtx && "Empty decl context.");
   replaceQualifiedSymbolInDeclContext(Result, DeclCtx->getDeclContext(), Start,
                                       End, FromDecl);
 }
 
 void ChangeNamespaceTool::fixUsingShadowDecl(

clang-tools-extra/trunk/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, UsingAliasDeclInGlobal) {
+  std::string Code =
+      "namespace nx { namespace ny { class X {}; } }\n"
+      "using Y = nx::ny::X;\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "void f() { Y y; }\n"
+      "} // namespace nb\n"
+      "} // namespace na\n";
+
+  std::string Expected = "namespace nx { namespace ny { class X {}; } }\n"
+                         "using Y = nx::ny::X;\n"
+                         "\n"
+                         "namespace x {\n"
+                         "namespace y {\n"
+                         "void f() { Y y; }\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
+
+TEST_F(ChangeNamespaceTest, TypedefAliasDecl) {
+  std::string Code =
+      "namespace nx { namespace ny { class X {}; } }\n"
+      "namespace na {\n"
+      "namespace nb {\n"
+      "typedef nx::ny::X Y;\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"
+                         "typedef nx::ny::X Y;\n"
+                         "void f() { Y y; }\n"
+                         "} // namespace y\n"
+                         "} // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
 } // anonymous namespace
 } // namespace change_namespace
 } // namespace clang