[clangd] Avoid crash when printing call to string literal operator template in hover

[kadircet]

can you move the test into llvm/llvm-project/clang/unittests/AST/StmtPrinterTest.cpp ?

while there, also a test on pack-extended user defined literals would be nice.

[nridge]

Move test to StmtPrinterTests, add test for literal operator using pack

[kadircet]

thanks!

clang/lib/AST/StmtPrinter.cpp

case UserDefinedLiteral::LOK_Raw:
     OS << cast<StringLiteral>(Node->getArg(0)->IgnoreImpCasts())->getString();
     break;
   case UserDefinedLiteral::LOK_Template: {
     const auto *DRE = cast<DeclRefExpr>(Node->getCallee()->IgnoreImpCasts());
     const TemplateArgumentList *Args =
       cast<FunctionDecl>(DRE->getDecl())->getTemplateSpecializationArgs();
     assert(Args);
 
-    if (Args->size() != 1) {
+    if (Args->size() != 1 || Args->get(0).getKind() != TemplateArgument::Pack) {
       const TemplateParameterList *TPL = nullptr;
       if (!DRE->hadMultipleCandidates())
         if (const auto *TD = dyn_cast<TemplateDecl>(DRE->getDecl()))
           TPL = TD->getTemplateParameters();
       OS << "operator\"\"" << Node->getUDSuffix()->getName();
       printTemplateArgumentList(OS, Args->asArray(), Policy, TPL);
       OS << "()";
       return;

clang/unittests/AST/StmtPrinterTest.cpp

 #include "gtest/gtest.h"
 
 using namespace clang;
 using namespace ast_matchers;
 using namespace tooling;
 
 namespace {
 
-enum class StdVer { CXX98, CXX11, CXX14, CXX17, CXX2a };
+enum class StdVer { CXX98, CXX11, CXX14, CXX17, CXX20 };
 
 DeclarationMatcher FunctionBodyMatcher(StringRef ContainingFunction) {
   return functionDecl(hasName(ContainingFunction),
                       has(compoundStmt(has(stmt().bind("id")))));
 }
 
 static void PrintStmt(raw_ostream &Out, const ASTContext *Context,
                       const Stmt *S, PrintingPolicyAdjuster PolicyAdjuster) {
PrintedStmtCXXMatches(StdVer Standard, StringRef Code, const T &NodeMatch,
                       StringRef ExpectedPrinted,
                       PrintingPolicyAdjuster PolicyAdjuster = nullptr) {
   const char *StdOpt;
   switch (Standard) {
   case StdVer::CXX98: StdOpt = "-std=c++98"; break;
   case StdVer::CXX11: StdOpt = "-std=c++11"; break;
   case StdVer::CXX14: StdOpt = "-std=c++14"; break;
   case StdVer::CXX17: StdOpt = "-std=c++17"; break;
-  case StdVer::CXX2a: StdOpt = "-std=c++2a"; break;
+  case StdVer::CXX20:
+    StdOpt = "-std=c++20";
+    break;
   }
 
   std::vector<std::string> Args = {
     StdOpt,
     "-Wno-unused-value",
   };
   return PrintedStmtMatches(Code, Args, NodeMatch, ExpectedPrinted,
                             PolicyAdjuster);

 TEST(StmtPrinter, TestFloatingPointLiteral) {
   ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX98,
     "void A() { 1.0f, -1.0f, 1.0, -1.0, 1.0l, -1.0l; }",
     FunctionBodyMatcher("A"),
     "1.F , -1.F , 1. , -1. , 1.L , -1.L"));
     // Should be: with semicolon
 }
 
+TEST(StmtPrinter, TestStringLiteralOperatorTemplate_Pack) {
+  ASSERT_TRUE(PrintedStmtCXXMatches(StdVer::CXX11,
+                                    R"cpp(
+    template <char...> constexpr double operator""_c() { return 42; }
+    void A() {
+      constexpr auto waldo = 42_c;
+    }
+)cpp",
+                                    FunctionBodyMatcher("A"),
+                                    "constexpr auto waldo = 42_c;\n"));
+}
+
+TEST(StmtPrinter, TestStringLiteralOperatorTemplate_Class) {
+  ASSERT_TRUE(
+      PrintedStmtCXXMatches(StdVer::CXX20,
+                            R"cpp(
+    struct C {
+      template <unsigned N> constexpr C(const char (&)[N]) : n(N) {}
+      unsigned n;
+    };
+    template <C c> constexpr auto operator""_c() { return c.n; }
+    void A() {
+      constexpr auto waldo = "abc"_c;
+    }
+)cpp",
+                            FunctionBodyMatcher("A"),
+                            "constexpr auto waldo = operator\"\"_c<{4}>();\n"));
+}
+
 TEST(StmtPrinter, TestCXXConversionDeclImplicit) {
   ASSERT_TRUE(PrintedStmtCXXMatches(
       StdVer::CXX98,
       "struct A {"
       "operator void *();"
       "A operator&(A);"
       "};"
       "void bar(void *);"