[clang][Index] Enable indexing of Template Type Parameters behind a flag

[kadircet]

Summary

clangd uses indexing api to provide references and it was not possible
to perform symbol information for template parameters. This patch enables
visiting of TemplateTypeParmTypeLocs.

This change also deletes TemplateTemplateParmType from funcitonLocal check.

[ilya-biryukov]

lib/Index/IndexingContext.cpp

51

Do we call handleDecl for template parameters now too?

unittests/Index/IndexTests.cpp

182

could we add a template template parameter into the test too?

[kadircet]

• Fix handling of TemplateTemplateTypeParams

[kadircet]

lib/Index/IndexingContext.cpp

51

No we don't. I believe having the decl itself is not that useful for a template parameter without a reference to it. We only call handlereference.

[ilya-biryukov]

include/clang/Index/IndexingAction.h

49

NIT: maybe rename to IndexTemplateParameters? The ParmDecl is a somewhat weird name that does not add much clarity.

lib/Index/IndexingContext.cpp

51

I'm probably call both just for the sake of symmetry.
How does IndexParametersInDeclarations behaves? When set to true will it call both handleDecl and handleReference?
I'd argue we should do the same for template parameters.

[kadircet]

• Change options name
• Also index decls

lib/Index/IndexingContext.cpp

51

yes it calls both, OK than adding also the handleDecl

[ilya-biryukov]

LGTM, but see the comment about avoiding code duplication

lib/Index/IndexDecl.cpp

680

Maybe do it once on top of TP to avoid code duplication?

[kadircet]

• Move handleDecl call to top of the loop

[kadircet]

• Rebase

include/clang/Index/IndexingAction.h

struct IndexingOptions {
   bool IndexFunctionLocals = false;
   bool IndexImplicitInstantiation = false;
   // Whether to index macro definitions in the Preprocesor when preprocessor
   // callback is not available (e.g. after parsing has finished). Note that
   // macro references are not available in Proprocessor.
   bool IndexMacrosInPreprocessor = false;
   // Has no effect if IndexFunctionLocals are false.
   bool IndexParametersInDeclarations = false;
+  bool IndexTemplateParameters = false;
 };
 
 /// Creates a frontend action that indexes all symbols (macros and AST decls).
 /// \param WrappedAction another frontend action to wrap over or null.
 std::unique_ptr<FrontendAction>
 createIndexingAction(std::shared_ptr<IndexDataConsumer> DataConsumer,
                      IndexingOptions Opts,
                      std::unique_ptr<FrontendAction> WrappedAction);

lib/Index/IndexDecl.cpp

