[clangd] Have template template arguments target their referenced template decl

[nridge]

Summary

As part of this change, DynTypedNode is enhanced to allow
storing a TemplateArgumentLoc.

Fixes https://github.com/clangd/clangd/issues/473

[hokein]

The code looks good.

I think we'd better to have some sort of tests in clang (rather than relying on clangd test). It seems that the only way to test it in clang is through ASTMatcher. Do you mind adding a templateArgumentLoc matcher as well? and add a test in unittests/ASTMatchers/ASTMatchersTraversalTest.cpp.
With that, I think it would be nice to have two patches, one for clang, the other is for clangd.

[nridge]

Address review comments

[nridge]

I've added the matcher and split the clang parts into D85621

[hokein]

clang-tools-extra/clangd/Selection.cpp

482

can we add a test for the Selection?

[nridge]

Add Selection test

Also simplify the FindTarget test case a bit

clang-tools-extra/clangd/FindTarget.cpp

void add(const CXXCtorInitializer *CCI, RelSet Flags) {
     if (!CCI)
       return;
     debug(*CCI, Flags);
 
     if (CCI->isAnyMemberInitializer())
       add(CCI->getAnyMember(), Flags);
     // Constructor calls contain a TypeLoc node, so we don't handle them here.
   }
+
+  void add(const TemplateArgument &Arg, RelSet Flags) {
+    // Only used for template template arguments.
+    // For type and non-type template arguments, SelectionTree
+    // will hit a more specific node (e.g. a TypeLoc or a
+    // DeclRefExpr).
+    if (Arg.getKind() == TemplateArgument::Template ||
+        Arg.getKind() == TemplateArgument::TemplateExpansion) {
+      if (TemplateDecl *TD = Arg.getAsTemplate().getAsTemplateDecl()) {
+        report(TD, Flags);
+      }
+    }
+  }
 };
 
 } // namespace
 
 llvm::SmallVector<std::pair<const NamedDecl *, DeclRelationSet>, 1>
 allTargetDecls(const ast_type_traits::DynTypedNode &N) {
   dlog("allTargetDecls({0})", nodeToString(N));
   TargetFinder Finder;
   DeclRelationSet Flags;
   if (const Decl *D = N.get<Decl>())
     Finder.add(D, Flags);
   else if (const Stmt *S = N.get<Stmt>())
     Finder.add(S, Flags);
   else if (const NestedNameSpecifierLoc *NNSL = N.get<NestedNameSpecifierLoc>())
     Finder.add(NNSL->getNestedNameSpecifier(), Flags);
   else if (const NestedNameSpecifier *NNS = N.get<NestedNameSpecifier>())
     Finder.add(NNS, Flags);
   else if (const TypeLoc *TL = N.get<TypeLoc>())
     Finder.add(TL->getType(), Flags);
   else if (const QualType *QT = N.get<QualType>())
     Finder.add(*QT, Flags);
   else if (const CXXCtorInitializer *CCI = N.get<CXXCtorInitializer>())
     Finder.add(CCI, Flags);
+  else if (const TemplateArgumentLoc *TAL = N.get<TemplateArgumentLoc>())
+    Finder.add(TAL->getArgument(), Flags);
 
   return Finder.takeDecls();
 }
 
 llvm::SmallVector<const NamedDecl *, 1>
 targetDecl(const ast_type_traits::DynTypedNode &N, DeclRelationSet Mask) {
   llvm::SmallVector<const NamedDecl *, 1> Result;
   for (const auto &Entry : allTargetDecls(N)) {

clang-tools-extra/clangd/Selection.cpp

bool TraverseDecl(Decl *X) {
     // Base::TraverseDecl will suppress children, but not this node itself.
     if (X && X->isImplicit())
       return true;
     return traverseNode(X, [&] { return Base::TraverseDecl(X); });
   }
   bool TraverseTypeLoc(TypeLoc X) {
     return traverseNode(&X, [&] { return Base::TraverseTypeLoc(X); });
   }
+  bool TraverseTemplateArgumentLoc(const TemplateArgumentLoc &X) {
+    return traverseNode(&X,
+                        [&] { return Base::TraverseTemplateArgumentLoc(X); });
+  }
   bool TraverseNestedNameSpecifierLoc(NestedNameSpecifierLoc X) {
     return traverseNode(
         &X, [&] { return Base::TraverseNestedNameSpecifierLoc(X); });
   }
   bool TraverseConstructorInitializer(CXXCtorInitializer *X) {
     return traverseNode(
         X, [&] { return Base::TraverseConstructorInitializer(X); });
   }

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

Code = R"cpp(
     template<typename T> class Foo{};
     template<typename T> class Foo<T*>{};
     [[Foo<int*>]] B;
   )cpp";
   EXPECT_DECLS("TemplateSpecializationTypeLoc",
                {"template<> class Foo<int *>", Rel::TemplateInstantiation},
                {"template <typename T> class Foo<T *>", Rel::TemplatePattern});
 
+  Code = R"cpp(
+    // Template template argument.
+    template<typename T> struct Vector {};
+    template <template <typename> class Container>
+    struct A {};
+    A<[[Vector]]> a;
+  )cpp";
+  EXPECT_DECLS("TemplateArgumentLoc", {"template <typename T> struct Vector"});
+
   Flags.push_back("-std=c++17"); // for CTAD tests
 
   Code = R"cpp(
     // Class template argument deduction
     template <typename T>
     struct Test {
       Test(T);
     };

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

Case Cases[] = {
 
       {R"cpp(
         struct S1 { void f(); };
         struct S2 { S1 * operator->(); };
         void test(S2 s2) {
           s2[[-^>]]f();
         }
       )cpp",
-       "DeclRefExpr"} // DeclRefExpr to the "operator->" method.
-  };
+       "DeclRefExpr"}, // DeclRefExpr to the "operator->" method.
+
+      // Template template argument.
+      {R"cpp(
+        template <typename> class Vector {};
+        template <template <typename> class Container> class A {};
+        A<[[V^ector]]> a;
+      )cpp",
+       "TemplateArgumentLoc"}};
+
   for (const Case &C : Cases) {
     trace::TestTracer Tracer;
     Annotations Test(C.Code);
 
     TestTU TU;
     TU.Code = std::string(Test.code());
 
     // FIXME: Auto-completion in a template requires disabling delayed template