Add field designated initializers logic in Tooling/Rename

[dcastagna]

Summary

clang Tooling, and more specifically Refactoring/Rename, have support
code to extract source locations given a Unified Symbol Resolution set.
This support code is used by clang-rename and other tools that might not
be in the tree.

Currently field designated initializer are not supported.
So, renaming S::a to S::b in this code:

S s = { .a = 10 };

will not extract the field designated initializer for a (the 'a' after the
dot).

This CL adds support for field designated initialized to RecursiveSymbolVisitor
and RenameLocFinder that is used in createRenameAtomicChanges.

[jlebar]

I can't argue with this.

[dcastagna]

Fixed clang-format pre-merge lints

[dcastagna]

Actually run git clang-format

[dcastagna]

clang-format again

[jlebar]

I guess you need me or Michael to push this. Happy to do so once you're
happy with it.

[dcastagna]

Thank you Justin.
I'm happy with this now that I finally managed to get rid of the lint errors.
Let's wait for Micheal's opinion or until tomorrow and then we can push it?

[mkuper]

I defer to Justin, he knows AST much better than I do.

clang/include/clang/Tooling/Refactoring/RecursiveSymbolVisitor.h

bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc NNS) {
     if (NNS) {
       const NamespaceDecl *ND = NNS.getNestedNameSpecifier()->getAsNamespace();
       if (!visit(ND, NNS.getLocalBeginLoc(), NNS.getLocalEndLoc()))
         return false;
     }
     return BaseType::TraverseNestedNameSpecifierLoc(NNS);
   }
 
+  bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
+    for (const DesignatedInitExpr::Designator &D : E->designators()) {
+      if (D.isFieldDesignator() && D.getField()) {
+        const FieldDecl *Decl = D.getField();
+        if (!visit(Decl, D.getFieldLoc(), D.getFieldLoc()))
+          return false;
+      }
+    }
+    return true;
+  }
+
 private:
   const SourceManager &SM;
   const LangOptions &LangOpts;
 
   bool visit(const NamedDecl *ND, SourceLocation BeginLoc,
              SourceLocation EndLoc) {
     return static_cast<T *>(this)->visitSymbolOccurrence(
         ND, SourceRange(BeginLoc, EndLoc));

clang/lib/Tooling/Refactoring/Rename/USRLocFinder.cpp

if (isInUSRSet(Decl)) {
                             /*FromDecl=*/nullptr,
                             /*Context=*/nullptr,
                             /*Specifier=*/nullptr,
                             /*IgnorePrefixQualifiers=*/true});
     }
     return true;
   }
 
+  bool VisitDesignatedInitExpr(const DesignatedInitExpr *E) {
+    for (const DesignatedInitExpr::Designator &D : E->designators()) {
+      if (D.isFieldDesignator() && D.getField()) {
+        const FieldDecl* Decl = D.getField();
+        if (isInUSRSet(Decl)) {
+            auto StartLoc = D.getFieldLoc();
+            auto EndLoc = D.getFieldLoc();
+            RenameInfos.push_back({StartLoc, EndLoc,
+                                  /*FromDecl=*/nullptr,
+                                  /*Context=*/nullptr,
+                                  /*Specifier=*/nullptr,
+                                  /*IgnorePrefixQualifiers=*/true});
+        }
+      }
+    }
+    return true;
+  }
+
   bool VisitCXXConstructorDecl(const CXXConstructorDecl *CD) {
     // Fix the constructor initializer when renaming class members.
     for (const auto *Initializer : CD->inits()) {
       // Ignore implicit initializers.
       if (!Initializer->isWritten())
         continue;
 
       if (const FieldDecl *FD = Initializer->getMember()) {

clang/unittests/Rename/RenameClassTest.cpp

std::string Expected = R"(
       namespace foo {
       using Alias = b::B;
       Alias a;
       })";
   std::string After = runClangRenameOnCode(Before, "a::A", "b::B");
   CompareSnippets(Expected, After);
 }
 
+TEST_F(ClangRenameTest, FieldDesignatedInitializers) {
+  std::string Before = R"(
+      struct S {
+        int a;
+      };
+      void foo() {
+        S s = { .a = 10 };
+        s.a = 20;
+      })";
+  std::string Expected = R"(
+      struct S {
+        int b;
+      };
+      void foo() {
+        S s = { .b = 10 };
+        s.b = 20;
+      })";
+  std::string After = runClangRenameOnCode(Before, "S::a", "S::b");
+  CompareSnippets(Expected, After);
+}
+
 // FIXME: investigate why the test fails when adding a new USR to the USRSet.
 TEST_F(ClangRenameTest, DISABLED_NestedTemplates) {
   std::string Before = R"(
       namespace a { template <typename T> struct A {}; }
       a::A<a::A<int>> foo;)";
   std::string Expected = R"(
       namespace a { template <typename T> struct B {}; }
       b::B<b::B<int>> foo;)";