[clangd] Enable indexing of template type parameters

[kadircet]

Summary

Fixes https://bugs.llvm.org/show_bug.cgi?id=36285

[ilya-biryukov]

It feels that storing template parameters in the index is a waste, one can only access them through the scope they are introduced in (there are out-of-line definitions of a function, but I think we treat every redeclaration of template headers separately).
Can we get the information from the AST whenever we need it?

[kadircet]

• Turn off indexing of template type parms for dynamic index

[kadircet]

Yeah you are right, no need to have those in the index. I thought we looked at only index for findreferences(which turned out to be wrong, we also traverse ast), therefore I had turned this functionality on for dynamic index.

[ilya-biryukov]

clangd/XRefs.cpp

42–43

Should probably also handle TemplateTemplateParmDecl?
Could we add tests for template template parameters too?

// two most-used constructs with template template parameter references.
template<template <class> class U>
struct Foo {
  ^U<int> f;
  Foo<^U> x;
};

[kadircet]

• Add handling for template template type parameters

[ilya-biryukov]

LGTM

[kadircet]

• Option's name has changed

clangd/XRefs.cpp

const Decl *getDefinition(const Decl *D) {
   // Decl has one definition that we can find.
   if (const auto *TD = dyn_cast<TagDecl>(D))
     return TD->getDefinition();
   if (const auto *VD = dyn_cast<VarDecl>(D))
     return VD->getDefinition();
   if (const auto *FD = dyn_cast<FunctionDecl>(D))
     return FD->getDefinition();
   // Only a single declaration is allowed.
-  if (isa<ValueDecl>(D)) // except cases above
+  if (isa<ValueDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
+      isa<TemplateTemplateParmDecl>(D)) // except cases above
     return D;
   // Multiple definitions are allowed.
   return nullptr; // except cases above
 }
 
 void logIfOverflow(const SymbolLocation &Loc) {
   if (Loc.Start.hasOverflow() || Loc.End.hasOverflow())
     log("Possible overflow in symbol location: {0}", Loc);

 IdentifiedSymbol getSymbolAtPosition(ParsedAST &AST, SourceLocation Pos) {
   auto DeclMacrosFinder = DeclarationAndMacrosFinder(Pos, AST.getASTContext(),
                                                      AST.getPreprocessor());
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
   IndexOpts.IndexFunctionLocals = true;
   IndexOpts.IndexParametersInDeclarations = true;
+  IndexOpts.IndexTemplateParameters = true;
   indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
                      AST.getLocalTopLevelDecls(), DeclMacrosFinder, IndexOpts);
 
   return {DeclMacrosFinder.getFoundDecls(), DeclMacrosFinder.takeMacroInfos()};
 }
 
 Range getTokenRange(ParsedAST &AST, SourceLocation TokLoc) {
   const SourceManager &SourceMgr = AST.getASTContext().getSourceManager();

 std::vector<ReferenceFinder::Reference>
 findRefs(const std::vector<const Decl *> &Decls, ParsedAST &AST) {
   ReferenceFinder RefFinder(AST.getASTContext(), AST.getPreprocessor(), Decls);
   index::IndexingOptions IndexOpts;
   IndexOpts.SystemSymbolFilter =
       index::IndexingOptions::SystemSymbolFilterKind::All;
   IndexOpts.IndexFunctionLocals = true;
   IndexOpts.IndexParametersInDeclarations = true;
+  IndexOpts.IndexTemplateParameters = true;
   indexTopLevelDecls(AST.getASTContext(), AST.getPreprocessor(),
                      AST.getLocalTopLevelDecls(), RefFinder, IndexOpts);
   return std::move(RefFinder).take();
 }
 
 } // namespace
 
 std::vector<DocumentHighlight> findDocumentHighlights(ParsedAST &AST,

unittests/clangd/SymbolInfoTests.cpp

std::pair<const char *, std::vector<SymbolDetails>>
         )cpp",
               {CreateExpectedSymbolDetails("foo", "", "c:@S@foo")}},
           {
               R"cpp( // Template parameter reference - type param
           template<class TT> struct bar {
             T^T t;
           };
         )cpp",
-              {/* not implemented */}},
+              {CreateExpectedSymbolDetails("TT", "bar::", "c:TestTU.cpp@65")}},
           {
               R"cpp( // Template parameter reference - type param
           template<int NN> struct bar {
             int a = N^N;
           };
         )cpp",
-              {/* not implemented */}},
+              {CreateExpectedSymbolDetails("NN", "bar::", "c:TestTU.cpp@65")}},
           {
               R"cpp( // Class member reference - objec
           struct foo {
             int aa;
           };
           void bar() {
             foo f;
             f.a^a;

unittests/clangd/XRefsTests.cpp

const char *Tests[] = {
 
       R"cpp(// Typedef
         typedef int $decl[[Foo]];
         int main() {
           ^Foo bar;
         }
       )cpp",
 
-      /* FIXME: clangIndex doesn't handle template type parameters
       R"cpp(// Template type parameter
-        template <[[typename T]]>
+        template <typename [[T]]>
         void foo() { ^T t; }
-      )cpp", */
+      )cpp",
+
+      R"cpp(// Template template type parameter
+        template <template<typename> class [[T]]>
+        void foo() { ^T<int> t; }
+      )cpp",
 
       R"cpp(// Namespace
         namespace $decl[[ns]] {
         struct Foo { static void bar(); }
         } // namespace ns
         int main() { ^ns::Foo::bar(); }
       )cpp",