[clangd] Fixed printTemplateSpecializationArgs not printing partial variable specialization arguments.

[jvikstrom]

Summary

printTemplateSpecializationArgs was not printing partial variable specialization args. This adds an additional If clause where we check if it's a VariableTemplatePartialSpecializationDecl and returns the ArgumentLocs if that's the case.
Also adds tests for printTemplateSpecializationArgs in ASTTests.cpp.

[hokein]

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

40

looks like the related tests are in PrintASTTests.cpp, could you move the test there?

[jvikstrom]

Merged test with PrintASTTest.cpp.

[jvikstrom]

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

40

Oh I didn't see that test file. Seems like a lot of this is already tested, so just removing everything that isn't related to template variables.

clang-tools-extra/clangd/AST.cpp

getTemplateSpecializationArgLocs(const NamedDecl &ND) {
   if (auto *Func = llvm::dyn_cast<FunctionDecl>(&ND)) {
     if (const ASTTemplateArgumentListInfo *Args =
             Func->getTemplateSpecializationArgsAsWritten())
       return Args->arguments();
   } else if (auto *Cls =
                  llvm::dyn_cast<ClassTemplatePartialSpecializationDecl>(&ND)) {
     if (auto *Args = Cls->getTemplateArgsAsWritten())
       return Args->arguments();
+  } else if (auto *Var =
+                 llvm::dyn_cast<VarTemplatePartialSpecializationDecl>(&ND)) {
+    if (auto *Args = Var->getTemplateArgsAsWritten())
+      return Args->arguments();
   } else if (auto *Var = llvm::dyn_cast<VarTemplateSpecializationDecl>(&ND))
     return Var->getTemplateArgsInfo().arguments();
   // We return None for ClassTemplateSpecializationDecls because it does not
   // contain TemplateArgumentLoc information.
   return llvm::None;
 }
 
 template <class T>

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

 //===-- ASTTests.cpp --------------------------------------------*- 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 "gtest/gtest.h"
+#include "TestTU.h"
 
 namespace clang {
 namespace clangd {
 namespace {
 
 TEST(ExpandAutoType, ShortenNamespace) {
   ASSERT_EQ("TestClass", shortenNamespace("TestClass", ""));
 
ASSERT_EQ(
       "testns2::TestClass",
       shortenNamespace("testns1::testns2::TestClass", "testns1"));
 
   ASSERT_EQ("TestClass<testns1::OtherClass>",
             shortenNamespace(
                 "testns1::TestClass<testns1::OtherClass>", "testns1"));
 }
 
+TEST(PrintTemplateSpecializationArgs, PrintsTemplateArgs) {
+  TestTU TU;
+  TU.Code = R"cpp(
+    template<class T>
+    void foo(T) {}
+    template<>
+    void foo<int>(int) {}
+
+    template<class T, class U>
+    struct K {};
+    template<class J>
+    struct K<int, J> {};
+    template<>
+    struct K<int, double> {};
+
+    template<class T>
+    T S = T(10);
+
+    template <class T>
+    int S<T*> = 0;
+    template <>
+    int S<double> = 0;
+  )cpp";
+
+  // The expected template args string representation for every top level decl
+  // in the TU.
+  std::vector<std::string> ExpectedTemplateDeclArgs{
+      "", "<int>", "", "<int, J>", "<int, double>", "", "<T *>", "<double>"};
+
+  std::vector<Decl *> TopLevel = TU.build().getLocalTopLevelDecls();
+  std::vector<std::string> ActualTemplateArgs;
+  for (const Decl *D : TopLevel) {
+    if (const NamedDecl *ND = dyn_cast<NamedDecl>(D))
+      ActualTemplateArgs.push_back(printTemplateSpecializationArgs(*ND));
+  }
+
+  EXPECT_EQ(ExpectedTemplateDeclArgs, ActualTemplateArgs);
+}
 
 } // namespace
 } // namespace clangd
 } // namespace clang

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

EXPECT_THAT(
                         AllOf(DeclNamed("f"), WithTemplateArgs("<bool>")),
                         AllOf(DeclNamed("f"), WithTemplateArgs("<double>")),
                         AllOf(DeclNamed("V"), WithTemplateArgs("")),
                         AllOf(DeclNamed("V"), WithTemplateArgs("<T *>")),
                         AllOf(DeclNamed("V"), WithTemplateArgs("<bool>")),
                         AllOf(DeclNamed("foo"), WithTemplateArgs("")),
                         AllOf(DeclNamed("i"), WithTemplateArgs("")),
                         AllOf(DeclNamed("d"), WithTemplateArgs("")),
-                        AllOf(DeclNamed("foo"), WithTemplateArgs("<>")),
+                        AllOf(DeclNamed("foo"), WithTemplateArgs("<T *>")),
                         AllOf(DeclNamed("foo"), WithTemplateArgs("<bool>"))}));
 }
 
 TEST(ClangdUnitTest, TokensAfterPreamble) {
   TestTU TU;
   TU.AdditionalFiles["foo.h"] = R"(
     int foo();
   )";