[clangd] Improve hover for auto on template instantiations

[kadircet]

Summary

Follow-up to D71543

[merge_guards_bot]

Unit tests: pass. 60957 tests passed, 0 failed and 726 were skipped.

clang-format: pass.

Build artifacts: diff.json, CMakeCache.txt, console-log.txt, test-results.xml

[ilya-biryukov]

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

556

NIT: Maybe remove default argument from this test for now and file a bug for fixing this instead?
Tracking this in the issue tracker seems to be better than in code.

[kadircet]

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

556

sure filed https://github.com/clangd/clangd/issues/229

[kadircet]

integrated into D71543

[sammccall]

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

1209

Hang on, I think we're going round in circles with this design.

IIRC the idea was that Name doesn't include template parameters, signature, etc, so clients control rendering.

Isn't it easy to reconstitute this from the template argument list in the hover info?

[kadircet]

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

1209

we were only storing template parameters, not arguments. they've always been the part of the name, they had disappeared after a previous patch, as an intermediate state and this was introducing them back.

i am planning to move template arguments into a different field though, as template parameters, which should also help with dropping default arguments.

clang-tools-extra/clangd/Hover.cpp

 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/Index/IndexSymbol.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/raw_ostream.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 PrintingPolicy printingPolicyForDecls(PrintingPolicy Base) {
llvm::Optional<HoverInfo> getHover(ParsedAST &AST, Position Pos,
                                    const SymbolIndex *Index) {
   const SourceManager &SM = AST.getSourceManager();
   llvm::Optional<HoverInfo> HI;
   SourceLocation SourceLocationBeg = SM.getMacroArgExpandedLocation(
       getBeginningOfIdentifier(Pos, SM, AST.getLangOpts()));
 
   if (auto Deduced = getDeducedType(AST.getASTContext(), SourceLocationBeg)) {
     // Find the corresponding decl to populate kind and fetch documentation.
-    DeclRelationSet Rel = DeclRelation::TemplatePattern | DeclRelation::Alias;
+    DeclRelationSet Rel = DeclRelation::TemplateInstantiation |
+                          DeclRelation::TemplatePattern | DeclRelation::Alias;
     auto Decls =
         targetDecl(ast_type_traits::DynTypedNode::create(*Deduced), Rel);
-    HI = getHoverContents(*Deduced, Decls.empty() ? nullptr : Decls.front(),
-                          AST.getASTContext(), Index);
+    // Select the target decl, biased towards instantiations.
+    auto *D = [&Decls]() -> const Decl * {
+      if (Decls.empty())
+        return nullptr;
+      auto *Spec = llvm::find_if(Decls, [](const Decl *D) {
+        return llvm::isa<ClassTemplateSpecializationDecl>(D);
+      });
+      if (Spec != Decls.end())
+        return *Spec;
+      return Decls.front();
+    }();
+    HI = getHoverContents(*Deduced, D, AST.getASTContext(), Index);
   } else if (auto M = locateMacroAt(SourceLocationBeg, AST.getPreprocessor())) {
     HI = getHoverContents(*M, AST);
   } else {
     auto Offset = positionToOffset(SM.getBufferData(SM.getMainFileID()), Pos);
     if (!Offset) {
       llvm::consumeError(Offset.takeError());
       return llvm::None;
     }

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

void foo())cpp";
       // auto on template instantiation
       {R"cpp(
         template<typename T> class Foo{};
         void foo() {
           [[au^to]] x = Foo<int>();
         }
         )cpp",
        [](HoverInfo &HI) {
-         HI.Name = "Foo";
+         HI.Name = "Foo<int>";
          HI.Kind = index::SymbolKind::Class;
        }},
       // auto on specialized template
       {R"cpp(
         template<typename T> class Foo{};
         template<> class Foo<int>{};
         void foo() {
           [[au^to]] x = Foo<int>();
void foo())cpp";
           void foo() {
             [[au^to]] x = ns::Foo();
           }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "Foo";
             HI.Kind = index::SymbolKind::Class;
           }},
+      {
+          R"cpp(
+          template <typename T, typename C = int> class Foo {};
+          class X;
+          void foo() {
+            [[^auto]] x = Foo<X>();
+          }
+          )cpp",
+          [](HoverInfo &HI) {
+            // FIXME: Drop default arguments.
+            HI.Name = "Foo<X, int>";
+            HI.Kind = index::SymbolKind::Class;
+          }},
   };
   for (const auto &Case : Cases) {
     SCOPED_TRACE(Case.Code);
 
     Annotations T(Case.Code);
     TestTU TU = TestTU::withCode(T.code());
     TU.ExtraArgs.push_back("-std=c++17");
     TU.ExtraArgs.push_back("-fno-delayed-template-parsing");
const std::function<void(HoverInfo &)> ExpectedBuilder;
               class initializer_list {};
             }
             void foo() {
               ^[[auto]] i = {1,2};
             }
           )cpp",
           [](HoverInfo &HI) {
             // FIXME: Print template instantiation parameters.
-            HI.Name = "initializer_list";
+            HI.Name = "initializer_list<int>";
             HI.Kind = index::SymbolKind::Class;
           }},
       {
           R"cpp(// User defined conversion to auto
             struct Bar {
               operator ^[[auto]]() const { return 10; }
             };
           )cpp",