bool VisitTemplateDecl(const TemplateDecl *D) {
     if (!Parent)
       return true;
 
     // Index the default values for the template parameters.
     if (D->getTemplateParameters() &&
         shouldIndexTemplateParameterDefaultValue(Parent)) {
       const TemplateParameterList *Params = D->getTemplateParameters();
       for (const NamedDecl *TP : *Params) {
+        if (IndexCtx.shouldIndexTemplateParameters())
+          IndexCtx.handleDecl(TP);
         if (const auto *TTP = dyn_cast<TemplateTypeParmDecl>(TP)) {
           if (TTP->hasDefaultArgument())
             IndexCtx.indexTypeSourceInfo(TTP->getDefaultArgumentInfo(), Parent);
         } else if (const auto *NTTP = dyn_cast<NonTypeTemplateParmDecl>(TP)) {
           if (NTTP->hasDefaultArgument())
             IndexCtx.indexBody(NTTP->getDefaultArgument(), Parent);
         } else if (const auto *TTPD = dyn_cast<TemplateTemplateParmDecl>(TP)) {
           if (TTPD->hasDefaultArgument())
             handleTemplateArgumentLoc(TTPD->getDefaultArgument(), Parent,
                                       TP->getLexicalDeclContext());
         }
       }

lib/Index/IndexSymbol.cpp

 }
 
 bool index::isFunctionLocalSymbol(const Decl *D) {
   assert(D);
 
   if (isa<ParmVarDecl>(D))
     return true;
 
-  if (isa<TemplateTemplateParmDecl>(D))
-    return true;
-
   if (isa<ObjCTypeParamDecl>(D))
     return true;
 
   if (isa<UsingDirectiveDecl>(D))
     return false;
   if (!D->getParentFunctionOrMethod())
     return false;
 

lib/Index/IndexTypeSourceInfo.cpp

public:
   bool shouldWalkTypesOfTypeLocs() const { return false; }
 
 #define TRY_TO(CALL_EXPR)                                                      \
   do {                                                                         \
     if (!CALL_EXPR)                                                            \
       return false;                                                            \
   } while (0)
 
+  bool VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc TTPL) {
+    SourceLocation Loc = TTPL.getNameLoc();
+    TemplateTypeParmDecl *TTPD = TTPL.getDecl();
+    return IndexCtx.handleReference(TTPD, Loc, Parent, ParentDC,
+                                    SymbolRoleSet());
+  }
+
   bool VisitTypedefTypeLoc(TypedefTypeLoc TL) {
     SourceLocation Loc = TL.getNameLoc();
     TypedefNameDecl *ND = TL.getTypedefNameDecl();
     if (ND->isTransparentTag()) {
       TagDecl *Underlying = ND->getUnderlyingType()->getAsTagDecl();
       return IndexCtx.handleReference(Underlying, Loc, Parent,
                                       ParentDC, SymbolRoleSet(), Relations);
     }

lib/Index/IndexingContext.h

public:
   }
 
   bool shouldIndexFunctionLocalSymbols() const;
 
   bool shouldIndexImplicitInstantiation() const;
 
   bool shouldIndexParametersInDeclarations() const;
 
+  bool shouldIndexTemplateParameters() const;
+
   static bool isTemplateImplicitInstantiation(const Decl *D);
 
   bool handleDecl(const Decl *D, SymbolRoleSet Roles = SymbolRoleSet(),
                   ArrayRef<SymbolRelation> Relations = None);
 
   bool handleDecl(const Decl *D, SourceLocation Loc,
                   SymbolRoleSet Roles = SymbolRoleSet(),
                   ArrayRef<SymbolRelation> Relations = None,

lib/Index/IndexingContext.cpp

 bool IndexingContext::shouldIndexImplicitInstantiation() const {
   return IndexOpts.IndexImplicitInstantiation;
 }
 
 bool IndexingContext::shouldIndexParametersInDeclarations() const {
   return IndexOpts.IndexParametersInDeclarations;
 }
 
+bool IndexingContext::shouldIndexTemplateParameters() const {
+  return IndexOpts.IndexTemplateParameters;
+}
+
 bool IndexingContext::handleDecl(const Decl *D,
                                  SymbolRoleSet Roles,
                                  ArrayRef<SymbolRelation> Relations) {
   return handleDecl(D, D->getLocation(), Roles, Relations);
 }
 
 bool IndexingContext::handleDecl(const Decl *D, SourceLocation Loc,
                                  SymbolRoleSet Roles,
                                  ArrayRef<SymbolRelation> Relations,
bool IndexingContext::handleReference(const NamedDecl *D, SourceLocation Loc,
                                       const DeclContext *DC,
                                       SymbolRoleSet Roles,
                                       ArrayRef<SymbolRelation> Relations,
                                       const Expr *RefE,
                                       const Decl *RefD) {
   if (!shouldIndexFunctionLocalSymbols() && isFunctionLocalSymbol(D))
     return true;
 
-  if (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D))
+  if (!shouldIndexTemplateParameters() &&
+      (isa<NonTypeTemplateParmDecl>(D) || isa<TemplateTypeParmDecl>(D) ||
+       isa<TemplateTemplateParmDecl>(D))) {
     return true;
+  }
 
   return handleDeclOccurrence(D, Loc, /*IsRef=*/true, Parent, Roles, Relations,
                               RefE, RefD, DC);
 }
 
 static void reportModuleReferences(const Module *Mod,
                                    ArrayRef<SourceLocation> IdLocs,
                                    const ImportDecl *ImportD,

unittests/Index/IndexTests.cpp

TEST(IndexTest, IndexParametersInDecls) {
   Index->Symbols.clear();
   tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols, Not(Contains(QName("bar"))));
 }
 
 TEST(IndexTest, IndexExplicitTemplateInstantiation) {
   std::string Code = R"cpp(
     template <typename T>
     struct Foo { void bar() {} };
     template <>
     struct Foo<int> { void bar() {} };
     void foo() {
       Foo<char> abc;
       Foo<int> b;
     }
   )cpp";
   auto Index = std::make_shared<Indexer>();
TEST(IndexTest, IndexTemplateInstantiationPartial) {
   auto Index = std::make_shared<Indexer>();
   IndexingOptions Opts;
   tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
   EXPECT_THAT(Index->Symbols,
               Contains(AllOf(QName("Foo"), WrittenAt(Position(8, 7)),
                              DeclAt(Position(5, 12)))));
 }
 
+TEST(IndexTest, IndexTypeParmDecls) {
+  std::string Code = R"cpp(
+    template <typename T, int I, template<typename> class C, typename NoRef>
+    struct Foo {
+      T t = I;
+      C<int> x;
+    };
+  )cpp";
+  auto Index = std::make_shared<Indexer>();
+  IndexingOptions Opts;
+  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  EXPECT_THAT(Index->Symbols, AllOf(Not(Contains(QName("Foo::T"))),
+                                    Not(Contains(QName("Foo::I"))),
+                                    Not(Contains(QName("Foo::C"))),
+                                    Not(Contains(QName("Foo::NoRef")))));
+
+  Opts.IndexTemplateParameters = true;
+  Index->Symbols.clear();
+  tooling::runToolOnCode(new IndexAction(Index, Opts), Code);
+  EXPECT_THAT(Index->Symbols,
+              AllOf(Contains(QName("Foo::T")), Contains(QName("Foo::I")),
+                    Contains(QName("Foo::C")), Contains(QName("Foo::NoRef"))));
+}
+
 } // namespace
 } // namespace index
 } // namespace clang