[clangd] Fix a crash while printing Template Arguments

[ilya-biryukov]

LGTM

clangd/AST.cpp

95

NIT: maybe shorten the comment?
Something like // FIXME: Fix cases when getTypeAsWritten returns null, e.g. friend decls.

unittests/clangd/SymbolCollectorTests.cpp

1226

NIT: or something like getTypeAsWritten is missing for friend declaration, this should be fixed in the AST>

[Eugene.Zelenko]

clangd/AST.cpp

86

Return type is not obvious, so auto should not be used.

[kadircet]

• Address comments

[kadircet]

It is incorporated into D59639

clangd/AST.cpp

 //===--- AST.cpp - Utility AST functions  -----------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "AST.h"
 
 #include "clang/AST/ASTContext.h"
 #include "clang/AST/Decl.h"
 #include "clang/AST/DeclTemplate.h"
 #include "clang/AST/TemplateBase.h"
+#include "clang/AST/Type.h"
 #include "clang/AST/TypeLoc.h"
 #include "clang/Basic/SourceLocation.h"
 #include "clang/Basic/SourceManager.h"
 #include "clang/Index/USRGeneration.h"
 #include "llvm/ADT/SmallVector.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/ScopedPrinter.h"
 
std::string printQualifiedName(const NamedDecl &ND) {
   // reflects the way they're most commonly used for lookup. Ideally we'd
   // include them, but at query time it's hard to find all the inline
   // namespaces to query: the preamble doesn't have a dedicated list.
   Policy.SuppressUnwrittenScope = true;
   ND.printQualifiedName(OS, Policy);
   if (auto Args = getTemplateSpecializationArgLocs(ND))
     printTemplateArgumentList(OS, *Args, Policy);
   else if (auto *Cls = llvm::dyn_cast<ClassTemplateSpecializationDecl>(&ND)) {
-    if (auto STL = Cls->getTypeAsWritten()
-                       ->getTypeLoc()
-                       .getAs<TemplateSpecializationTypeLoc>()) {
+    if (auto *TSI = Cls->getTypeAsWritten()) {
+      if (auto STL = TSI->getTypeLoc().getAs<TemplateSpecializationTypeLoc>()) {
         llvm::SmallVector<TemplateArgumentLoc, 8> ArgLocs;
         ArgLocs.reserve(STL.getNumArgs());
         for (unsigned I = 0; I < STL.getNumArgs(); ++I)
           ArgLocs.push_back(STL.getArgLoc(I));
         printTemplateArgumentList(OS, ArgLocs, Policy);
       }
+    } else {
+      // FIXME: Cls->getTypeAsWritten might return null in some cases, e.g.
+      // clang sees first sees a friend declaration and then the specialization.
+      // In that case fall back to TemplateArguments without Location info,
+      printTemplateArgumentList(OS, Cls->getTemplateArgs().asArray(), Policy);
+    }
   }
   OS.flush();
   assert(!StringRef(QName).startswith("::"));
   return QName;
 }
 
 static const TemplateArgumentList *
 getTemplateSpecializationArgs(const NamedDecl &ND) {

unittests/clangd/SymbolCollectorTests.cpp

TEST_F(SymbolCollectorTest, UsingDecl) {
   void foo();
   namespace std {
     using ::foo;
   })";
   runSymbolCollector(Header, /**/ "");
   EXPECT_THAT(Symbols, Contains(QName("std::foo")));
 }
 
+TEST_F(SymbolCollectorTest, TemplateSpecForwardDecl) {
+  // FIXME: This should be fixed in AST to point at specialization. Exercised
+  // just to make sure we don't crash.
+  Annotations Header(R"(
+  template <typename T> struct [[Foo]];
+  struct Bar {
+  friend class Foo<int>;
+  };
+  template <> struct Foo<int> {};
+  )");
+  runSymbolCollector(Header.code(), /*Main=*/"");
+  EXPECT_THAT(Symbols,
+              Contains(AllOf(QName("Foo<int>"), DeclRange(Header.range()),
+                             ForCodeCompletion(true))));
+}
+
 } // namespace
 } // namespace clangd
 } // namespace clang