[clangd] Don't consider class template params part of constructor name.

[sammccall]

Summary

This is shorter and usually the extra info is noise.
There are cases where the params become type-parameter-0-0 that are hard to fix.

This affects a few features:

• 'name' field in structured hover API (not exposed yet)
• 'name' field in locateSymbolAt (not exposed in LSP)
• 'document/symbol' - the symbol is hierarchically nested in the class template, or written as foo<t>::foo when defined out-of-line.

Added a test case for hover from https://github.com/clangd/clangd/issues/76.
This patch fixes one field, but no fewer than four others are wrong!
I'll fix them...

[merge_guards_bot]

Build result: pass - 60134 tests passed, 0 failed and 729 were skipped.
Log files: console-log.txt, CMakeCache.txt

clang-tools-extra/clangd/AST.cpp

std::string printUsingNamespaceName(const ASTContext &Ctx,
   D.getNominatedNamespaceAsWritten()->printName(Out);
   return Out.str();
 }
 
 std::string printName(const ASTContext &Ctx, const NamedDecl &ND) {
   std::string Name;
   llvm::raw_string_ostream Out(Name);
   PrintingPolicy PP(Ctx.getLangOpts());
+  // We don't consider a class template's args part of the constructor name.
+  PP.SuppressTemplateArgsInCXXConstructors = true;
 
   // Handle 'using namespace'. They all have the same name - <using-directive>.
   if (auto *UD = llvm::dyn_cast<UsingDirectiveDecl>(&ND)) {
     Out << "using namespace ";
     if (auto *Qual = UD->getQualifier())
       Qual->print(Out, PP);
     UD->getNominatedNamespaceAsWritten()->printName(Out);
     return Out.str();

clang-tools-extra/clangd/XRefs.cpp

 /// 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;
     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))

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

void foo())cpp";
        [](HoverInfo &HI) {
          HI.NamespaceScope = "";
          HI.LocalScope = "foo::(anonymous class)::operator()::";
          HI.Name = "test";
          HI.Kind = SymbolKind::Variable;
          HI.Definition = "int test";
          HI.Type = "int";
        }},
-      // Partially-specialized class decl. (formerly type-parameter-0-0)
+      // Partially-specialized class template. (formerly type-parameter-0-0)
       {R"cpp(
         template <typename T> class X;
         template <typename T> class [[^X]]<T*> {};
         )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 T> struct X<T*>{ [[^X]](); };
+          )cpp",
+       [](HoverInfo &HI) {
+         HI.NamespaceScope = "";
+         HI.Name = "X";
+         HI.LocalScope = "X::";        // FIXME: Should be X<T *>::
+         HI.Kind = SymbolKind::Method; // FIXME: Should be Constructor
+         HI.Type = "void ()";          // FIXME: Should be None
+         HI.ReturnType = "void";       // FIXME: Should be None or X<T*>
+         HI.Definition = "X<type - parameter - 0 - 0 *>()"; // FIXME: --> X()
+         HI.Parameters.emplace();
+       }},
 
       // auto on lambda
       {R"cpp(
         void foo() {
           [[au^to]] lamb = []{};
         }
         )cpp",
        [](HoverInfo &HI) {