[clangd] Fix template type aliases in findExplicitReference

[kadircet]

clang-tools-extra/clangd/FindTarget.cpp

478 ↗

(On Diff #222104)

can you explain why these two are special and get to keep Alias decls? Whereas the others dont?

[ilya-biryukov]

clang-tools-extra/clangd/FindTarget.cpp

478 ↗

(On Diff #222104)

There are two cases to consider for a reference of the form Templ<int> in type positions:

1. Templ is a template type alias

template <class X>
Templ = vector<X>;

in this case targetDecl returns Templ with mask Alias | TemplatePattern and vector<int> with mask Underlying
since we are interested in the thing explicitly written in the source code, we want Templ and not vector.

2. Templ is a name of some template type (a class or template template parameter)

in this case targetDecl returns Templ with mask TemplatePattern and that's what we want to return, since this is what was written in the source code.

So in both cases the important thing is to not filter-out the result with mask Alias. This is exactly what this patch does.

[kadircet]

LGTM.

clang-tools-extra/clangd/FindTarget.cpp

478 ↗

(On Diff #222104)

thanks! I was rather asking for comments in the code though :D

Please also mention them in comments.

[ilya-biryukov]

• Add a comment

clang-tools-extra/trunk/clangd/FindTarget.cpp

void VisitElaboratedTypeLoc(ElaboratedTypeLoc L) {
       Visit(L.getNamedTypeLoc().getUnqualifiedLoc());
       // Fill in the qualifier.
       if (!Ref)
         return;
       assert(!Ref->Qualifier.hasQualifier() && "qualifier already set");
       Ref->Qualifier = L.getQualifierLoc();
     }
 
-    void VisitDeducedTemplateSpecializationTypeLoc(
-        DeducedTemplateSpecializationTypeLoc L) {
-      Ref = ReferenceLoc{
-          NestedNameSpecifierLoc(), L.getNameLoc(),
-          explicitReferenceTargets(DynTypedNode::create(L.getType()))};
-    }
-
     void VisitTagTypeLoc(TagTypeLoc L) {
       Ref =
           ReferenceLoc{NestedNameSpecifierLoc(), L.getNameLoc(), {L.getDecl()}};
     }
 
     void VisitTemplateTypeParmTypeLoc(TemplateTypeParmTypeLoc L) {
       Ref =
           ReferenceLoc{NestedNameSpecifierLoc(), L.getNameLoc(), {L.getDecl()}};
     }
 
     void VisitTemplateSpecializationTypeLoc(TemplateSpecializationTypeLoc L) {
+      // We must ensure template type aliases are included in results if they
+      // were written in the source code, e.g. in
+      //    template <class T> using valias = vector<T>;
+      //    ^valias<int> x;
+      // 'explicitReferenceTargets' will return:
+      //    1. valias with mask 'Alias'.
+      //    2. 'vector<int>' with mask 'Underlying'.
+      //  we want to return only #1 in this case.
       Ref = ReferenceLoc{
           NestedNameSpecifierLoc(), L.getTemplateNameLoc(),
-          explicitReferenceTargets(DynTypedNode::create(L.getType()))};
+          explicitReferenceTargets(DynTypedNode::create(L.getType()),
+                                   DeclRelation::Alias)};
+    }
+    void VisitDeducedTemplateSpecializationTypeLoc(
+        DeducedTemplateSpecializationTypeLoc L) {
+      Ref = ReferenceLoc{
+          NestedNameSpecifierLoc(), L.getNameLoc(),
+          explicitReferenceTargets(DynTypedNode::create(L.getType()),
+                                   DeclRelation::Alias)};
     }
 
     void VisitDependentTemplateSpecializationTypeLoc(
         DependentTemplateSpecializationTypeLoc L) {
       Ref = ReferenceLoc{
           L.getQualifierLoc(), L.getTemplateNameLoc(),
           explicitReferenceTargets(DynTypedNode::create(L.getType()))};
     }

clang-tools-extra/trunk/clangd/unittests/FindTargetTests.cpp

std::pair</*Code*/ llvm::StringRef, /*References*/ llvm::StringRef> Cases[] =
           template <> struct vector<bool> { using value_type = bool; };
           void foo() {
             $0^vector<int> vi;
             $1^vector<bool> vb;
           }
         )cpp",
            "0: targets = {vector<int>}\n"
            "1: targets = {vector<bool>}\n"},
-          // FIXME: Fix 'allTargetDecls' to return alias template and re-enable.
           // Template type aliases.
-          //   {R"cpp(
-          //   template <class T> struct vector { using value_type = T; };
-          //   template <> struct vector<bool> { using value_type = bool; };
-          //   template <class T> using valias = vector<T>;
-          //   void foo() {
-          //     $0^valias<int> vi;
-          //     $1^valias<bool> vb;
-          //   }
-          // )cpp",
-          //    "0: targets = {valias}\n"
-          //    "1: targets = {valias}\n"},
-
+          {R"cpp(
+            template <class T> struct vector { using value_type = T; };
+            template <> struct vector<bool> { using value_type = bool; };
+            template <class T> using valias = vector<T>;
+            void foo() {
+              $0^valias<int> vi;
+              $1^valias<bool> vb;
+            }
+          )cpp",
+           "0: targets = {valias}\n"
+           "1: targets = {valias}\n"},
           // MemberExpr should know their using declaration.
           {R"cpp(
             struct X { void func(int); }
             struct Y : X {
               using X::func;
             };
             void foo(Y y) {
               $0^y.$1^func(1);