[clangd] Support renaming designated initializers

[kbobyrev]

Summary

Clangd does not find references of designated iniitializers yet and, as a
result, is unable to rename such references. This patch addresses this issue.

Resolves: https://github.com/clangd/clangd/issues/247

[kbobyrev]

Remove duplicated testt

[merge_guards_bot]

Unit tests: fail. 61928 tests passed, 1 failed and 783 were skipped.

failed: libc++.std/thread/thread_mutex/thread_mutex_requirements/thread_sharedtimedmutex_requirements/thread_sharedtimedmutex_class/try_lock.pass.cpp

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[merge_guards_bot]

Unit tests: pass. 61929 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[merge_guards_bot]

Unit tests: pass. 61929 tests passed, 0 failed and 783 were skipped.

clang-tidy: unknown.

clang-format: pass.

Build artifacts: diff.json, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

[sammccall]

clang-tools-extra/clangd/FindTarget.cpp

665

you're breaking after the first one - I think you'd like to report every one instead?
You'd test this with a DIE like { .Foo.Bar = 2 } where Foo has struct type.

(targetDecl only reports the *last* one, because the Designator can't be a DynTypedNode, but we don't care about that here)

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

592–593

isn't this spelled c++20 yet?

[sammccall]

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

592–593

(No, it's not)

[kbobyrev]

Going to deal with nested designated inits soon and update the patch.

[kbobyrev]

Add tests for nested designated initializers.

clang-tools-extra/clangd/FindTarget.cpp

665

Sorry, I tried to understand this comment but I wasn't able to in the end. Could you please elaborate on this?

I'm adding the test cases that I originally thought you meant, but those work correctly so I assume I didn't understand what case you were referring to.

[merge_guards_bot]

Unit tests: pass. 62405 tests passed, 0 failed and 839 were skipped.

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[sammccall]

clang-tools-extra/clangd/FindTarget.cpp

665

Sorry, I'm not sure what I was thinking here - code LG.

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : ConstStmtVisitor<Visitor> {
     void VisitSizeOfPackExpr(const SizeOfPackExpr *E) {
       Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
                                   E->getPackLoc(),
                                   /*IsDecl=*/false,
                                   {E->getPack()}});
     }
 
     void VisitObjCPropertyRefExpr(const ObjCPropertyRefExpr *E) {
       Refs.push_back(ReferenceLoc{
           NestedNameSpecifierLoc(), E->getLocation(),
           /*IsDecl=*/false,
           // Select the getter, setter, or @property depending on the call.
           explicitReferenceTargets(DynTypedNode::create(*E), {})});
     }
+
+    void VisitDesignatedInitExpr(const DesignatedInitExpr *DIE) {
+      for (const DesignatedInitExpr::Designator &D : DIE->designators()) {
+        if (!D.isFieldDesignator())
+          continue;
+        Refs.push_back(ReferenceLoc{NestedNameSpecifierLoc(),
+                                    D.getFieldLoc(),
+                                    /*IsDecl=*/false,
+                                    {D.getField()}});
+      }
+    }
   };
 
   Visitor V;
   V.Visit(E);
   return V.Refs;
 }
 
 llvm::SmallVector<ReferenceLoc, 2> refInTypeLoc(TypeLoc L) {

clang-tools-extra/clangd/unittests/FindTargetTests.cpp

protected:
   /// See actual tests for examples of annotation format.
   AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     TestTU TU;
     TU.Code = std::string(Code);
 
     // FIXME: Auto-completion in a template requires disabling delayed template
     // parsing.
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     TU.ExtraArgs.push_back("-std=c++2a");
     TU.ExtraArgs.push_back("-xobjective-c++");
 
     auto AST = TU.build();
     auto *TestDecl = &findDecl(AST, "foo");
     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
       TestDecl = T->getTemplatedDecl();
 
     std::vector<ReferenceLoc> Refs;
     if (const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
             @end
             I *f;
             void foo() {
               $0^f.$1^x.$2^y = 0;
             }
           )cpp",
            "0: targets = {f}\n"
            "1: targets = {I::x}\n"
-           "2: targets = {I::setY:}\n"}};
+           "2: targets = {I::setY:}\n"},
+       // Designated initializers.
+       {R"cpp(
+            void foo() {
+              struct $0^Foo {
+                int $1^Bar;
+              };
+              $2^Foo $3^f { .$4^Bar = 42 };
+            }
+        )cpp",
+        "0: targets = {Foo}, decl\n"
+        "1: targets = {foo()::Foo::Bar}, decl\n"
+        "2: targets = {Foo}\n"
+        "3: targets = {f}, decl\n"
+        "4: targets = {foo()::Foo::Bar}\n"},
+       {R"cpp(
+            void foo() {
+              struct $0^Baz {
+                int $1^Field;
+              };
+              struct $2^Bar {
+                $3^Baz $4^Foo;
+              };
+              $5^Bar $6^bar { .$7^Foo.$8^Field = 42 };
+            }
+        )cpp",
+        "0: targets = {Baz}, decl\n"
+        "1: targets = {foo()::Baz::Field}, decl\n"
+        "2: targets = {Bar}, decl\n"
+        "3: targets = {Baz}\n"
+        "4: targets = {foo()::Bar::Foo}, decl\n"
+        "5: targets = {Bar}\n"
+        "6: targets = {bar}, decl\n"
+        "7: targets = {foo()::Bar::Foo}\n"
+        "8: targets = {foo()::Baz::Field}\n"}};
 
   for (const auto &C : Cases) {
     llvm::StringRef ExpectedCode = C.first;
     llvm::StringRef ExpectedRefs = C.second;
 
     auto Actual =
         annotateReferencesInFoo(llvm::Annotations(ExpectedCode).code());
     EXPECT_EQ(ExpectedCode, Actual.AnnotatedCode);
     EXPECT_EQ(ExpectedRefs, Actual.DumpedReferences) << ExpectedCode;
   }
 }
 
 } // namespace
 } // namespace clangd
 } // namespace clang

clang-tools-extra/clangd/unittests/RenameTests.cpp

llvm::StringRef Tests[] = {
 
       // template class in template argument list.
       R"cpp(
         template<typename T>
         class [[Fo^o]] {};
         template <template<typename> class Z> struct Bar { };
         template <> struct Bar<[[Foo]]> {};
       )cpp",
+
+      // Designated initializer.
+      R"cpp(
+        struct Bar {
+          int [[Fo^o]];
+        };
+        Bar bar { .[[^Foo]] = 42 };
+      )cpp",
+
+      // Nested designated initializer.
+      R"cpp(
+        struct Baz {
+          int Field;
+        };
+        struct Bar {
+          Baz [[Fo^o]];
+        };
+        // FIXME:    v selecting here results in renaming Field.
+        Bar bar { .[[Foo]].Field = 42 };
+      )cpp",
+      R"cpp(
+        struct Baz {
+          int [[Fiel^d]];
+        };
+        struct Bar {
+          Baz Foo;
+        };
+        Bar bar { .Foo.[[^Field]] = 42 };
+      )cpp",
   };
   for (llvm::StringRef T : Tests) {
     SCOPED_TRACE(T);
     Annotations Code(T);
     auto TU = TestTU::withCode(Code.code());
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
     auto AST = TU.build();
     llvm::StringRef NewName = "abcde";