[AST] Print NTTP args as string-literals when possible

[lichray]

Summary

C++20 non-type template parameter prints MyType<{{116, 104, 105, 115}}> when the code is as simple as MyType<"this">. This patch prints MyType<{"this"}>, with one layer of braces preserved for the intermediate structural type to trigger CTAD.

StringLiteral handles this case, but StringLiteral inside APValue code looks like a circular dependency. The proposed patch implements a cheap strategy to emit string literals in diagnostic messages only when they are readable and fall back to integer sequences.

[lichray]

Fix failed assertion

[lichray]

This comment was removed by lichray.

[lichray]

• Add tests

[lichray]

Add EOL to source file

[rsmith]

clang/lib/AST/APValue.cpp

628–629

Is there anything you can factor out of StringLiteral::outputString and reuse here? At least the single-character printing code seems like something we should try to not overly duplicate.

637–639

We should drop all trailing zeroes here, because array initialization from a string literal will reconstruct them.

641–643

Prefer llvm::SmallString<N> and push_back.

645

...except that some callers want output that uniquely identifies the template argument, and moreover some callers want output that is valid C++ code that produces the same template-id.

It'd be better to do this behind a PrintingPolicy flag that the diagnostics engine sets. But we'd want to turn that flag off during template type diffing.

869–870

(The existing code is also doing elision here that will be inappropriate for some callers. If you add a PrintingPolicy to unambiguously print template arguments, it should disable this check too.)

[lichray]

Ensure the ellipses output is never shorter than the normal ones (will look at review comments later)

[lichray]

clang/lib/AST/APValue.cpp

628–629

The goals of the two routines are different. StringLiteral::outputString must output something that can parse back as a string literal, even it doesn't decode UTF-8 right now; the new routine in this patch doesn't have to -- it can give up anytime it wants.

I wish switch statements were more composable. But if you don't mind, I can add a function in CharInfo.h to test and get the C-style escaped char and retire the outmost switch statements in those two routines.

637–639

Are you sure? MyType<{""}> and MyType<{"\0\0\0"}> are different types.

[rsmith]

clang/lib/AST/APValue.cpp

637–639

That's a separate bug. APValue's printing is not intended to identify the type of the result, only to identify the value in the case where we already know the type. Eg, we don't print a type suffix on a pretty-printed integer value. For the specific case of template parameters, it's the responsibility of the template argument printing code to uniquely identify the template argument.

When a template parameter has a deduced class type, we should include that type in the printed output in order to uniquely identify the specialization, but we don't, because that's not been implemented yet. When that's fixed, we should print those cases as MyType<Str<char, 1>{""}> and MyType<Str<char, 4>{""}>. This is necessary anyway, because we can't in general assume that the resulting value is enough to indicate what type CTAD will have selected.

We already handle this properly in some cases, but see this FIXMEs: https://github.com/llvm/llvm-project/blob/6c2be3015e07f25912b8cd5b75214c532f568638/clang/lib/AST/TemplateBase.cpp#L433

See also some related issues: https://godbolt.org/z/YhcdMYx6n (note that the non-struct enum case is handled properly but the enum-in-struct case is not).

[lichray]

clang/lib/AST/APValue.cpp

637–639

That's a separate bug. [...]

When a template parameter has a deduced class type, we should include that type in the printed output in order to uniquely identify the specialization, but we don't, because that's not been implemented yet. When that's fixed, we should print those cases as MyType<Str<char, 1>{""}> and MyType<Str<char, 4>{""}>. This is necessary anyway, because we can't in general assume that the resulting value is enough to indicate what type CTAD will have selected.

But it looks like a feature rather than a bug? String literals provided both type and value to emphasis a structural type's value for equivalence comparison. The reason of why MyType<{""}> and MyType<"\0\0\0"> are different looks more obvious to me.

See also some related issues: https://godbolt.org/z/YhcdMYx6n (note that the non-struct enum case is handled properly but the enum-in-struct case is not).

I'm fine if a specific NTTP, A, is treated differently from auto. But the last case is similar to this https://godbolt.org/z/YcscTrchM Which I thought about printing something like Y<{(E[]){97, 98}}> :)

[lichray]

clang/lib/AST/APValue.cpp

637–639

That discussion looks OT... For now, not shrinking "\0\0\0" down to "" follows the existing logic, i.e., we are printing {0, 0, 0} even though it's an array.

[lichray]

clang/lib/AST/APValue.cpp

637–639

Nvm, I did not realize that null characters cannot be safely escaped with just \0 without looking at the characters that follow it. Dropping that case and fallback to print the integer sequence.

645

Added Policy.EntireContentsOfLargeArray.

[lichray]

• Switch to llvm::SmallString
• Refactor code that prints C-style builtin escape sequences
• Stop printing strings with embedded NULs in NTTP types
• Add an EntireContentsOfLargeArray pretty-print policy

[lichray]

Ping. Ready to review again.

[lichray]

@rsmith Ping. I'm all on you :) You are almost the only one designed these files.

[rsmith]

clang/include/clang/AST/PrettyPrinter.h

286

It looks like nothing is setting this to true yet, so that part of this patch seems untested. The places I think we want to set this to true are:

1. When forming types in a diagnostic, if we have two types that differ only in the contents of large arrays. That's checked in here: https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/ASTDiagnostic.cpp#L259
   
   I think what we'd want is: if we still have a collision between type names after comparing the canonical strings (https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/ASTDiagnostic.cpp#L291), then set this policy to true for the rest of the function, and recompute S and CanS.
   
   This should be detectable in a case such as:

