[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.

902–903

(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

288 ↗

(On Diff #391833)

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 ↗

(On Diff #391833)

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

288 ↗

(On Diff #391833)

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

288 ↗

(On Diff #391833)

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 ↗

(On Diff #408137)

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 ↗

(On Diff #408137)

[lichray]

• Revert some auto's

[lichray]

clang/include/clang/Basic/CharInfo.h

199–200 ↗

(On Diff #408137)

? 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 ↗

(On Diff #408137)

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 ↗

(On Diff #408137)

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 ↗

(On Diff #408137)

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/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 ArrayType *ATy,
+                                    const APValue *Data, size_t Size) {
+  if (Size == 0)
+    return false;
+
+  QualType Ty = ATy->getElementType();
+  if (!Ty->isAnyCharacterType())
+    return false;
+
+  // Nothing we can do about a sequence that is not null-terminated
+  if (!Data[--Size].getInt().isZero())
+    return false;
+
+  constexpr size_t MaxN = 36;
+  char Buf[MaxN * 2 + 3] = {'"'}; // "At most 36 escaped chars" + \0
+  auto *pBuf = Buf + 1;
+
+  // Better than printing a two-digit sequence of 10 integers.
+  StringRef Ellipsis;
+  if (Size > MaxN) {
+    Ellipsis = "[...]";
+    Size = std::min(MaxN - Ellipsis.size(), Size);
+  }
+
+  auto writeEscape = [](char *Ptr, char Ch) {
+    Ptr[0] = '\\';
+    Ptr[1] = Ch;
+    return Ptr + 2;
+  };
+
+  for (auto &Val : ArrayRef<const APValue>(Data, Size)) {
+    auto Char64 = Val.getInt().getExtValue();
+    if (Char64 > 0x7f)
+      return false; // Bye bye, see you in integers.
+    switch (auto Ch = static_cast<unsigned char>(Char64)) {
+    default:
+      if (isPrintable(Ch)) {
+        *pBuf++ = Ch;
+        break;
+      }
+      return false;
+    case '\\':
+    case '\'': // The diagnostic message is 'quoted'
+    case '"':
+      pBuf = writeEscape(pBuf, Ch);
+      break;
+    case '\0':
+      pBuf = writeEscape(pBuf, '0');
+      break;
+    case '\a':
+      pBuf = writeEscape(pBuf, 'a');
+      break;
+    case '\b':
+      pBuf = writeEscape(pBuf, 'b');
+      break;
+    case '\f':
+      pBuf = writeEscape(pBuf, 'f');
+      break;
+    case '\n':
+      pBuf = writeEscape(pBuf, 'n');
+      break;
+    case '\r':
+      pBuf = writeEscape(pBuf, 'r');
+      break;
+    case '\t':
+      pBuf = writeEscape(pBuf, 't');
+      break;
+    case '\v':
+      pBuf = writeEscape(pBuf, 'v');
+      break;
+    }
+  }
+
+  if (!Ellipsis.empty()) {
+    memcpy(pBuf, Ellipsis.data(), Ellipsis.size());
+    pBuf += Ellipsis.size();
+  }
+  *pBuf++ = '"';
+
+  if (Ty->isWideCharType())
+    Out << 'L';
+  else if (Ty->isChar8Type())
+    Out << "u8";
+  else if (Ty->isChar16Type())
+    Out << 'u';
+  else if (Ty->isChar32Type())
+    Out << 'U';
+
+  Out << StringRef(Buf, pBuf - 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, 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;
+          Out << "...}";
+          return;
         }
+        LLVM_FALLTHROUGH;
+      default:
         getArrayInitializedElt(I).printPretty(Out, Policy, ElemTy, Ctx);
       }
     }
     Out << '}';
     return;
   }
   case APValue::Struct: {
     Out << '{';

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 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<{"escape\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, ...}}>
+  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 even more characters as string"}>
+  new ASCII<"print even more characters as string">;
+  // CHECK{LITERAL}: ASCII<{"print many characters no more t[...]"}>
+  new ASCII<"print many characters no more than a limit">;
+  // CHECK{LITERAL}: ASCII<{"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"}>
+  new ASCII<"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0">;
+  // CHECK{LITERAL}: ASCII<{"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n[...]"}>
+  new ASCII<"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n">;
+}
+
+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<{L"escape\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, ...}}>
+  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 even more characters as string"}>
+  new ASCII<L"print even more characters as string">;
+  // CHECK{LITERAL}: ASCII<{L"print many characters no more t[...]"}>
+  new ASCII<L"print many characters no more than a limit">;
+  // CHECK{LITERAL}: ASCII<{L"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0"}>
+  new ASCII<L"\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0">;
+  // CHECK{LITERAL}: ASCII<{L"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n[...]"}>
+  new ASCII<L"\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n\n">;
+}
+
+void utf8()
+{
+  // CHECK{LITERAL}: ASCII<{u8""}>
+  new ASCII<u8"">;
+  // CHECK{LITERAL}: ASCII<{u8"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<u8R"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{u8"escape\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 many characters no more t[...]"}>
+  new ASCII<u8"print many characters no more than a limit">;
+}
+
+void utf16()
+{
+  // CHECK{LITERAL}: ASCII<{u""}>
+  new ASCII<u"">;
+  // CHECK{LITERAL}: ASCII<{u"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<uR"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{u"escape\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 many characters no more t[...]"}>
+  new ASCII<u"print many characters no more than a limit">;
+}
+
+void utf32()
+{
+  // CHECK{LITERAL}: ASCII<{U""}>
+  new ASCII<U"">;
+  // CHECK{LITERAL}: ASCII<{U"\\`~!@#$%^&*()_+-={}[]|\'\";:,.<>?/"}>
+  new ASCII<UR"(\`~!@#$%^&*()_+-={}[]|'";:,.<>?/)">;
+  // CHECK{LITERAL}: ASCII<{U"escape\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 many characters no more t[...]"}>
+  new ASCII<U"print many characters no more than a limit">;
+}
 No newline at end of file