[Index] Compute correct symbol kind for variable templates

[ilya-biryukov]

Summary

The index library itself seems to never pass variable templates as
input, however clangd does.

[kadircet]

clang/lib/Index/IndexSymbol.cpp

99

what about function and class templates? Are they handled in somewhere else?

[ilya-biryukov]

clang/lib/Index/IndexSymbol.cpp

99

Yeah, they're handled in ifs and a large switch below. I tried unifying those cases (matching a TemplateDecl here instead of VarTemplateDecl), but they start producing different results for template classes and this function is mostly not called for templates from withing the index library (only for the underlying declarations) and it's only clangd that cares about the returned value in that case.

So I decided to make a minimal change that fixes clangd, but does not change behavior of the index library to avoid potential fallout of a more general fix.

[kadircet]

LGTM

clang/lib/Index/IndexSymbol.cpp

99

ok then it makes sense, could you also add a test case for one of the fall-through cases(static member/parameter(?) etc.)?

[ilya-biryukov]

• Add a test for static variable template member

[ilya-biryukov]

clang/lib/Index/IndexSymbol.cpp

99

Done. (Only static member, though, since we can't have templated parameters or non-static fields)

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

Results = completions(
               void *a;
             };
         };
         auto u = X().^
       )cpp");
   EXPECT_THAT(
       Results.Completions,
       UnorderedElementsAre(AllOf(Named("a"), Kind(CompletionItemKind::Field))));
+
+  // Completion kinds for templates should not be unknown.
+  Results = completions(
+      R"cpp(
+        template <class T> struct complete_class {};
+        template <class T> void complete_function();
+        template <class T> using complete_type_alias = int;
+        template <class T> int complete_variable = 10;
+
+        auto x = complete_^
+      )cpp");
+  EXPECT_THAT(
+      Results.Completions,
+      UnorderedElementsAre(
+          AllOf(Named("complete_class"), Kind(CompletionItemKind::Class)),
+          AllOf(Named("complete_function"), Kind(CompletionItemKind::Function)),
+          AllOf(Named("complete_type_alias"),
+                Kind(CompletionItemKind::Reference)),
+          AllOf(Named("complete_variable"),
+                Kind(CompletionItemKind::Variable))));
 }
 
 TEST(CompletionTest, NoDuplicates) {
   auto Results = completions(
       R"cpp(
           class Adapter {
           };
 

clang/lib/Index/IndexSymbol.cpp

SymbolInfo index::getSymbolInfo(const Decl *D) {
 
   if (isFunctionLocalSymbol(D)) {
     Info.Properties |= (SymbolPropertySet)SymbolProperty::Local;
   }
   if (isa<ObjCProtocolDecl>(D->getDeclContext())) {
     Info.Properties |= (SymbolPropertySet)SymbolProperty::ProtocolInterface;
   }
 
+  if (auto *VT = dyn_cast<VarTemplateDecl>(D)) {
+    Info.Properties |= (SymbolPropertySet)SymbolProperty::Generic;
+    Info.Lang = SymbolLanguage::CXX;
+    // All other fields are filled from the templated decl.
+    D = VT->getTemplatedDecl();
+  }
+
   if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
     switch (TD->getTagKind()) {
     case TTK_Struct:
       Info.Kind = SymbolKind::Struct; break;
     case TTK_Union:
       Info.Kind = SymbolKind::Union; break;
     case TTK_Class:
       Info.Kind = SymbolKind::Class;
if (const TagDecl *TD = dyn_cast<TagDecl>(D)) {
     case Decl::MSProperty:
       Info.Kind = SymbolKind::InstanceProperty;
       if (const CXXRecordDecl *CXXRec =
               dyn_cast<CXXRecordDecl>(D->getDeclContext())) {
         if (!CXXRec->isCLike())
           Info.Lang = SymbolLanguage::CXX;
       }
       break;
+    case Decl::ClassTemplatePartialSpecialization:
+    case Decl::ClassScopeFunctionSpecialization:
+    case Decl::ClassTemplateSpecialization:
+    case Decl::CXXRecord:
+    case Decl::Enum:
+    case Decl::Record:
+      llvm_unreachable("records handled before");
+      break;
+    case Decl::VarTemplateSpecialization:
+    case Decl::VarTemplatePartialSpecialization:
+    case Decl::ImplicitParam:
+    case Decl::ParmVar:
+    case Decl::Var:
+    case Decl::VarTemplate:
+      llvm_unreachable("variables handled before");
+      break;
+    // Other decls get the 'unknown' kind.
     default:
       break;
     }
   }
 
   if (Info.Kind == SymbolKind::Unknown)
     return Info;