void f(X<{"some very long string that differs here: x"}>);
void g() {
  f(X<{"some very long string that differs here: y"}>());
}

... where the diagnostic should include the whole string, not elide the differing portion at the end.

2. In the -ast-print output: when pretty-printing as code, we want to produce correct, non-elided template arguments. I think this will require passing a printing policy into TemplateParamObjectDecl::printAsInit and ::printAsExpr (https://github.com/llvm/llvm-project/blob/main/clang/lib/AST/DeclTemplate.cpp#L1509). This should be detectable in the output of -ast-print, where we do not want to elide any part of template arguments. Perhaps StmtPrinter and DeclPrinter should enable this PrintingPolicy flag?

3. When generating debug information: https://github.com/llvm/llvm-project/blob/main/clang/lib/CodeGen/CGDebugInfo.cpp#L230
   
   It's generally important that debug information has complete type names.

clang/include/clang/Basic/CharInfo.h

50

I think this should also return false for negative values.

clang/lib/AST/APValue.cpp

630–631

Consider passing in an ArrayRef here instead of forming one below.

654

I think ArrayRef<T> and ArrayRef<const T> are effectively the same thing (you'd need MutableArrayRef to remove the implied const), so you should be able to just use ArrayRef<APValue> here.

[lichray]

• Fix categorizing int64_t chars of negative values
• More ArrayRef
• Fix and test the EntireContentsOfLargeArray bit

[lichray]

clang/include/clang/AST/PrettyPrinter.h

286

Added PrintingPolicy parameter to TemplateParamObjectDecl::printAsInit and printAsExpr, fixed the implementation, and added tests for the effect of the new EntireContentsOfLargeArray bit.

Whether how diagnosis, codegen, and higher-level printers should make use of them, I think they're outside the scope of this patch.

[lichray]

• Put tests in TypePrinterTest.cpp

[lichray]

• clang-format

[lichray]

Rebase

[rsmith]

clang/include/clang/AST/PrettyPrinter.h

286

Generally I agree, we don't need to fix all the places that should be setting this new flag as part of the same patch, but I think at least -ast-print should be fixed here, given how obviously broken it currently is. That would also remove the need to add a unit test for the new flag.

clang/test/SemaTemplate/temp_arg_string_printing.cpp

2

Please use something like diagnostics to test that elision happens, rather than -ast-print, because -ast-print aims to produce valid C++ code that has the same meaning as the input -- this is a canonical example of a case that should *not* elide large array contents.

[lichray]

• Flip the default and set EntireContentsOfLargeArray off only in diagnosis

[lichray]

Restricted the ellipsis only to diagnosis. Type comparison now shows full initializers, which could be made smarter next time.

[lichray]

Ping.

[lichray]

Rebased

[lichray]

Rebased

[lichray]

Rerun pre-merge checks

[aaron.ballman]

clang/include/clang/Basic/CharInfo.h

199–200

We're also missing \? right?

clang/lib/AST/APValue.cpp

658

663

676–683

Not quite the same thing, but do we have to worry about printing pascal strings here? (e.g., do we need to do "\pwhatever"?

clang/lib/AST/Expr.cpp

1137

[lichray]

• Revert some auto's

[lichray]

clang/include/clang/Basic/CharInfo.h

199–200

? does not seem to need "escaping?"

clang/lib/AST/APValue.cpp

676–683

This is in APValue where we lost the context of StringLiteral; nothing tells me that this array was created from a Pascal string literal. Unless you want to do some heuristics, like printing "\pthis" when seens an unsigned char[6] where the first element = 4 (last element = 0 is checked at the beginning).

[aaron.ballman]

clang/include/clang/Basic/CharInfo.h

199–200

It's the only simple escape sequence we're not handling here: http://eel.is/c++draft/lex.literal#nt:simple-escape-sequence-char

(You need to escape ? thanks to trigraphs. Consider a string literal like "This does what now??!".)

clang/lib/AST/APValue.cpp

676–683

Whelp, that explains that. I think the current behavior is fine (I have to imagine the number of people still using Pascal strings is as high as four or five these days).

[lichray]

clang/include/clang/Basic/CharInfo.h

199–200

It's the only simple escape sequence we're not handling here: http://eel.is/c++draft/lex.literal#nt:simple-escape-sequence-char

(You need to escape ? thanks to trigraphs. Consider a string literal like "This does what now??!".)

Hmm, I think we're safe here

~/devel/llvm-project> ./build/bin/clang++ -fsyntax-only -std=c++14 c.cc
c.cc:1:50: warning: trigraph converted to '|' character [-Wtrigraphs]
void foo() { char const s[] = "This does what now??!"; }
                                                 ^
1 warning generated.
~/devel/llvm-project> ./build/bin/clang++ -fsyntax-only -std=c++20 c.cc
c.cc:1:50: warning: trigraph ignored [-Wtrigraphs]
void foo() { char const s[] = "This does what now??!"; }
                                                 ^
1 warning generated.

For these reasons,

1. I don't want users to copy diagnosis messages, paste them into a program, and get something different. This has been prevented by the warnings.
2. We support trigraph up to C++14, way behind the version (C++20) we can use string literals in NTTP. So it should be mostly fine.
3. In C++14 we can use the characters in NTTP, but that one has a different diagnosis:

template <char C> class ASCII {};

void Foo(ASCII<'?'>);
void Foo(ASCII<'??!'>);
void test_pascal() {
  ASCII<'!'> a;
  Foo(a);
}

c.cc:4:17: warning: trigraph converted to '|' character [-Wtrigraphs]
void Foo(ASCII<'??!'>);
                ^
c.cc:7:3: error: no matching function for call to 'Foo'
  Foo(a);
  ^~~
c.cc:3:6: note: candidate function not viable: no known conversion from 'ASCII<'!' aka 33>' to 'ASCII<'?' aka 63>' for 1st argument
void Foo(ASCII<'?'>);
     ^
c.cc:4:6: note: candidate function not viable: no known conversion from 'ASCII<'!' aka 33>' to 'ASCII<'|' aka 124>' for 1st argument
void Foo(ASCII<'??!'>);
     ^
1 warning and 1 error generated.

Looks nice to me even if we don't escape.

[aaron.ballman]

Aside from a testing nit, this LGTM!

clang/include/clang/Basic/CharInfo.h

199–200

Okay, that sounds reasonable to me, thank you for checking! Can you add a trigraph test case so that it's clear we purposefully don't escape the \? (with some comment to that effect)?

[lichray]

• Add a trigraph test case

clang/include/clang/AST/DeclTemplate.h

private:
   friend class ASTDeclReader;
 
 public:
   /// Print this template parameter object in a human-readable format.
   void printName(llvm::raw_ostream &OS) const override;
 
   /// Print this object as an equivalent expression.
   void printAsExpr(llvm::raw_ostream &OS) const;
+  void printAsExpr(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
 
   /// Print this object as an initializer suitable for a variable of the
   /// object's type.
   void printAsInit(llvm::raw_ostream &OS) const;
+  void printAsInit(llvm::raw_ostream &OS, const PrintingPolicy &Policy) const;
 
   const APValue &getValue() const { return Value; }
 
   static void Profile(llvm::FoldingSetNodeID &ID, QualType T,
                       const APValue &V) {
     ID.AddPointer(T.getCanonicalType().getAsOpaquePtr());
     V.Profile(ID);
   }

clang/include/clang/AST/PrettyPrinter.h

PrintingPolicy(const LangOptions &LO)
         UnderscoreAlignof(LO.C11), UseVoidForZeroParams(!LO.CPlusPlus),
         SplitTemplateClosers(!LO.CPlusPlus11), TerseOutput(false),
         PolishForDeclaration(false), Half(LO.Half),
         MSWChar(LO.MicrosoftExt && !LO.WChar), IncludeNewlines(true),
         MSVCFormatting(false), ConstantsAsWritten(false),
         SuppressImplicitBase(false), FullyQualifiedName(false),
         PrintCanonicalTypes(false), PrintInjectedClassNameWithArguments(true),
         UsePreferredNames(true), AlwaysIncludeTypeForTemplateArgument(false),
-        CleanUglifiedParameters(false) {}
+        CleanUglifiedParameters(false), EntireContentsOfLargeArray(true) {}
 
   /// Adjust this printing policy for cases where it's known that we're
   /// printing C++ code (for instance, if AST dumping reaches a C++-only
   /// construct). This should not be used if a real LangOptions object is
   /// available.
   void adjustForCPlusPlus() {
     SuppressTagKeyword = true;
     Bool = true;
struct PrintingPolicy {
   unsigned UsePreferredNames : 1;
 
   /// Whether to use type suffixes (eg: 1U) on integral non-type template
   /// parameters.
   unsigned AlwaysIncludeTypeForTemplateArgument : 1;
 
   /// Whether to strip underscores when printing reserved parameter names.
   /// e.g. std::vector<class _Tp> becomes std::vector<class Tp>.
   /// This only affects parameter names, and so describes a compatible API.
   unsigned CleanUglifiedParameters : 1;
 
+  /// Whether to print the entire array initializers, especially on non-type
+  /// template parameters, no matter how many elements there are.
+  unsigned EntireContentsOfLargeArray : 1;
+
   /// Callbacks to use to allow the behavior of printing to be customized.
   const PrintingCallbacks *Callbacks = nullptr;
 };
 
 } // end namespace clang
 
 #endif

clang/include/clang/Basic/CharInfo.h

namespace charinfo {
   };
 
   enum {
     CHAR_XUPPER = CHAR_XLETTER | CHAR_UPPER,
     CHAR_XLOWER = CHAR_XLETTER | CHAR_LOWER
   };
 } // end namespace charinfo
 
-/// Returns true if this is an ASCII character.
+/// Returns true if a byte is an ASCII character.
 LLVM_READNONE inline bool isASCII(char c) {
   return static_cast<unsigned char>(c) <= 127;
 }
 
 LLVM_READNONE inline bool isASCII(unsigned char c) { return c <= 127; }
 
-/// Returns true if this is an ASCII character.
+/// Returns true if a codepoint is an ASCII character.
 LLVM_READNONE inline bool isASCII(uint32_t c) { return c <= 127; }
+LLVM_READNONE inline bool isASCII(int64_t c) { return 0 <= c && c <= 127; }
 
 /// Returns true if this is a valid first character of a C identifier,
 /// which is [a-zA-Z_].
 LLVM_READONLY inline bool isAsciiIdentifierStart(unsigned char c,
                                                  bool AllowDollar = false) {
   using namespace charinfo;
   if (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_UNDER))
     return true;

 
 /// Return true if this is the body character of a C++ raw string delimiter.
 LLVM_READONLY inline bool isRawStringDelimBody(unsigned char c) {
   using namespace charinfo;
   return (InfoTable[c] & (CHAR_UPPER|CHAR_LOWER|CHAR_PERIOD|
                           CHAR_DIGIT|CHAR_UNDER|CHAR_RAWDEL)) != 0;
 }
 
+enum class EscapeChar {
+  Single = 1,
+  Double = 2,
+  SingleAndDouble = static_cast<int>(Single) | static_cast<int>(Double),
+};
+
+/// Return C-style escaped string for special characters, or an empty string if
+/// there is no such mapping.
+template <EscapeChar Opt, class CharT>
+LLVM_READONLY inline auto escapeCStyle(CharT Ch) -> StringRef {
+  switch (Ch) {
+  case '\\':
+    return "\\\\";
+  case '\'':
+    if ((static_cast<int>(Opt) & static_cast<int>(EscapeChar::Single)) == 0)
+      break;
+    return "\\'";
+  case '"':
+    if ((static_cast<int>(Opt) & static_cast<int>(EscapeChar::Double)) == 0)
+      break;
+    return "\\\"";
+  case '\a':
+    return "\\a";
+  case '\b':
+    return "\\b";
+  case '\f':
+    return "\\f";
+  case '\n':
+    return "\\n";
+  case '\r':
+    return "\\r";
+  case '\t':
+    return "\\t";
+  case '\v':
+    return "\\v";
+  }
+  return {};
+}
 
 /// Converts the given ASCII character to its lowercase equivalent.
 ///
 /// If the character is not an uppercase character, it is returned as is.
 LLVM_READONLY inline char toLowercase(char c) {
   if (isUppercase(c))
     return c + 'a' - 'A';
   return c;

clang/lib/AST/APValue.cpp

 static double GetApproxValue(const llvm::APFloat &F) {
   llvm::APFloat V = F;
   bool ignored;
   V.convert(llvm::APFloat::IEEEdouble(), llvm::APFloat::rmNearestTiesToEven,
             &ignored);
   return V.convertToDouble();
 }
 
+static bool TryPrintAsStringLiteral(raw_ostream &Out,
+                                    const PrintingPolicy &Policy,
+                                    const ArrayType *ATy,
+                                    ArrayRef<APValue> Inits) {
+  if (Inits.empty())
+    return false;
+
+  QualType Ty = ATy->getElementType();
+  if (!Ty->isAnyCharacterType())
+    return false;
+
+  // Nothing we can do about a sequence that is not null-terminated
+  if (!Inits.back().getInt().isZero())
+    return false;
+  else
+    Inits = Inits.drop_back();
+
+  llvm::SmallString<40> Buf;
+  Buf.push_back('"');
+
+  // Better than printing a two-digit sequence of 10 integers.
+  constexpr size_t MaxN = 36;
+  StringRef Ellipsis;
+  if (Inits.size() > MaxN && !Policy.EntireContentsOfLargeArray) {
+    Ellipsis = "[...]";
+    Inits =
+        Inits.take_front(std::min(MaxN - Ellipsis.size() / 2, Inits.size()));
+  }
+
+  for (auto &Val : Inits) {
+    int64_t Char64 = Val.getInt().getExtValue();
+    if (!isASCII(Char64))
+      return false; // Bye bye, see you in integers.
+    auto Ch = static_cast<unsigned char>(Char64);
+    // The diagnostic message is 'quoted'
+    StringRef Escaped = escapeCStyle<EscapeChar::SingleAndDouble>(Ch);
+    if (Escaped.empty()) {
+      if (!isPrintable(Ch))
+        return false;
+      Buf.emplace_back(Ch);
+    } else {
+      Buf.append(Escaped);
+    }
+  }
+
+  Buf.append(Ellipsis);
+  Buf.push_back('"');
+
+  if (Ty->isWideCharType())
+    Out << 'L';
+  else if (Ty->isChar8Type())
+    Out << "u8";
+  else if (Ty->isChar16Type())
+    Out << 'u';
+  else if (Ty->isChar32Type())
+    Out << 'U';
+
+  Out << Buf;
+  return true;
+}
+
 void APValue::printPretty(raw_ostream &Out, const ASTContext &Ctx,
                           QualType Ty) const {
   printPretty(Out, Ctx.getPrintingPolicy(), Ty, &Ctx);
 }
 
 void APValue::printPretty(raw_ostream &Out, const PrintingPolicy &Policy,
                           QualType Ty, const ASTContext *Ctx) const {
   // There are no objects of type 'void', but values of this type can be
if (isLValueOnePastTheEnd()) {
       Out << " + 1";
       if (IsReference)
         Out << ')';
     }
     return;
   }
   case APValue::Array: {
     const ArrayType *AT = Ty->castAsArrayTypeUnsafe();
+    unsigned N = getArrayInitializedElts();
+    if (N != 0 && TryPrintAsStringLiteral(Out, Policy, AT,
+                                          {&getArrayInitializedElt(0), N}))
+      return;
     QualType ElemTy = AT->getElementType();
     Out << '{';
-    if (unsigned N = getArrayInitializedElts()) {
-      getArrayInitializedElt(0).printPretty(Out, Policy, ElemTy, Ctx);
-      for (unsigned I = 1; I != N; ++I) {
+    unsigned I = 0;
+    switch (N) {
+    case 0:
+      for (; I != N; ++I) {
         Out << ", ";
-        if (I == 10) {
-          // Avoid printing out the entire contents of large arrays.
-          Out << "...";
-          break;
+        if (I == 10 && !Policy.EntireContentsOfLargeArray) {
+          Out << "...}";
+          return;
         }
+        LLVM_FALLTHROUGH;
+      default:
         getArrayInitializedElt(I).printPretty(Out, Policy, ElemTy, Ctx);
       }
     }
     Out << '}';
     return;
   }
   case APValue::Struct: {
     Out << '{';

clang/lib/AST/ASTDiagnostic.cpp

   void PrintValueDecl(ValueDecl *VD, bool AddressOf, Expr *E, bool NullPtr) {
     if (VD) {
       if (AddressOf)
         OS << "&";
       else if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(VD)) {
         // FIXME: Diffing the APValue would be neat.
         // FIXME: Suppress this and use the full name of the declaration if the
         // parameter is a pointer or reference.
-        TPO->printAsInit(OS);
+        TPO->printAsInit(OS, Policy);
         return;
       }
       VD->printName(OS);
       return;
     }
 
     if (NullPtr) {
       if (E && !isa<CXXNullPtrLiteralExpr>(E)) {

clang/lib/AST/DeclTemplate.cpp

 
 void TemplateParamObjectDecl::printName(llvm::raw_ostream &OS) const {
   OS << "<template param ";
   printAsExpr(OS);
   OS << ">";
 }
 
 void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS) const {
-  const ASTContext &Ctx = getASTContext();
-  getType().getUnqualifiedType().print(OS, Ctx.getPrintingPolicy());
-  printAsInit(OS);
+  printAsExpr(OS, getASTContext().getPrintingPolicy());
+}
+
+void TemplateParamObjectDecl::printAsExpr(llvm::raw_ostream &OS,
+                                          const PrintingPolicy &Policy) const {
+  getType().getUnqualifiedType().print(OS, Policy);
+  printAsInit(OS, Policy);
 }
 
 void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS) const {
-  const ASTContext &Ctx = getASTContext();
-  getValue().printPretty(OS, Ctx, getType());
+  printAsInit(OS, getASTContext().getPrintingPolicy());
+}
+
+void TemplateParamObjectDecl::printAsInit(llvm::raw_ostream &OS,
+                                          const PrintingPolicy &Policy) const {
+  getValue().printPretty(OS, Policy, getType(), &getASTContext());
 }

clang/lib/AST/Expr.cpp

void CharacterLiteral::print(unsigned Val, CharacterKind Kind,
   case CharacterLiteral::UTF16:
     OS << 'u';
     break;
   case CharacterLiteral::UTF32:
     OS << 'U';
     break;
   }
 
-  switch (Val) {
-  case '\\':
-    OS << "'\\\\'";
-    break;
-  case '\'':
-    OS << "'\\''";
-    break;
-  case '\a':
-    // TODO: K&R: the meaning of '\\a' is different in traditional C
-    OS << "'\\a'";
-    break;
-  case '\b':
-    OS << "'\\b'";
-    break;
-  // Nonstandard escape sequence.
-  /*case '\e':
-    OS << "'\\e'";
-    break;*/
-  case '\f':
-    OS << "'\\f'";
-    break;
-  case '\n':
-    OS << "'\\n'";
-    break;
-  case '\r':
-    OS << "'\\r'";
-    break;
-  case '\t':
-    OS << "'\\t'";
-    break;
-  case '\v':
-    OS << "'\\v'";
-    break;
-  default:
+  StringRef Escaped = escapeCStyle<EscapeChar::Single>(Val);
+  if (!Escaped.empty()) {
+    OS << "'" << Escaped << "'";
+  } else {
     // A character literal might be sign-extended, which
     // would result in an invalid \U escape sequence.
     // FIXME: multicharacter literals such as '\xFF\xFF\xFF\xFF'
     // are not correctly handled.
     if ((Val & ~0xFFu) == ~0xFFu && Kind == CharacterLiteral::Ascii)
       Val &= 0xFFu;
     if (Val < 256 && isPrintable((unsigned char)Val))
       OS << "'" << (char)Val << "'";
void StringLiteral::outputString(raw_ostream &OS) const {
   case UTF16: OS << 'u'; break;
   case UTF32: OS << 'U'; break;
   }
   OS << '"';
   static const char Hex[] = "0123456789ABCDEF";
 
   unsigned LastSlashX = getLength();
   for (unsigned I = 0, N = getLength(); I != N; ++I) {
-    switch (uint32_t Char = getCodeUnit(I)) {
-    default:
+    uint32_t Char = getCodeUnit(I);
+    StringRef Escaped = escapeCStyle<EscapeChar::Double>(Char);
+    if (Escaped.empty()) {
       // FIXME: Convert UTF-8 back to codepoints before rendering.
 
       // Convert UTF-16 surrogate pairs back to codepoints before rendering.
       // Leave invalid surrogates alone; we'll use \x for those.
       if (getKind() == UTF16 && I != N - 1 && Char >= 0xd800 &&
           Char <= 0xdbff) {
         uint32_t Trail = getCodeUnit(I + 1);
         if (Trail >= 0xdc00 && Trail <= 0xdfff) {
if (Escaped.empty()) {
           // FIXME: Is this the best way to print wchar_t?
           OS << "\\x";
           int Shift = 28;
           while ((Char >> Shift) == 0)
             Shift -= 4;
           for (/**/; Shift >= 0; Shift -= 4)
             OS << Hex[(Char >> Shift) & 15];
           LastSlashX = I;
-          break;
+          continue;
         }
 
         if (Char > 0xffff)
           OS << "\\U00"
              << Hex[(Char >> 20) & 15]
              << Hex[(Char >> 16) & 15];
         else
           OS << "\\u";
         OS << Hex[(Char >> 12) & 15]
            << Hex[(Char >>  8) & 15]
            << Hex[(Char >>  4) & 15]
            << Hex[(Char >>  0) & 15];
-        break;
+        continue;
       }
 
       // If we used \x... for the previous character, and this character is a
       // hexadecimal digit, prevent it being slurped as part of the \x.
       if (LastSlashX + 1 == I) {
         switch (Char) {
           case '0': case '1': case '2': case '3': case '4':
           case '5': case '6': case '7': case '8': case '9':
           case 'a': case 'b': case 'c': case 'd': case 'e': case 'f':
           case 'A': case 'B': case 'C': case 'D': case 'E': case 'F':
             OS << "\"\"";
         }
       }
 
       assert(Char <= 0xff &&
              "Characters above 0xff should already have been handled.");
 
       if (isPrintable(Char))
         OS << (char)Char;
       else  // Output anything hard as an octal escape.
         OS << '\\'
            << (char)('0' + ((Char >> 6) & 7))
            << (char)('0' + ((Char >> 3) & 7))
            << (char)('0' + ((Char >> 0) & 7));
-      break;
+    } else {
       // Handle some common non-printable cases to make dumps prettier.
-    case '\\': OS << "\\\\"; break;
-    case '"': OS << "\\\""; break;
-    case '\a': OS << "\\a"; break;
-    case '\b': OS << "\\b"; break;
-    case '\f': OS << "\\f"; break;
-    case '\n': OS << "\\n"; break;
-    case '\r': OS << "\\r"; break;
-    case '\t': OS << "\\t"; break;
-    case '\v': OS << "\\v"; break;
+      OS << Escaped;
     }
   }
   OS << '"';
 }
 
 /// getLocationOfByte - Return a source location that points to the specified
 /// byte of this string literal.
 ///

clang/lib/AST/StmtPrinter.cpp

 }
 
 void StmtPrinter::VisitDeclRefExpr(DeclRefExpr *Node) {
   if (const auto *OCED = dyn_cast<OMPCapturedExprDecl>(Node->getDecl())) {
     OCED->getInit()->IgnoreImpCasts()->printPretty(OS, nullptr, Policy);
     return;
   }
   if (const auto *TPOD = dyn_cast<TemplateParamObjectDecl>(Node->getDecl())) {
-    TPOD->printAsExpr(OS);
+    TPOD->printAsExpr(OS, Policy);
     return;
   }
   if (NestedNameSpecifier *Qualifier = Node->getQualifier())
     Qualifier->print(OS, Policy);
   if (Node->hasTemplateKeyword())
     OS << "template ";
   if (Policy.CleanUglifiedParameters &&
       isa<ParmVarDecl, NonTypeTemplateParmDecl>(Node->getDecl()) &&

clang/lib/AST/TemplateBase.cpp

case Type: {
     break;
   }
 
   case Declaration: {
     // FIXME: Include the type if it's not obvious from the context.
     NamedDecl *ND = getAsDecl();
     if (getParamTypeForDecl()->isRecordType()) {
       if (auto *TPO = dyn_cast<TemplateParamObjectDecl>(ND)) {
-        TPO->printAsInit(Out);
+        TPO->printAsInit(Out, Policy);
         break;
       }
     }
     if (auto *VD = dyn_cast<ValueDecl>(ND)) {
       if (needsAmpersandOnTemplateArg(getParamTypeForDecl(), VD->getType()))
         Out << "&";
     }
     ND->printQualifiedName(Out);

clang/lib/Sema/Sema.cpp

PrintingPolicy Sema::getPrintingPolicy(const ASTContext &Context,
   if (!Policy.Bool) {
     if (const MacroInfo *BoolMacro = PP.getMacroInfo(Context.getBoolName())) {
       Policy.Bool = BoolMacro->isObjectLike() &&
                     BoolMacro->getNumTokens() == 1 &&
                     BoolMacro->getReplacementToken(0).is(tok::kw__Bool);
     }
   }
 
+  // Shorten the data output if needed
+  Policy.EntireContentsOfLargeArray = false;
+
   return Policy;
 }
 
 void Sema::ActOnTranslationUnitScope(Scope *S) {
   TUScope = S;
   PushDeclContext(S, Context.getTranslationUnitDecl());
 }
 

clang/test/SemaCXX/cxx2a-nttp-printing.cpp

+// RUN: %clang_cc1 %s -std=c++20 -fsyntax-only -verify
+
+template <int N> struct Str {
+  constexpr Str(char const (&s)[N]) { __builtin_memcpy(value, s, N); }
+  char value[N];
+};
+
+template <Str V> class ASCII {};
+
+void Foo(ASCII<"this nontype template argument is too long to print">); // expected-note {{no known conversion from 'ASCII<{"this nontype template argument is too long"}>' to 'ASCII<{"this nontype template argument is too long to print"}>'}}
+void Bar(ASCII<"this nttp argument is too short">);                     // expected-note {{no known conversion from 'ASCII<{{119, 97, 105, 116, 32, 97, 32, 115, 27, 99, 111, 110, 100, 0}}>' to 'ASCII<{"this nttp argument is too short"}>'}}
+void Meow(ASCII<"what|">);                                              // expected-note {{no known conversion from 'ASCII<{"what??!"}>' to 'ASCII<{"what|"}>' for 1st argument}}
+
+void test_ascii() {
+  ASCII<"this nontype template argument"
+        " is too long">
+      a;
+  Foo(a);                 // expected-error {{no matching function}}
+  decltype(a)::display(); // expected-error {{no member named 'display' in 'ASCII<{"this nontype template argument is [...]"}>'}}
+}
+
+void test_non_ascii() {
+  ASCII<"wait a s\033cond"> a;
+  Bar(a);                 // expected-error {{no matching function}}
+  decltype(a)::display(); // expected-error {{no member named 'display' in 'ASCII<{{119, 97, 105, 116, 32, 97, 32, 115, 27, 99, ...}}>'}}
+}
+
+// The dialects (C++20 and above) that accept string literals as non-type
+// template arguments do not support trigraphs.
+void test_trigraph() {
+  ASCII<"what??!"> a;     // expected-warning {{trigraph ignored}}
+  Meow(a);                // expected-error {{no matching function}}
+  decltype(a)::display(); // expected-error {{no member named 'display' in 'ASCII<{"what??!"}>'}}
+}

clang/test/SemaTemplate/temp_arg_string_printing.cpp

+// RUN: %clang_cc1 -std=c++20 -fsyntax-only -ast-print %s | FileCheck %s
+
+using size_t = __SIZE_TYPE__;
+static_assert(__has_builtin(__make_integer_seq));
+
+template <class T, T... I> class idx_seq {};
+template <size_t N> using make_idx_seq = __make_integer_seq<idx_seq, size_t, N>;
+
+template <class CharT, size_t N>
+struct Str {
+  constexpr Str(CharT const (&s)[N]) : Str(s, make_idx_seq<N>()) {}
+  CharT value[N];
+
+private:
+  template <size_t... I>
+  constexpr Str(CharT const (&s)[N], idx_seq<size_t, I...>) : value{s[I]...} {}
+};
+
+template <Str> class ASCII {};
+
+void not_string() {
+  // CHECK{LITERAL}: ASCII<{{9, -1, 42}}>
+  new ASCII<(int[]){9, -1, 42}>;
+  // CHECK{LITERAL}: ASCII<{{3.140000e+00, 0.000000e+00, 4.200000e+01}}>
+  new ASCII<(double[]){3.14, 0., 42.}>;
+}
+
+void narrow() {
+  // CHECK{LITERAL}: ASCII<{""}>
+  new ASCII<"">;
+  // CHECK{LITERAL}: ASCII<{"the quick brown fox jumps"}>
+  new ASCII<"the quick brown fox jumps">;
+  // CHECK{LITERAL}: ASCII<{"OVER THE LAZY DOG 0123456789"}>
+  new ASCII<"OVER THE LAZY DOG 0123456789">;
+  // CHECK{LITERAL}: ASCII<{"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<R"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{{101, 115, 99, 97, 112, 101, 0, 0}}>
+  new ASCII<"escape\0">;
+  // CHECK{LITERAL}: ASCII<{"escape\r\n"}>
+  new ASCII<"escape\r\n">;
+  // CHECK{LITERAL}: ASCII<{"escape\\\t\f\v"}>
+  new ASCII<"escape\\\t\f\v">;
+  // CHECK{LITERAL}: ASCII<{"escape\a\bc"}>
+  new ASCII<"escape\a\b\c">;
+  // CHECK{LITERAL}: ASCII<{{110, 111, 116, 17, 0}}>
+  new ASCII<"not\x11">;
+  // CHECK{LITERAL}: ASCII<{{18, 20, 127, 16, 1, 32, 97, 98, 99, 0}}>
+  new ASCII<"\x12\x14\x7f\x10\x01 abc">;
+  // CHECK{LITERAL}: ASCII<{{18, 20, 127, 16, 1, 32, 97, 98, 99, 100, 0}}>
+  new ASCII<"\x12\x14\x7f\x10\x01 abcd">;
+  // CHECK{LITERAL}: ASCII<{"print more characters as string"}>
+  new ASCII<"print more characters as string">;
+  // CHECK{LITERAL}: ASCII<{"print more characters as string, no uplimit"}>
+  new ASCII<"print more characters as string, no uplimit">;
+}
+
+void wide() {
+  // CHECK{LITERAL}: ASCII<{L""}>
+  new ASCII<L"">;
+  // CHECK{LITERAL}: ASCII<{L"the quick brown fox jumps"}>
+  new ASCII<L"the quick brown fox jumps">;
+  // CHECK{LITERAL}: ASCII<{L"OVER THE LAZY DOG 0123456789"}>
+  new ASCII<L"OVER THE LAZY DOG 0123456789">;
+  // CHECK{LITERAL}: ASCII<{L"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<LR"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{{101, 115, 99, 97, 112, 101, 0, 0}}>
+  new ASCII<L"escape\0">;
+  // CHECK{LITERAL}: ASCII<{L"escape\r\n"}>
+  new ASCII<L"escape\r\n">;
+  // CHECK{LITERAL}: ASCII<{L"escape\\\t\f\v"}>
+  new ASCII<L"escape\\\t\f\v">;
+  // CHECK{LITERAL}: ASCII<{L"escape\a\bc"}>
+  new ASCII<L"escape\a\b\c">;
+  // CHECK{LITERAL}: ASCII<{{110, 111, 116, 17, 0}}>
+  new ASCII<L"not\x11">;
+  // CHECK{LITERAL}: ASCII<{{18, 20, 255, 22909, 136, 32, 97, 98, 99, 0}}>
+  new ASCII<L"\x12\x14\xff\x597d\x88 abc">;
+  // CHECK{LITERAL}: ASCII<{{18, 20, 255, 22909, 136, 32, 97, 98, 99, 100, 0}}>
+  new ASCII<L"\x12\x14\xff\x597d\x88 abcd">;
+  // CHECK{LITERAL}: ASCII<{L"print more characters as string"}>
+  new ASCII<L"print more characters as string">;
+  // CHECK{LITERAL}: ASCII<{L"print more characters as string, no uplimit"}>
+  new ASCII<L"print more characters as string, no uplimit">;
+}
+
+void utf8() {
+  // CHECK{LITERAL}: ASCII<{u8""}>
+  new ASCII<u8"">;
+  // CHECK{LITERAL}: ASCII<{u8"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<u8R"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{{101, 115, 99, 97, 112, 101, 0, 0}}>
+  new ASCII<u8"escape\0">;
+  // CHECK{LITERAL}: ASCII<{u8"escape\r\n"}>
+  new ASCII<u8"escape\r\n">;
+  // CHECK{LITERAL}: ASCII<{{229, 165, 189, 239, 191, 189, 0}}>
+  new ASCII<u8"\u597d\ufffd">;
+  // CHECK{LITERAL}: ASCII<{u8"print more characters as string, no uplimit"}>
+  new ASCII<u8"print more characters as string, no uplimit">;
+}
+
+void utf16() {
+  // CHECK{LITERAL}: ASCII<{u""}>
+  new ASCII<u"">;
+  // CHECK{LITERAL}: ASCII<{u"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<uR"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{{101, 115, 99, 97, 112, 101, 0, 0}}>
+  new ASCII<u"escape\0">;
+  // CHECK{LITERAL}: ASCII<{u"escape\r\n"}>
+  new ASCII<u"escape\r\n">;
+  // CHECK{LITERAL}: ASCII<{{22909, 65533, 0}}>
+  new ASCII<u"\u597d\ufffd">;
+  // CHECK{LITERAL}: ASCII<{u"print more characters as string, no uplimit"}>
+  new ASCII<u"print more characters as string, no uplimit">;
+}
+
+void utf32() {
+  // CHECK{LITERAL}: ASCII<{U""}>
+  new ASCII<U"">;
+  // CHECK{LITERAL}: ASCII<{U"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<UR"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{{101, 115, 99, 97, 112, 101, 0, 0}}>
+  new ASCII<U"escape\0">;
+  // CHECK{LITERAL}: ASCII<{U"escape\r\n"}>
+  new ASCII<U"escape\r\n">;
+  // CHECK{LITERAL}: ASCII<{{22909, 131358, 0}}>
+  new ASCII<U"\u597d\U0002011E">;
+  // CHECK{LITERAL}: ASCII<{U"print more characters as string, no uplimit"}>
+  new ASCII<U"print more characters as string, no uplimit">;
+}

clang/unittests/AST/TypePrinterTest.cpp

TEST(TypePrinter, ParamsUglified) {
 
   ASSERT_TRUE(PrintedTypeMatches(Code, {},
                                  varDecl(hasType(qualType().bind("id"))),
                                  "const __f<_Tp &> *", nullptr));
   ASSERT_TRUE(PrintedTypeMatches(Code, {},
                                  varDecl(hasType(qualType().bind("id"))),
                                  "const f<Tp &> *", Clean));
 }
+
+TEST(TypePrinter, TemplateIdWithNTTP) {
+  constexpr char Code[] = R"cpp(
+    template <int N>
+    struct Str {
+      constexpr Str(char const (&s)[N]) { __builtin_memcpy(value, s, N); }
+      char value[N];
+    };
+    template <Str> class ASCII {};
+
+    ASCII<"this nontype template argument is too long to print"> x;
+  )cpp";
+  auto Matcher = classTemplateSpecializationDecl(
+      hasName("ASCII"), has(cxxConstructorDecl(
+                            isMoveConstructor(),
+                            has(parmVarDecl(hasType(qualType().bind("id")))))));
+
+  ASSERT_TRUE(PrintedTypeMatches(
+      Code, {"-std=c++20"}, Matcher,
+      R"(ASCII<{"this nontype template argument is [...]"}> &&)",
+      [](PrintingPolicy &Policy) {
+        Policy.EntireContentsOfLargeArray = false;
+      }));
+
+  ASSERT_TRUE(PrintedTypeMatches(
+      Code, {"-std=c++20"}, Matcher,
+      R"(ASCII<{"this nontype template argument is too long to print"}> &&)",
+      [](PrintingPolicy &Policy) {
+        Policy.EntireContentsOfLargeArray = true;
+      }));
+}