[clang][Index] Fix the incomplete instantiations in libindex.

[hokein]

Summary

libindex will canonicalize references to template instantiations:

• 1) reference to an explicit template specialization, report the specializatiion
• 2) otherwise, report the primary template

but 2) is not true for incomplete instantiations, this patch fixes this.

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

[kadircet]

clang/lib/Index/IndexingContext.cpp

175

i believe this might as well be an explicit instantiation, e.g.

template <typename T> struct Foo{};
template <> struct Foo<int>;

void foo(Foo<int>);

could you check what this yield for TKind (and add tests)?

even if this one is also TSK_Undeclared I suppose it is still OK to make use of
TemplatedDecl for indexing purposes, but will likely need some changes in the
function name(ImplicitOrUninstantiated?)/documentation.

175

nit: please use isa instead to emphasize on the fact that we are returning a bool.
also please move it into switch statement.

clang/test/Index/Core/index-source.cpp

324

this looks like a regression, previously when indexing this symbol it was known that first template argument was a SpecializationDecl<Cls> now it is class template instead.

(same for the 2 below)

[kadircet]

clang/lib/Index/IndexingContext.cpp

217

maybe return templateddecl iff instantiationpattern is null ?

[hokein]

address review comments.

clang/lib/Index/IndexingContext.cpp

175

I think explicit instantiation is fine, as it will create a complete specialization, TSK will be TSK_ExplicitInstantiationDeclaration or TSK_ExplicitInstantiationDefinition.

we will get the primary template, no behavior change before/after this patch. Added a test.

clang/test/Index/Core/index-source.cpp

324

yeah, that was my thought previously, but it turns out not -- it is a bug I think, there is no explicit specialization for SpecializationDecl<Cls>, so we should give the primary template.

Take a look on Line 60 of this file, TemplCls<int> gtv(0); it gives the primary class template as well.

[kadircet]

clang/lib/Index/IndexingContext.cpp

180

not just instantiation but rather implicit instantiation.

217

nit:

if(const auto *Temp ...)
 return Temp..;
return templateddecl

222

there might be other reasons for not having an instantiation yet (e.g dependent code), maybe just say fallback to class template if no instantiation is available yet?

clang/test/Index/Core/index-instantiated-source.cpp

103

yes this is an explicit instantiation and will have TSKKind set properly.

but i was talking about an explicit specialization in the example above, i.e:

template <> class Foo<float>;

which will still have TSK_Undeclared (I believe, haven't checked).

and let me make myself clear, I am not opposed to the idea of making this also a ref to the primary template instead of the specialization, I just want to make sure we spell it out in the comments and tests explicitly.

104

this is not valid, as you can't define a variable of incomplete type, this needs to be in a function declaration (as I provided in the example) or you can also try making this a pointer as you did below.

i.e.:

void foo(Foo<float>);

clang/test/Index/Core/index-source.cpp

324

yeah makes sense actually, also this is a Ref, not a decl or def so it is not very logical for it to point at some implicit decl.

SGTM

[hokein]

Add an explicit template declaration (not definition) testcase.

clang/test/Index/Core/index-instantiated-source.cpp

103

Added an explicit specialization declaration (but not definition) case.

In this case, the TSK_Kind is TSK_ExplicitSpecialization, so the result is SpecializationDecl.

104

This is valid code, as this is an explicit instantiation (I thought you meat explicit instantiation).

[kadircet]

LGTM, please fix the formatting warnings though (at least the ones in the implementation)

[hokein]

Fix the format.

[hokein]

Thanks for the review!

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

const char *Tests[] = {
           int x = [[MACRO]]([[MACRO]](1));
         }
       )cpp",
 
       R"cpp(
         int [[v^ar]] = 0;
         void foo(int s = [[var]]);
       )cpp",
+
+      R"cpp(
+       template <typename T>
+       class [[Fo^o]] {};
+       void func([[Foo]]<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,

clang/lib/Index/IndexingContext.cpp

bool IndexingContext::isTemplateImplicitInstantiation(const Decl *D) {
   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
     if (ED->getInstantiatedFromMemberEnum())
       TKind = ED->getTemplateSpecializationKind();
   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D) ||
              isa<EnumConstantDecl>(D)) {
     if (const auto *Parent = dyn_cast<Decl>(D->getDeclContext()))
       return isTemplateImplicitInstantiation(Parent);
   }
