[clangd] Fix hover 'local scope' to include class template params

[sammccall]

Summary

Fixes the last part of https://github.com/clangd/clangd/issues/76

[merge_guards_bot]

Build result: fail - 60138 tests passed, 2 failed and 729 were skipped.

failed: LLVM.CodeGen/NVPTX/vectorize-misaligned.ll
failed: LLVM.Transforms/LoadStoreVectorizer/AMDGPU/merge-stores.ll

Log files: console-log.txt, CMakeCache.txt

[kadircet]

LGTM, with a question. What about default template params? I believe we would also like to print them, could you add a test case for that?

[sammccall]

In D70325#1749432, @kadircet wrote:

LGTM, with a question. What about default template params? I believe we would also like to print them, could you add a test case for that?

They're not printed, as the type is "as written". Added a testcase and a FIXME.
(I don't think this case is terribly important - either behavior seems to have its advantages, the combination of default parameters and partial specialization is fairly rare, and not much confusion seems likely in practice)

[sammccall]

add fixme

[kadircet]

thanks! but again it looks as if rebasing went wrong :/

[sammccall]

Sorry about the bad rebase, I landed the right version i think :-)

In D70325#1750496, @sammccall wrote:

In D70325#1749432, @kadircet wrote:

LGTM, with a question. What about default template params? I believe we would also like to print them, could you add a test case for that?

They're not printed, as the type is "as written". Added a testcase and a FIXME.
(I don't think this case is terribly important - either behavior seems to have its advantages, the combination of default parameters and partial specialization is fairly rare, and not much confusion seems likely in practice)

Forgot to mention, I didn't fix this because it's significantly more work: for Type you have access to the canonical args (with defaults, but with type-parameter-0-0 instead of T), and the as-written args (where defaults are omitted).
I think you have to trawl around special casing various Decls if you want this to work. I wanted to get the cheap improvement in because realistically I won't get to that refinement soon.

clang-tools-extra/clangd/XRefs.cpp

 }
 
 /// Given a declaration \p D, return a human-readable string representing the
 /// local scope in which it is declared, i.e. class(es) and method name. Returns
 /// an empty string if it is not local.
 static std::string getLocalScope(const Decl *D) {
   std::vector<std::string> Scopes;
   const DeclContext *DC = D->getDeclContext();
-  auto GetName = [](const Decl *D) {
-    const NamedDecl *ND = dyn_cast<NamedDecl>(D);
-    std::string Name = ND->getNameAsString();
-    // FIXME(sammccall): include template params/specialization args?.
-    if (!Name.empty())
-      return Name;
+  auto GetName = [](const TypeDecl *D) {
+    if (!D->getDeclName().isEmpty()) {
+      PrintingPolicy Policy = D->getASTContext().getPrintingPolicy();
+      Policy.SuppressScope = true;
+      return declaredType(D).getAsString(Policy);
+    }
     if (auto RD = dyn_cast<RecordDecl>(D))
       return ("(anonymous " + RD->getKindName() + ")").str();
     return std::string("");
   };
   while (DC) {
     if (const TypeDecl *TD = dyn_cast<TypeDecl>(DC))
       Scopes.push_back(GetName(TD));
     else if (const FunctionDecl *FD = dyn_cast<FunctionDecl>(DC))

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

void foo())cpp";
        [](HoverInfo &HI) {
          HI.Name = "X<T *>";
          HI.NamespaceScope = "";
          HI.Kind = SymbolKind::Class;
          HI.Definition = "template <typename T> class X<T *> {}";
        }},
       // Constructor of partially-specialized class template
       {R"cpp(
-          template<typename> struct X;
+          template<typename, typename=void> struct X;
           template<typename T> struct X<T*>{ [[^X]](); };
           )cpp",
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.Name = "X";
-         HI.LocalScope = "X::";        // FIXME: Should be X<T *>::
+         HI.LocalScope = "X<T *>::"; // FIXME: X<T *, void>::
          HI.Kind = SymbolKind::Constructor;
          HI.ReturnType = "X<T *>";
          HI.Definition = "X()";
          HI.Parameters.emplace();
        }},
       {"class X { [[^~]]X(); };", // FIXME: Should be [[~X]]()
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
void foo())cpp";
          HI.Name = "GREEN";
          HI.NamespaceScope = "";
          HI.LocalScope = "Color::";
          HI.Definition = "GREEN";
          HI.Kind = SymbolKind::EnumMember;
          HI.Type = "enum Color";
          HI.Value = "1";
        }},
-      // FIXME: We should use the Decl referenced, even if it comes from an
-      // implicit instantiation.
+      // FIXME: We should use the Decl referenced, even if from an implicit
+      // instantiation. Then the scope would be Add<1, 2> and the value 3.
       {R"cpp(
         template<int a, int b> struct Add {
           static constexpr int result = a + b;
         };
         int bar = Add<1, 2>::[[resu^lt]];
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "result";
          HI.Definition = "static constexpr int result = a + b";
          HI.Kind = SymbolKind::Property;
          HI.Type = "const int";
          HI.NamespaceScope = "";
-         HI.LocalScope = "Add::";
+         HI.LocalScope = "Add<a, b>::";
        }},
       {R"cpp(
         const char *[[ba^r]] = "1234";
         )cpp",
        [](HoverInfo &HI) {
          HI.Name = "bar";
          HI.Definition = "const char *bar = \"1234\"";
          HI.Kind = SymbolKind::Variable;