[change-namespace] fix qualifier of function references.

[hokein]

change-namespace/ChangeNamespace.cpp

290 ↗

(On Diff #72054)

s/exlude/exclude.

unittests/change-namespace/ChangeNamespaceTests.cpp

317 ↗

(On Diff #72054)

Add a test for the case you mentioned in above?

// Ignore static methods since they will be handled by nested name specifiers.

[ioeric]

• Addressing review comments: added a test case for out-of-line static method and fixed a bug.

[hokein]

LGTM.

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

while (!OldNsSplitted.empty() && !NewNsSplitted.empty() &&
     OldNsSplitted.erase(OldNsSplitted.begin());
     NewNsSplitted.erase(NewNsSplitted.begin());
   }
   DiffOldNamespace = joinNamespaces(OldNsSplitted);
   DiffNewNamespace = joinNamespaces(NewNsSplitted);
 }
 
 // FIXME: handle the following symbols:
-//   - Function references.
 //   - Variable references.
 void ChangeNamespaceTool::registerMatchers(ast_matchers::MatchFinder *Finder) {
   // Match old namespace blocks.
   std::string FullOldNs = "::" + OldNamespace;
   Finder->addMatcher(
       namespaceDecl(hasName(FullOldNs), isExpansionInFileMatching(FilePattern))
           .bind("old_ns"),
       this);
Finder->addMatcher(
       usingDecl(hasAnyUsingShadowDecl(IsInMovedNs)).bind("using_decl"), this);
   // Handle types in nested name specifier.
   Finder->addMatcher(nestedNameSpecifierLoc(
                          hasAncestor(decl(IsInMovedNs).bind("dc")),
                          loc(nestedNameSpecifier(specifiesType(
                              hasDeclaration(DeclMatcher.bind("from_decl"))))))
                          .bind("nested_specifier_loc"),
                      this);
+
+  // Handle function.
+  // Only handle functions that are defined in a namespace excluding static
+  // methods (qualified by nested specifier) and functions defined in the global
+  // namespace.
+  // Note that the matcher does not exclude calls to out-of-line static method
+  // definitions, so we need to exclude them in the callback handler.
+  auto FuncMatcher = functionDecl(
+      hasParent(namespaceDecl()),
+      unless(anyOf(IsInMovedNs, hasAncestor(namespaceDecl(isAnonymous())),
+                   hasAncestor(cxxRecordDecl()))));
+  Finder->addMatcher(
+      decl(forEachDescendant(callExpr(callee(FuncMatcher)).bind("call")),
+           IsInMovedNs)
+          .bind("dc"),
+      this);
 }
 
 void ChangeNamespaceTool::run(
     const ast_matchers::MatchFinder::MatchResult &Result) {
   if (const auto *NsDecl = Result.Nodes.getNodeAs<NamespaceDecl>("old_ns")) {
     moveOldNamespace(Result, NsDecl);
   } else if (const auto *FwdDecl =
                  Result.Nodes.getNodeAs<CXXRecordDecl>("fwd_decl")) {
     moveClassForwardDeclaration(Result, FwdDecl);
   } else if (const auto *UsingDeclaration =
                  Result.Nodes.getNodeAs<UsingDecl>("using_decl")) {
     fixUsingShadowDecl(Result, UsingDeclaration);
   } else if (const auto *Specifier =
                  Result.Nodes.getNodeAs<NestedNameSpecifierLoc>(
                      "nested_specifier_loc")) {
     SourceLocation Start = Specifier->getBeginLoc();
     SourceLocation End = EndLocationForType(Specifier->getTypeLoc());
     fixTypeLoc(Result, Start, End, Specifier->getTypeLoc());
-  } else {
-    const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>("type");
-    assert(TLoc != nullptr && "Expecting callback for TypeLoc");
+  } else if (const auto *TLoc = Result.Nodes.getNodeAs<TypeLoc>("type")) {
     fixTypeLoc(Result, startLocationForType(*TLoc), EndLocationForType(*TLoc),
                *TLoc);
+  } else {
+    const auto* Call = Result.Nodes.getNodeAs<clang::CallExpr>("call");
+    assert(Call != nullptr &&"Expecting callback for CallExpr.");
+    const clang::FunctionDecl* Func = Call->getDirectCallee();
+    assert(Func != nullptr);
+    // Ignore out-of-line static methods since they will be handled by nested
+    // name specifiers.
+    if (Func->getCanonicalDecl()->getStorageClass() ==
+            clang::StorageClass::SC_Static &&
+        Func->isOutOfLine())
+      return;
+    std::string Name = Func->getQualifiedNameAsString();
+    const clang::Decl *Context = Result.Nodes.getNodeAs<clang::Decl>("dc");
+    assert(Context && "Empty decl context.");
+    clang::SourceRange CalleeRange = Call->getCallee()->getSourceRange();
+    replaceQualifiedSymbolInDeclContext(Result, Context, CalleeRange.getBegin(),
+                                        CalleeRange.getEnd(), Name);
   }
 }
 
 // Stores information about a moved namespace in `MoveNamespaces` and leaves
 // the actual movement to `onEndOfTranslationUnit()`.
 void ChangeNamespaceTool::moveOldNamespace(
     const ast_matchers::MatchFinder::MatchResult &Result,
     const NamespaceDecl *NsDecl) {

clang-tools-extra/trunk/unittests/change-namespace/ChangeNamespaceTests.cpp

std::string Expected =
       "    int X = na::C_A::Nested::NestedX;\n"
       "  }\n"
       "};\n"
       "}  // namespace y\n"
       "}  // namespace x\n";
   EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
 }
 
+TEST_F(ChangeNamespaceTest, FixFunctionNameSpecifiers) {
+  std::string Code =
+      "namespace na {\n"
+      "class A {\n"
+      "public:\n"
+      "  static void f() {}\n"
+      "  static void g();\n"
+      "};\n"
+      "void A::g() {}"
+      "void a_f() {}\n"
+      "static void static_f() {}\n"
+      "namespace nb {\n"
+      "void f() { a_f(); static_f(); A::f(); }\n"
+      "void g() { f(); A::g(); }\n"
+      "}  // namespace nb\n"
+      "}  // namespace na\n";
+  std::string Expected =
+      "namespace na {\n"
+      "class A {\n"
+      "public:\n"
+      "  static void f() {}\n"
+      "  static void g();\n"
+      "};\n"
+      "void A::g() {}"
+      "void a_f() {}\n"
+      "static void static_f() {}\n"
+      "\n"
+      "}  // namespace na\n"
+      "namespace x {\n"
+      "namespace y {\n"
+      "void f() { na::a_f(); na::static_f(); na::A::f(); }\n"
+      "void g() { f(); na::A::g(); }\n"
+      "}  // namespace y\n"
+      "}  // namespace x\n";
+  EXPECT_EQ(format(Expected), runChangeNamespaceOnCode(Code));
+}
+
 } // anonymous namespace
 } // namespace change_namespace
 } // namespace clang