[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/AST.h

 bool isExplicitTemplateSpecialization(const NamedDecl *D);
 
 /// Returns a nested name specifier loc of \p ND if it was present in the
 /// source, e.g.
 ///     void ns::something::foo() -> returns 'ns::something'
 ///     void foo() -> returns null
 NestedNameSpecifierLoc getQualifierLoc(const NamedDecl &ND);
 
+// Returns a type corresponding to a declaration of that type.
+// Unlike the method on ASTContext, attempts to preserve the type as-written
+// (i.e. vector<T*> rather than vector<type-parameter-0-0 *>.
+QualType declaredType(const TypeDecl *D);
+
 } // namespace clangd
 } // namespace clang
 
 #endif // LLVM_CLANG_TOOLS_EXTRA_CLANGD_AST_H_

clang-tools-extra/clangd/AST.cpp

std::string printType(const QualType QT, const DeclContext & Context){
   PrintingPolicy PP(Context.getParentASTContext().getPrintingPolicy());
   PP.SuppressUnwrittenScope = 1;
   PP.SuppressTagKeyword = 1;
   return shortenNamespace(
       QT.getAsString(PP),
       printNamespaceScope(Context) );
 }
 
+QualType declaredType(const TypeDecl *D) {
+  if (const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(D))
+    if (const auto *TSI = CTSD->getTypeAsWritten())
+      return TSI->getType();
+  return D->getASTContext().getTypeDeclType(D);
+}
 
 } // namespace clangd
 } // namespace clang

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))
static void enhanceFromIndex(HoverInfo &Hover, const Decl *D,
   if (!ID)
     return;
   LookupRequest Req;
   Req.IDs.insert(*ID);
   Index->lookup(
       Req, [&](const Symbol &S) { Hover.Documentation = S.Documentation; });
 }
 
+// Populates Type, ReturnType, and Parameters for function-like decls.
+static void fillFunctionTypeAndParams(HoverInfo &HI, const Decl *D,
+                                      const FunctionDecl *FD,
+                                      const PrintingPolicy &Policy) {
+  HI.Parameters.emplace();
+  for (const ParmVarDecl *PVD : FD->parameters()) {
+    HI.Parameters->emplace_back();
+    auto &P = HI.Parameters->back();
+    if (!PVD->getType().isNull()) {
+      P.Type.emplace();
+      llvm::raw_string_ostream OS(*P.Type);
+      PVD->getType().print(OS, Policy);
+    } else {
+      std::string Param;
+      llvm::raw_string_ostream OS(Param);
+      PVD->dump(OS);
+      OS.flush();
+      elog("Got param with null type: {0}", Param);
+    }
+    if (!PVD->getName().empty())
+      P.Name = PVD->getNameAsString();
+    if (PVD->hasDefaultArg()) {
+      P.Default.emplace();
+      llvm::raw_string_ostream Out(*P.Default);
+      PVD->getDefaultArg()->printPretty(Out, nullptr, Policy);
+    }
+  }
+
+  if (const auto* CCD = llvm::dyn_cast<CXXConstructorDecl>(FD)) {
+    // Constructor's "return type" is the class type.
+    HI.ReturnType = declaredType(CCD->getParent()).getAsString(Policy);
+    // Don't provide any type for the constructor itself.
+  } else if (const auto* CDD = llvm::dyn_cast<CXXDestructorDecl>(FD)){
+    HI.ReturnType = "void";
+  } else {
+    HI.ReturnType = FD->getReturnType().getAsString(Policy);
+
+    QualType FunctionType = FD->getType();
+    if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D)) // Lambdas
+      FunctionType = VD->getType().getDesugaredType(D->getASTContext());
+    HI.Type = FunctionType.getAsString(Policy);
+  }
+  // FIXME: handle variadics.
+}
+
 /// Generate a \p Hover object given the declaration \p D.
 static HoverInfo getHoverContents(const Decl *D, const SymbolIndex *Index) {
   HoverInfo HI;
   const ASTContext &Ctx = D->getASTContext();
 
   HI.NamespaceScope = getNamespaceScope(D);
   if (!HI.NamespaceScope->empty())
     HI.NamespaceScope->append("::");
if (const auto FTD = FD->getDescribedTemplate()) {
       HI.TemplateParameters =
           fetchTemplateParameters(FTD->getTemplateParameters(), Policy);
       D = FTD;
     }
   }
 
   // Fill in types and params.
   if (const FunctionDecl *FD = getUnderlyingFunction(D)) {
-    HI.ReturnType.emplace();
-    {
-      llvm::raw_string_ostream OS(*HI.ReturnType);
-      FD->getReturnType().print(OS, Policy);
-    }
-
-    HI.Parameters.emplace();
-    for (const ParmVarDecl *PVD : FD->parameters()) {
-      HI.Parameters->emplace_back();
-      auto &P = HI.Parameters->back();
-      if (!PVD->getType().isNull()) {
-        P.Type.emplace();
-        llvm::raw_string_ostream OS(*P.Type);
-        PVD->getType().print(OS, Policy);
-      } else {
-        std::string Param;
-        llvm::raw_string_ostream OS(Param);
-        PVD->dump(OS);
-        OS.flush();
-        elog("Got param with null type: {0}", Param);
-      }
-      if (!PVD->getName().empty())
-        P.Name = PVD->getNameAsString();
-      if (PVD->hasDefaultArg()) {
-        P.Default.emplace();
-        llvm::raw_string_ostream Out(*P.Default);
-        PVD->getDefaultArg()->printPretty(Out, nullptr, Policy);
-      }
-    }
-
-    HI.Type.emplace();
-    llvm::raw_string_ostream TypeOS(*HI.Type);
-    // Lambdas
-    if (const VarDecl *VD = llvm::dyn_cast<VarDecl>(D))
-      VD->getType().getDesugaredType(D->getASTContext()).print(TypeOS, Policy);
-    // Functions
-    else
-      FD->getType().print(TypeOS, Policy);
-    // FIXME: handle variadics.
+    fillFunctionTypeAndParams(HI, D, FD, Policy);
   } else if (const auto *VD = dyn_cast<ValueDecl>(D)) {
     HI.Type.emplace();
     llvm::raw_string_ostream OS(*HI.Type);
     VD->getType().print(OS, Policy);
   }
 
   // Fill in value with evaluated initializer if possible.
   // FIXME(kadircet): Also set Value field for expressions like "sizeof" and

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.Type = "void ()";          // FIXME: Should be None
-         HI.ReturnType = "void";       // FIXME: Should be None or X<T*>
+         HI.ReturnType = "X<T *>";
          HI.Definition = "X()";
          HI.Parameters.emplace();
        }},
 
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
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;