[clangd] Fix the incomplete template specialization in findTarget.

[hokein]

Summary

FindTarget doesn't report the TemplatePattern for incomplete
specialization.

[hokein]

Fix an accident change.

[hokein]

Fxi the tests.

clang-tools-extra/clangd/FindTarget.cpp

 #include "clang/AST/TemplateBase.h"
 #include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/AST/TypeLocVisitor.h"
 #include "clang/AST/TypeVisitor.h"
 #include "clang/Basic/LangOptions.h"
 #include "clang/Basic/OperatorKinds.h"
 #include "clang/Basic/SourceLocation.h"
+#include "clang/Basic/Specifiers.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/raw_ostream.h"
 #include <utility>
 #include <vector>
 
const Type *getPointeeType(const Type *T) {
   const TemplateArgument &FirstArg = TST->getArg(0);
   if (FirstArg.getKind() != TemplateArgument::Type)
     return nullptr;
   return FirstArg.getAsType().getTypePtrOrNull();
 }
 
 const NamedDecl *getTemplatePattern(const NamedDecl *D) {
   if (const CXXRecordDecl *CRD = dyn_cast<CXXRecordDecl>(D)) {
-    return CRD->getTemplateInstantiationPattern();
+    if (const auto *Result = CRD->getTemplateInstantiationPattern())
+      return Result;
+    // getTemplateInstantiationPattern returns null if the Specialization is
+    // incomplete (e.g. the type didn't need to be complete), fall back to the
+    // primary template.
+    if (CRD->getTemplateSpecializationKind() == TSK_Undeclared)
+      if (const auto *Spec = dyn_cast<ClassTemplateSpecializationDecl>(CRD))
+        return Spec->getSpecializedTemplate()->getTemplatedDecl();
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     return FD->getTemplateInstantiationPattern();
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
     // Hmm: getTIP returns its arg if it's not an instantiation?!
     VarDecl *T = VD->getTemplateInstantiationPattern();
     return (T == D) ? nullptr : T;
   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
     return ED->getInstantiatedFromMemberEnum();

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

Code = R"cpp(
     template<int x> class Foo{};
     [[Foo<42>]] B;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc",
                {"template<> class Foo<42>", Rel::TemplateInstantiation},
                {"class Foo", Rel::TemplatePattern});
 
   Code = R"cpp(
+    template<typename T> class Foo {};
+    // The "Foo<int>" SpecializationDecl is incomplete, there is no
+    // instantiation happening.
+    void func([[Foo<int>]] *);
+  )cpp";
+  EXPECT_DECLS("TemplateSpecializationTypeLoc",
+               {"class Foo", Rel::TemplatePattern},
+               {"template<> class Foo<int>", Rel::TemplateInstantiation});
+
+  Code = R"cpp(
     // Explicit specialization.
     template<int x> class Foo{};
     template<> class Foo<42>{};
     [[Foo<42>]] B;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc", "template<> class Foo<42>");
 
   Code = R"cpp(

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

const char *Tests[] = {
         void foo(int s = [[var]]);
       )cpp",
 
       R"cpp(
        template <typename T>
        class [[Fo^o]] {};
        void func([[Foo]]<int>);
       )cpp",
+
+      R"cpp(
+       template <typename T>
+       class [[Foo]] {};
+       void func([[Fo^o]]<int>);
+      )cpp",
   };
   for (const char *Test : Tests) {
     Annotations T(Test);
     auto AST = TestTU::withCode(T.code()).build();
     std::vector<Matcher<Location>> ExpectedLocations;
     for (const auto &R : T.ranges())
       ExpectedLocations.push_back(RangeIs(R));
     EXPECT_THAT(findReferences(AST, T.point(), 0).References,