[Index] Fix reported references in presence of template type aliases

[ilya-biryukov]

Summary

See the added test for an example.

[kadircet]

LGTM, thanks!

clang/lib/Index/IndexTypeSourceInfo.cpp

140

why not merge with next condition?

[ilya-biryukov]

• Address a comment

[ilya-biryukov]

clang/lib/Index/IndexTypeSourceInfo.cpp

140

Thanks!

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

TEST(LocateSymbol, Ambiguous) {
   EXPECT_THAT(locateSymbolAt(AST, T.point("7")), ElementsAre(Sym("abc")));
   EXPECT_THAT(locateSymbolAt(AST, T.point("8")),
               ElementsAre(Sym("Foo"), Sym("abcd")));
   EXPECT_THAT(locateSymbolAt(AST, T.point("9")),
               // First one is class definition, second is the constructor.
               ElementsAre(Sym("Foo"), Sym("Foo")));
 }
 
+TEST(LocateSymbol, TemplateTypedefs) {
+  auto T = Annotations(R"cpp(
+    template <class T> struct function {};
+    template <class T> using callback = function<T()>;
+
+    c^allback<int> foo;
+  )cpp");
+  auto AST = TestTU::withCode(T.code()).build();
+  EXPECT_THAT(locateSymbolAt(AST, T.point()), ElementsAre(Sym("callback")));
+}
+
 TEST(LocateSymbol, RelPathsInCompileCommand) {
   // The source is in "/clangd-test/src".
   // We build in "/clangd-test/build".
 
   Annotations SourceAnnotations(R"cpp(
 #include "header_in_preamble.h"
 int [[foo]];
 #include "header_not_in_preamble.h"

clang/lib/Index/IndexTypeSourceInfo.cpp

#define TRY_TO(CALL_EXPR)                                                      \
   bool VisitObjCObjectTypeLoc(ObjCObjectTypeLoc TL) {
     for (unsigned i = 0, e = TL.getNumProtocols(); i != e; ++i) {
       IndexCtx.handleReference(TL.getProtocol(i), TL.getProtocolLoc(i),
                                Parent, ParentDC, SymbolRoleSet(), Relations);
     }
     return true;
   }
 
-  template<typename TypeLocType>
-  bool HandleTemplateSpecializationTypeLoc(TypeLocType TL) {
-    if (const auto *T = TL.getTypePtr()) {
-      if (CXXRecordDecl *RD = T->getAsCXXRecordDecl()) {
-        if (!RD->isImplicit() || IndexCtx.shouldIndexImplicitInstantiation()) {
-          IndexCtx.handleReference(RD, TL.getTemplateNameLoc(), Parent,
-                                   ParentDC, SymbolRoleSet(), Relations);
-          return true;
-        }
-      }
-      if (const TemplateDecl *D = T->getTemplateName().getAsTemplateDecl())
-        IndexCtx.handleReference(D, TL.getTemplateNameLoc(), Parent, ParentDC,
-                                 SymbolRoleSet(), Relations);
-    }
-    return true;
-  }
+  void HandleTemplateSpecializationTypeLoc(TemplateName TemplName,
+                                           SourceLocation TemplNameLoc,
+                                           CXXRecordDecl *ResolvedClass,
+                                           bool IsTypeAlias) {
+    if (ResolvedClass) {
+      // In presence of type aliases, the resolved class was never written in
+      // the code so don't report it.
+      if (!IsTypeAlias && (!ResolvedClass->isImplicit() ||
+                           IndexCtx.shouldIndexImplicitInstantiation())) {
+        IndexCtx.handleReference(ResolvedClass, TemplNameLoc, Parent, ParentDC,
+                                 SymbolRoleSet(), Relations);
+        return;
+    if (const TemplateDecl *D = TemplName.getAsTemplateDecl())
+      IndexCtx.handleReference(D, TemplNameLoc, Parent, ParentDC,
 
   bool VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc TL) {
-    return HandleTemplateSpecializationTypeLoc(TL);
+    auto *T = TL.getTypePtr();
+    if (!T)
+      return true;
+    HandleTemplateSpecializationTypeLoc(
+        T->getTemplateName(), TL.getTemplateNameLoc(), T->getAsCXXRecordDecl(),
+        T->isTypeAlias());
+    return true;
   }
 
   bool VisitDeducedTemplateSpecializationTypeLoc(DeducedTemplateSpecializationTypeLoc TL) {
-    return HandleTemplateSpecializationTypeLoc(TL);
+    auto *T = TL.getTypePtr();
+    if (!T)
+      return true;
+    HandleTemplateSpecializationTypeLoc(
+        T->getTemplateName(), TL.getTemplateNameLoc(), T->getAsCXXRecordDecl(),
+        /*IsTypeAlias=*/false);
+    return true;
   }
 
   bool VisitDependentNameTypeLoc(DependentNameTypeLoc TL) {
     const DependentNameType *DNT = TL.getTypePtr();
     const NestedNameSpecifier *NNS = DNT->getQualifier();
     const Type *T = NNS->getAsType();
     if (!T)
       return true;