[clangd] Capture the missing injected class names in findExplicitReferences.

[hokein]

Summary

Fixes https://github.com/clangd/clangd/issues/237.

[merge_guards_bot]

Unit tests: pass. 62043 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

[kadircet]

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

736

looks like we are getting duplicates here

[kadircet]

LGTM

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

736

looking at this again, this is actually not caused by this change, it was always there we just didn't notice it before since no one tested class templates.

could you put a fixme on it?

[kbobyrev]

It would also be great to have the original rename test from the linked issue since something might potentially go wrong in-between findExplicitReferences and rename action (and also to expand the testset because the existing one is not really extensive :().

[hokein]

• add fixme
• add rename test

[hokein]

In D73088#1830960, @kbobyrev wrote:

It would also be great to have the original rename test from the linked issue since something might potentially go wrong in-between findExplicitReferences.

Done.

and rename action (and also to expand the testset because the existing one is not really extensive :().

yeap, there is some room to improve the test code here (e.g. using an idea similar to CodeContext in TweakTesting), previously we put the test code to a wrapper foo function, it is sufficient for most cases, but not for this patch as defining a template class in a function body is forbidden in C++. I think we can adress this afterwards.

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

736

Done.

[merge_guards_bot]

Unit tests: fail. 62042 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

clang-tools-extra/clangd/FindTarget.cpp

struct Visitor : TypeLocVisitor<Visitor> {
     void VisitDeducedTemplateSpecializationTypeLoc(
         DeducedTemplateSpecializationTypeLoc L) {
       Ref = ReferenceLoc{
           NestedNameSpecifierLoc(), L.getNameLoc(), /*IsDecl=*/false,
           explicitReferenceTargets(DynTypedNode::create(L.getType()),
                                    DeclRelation::Alias)};
     }
 
+    void VisitInjectedClassNameTypeLoc(InjectedClassNameTypeLoc TL) {
+      Ref = ReferenceLoc{NestedNameSpecifierLoc(),
+                         TL.getNameLoc(),
+                         /*IsDecl=*/false,
+                         {TL.getDecl()}};
+    }
+
     void VisitDependentTemplateSpecializationTypeLoc(
         DependentTemplateSpecializationTypeLoc L) {
       Ref = ReferenceLoc{
           L.getQualifierLoc(), L.getTemplateNameLoc(), /*IsDecl=*/false,
           explicitReferenceTargets(DynTypedNode::create(L.getType()), {})};
     }
 
     void VisitDependentNameTypeLoc(DependentNameTypeLoc L) {

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

-//===-- FindSymbolsTests.cpp -------------------------*- C++ -*------------===//
+//===-- FindTargetTests.cpp --------------------------*- C++ -*------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 #include "FindTarget.h"
 

 
 class FindExplicitReferencesTest : public ::testing::Test {
 protected:
   struct AllRefs {
     std::string AnnotatedCode;
     std::string DumpedReferences;
   };
 
-  /// Parses \p Code, finds function '::foo' and annotates its body with results
-  /// of findExplicitReferecnces.
+  /// Parses \p Code, finds function or namespace '::foo' and annotates its body
+  /// with results of findExplicitReferecnces.
   /// See actual tests for examples of annotation format.
   AllRefs annotateReferencesInFoo(llvm::StringRef Code) {
     TestTU TU;
     TU.Code = 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++17");
 
     auto AST = TU.build();
     for (auto &D : AST.getDiagnostics()) {
       if (D.Severity > DiagnosticsEngine::Warning)
         ADD_FAILURE() << D << Code;
     }
 
     auto *TestDecl = &findDecl(AST, "foo");
     if (auto *T = llvm::dyn_cast<FunctionTemplateDecl>(TestDecl))
       TestDecl = T->getTemplatedDecl();
-    auto &Func = llvm::cast<FunctionDecl>(*TestDecl);
 
     std::vector<ReferenceLoc> Refs;
-    findExplicitReferences(Func.getBody(), [&Refs](ReferenceLoc R) {
+    if (const auto *Func = llvm::dyn_cast<FunctionDecl>(TestDecl))
+      findExplicitReferences(Func->getBody(), [&Refs](ReferenceLoc R) {
         Refs.push_back(std::move(R));
       });
+    else if (const auto *NS = llvm::dyn_cast<NamespaceDecl>(TestDecl))
+      findExplicitReferences(NS, [&Refs, &NS](ReferenceLoc R) {
+        // Avoid adding the namespace foo decl to the results.
+        if (R.Targets.size() == 1 && R.Targets.front() == NS)
+          return;
+        Refs.push_back(std::move(R));
+      });
+    else
+      ADD_FAILURE() << "Failed to find ::foo decl for test";
 
     auto &SM = AST.getSourceManager();
     llvm::sort(Refs, [&](const ReferenceLoc &L, const ReferenceLoc &R) {
       return SM.isBeforeInTranslationUnit(L.NameLoc, R.NameLoc);
     });
 
     std::string AnnotatedCode;
     unsigned NextCodeChar = 0;
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
               $0^valias<int> $1^vi;
               $2^valias<bool> $3^vb;
             }
           )cpp",
         "0: targets = {valias}\n"
         "1: targets = {vi}, decl\n"
         "2: targets = {valias}\n"
         "3: targets = {vb}, decl\n"},
+       // Injected class name.
+       {R"cpp(
+            namespace foo {
+              template <typename $0^T>
+              class $1^$2^Bar {
+                ~$3^Bar();
+                void $4^f($5^Bar);
+              };
+            }
+          )cpp",
+        "0: targets = {foo::Bar::T}, decl\n"
+        // FIXME: avoid the 2 duplicated foo::Bar references below, the first
+        // one comes from ClassTemplateDecl; the second comes from the
+        // underlying CXXRecordDecl.
+        "1: targets = {foo::Bar}, decl\n"
+        "2: targets = {foo::Bar}, decl\n"
+        "3: targets = {foo::Bar}\n"
+        "4: targets = {foo::Bar::f}, decl\n"
+        "5: targets = {foo::Bar}\n"},
        // MemberExpr should know their using declaration.
        {R"cpp(
             struct X { void func(int); };
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);

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

llvm::StringRef Tests[] = {
           [[F^oo]]();
           ~[[Foo]]();
           void foo(int x);
         };
         [[Foo]]::[[Fo^o]]() {}
         void [[Foo]]::foo(int x) {}
       )cpp",
 
+      // Rename template class, including constructor/destructor.
+      R"cpp(
+        template <typename T>
+        class [[F^oo]] {
+          [[F^oo]]();
+          ~[[F^oo]]();
+          void f([[Foo]] x);
+        };
+      )cpp",
+
       // Class in template argument.
       R"cpp(
         class [[F^oo]] {};
         template <typename T> void func();
         template <typename T> class Baz {};
         int main() {
           func<[[F^oo]]>();
           Baz<[[F^oo]]> obj;

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

)cpp",
         using $TemplateParameter[[TemplateParam1]] = $TemplateParameter[[T]];
         typedef $TemplateParameter[[T]] $TemplateParameter[[TemplateParam2]];
         using $Primitive[[IntType]] = int;
 
         using $Typedef[[Pointer]] = $TemplateParameter[[T]] *;
         using $Typedef[[LVReference]] = $TemplateParameter[[T]] &;
         using $Typedef[[RVReference]] = $TemplateParameter[[T]]&&;
         using $Typedef[[Array]] = $TemplateParameter[[T]]*[3];
-        using $Typedef[[MemberPointer]] = int (A::*)(int);
+        using $Typedef[[MemberPointer]] = int ($Class[[A]]::*)(int);
 
         // Use various previously defined typedefs in a function type.
         void $Method[[func]](
           $Typedef[[Pointer]], $Typedef[[LVReference]], $Typedef[[RVReference]],
           $Typedef[[Array]], $Typedef[[MemberPointer]]);
       };
     )cpp",
       R"cpp(