+
+  // Incomplete template specialization is not instantiated, we still treat it
+  // as an instantiation as we'd like to keep the canonicalized result
+  // consistent.
+  if (TKind == TSK_Undeclared)
+    return dyn_cast<ClassTemplateSpecializationDecl>(D);
+
   switch (TKind) {
     case TSK_Undeclared:
     case TSK_ExplicitSpecialization:
       return false;
     case TSK_ImplicitInstantiation:
     case TSK_ExplicitInstantiationDeclaration:
     case TSK_ExplicitInstantiationDefinition:
       return true;
   }
   llvm_unreachable("invalid TemplateSpecializationKind");
 }
 
getDeclContextForTemplateInstationPattern(const Decl *D) {
   else if (const auto *RD = dyn_cast<CXXRecordDecl>(D->getDeclContext()))
     return RD->getInstantiatedFromMemberClass();
   return nullptr;
 }
 
 static const Decl *adjustTemplateImplicitInstantiation(const Decl *D) {
   if (const ClassTemplateSpecializationDecl *
       SD = dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+    // Fallback to primary template if this is an incomplete specialization.
+    if (SD->getTemplateSpecializationKind() == TSK_Undeclared)
+      return SD->getSpecializedTemplate()->getTemplatedDecl();
     return SD->getTemplateInstantiationPattern();
   } else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(D)) {
     return FD->getTemplateInstantiationPattern();
   } else if (auto *VD = dyn_cast<VarDecl>(D)) {
     return VD->getTemplateInstantiationPattern();
   } else if (const auto *RD = dyn_cast<CXXRecordDecl>(D)) {
     return RD->getInstantiatedFromMemberClass();
   } else if (const auto *ED = dyn_cast<EnumDecl>(D)) {
     return ED->getInstantiatedFromMemberEnum();
   } else if (isa<FieldDecl>(D) || isa<TypedefNameDecl>(D)) {
     const auto *ND = cast<NamedDecl>(D);
     if (const CXXRecordDecl *Pattern =

clang/test/Index/Core/index-instantiated-source.cpp

// CHECK: [[@LINE-1]]:19 | type-alias/C++ | TypeAlias | c:@ST>2#T#T@TemplateClass@S@NestedType@TypeAlias |
   TT::NestedType::Typedef nestedTypedef;
 // CHECK: [[@LINE-1]]:19 | type-alias/C | Typedef | c:{{.*}}index-instantiated-source.cpp@ST>2#T#T@TemplateClass@S@NestedType@T@Typedef |
 
   TT::NestedType::Enum nestedEnum;
 // CHECK: [[@LINE-1]]:19 | enum/C | Enum | c:@ST>2#T#T@TemplateClass@S@NestedType@E@Enum |
   (void)TT::NestedType::Enum::EnumCase;
 // CHECK: [[@LINE-1]]:31 | enumerator/C | EnumCase | c:@ST>2#T#T@TemplateClass@S@NestedType@E@Enum@EnumCase |
 }
+
+namespace index_specialization {
+template<typename T>
+class Foo {};
+
+// if there are no explicit template specializations provided, report the
+// primary templates.
+Foo<int>* t1; // incomplete instantiation.
+// CHECK: [[@LINE-1]]:1 | class(Gen)/C++ | Foo | c:@N@index_specialization@ST>1#T@Foo | <no-cgname> | Ref,RelCont | rel: 1
+
+Foo<double> t2;
+// CHECK: [[@LINE-1]]:1 | class(Gen)/C++ | Foo | c:@N@index_specialization@ST>1#T@Foo | <no-cgname> | Ref,RelCont | rel: 1
+
+
+template<typename T>
+class Bar {};
+template<>
+class Bar<int> {};
+// report the explicit template specialization if it exists.
+Bar<int>* t3;
+// CHECK: [[@LINE-1]]:1 | class(Gen,TS)/C++ | Bar | c:@N@index_specialization@S@Bar>#I | <no-cgname> | Ref,RelCont | rel: 1
+}

clang/test/Index/Core/index-source.cpp

 void functionSp() { }
 
 struct Record {
   constexpr static int C = 2;
 };
 
 template<>
 void functionSp<SpecializationDecl<Cls>, Record::C>() {
 // CHECK: [[@LINE-1]]:6 | function(Gen,TS)/C++ | functionSp | c:@F@functionSp<#$@S@SpecializationDecl>#$@S@Cls#VI2># | __Z10functionSpI18SpecializationDeclI3ClsELi2EEvv | Def,RelSpecialization | rel: 1
 // CHECK:   RelSpecialization | functionSp | c:@FT@>2#T#NIfunctionSp#v#
-// CHECK: [[@LINE-3]]:17 | class(Gen,TS)/C++ | SpecializationDecl | c:@S@SpecializationDecl>#$@S@Cls | <no-cgname> | Ref,RelCont | rel: 1
+// CHECK: [[@LINE-3]]:17 | class(Gen)/C++ | SpecializationDecl | c:@ST>1#T@SpecializationDecl | <no-cgname> | Ref,RelCont | rel: 1
 // CHECK: [[@LINE-4]]:36 | class/C++ | Cls | c:@S@Cls | <no-cgname> | Ref,RelCont | rel: 1
 // CHECK: [[@LINE-5]]:50 | static-property/C++ | C | c:@S@Record@C | __ZN6Record1CE | Ref,RelCont | rel: 1
 // CHECK: [[@LINE-6]]:42 | struct/C++ | Record | c:@S@Record | <no-cgname> | Ref,RelCont | rel: 1
 }
 
 template<typename T, int x>
 class ClassWithCorrectSpecialization { };
 
 template<>
 class ClassWithCorrectSpecialization<SpecializationDecl<Cls>, Record::C> { };
-// CHECK: [[@LINE-1]]:38 | class(Gen,TS)/C++ | SpecializationDecl | c:@S@SpecializationDecl>#$@S@Cls | <no-cgname> | Ref | rel: 0
+// CHECK: [[@LINE-1]]:38 | class(Gen)/C++ | SpecializationDecl | c:@ST>1#T@SpecializationDecl | <no-cgname> | Ref | rel: 0
 // CHECK: [[@LINE-2]]:57 | class/C++ | Cls | c:@S@Cls | <no-cgname> | Ref | rel: 0
 // CHECK: [[@LINE-3]]:71 | static-property/C++ | C | c:@S@Record@C | __ZN6Record1CE | Ref,Read | rel: 0
 // CHECK: [[@LINE-4]]:63 | struct/C++ | Record | c:@S@Record | <no-cgname> | Ref | rel: 0
 
 namespace ns {
 // CHECK: [[@LINE-1]]:11 | namespace/C++ | ns | c:@N@ns | <no-cgname> | Decl | rel: 0
 namespace inner {
 // CHECK: [[@LINE-1]]:11 | namespace/C++ | inner | c:@N@ns@N@inner | <no-cgname> | Decl,RelChild | rel: 1

 }
 
 template<typename T>
 struct Guided { T t; };
 // CHECK: [[@LINE-1]]:8 | struct(Gen)/C++ | Guided | c:@ST>1#T@Guided | <no-cgname> | Def | rel: 0
 // CHECK-NEXT: [[@LINE-2]]:19 | field/C++ | t | c:@ST>1#T@Guided@FI@t | <no-cgname> | Def,RelChild | rel: 1
 // CHECK-NEXT: RelChild | Guided | c:@ST>1#T@Guided
 Guided(double) -> Guided<float>;
-// CHECK: [[@LINE-1]]:19 | struct(Gen,TS)/C++ | Guided | c:@S@Guided>#f | <no-cgname> | Ref | rel: 0
+// CHECK: [[@LINE-1]]:19 | struct(Gen)/C++ | Guided | c:@ST>1#T@Guided | <no-cgname> | Ref | rel: 0
 // CHECK-NEXT: [[@LINE-2]]:1 | struct(Gen)/C++ | Guided | c:@ST>1#T@Guided | <no-cgname> | Ref | rel: 0
 auto guided = Guided{1.0};
 // CHECK: [[@LINE-1]]:6 | variable/C | guided | c:@guided | _guided | Def | rel: 0
 // CHECK-NEXT: [[@LINE-2]]:15 | struct(Gen)/C++ | Guided | c:@ST>1#T@Guided | <no-cgname> | Ref,RelCont | rel: 1
 // CHECK-NEXT: RelCont | guided | c:@guided
 
 namespace rd33122110 {