[clangd][Hover] Handle uninstantiated templates

[kadircet]

Summary

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

[merge_guards_bot]

Unit tests: unknown.

clang-tidy: unknown.

clang-format: unknown.

Build artifacts: diff.json, console-log.txt

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

[sammccall]

Can you file a new bug or modify the upstream one to audit existing uses of getTemplateInstantiationPattern() (and maybe related functions)?

getSpecializedTemplate() is used with no null check in findTarget and xrefs, and I'm sure related cases are around too.

clang-tools-extra/clangd/Hover.cpp

210

I think "Template may not be instantiated e.g. if the type didn't need to be complete; fallback to primary template." might be enough of a comment here

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

559

make these comments meaningful

562

Can you add a comment about what specifically this is testing?
(Type isn't instantiated, we fall back to primary template)

[kadircet]

• Address comments

[merge_guards_bot]

Unit tests: fail. 62158 tests passed, 5 failed and 811 were skipped.

failed: libc++.std/language_support/cmp/cmp_partialord/partialord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongeq/cmp.strongeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_strongord/strongord.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakeq/cmp.weakeq.pass.cpp
failed: libc++.std/language_support/cmp/cmp_weakord/weakord.pass.cpp

clang-tidy: pass.

clang-format: pass.

Build artifacts: diff.json, clang-tidy.txt, clang-format.patch, CMakeCache.txt, console-log.txt, test-results.xml

Pre-merge checks is in beta. Report issue. Please join beta or enable it for your project.

clang-tools-extra/clangd/Hover.cpp

 #include "clang/AST/ASTTypeTraits.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclBase.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/Expr.h"
 #include "clang/AST/ExprCXX.h"
 #include "clang/AST/PrettyPrinter.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/Specifiers.h"
 #include "clang/Index/IndexSymbol.h"
 #include "llvm/ADT/None.h"
 #include "llvm/ADT/Optional.h"
 #include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/ADT/StringExtras.h"
 #include "llvm/ADT/StringRef.h"
 #include "llvm/Support/Casting.h"
const FunctionDecl *getUnderlyingFunction(const Decl *D) {
 
   // Non-lambda functions.
   return D->getAsFunction();
 }
 
 // Returns the decl that should be used for querying comments, either from index
 // or AST.
 const NamedDecl *getDeclForComment(const NamedDecl *D) {
-  if (const auto *CTSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(D))
-    if (const auto *TIP = CTSD->getTemplateInstantiationPattern())
+  if (const auto *TSD = llvm::dyn_cast<ClassTemplateSpecializationDecl>(D)) {
+    // We might get a non-instantiated decl, e.g.
+    // template <typename T> struct X {};
+    // X^<int>* x;
+    // Fallback to primary template in such cases.
+    if (TSD->getTemplateSpecializationKind() == TSK_Undeclared)
+      return TSD->getSpecializedTemplate();
+    if (const auto *TIP = TSD->getTemplateInstantiationPattern())
       return TIP;
-  if (const auto *VTSD = llvm::dyn_cast<VarTemplateSpecializationDecl>(D))
-    if (const auto *TIP = VTSD->getTemplateInstantiationPattern())
+  }
+  if (const auto *TSD = llvm::dyn_cast<VarTemplateSpecializationDecl>(D))
+    if (const auto *TIP = TSD->getTemplateInstantiationPattern())
       return TIP;
   if (const auto *FD = D->getAsFunction())
     if (const auto *TIP = FD->getTemplateInstantiationPattern())
       return TIP;
   return D;
 }
 
 // Look up information about D from the index, and add it to Hover.

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

class Foo {})cpp";
           }
           )cpp",
           [](HoverInfo &HI) {
             HI.Name = "Foo<X>";
             HI.Kind = index::SymbolKind::Class;
           }},
       {
           R"cpp(
+          // comment
           template <typename T> class Foo {};
-          Foo<int>* bar();
+          // comment2
+          template <typename T> class Foo<T*> {};
           void foo() {
-            [[^auto]] *x = bar();
+            [[Fo^o]]<int*> *x = nullptr;
           }
           )cpp",
           [](HoverInfo &HI) {
-            HI.Name = "Foo<int>";
+            HI.Name = "Foo<int *>";
             HI.Kind = index::SymbolKind::Class;
+            HI.NamespaceScope = "";
+            HI.Definition = "template <> class Foo<int *>";
+            // FIXME: Maybe force instantiation to make use of real template
+            // pattern.
+            HI.Documentation = "comment";
           }},
   };
   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");