fix: Emit refs for various kinds of templates in using decls (#306)

Author: varungandhi-src

indexer/ClangAstMacros.h

@@ -3,6 +3,7 @@
 
 #define FOR_EACH_DECL_TO_BE_INDEXED(F) \
   F(Binding)                           \
+  F(ClassTemplate)                     \
   F(EnumConstant)                      \
   F(Enum)                              \
   F(Field)                             \
@@ -13,10 +14,12 @@
   F(Record)                            \
   F(TemplateTemplateParm)              \
   F(TemplateTypeParm)                  \
+  F(TypeAliasTemplate)                 \
   F(TypedefName)                       \
   F(UsingShadow)                       \
   F(Using)                             \
-  F(Var)
+  F(Var)                               \
+  F(VarTemplate)
 
 #define FOR_EACH_TEMPLATE_PARM_TO_BE_INDEXED(F) \
   F(NonTypeTemplateParm)                        \

indexer/Indexer.cc

@@ -368,6 +368,10 @@ void TuIndexer::saveBindingDecl(const clang::BindingDecl &bindingDecl) {
                        std::nullopt);
 }
 
+void TuIndexer::saveClassTemplateDecl(const clang::ClassTemplateDecl &) {
+  // We'll emit a def for the inner RecordDecl, so don't do anything here
+}
+
 void TuIndexer::saveEnumConstantDecl(
     const clang::EnumConstantDecl &enumConstantDecl) {
   auto optSymbol =
@@ -695,17 +699,30 @@ void TuIndexer::saveTemplateSpecializationTypeLoc(
     }
     break;
   }
+  case Kind::UsingTemplate: {
+    auto *usingShadowDecl = templateName.getAsUsingShadowDecl();
+    if (auto optSymbol =
+            this->symbolFormatter.getUsingShadowSymbol(*usingShadowDecl)) {
+      this->saveReference(*optSymbol,
+                          templateSpecializationTypeLoc.getTemplateNameLoc());
+    }
+    break;
+  }
   case Kind::OverloadedTemplate:
   case Kind::AssumedTemplate:
   case Kind::QualifiedTemplate:
   case Kind::DependentTemplate:
   case Kind::SubstTemplateTemplateParm:
   case Kind::SubstTemplateTemplateParmPack:
-  case Kind::UsingTemplate:
     break;
   }
 }
 
+void TuIndexer::saveTypeAliasTemplateDecl(
+    const clang::TypeAliasTemplateDecl &) {
+  // We'll emit a def for the inner TypeAliasDecl, so don't do anything here
+}
+
 void TuIndexer::saveTypedefNameDecl(
     const clang::TypedefNameDecl &typedefNameDecl) {
   auto optSymbol = this->symbolFormatter.getNamedDeclSymbol(typedefNameDecl);
@@ -774,6 +791,10 @@ void TuIndexer::saveVarDecl(const clang::VarDecl &varDecl) {
   }
 }
 
+void TuIndexer::saveVarTemplateDecl(const clang::VarTemplateDecl &) {
+  // Skip emitting a definition here, as we'll emit one for the inner VarDecl.
+}
+
 void TuIndexer::saveCXXConstructExpr(
     const clang::CXXConstructExpr &cxxConstructExpr) {
   if (auto *cxxConstructorDecl = cxxConstructExpr.getConstructor()) {

indexer/SymbolFormatter.cc

@@ -359,6 +359,16 @@ SymbolFormatter::getBindingSymbol(const clang::BindingDecl &bindingDecl) {
   return this->getNextLocalSymbol(bindingDecl);
 }
 
+std::optional<std::string_view> SymbolFormatter::getClassTemplateSymbol(
+    const clang::ClassTemplateDecl &classTemplateDecl) {
+  return this->getRecordSymbol(*classTemplateDecl.getTemplatedDecl());
+}
+
+std::optional<std::string_view> SymbolFormatter::getTypeAliasTemplateSymbol(
+    const clang::TypeAliasTemplateDecl &typeAliasTemplateDecl) {
+  return this->getTypedefNameSymbol(*typeAliasTemplateDecl.getTemplatedDecl());
+}
+
 std::optional<std::string_view>
 SymbolFormatter::getNextLocalSymbol(const clang::NamedDecl &decl) {
   if (decl.getDeclName().isEmpty()) {
@@ -663,6 +673,11 @@ SymbolFormatter::getVarSymbol(const clang::VarDecl &varDecl) {
   });
 }
 
+std::optional<std::string_view> SymbolFormatter::getVarTemplateSymbol(
+    const clang::VarTemplateDecl &varTemplateDecl) {
+  return this->getVarSymbol(*varTemplateDecl.getTemplatedDecl());
+}
+
 std::string_view
 SymbolFormatter::formatTemporary(const clang::NamedDecl &namedDecl) {
   this->scratchBuffer.clear();

test/index/aliases/aliases.snapshot.cc

@@ -221,19 +221,24 @@
     using k::S;
 //        ^ reference [..] i/k/
 //           ^ definition [..] i/S#
+//           ^ reference [..] i/k/S#
     using SS = S<int>;
 //        ^^ definition [..] i/SS#
+//             ^ reference [..] i/S#
 
     using j::zero;
 //        ^ reference [..] i/j/
 //           ^^^^ definition [..] i/zero.
+//           ^^^^ reference [..] i/j/zero.
     static int zero_int = zero<int>;
 //             ^^^^^^^^ definition [..] i/zero_int.
 //                        ^^^^ reference [..] i/j/zero.
 
     using k::SAlias;
 //        ^ reference [..] i/k/
 //           ^^^^^^ definition [..] i/SAlias#
+//           ^^^^^^ reference [..] i/k/SAlias#
     using SAliasInt = SAlias<int>;
 //        ^^^^^^^^^ definition [..] i/SAliasInt#
+//                    ^^^^^^ reference [..] i/SAlias#
   }