[clangd] Handle deduction guides in TargetFinder and ExplicitReferenceCollector

[nridge]

Summary

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

[hokein]

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

404

looks like we insert "-std=c++17" twice, see line 389.

[nridge]

Address nit

clang-tools-extra/clangd/FindTarget.cpp

void add(const Decl *Dcl, RelSet Flags) {
     } else if (const UsingShadowDecl *USD = dyn_cast<UsingShadowDecl>(D)) {
       // Include the using decl, but don't traverse it. This may end up
       // including *all* shadows, which we don't want.
       report(USD->getUsingDecl(), Flags | Rel::Alias);
       // Shadow decls are synthetic and not themselves interesting.
       // Record the underlying decl instead, if allowed.
       D = USD->getTargetDecl();
       Flags |= Rel::Underlying; // continue with the underlying decl.
+    } else if (const auto *DG = dyn_cast<CXXDeductionGuideDecl>(D)) {
+      D = DG->getDeducedTemplate();
     }
 
     if (const Decl *Pat = getTemplatePattern(D)) {
       assert(Pat != D);
       add(Pat, Flags | Rel::TemplatePattern);
       // Now continue with the instantiation.
       Flags |= Rel::TemplateInstantiation;
     }
void VisitNamedDecl(const NamedDecl *ND) {
       if (ND->getDeclName().isIdentifier() &&
           !ND->getDeclName().getAsIdentifierInfo())
         return;
       Refs.push_back(ReferenceLoc{getQualifierLoc(*ND),
                                   ND->getLocation(),
                                   /*IsDecl=*/true,
                                   {ND}});
     }
+
+    void VisitCXXDeductionGuideDecl(const CXXDeductionGuideDecl *DG) {
+      // The class template name in a deduction guide targets the class
+      // template.
+      Refs.push_back(ReferenceLoc{DG->getQualifierLoc(),
+                                  DG->getNameInfo().getLoc(),
+                                  /*IsDecl=*/false,
+                                  {DG->getDeducedTemplate()}});
+    }
   };
 
   Visitor V;
   V.Visit(D);
   return V.Refs;
 }
 
 llvm::SmallVector<ReferenceLoc, 2> refInStmt(const Stmt *S) {

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

Code = R"cpp(
     template<typename T> class Foo{};
     template<typename T> class Foo<T*>{};
     [[Foo<int*>]] B;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc",
                {"template<> class Foo<int *>", Rel::TemplateInstantiation},
                {"template <typename T> class Foo<T *>", Rel::TemplatePattern});
 
+  Flags.push_back("-std=c++17"); // for CTAD tests
+
   Code = R"cpp(
     // Class template argument deduction
     template <typename T>
     struct Test {
       Test(T);
     };
     void foo() {
       [[Test]] a(5);
     }
   )cpp";
-  Flags.push_back("-std=c++17");
   EXPECT_DECLS("DeducedTemplateSpecializationTypeLoc",
                {"struct Test", Rel::TemplatePattern});
+
+  Code = R"cpp(
+    // Deduction guide
+    template <typename T>
+    struct Test {
+      template <typename I>
+      Test(I, I);
+    };
+    template <typename I>
+    [[Test]](I, I) -> Test<typename I::type>;
+  )cpp";
+  EXPECT_DECLS("CXXDeductionGuideDecl", {"template <typename T> struct Test"});
 }
 
 TEST_F(TargetDeclTest, Concept) {
   Code = R"cpp(
     template <typename T>
     concept Fooable = requires (T t) { t.foo(); };
 
     template <typename T> requires [[Fooable]]<T>
std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
         "7: targets = {a::b::S::type}, qualifier = 'struct S::'\n"
         "8: targets = {y}, decl\n"},
        {R"cpp(
          void foo() {
            $0^ten: // PRINT "HELLO WORLD!"
            goto $1^ten;
          }
        )cpp",
         "0: targets = {ten}, decl\n"
         "1: targets = {ten}\n"},
        // Simple templates.
        {R"cpp(
           template <class T> struct vector { using value_type = T; };
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
             $0^vector<int> $1^vi;
             $2^vector<bool> $3^vb;
           }
#endif
         "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"},
        {R"cpp(
            template<typename T>
            void crash(T);
            template<typename T>
            void foo() {
              $0^crash({.$1^x = $2^T()});
            }
         )cpp",
         "0: targets = {crash}\n"
         "1: targets = {}\n"
-        "2: targets = {T}\n"
-      },
+        "2: targets = {T}\n"},
        // unknown template name should not crash.
        {R"cpp(
         template <template <typename> typename T>
         struct Base {};
         namespace foo {
         template <typename $0^T>
         struct $1^Derive : $2^Base<$3^T::template $4^Unknown> {};
         }
       )cpp",
         "0: targets = {foo::Derive::T}, decl\n"
         "1: targets = {foo::Derive}, decl\n"
         "2: targets = {Base}\n"
         "3: targets = {foo::Derive::T}\n"
         "4: targets = {}, qualifier = 'T::'\n"},
+       // deduction guide
+       {R"cpp(
+          namespace foo {
+            template <typename $0^T>
+            struct $1^Test {
+              template <typename $2^I>
+              $3^Test($4^I);
             };
+            template <typename $5^I>
+            $6^Test($7^I) -> $8^Test<typename $9^I::$10^type>;
+          }
+        )cpp",
+        "0: targets = {T}, decl\n"
+        "1: targets = {foo::Test}, decl\n"
+        "2: targets = {I}, decl\n"
+        "3: targets = {foo::Test::Test<T>}, decl\n"
+        "4: targets = {I}\n"
+        "5: targets = {I}, decl\n"
+        "6: targets = {foo::Test}\n"
+        "7: targets = {I}\n"
+        "8: targets = {foo::Test}\n"
+        "9: targets = {I}\n"
+        "10: targets = {}, qualifier = 'I::'\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