Testing phabricator with sample diff. Do not submit!

[ioeric]

change-namespace/ChangeNamespace.cpp

289

asdasdsad

629

asdasda

633

asda

637

asdsadasdasd

[ioeric]

asdasdas

[ioeric]

asdasdasasdasda

change-namespace/ChangeNamespace.cpp

629

asdasds

[ioeric]

asdasdasasdasda

change-namespace/ChangeNamespace.cpp

293

asdasda

unittests/change-namespace/ChangeNamespaceTests.cpp

989

asdsad

[ioeric]

Testing email

change-namespace/ChangeNamespace.cpp

625–633

qqq

641

asdsa

change-namespace/ChangeNamespace.h

   // 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;

change-namespace/ChangeNamespace.cpp

       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)

     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")) {

   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.");

unittests/change-namespace/ChangeNamespaceTests.cpp

   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) {
+TEST_F(ChangeNamespaceTest, UsingAliasDeclInGlobal) {
   std::string Code =
-      "namespace nx { namespace ny { class X { public: X(int i) {} }; } }\n"
+      "namespace nx { namespace ny { class X {}; } }\n"
+      "using Y = nx::ny::X;\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"
+      "void f() { Y y; }\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";
+  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, ConstructorsAndUsingDeclInAnonymous) {
+
+TEST_F(ChangeNamespaceTest, TypedefAliasDecl) {
   std::string Code =
-      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
+      "namespace nx { namespace ny { class X {}; } }\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"
+      "typedef nx::ny::X Y;\n"
+      "void f() { Y y; }\n"
       "} // namespace nb\n"
       "} // namespace na\n";
-  std::string Expected =
-      "namespace nx { class XYZ { public: XYZ(int i) {} }; }\n"
-      "\n\n"
+
+  std::string Expected = "namespace nx { namespace ny { class X {}; } }\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";
+                         "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