[lldb/DataFormatters] Delete GetStringPrinterEscapingHelper

[vsk]

Summary

Languages can have different ways of formatting special characters.
E.g. when debugging C++ code a string might look like "\b", but when
debugging Swift code the same string would look like "\u{8}".

To make this work, plugins override GetStringPrinterEscapingHelper.
However, because there's a large amount of subtly divergent work done in
each override, we end up with large amounts of duplicated code. And all
the memory smashers fixed in one copy of the logic (see D73860) don't
get fixed in the others.

IMO the GetStringPrinterEscapingHelper is overly general and hard to
use. I propose deleting it and replacing it with an EscapeStyle enum,
which can be set as needed by each plugin.

A fix for some swift-lldb memory smashers falls out fairly naturally
from this deletion (https://github.com/apple/llvm-project/pull/1046). As
the swift logic becomes really tiny, I propose moving it upstream as
part of this change. I've added unit tests to cover it.

rdar://61419673

[vsk]

+ Raphael, I suppose this is in a similar direction as D68691.

[aprantl]

lldb/source/DataFormatters/StringPrinter.cpp

126

We have a lot of implementations of this function all over our projects (git grep '\\\\r' llvm/lib) that we might want to factor this into a support function.

[vsk]

lldb/source/DataFormatters/StringPrinter.cpp

126

I do see another utf decoder implementation in YAMLParser, but it's different enough from lldb's that I'd prefer to hold off on attempting to unify these for some later patch.

[JDevlieghere]

This looks great, especially with the extra unit tests. Thanks Vedant.

Have you asked the foundation people about the ASCII support in NSString?

[shafik]

lldb/source/DataFormatters/StringPrinter.cpp

50

m_deleter(std::move(rhs.m_deleter))

69

std::move(rhs.m_deleter)

173

constexpr

259

Maybe I am missing something but I don't think the sprintf below can go up to 14 chars.

[shafik]

lldb/unittests/DataFormatter/StringPrinterTests.cpp

109

We have raw string literals since C++11:

EXPECT_TRUE(matches("\a", R"("\a")"));

[labath]

I haven't looked at the code in detail, but it seems ok to me.

What does not seem ok is the hand-rolled matching in the tests. A more idiomatic approach would be to replace isFormatCorrect with a wrapper function which can be called from a test macro, and let gtest do the matching:
Say, something like this:

/// Return the formatted string, or None if formatting failed.
Optional<std::string> format(StringRef input, ...) {
  ...
  if (success)
    return out.GetString();
  return None;
}
...
EXPECT_EQ(format("foo", ...), std::string("foo")); // std::string is needed because Optional<string> and const char * are not comparable -- may want to make an alias/lambda for that

[vsk]

Sorry for the delay, I plan to have an update for this soon.

In D77843#1978964, @JDevlieghere wrote:

Have you asked the foundation people about the ASCII support in NSString?

No, I'm not sure what to ask. Having thought things over, I think my 'FIXME' about 'In practice, do we ever prefer ASCII-only formatting over UTF8 formatting?' was premature, so I'll delete it.

I did some experiments with forcing invalid data into an NSString and seeing what comes out of NSLog. Both with dataUsingEncoding:NSASCIIStringEncoding, or with just typing in invalid bytes, NSLog just prints an empty string (in the latter case -WCFString-literal even warns that input conversion is stopped after an invalid byte is seen). I don't think it'd be helpful for lldb to match that behavior? At least, we don't match that behavior today, we try to escape and print out the invalid bytes.

If we want to continue to not match NSLog's behavior, then I think we should we treat invalid bytes under ASCII vs. utf differently (we can print the actual character in the utf case, and a sequence of '\x..\x..' otherwise).

lldb/source/DataFormatters/StringPrinter.cpp

259

You're right, I got %x mixed up with %u.

[aprantl]

lldb/unittests/DataFormatter/StringPrinterTests.cpp

1

drop the redundant C++ marker

[vsk]

lldb/source/DataFormatters/StringPrinter.cpp

173

Cool, I learned that only 'constexpr' guarantees that you have a compile-time constant. Fixed here and below.

lldb/unittests/DataFormatter/StringPrinterTests.cpp

109

I personally find the current version much clearer, but can change this if others feel strongly.

[vsk]

Address review feedback:

• Use standard gtest operators (EXPECT_EQ)
• constexpr/std::move cleanup, comment cleanups, sprintf length fix

Also, I took the opportunity to further unify the ASCII and UTF8 handling --
this lets us delete a bunch of duplicated code. PTAL, thanks.

[vsk]

lldb/source/DataFormatters/StringPrinter.cpp

405

This is what I mean. The whole ReadStringAndDumpToStream<ASCII> specialization can be deleted and replaced with a call to DumpEncodedBufferToStream, as the UTF & ASCII code paths are really similar.

[labath]

The test stuff looks good to me.

lldb/unittests/DataFormatter/StringPrinterTests.cpp

32

it looks like escape_style could be a regular argument instead of a template.

109

I think the raw strings are cleaner, particularly when it comes to strings like "\\\"" and "\\\\"

[vsk]

Address review feedback:

• Make 'escape_style' a regular parameter, use raw string literals

[vsk]

Friendly ping.

[shafik]

lldb/source/DataFormatters/StringPrinter.cpp

174

I really wish we could get ride of the naked new. It seems possible.

• We know the buffer size
• We know the "expected" escaped_len
• We could write something like a make_StringPrinterBufferPointer in the same spirit as make_unique

The problem we want to avoid w/ the naked new is that the code becomes more complicated over time and somehow a later change disconnects the new w/ the creation of the StringPrinterBufferPointer which manages the lifetime.

This comment applies to the code later on as well.

[vsk]

• Avoid heap memory management in "StringPrinterBufferPointer" entirely.
• Rename "StringPrinterBufferPointer" to "DecodedCharBuffer", as that seems to more accurately reflect what the class is for.

[shafik]

LGTM with minor comments, this is a big set of changes, I would prefer if one of the other reviewers also gave it a second look.

lldb/source/DataFormatters/StringPrinter.cpp

49

just m_data it will decay to a pointer.

293–296

It feels like the two lambdas here could be one by also capturing elem_type, it would make the lambda larger but is that a concern? Not a big deal just feels like needlessly duplicate code.

648

Super nitpick, can we switch order of the UTF8 and the ASCII specialization so that they appear in the same order as the ReadStringAndDumpToStream above.

[vsk]

lldb/source/DataFormatters/StringPrinter.cpp

293–296

Sure, these can be folded together.

648

No, because the ASCII specialization calls the UTF8 specialization, and the compiler complains that the use occurs before the definition. I'll just reorder the specializations of ReadStringAndDumpToStream so that things match.

[vsk]

Address review feedback

[labath]

Yeah, I think this looks good too.

lldb/source/DataFormatters/StringPrinter.cpp

42–43

What's up with all the reinterpret_casting? T* is implicitly convertible to a void*...

[vsk]

lldb/source/DataFormatters/StringPrinter.cpp

42–43

Ah thanks for catching this, I'll get rid of the redundant casts before committing.

lldb/include/lldb/DataFormatters/StringPrinter.h

 namespace lldb_private {
 namespace formatters {
 class StringPrinter {
 public:
   enum class StringElementType { ASCII, UTF8, UTF16, UTF32 };
 
   enum class GetPrintableElementType { ASCII, UTF8 };
 
+  enum class EscapeStyle { CXX, Swift };
+
   class DumpToStreamOptions {
   public:
     DumpToStreamOptions() = default;
 
     void SetStream(Stream *s) { m_stream = s; }
 
     Stream *GetStream() const { return m_stream; }
 
public:
     void SetEscapeNonPrintables(bool e) { m_escape_non_printables = e; }
 
     bool GetEscapeNonPrintables() const { return m_escape_non_printables; }
 
     void SetIgnoreMaxLength(bool e) { m_ignore_max_length = e; }
 
     bool GetIgnoreMaxLength() const { return m_ignore_max_length; }
 
-    void SetLanguage(lldb::LanguageType l) { m_language_type = l; }
+    void SetEscapeStyle(EscapeStyle style) { m_escape_style = style; }
 
-    lldb::LanguageType GetLanguage() const { return m_language_type; }
+    EscapeStyle GetEscapeStyle() const { return m_escape_style; }
 
   private:
     /// The used output stream.
     Stream *m_stream = nullptr;
     /// String that should be printed before the heading quote character.
     std::string m_prefix_token;
     /// String that should be printed after the trailing quote character.
     std::string m_suffix_token;
     /// The quote character that should surround the string.
     char m_quote = '"';
     /// The length of the memory region that should be dumped in bytes.
     uint32_t m_source_size = 0;
     bool m_needs_zero_termination = true;
     /// True iff non-printable characters should be escaped when dumping
     /// them to the stream.
     bool m_escape_non_printables = true;
     /// True iff the max-string-summary-length setting of the target should
     /// be ignored.
     bool m_ignore_max_length = false;
     /// True iff a zero bytes ('\0') should terminate the memory region that
     /// is being dumped.
     bool m_zero_is_terminator = true;
-    /// The language that the generated string literal is supposed to be valid
-    /// for. This changes for example what and how certain characters are
-    /// escaped.
-    /// For example, printing the a string containing only a quote (") char
-    /// with eLanguageTypeC would escape the quote character.
-    lldb::LanguageType m_language_type = lldb::eLanguageTypeUnknown;
+    /// The language-specific style for escaping special characters.
+    EscapeStyle m_escape_style = EscapeStyle::CXX;
   };
 
   class ReadStringAndDumpToStreamOptions : public DumpToStreamOptions {
   public:
     ReadStringAndDumpToStreamOptions() = default;
 
     ReadStringAndDumpToStreamOptions(ValueObject &valobj);
 
public:
     void SetIsTruncated(bool t) { m_is_truncated = t; }
 
     bool GetIsTruncated() const { return m_is_truncated; }
   private:
     DataExtractor m_data;
     bool m_is_truncated = false;
   };
 
-  // I can't use a std::unique_ptr for this because the Deleter is a template
-  // argument there
-  // and I want the same type to represent both pointers I want to free and
-  // pointers I don't need to free - which is what this class essentially is
-  // It's very specialized to the needs of this file, and not suggested for
-  // general use
-  struct StringPrinterBufferPointer {
-  public:
-    typedef std::function<void(const uint8_t *)> Deleter;
-
-    StringPrinterBufferPointer(std::nullptr_t ptr)
-        : m_data(nullptr), m_size(0), m_deleter() {}
-
-    StringPrinterBufferPointer(const uint8_t *bytes, size_t size,
-                               Deleter deleter = nullptr)
-        : m_data(bytes), m_size(size), m_deleter(deleter) {}
-
-    StringPrinterBufferPointer(const char *bytes, size_t size,
-                               Deleter deleter = nullptr)
-        : m_data(reinterpret_cast<const uint8_t *>(bytes)), m_size(size),
-          m_deleter(deleter) {}
-
-    StringPrinterBufferPointer(StringPrinterBufferPointer &&rhs)
-        : m_data(rhs.m_data), m_size(rhs.m_size), m_deleter(rhs.m_deleter) {
-      rhs.m_data = nullptr;
-    }
-
-    ~StringPrinterBufferPointer() {
-      if (m_data && m_deleter)
-        m_deleter(m_data);
-      m_data = nullptr;
-    }
-
-    const uint8_t *GetBytes() const { return m_data; }
-
-    size_t GetSize() const { return m_size; }
-
-    StringPrinterBufferPointer &
-    operator=(StringPrinterBufferPointer &&rhs) {
-      if (m_data && m_deleter)
-        m_deleter(m_data);
-      m_data = rhs.m_data;
-      m_size = rhs.m_size;
-      m_deleter = rhs.m_deleter;
-      rhs.m_data = nullptr;
-      return *this;
-    }
-
-  private:
-    DISALLOW_COPY_AND_ASSIGN(StringPrinterBufferPointer);
-
-    const uint8_t *m_data;
-    size_t m_size;
-    Deleter m_deleter;
-  };
-
-  typedef std::function<StringPrinter::StringPrinterBufferPointer(
-      uint8_t *, uint8_t *, uint8_t *&)>
-      EscapingHelper;
-  typedef std::function<EscapingHelper(GetPrintableElementType)>
-      EscapingHelperGenerator;
-
-  static EscapingHelper
-  GetDefaultEscapingHelper(GetPrintableElementType elem_type);
-
   template <StringElementType element_type>
   static bool
   ReadStringAndDumpToStream(const ReadStringAndDumpToStreamOptions &options);
 
   template <StringElementType element_type>
   static bool
   ReadBufferAndDumpToStream(const ReadBufferAndDumpToStreamOptions &options);
 };
 
 } // namespace formatters
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_STRINGPRINTER_H

lldb/include/lldb/Target/Language.h

public:
 
   virtual HardcodedFormatters::HardcodedSyntheticFinder
   GetHardcodedSynthetics();
 
   virtual std::vector<ConstString>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic);
 
-  virtual lldb_private::formatters::StringPrinter::EscapingHelper
-      GetStringPrinterEscapingHelper(
-          lldb_private::formatters::StringPrinter::GetPrintableElementType);
-
   virtual std::unique_ptr<TypeScavenger> GetTypeScavenger();
 
   virtual const char *GetLanguageSpecificTypeLookupHelp();
 
   // If a language can have more than one possible name for a method, this
   // function can be used to enumerate them. This is useful when doing name
   // lookups.
   virtual std::vector<ConstString>

lldb/source/DataFormatters/StringPrinter.cpp

 
 #include <ctype.h>
 #include <locale>
 #include <memory>
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
+using GetPrintableElementType = StringPrinter::GetPrintableElementType;
+using StringElementType = StringPrinter::StringElementType;
+
+/// StringPrinterBufferPointer is basically a unique_ptr specialized for the
+/// needs of this file: the buffer pointer doesn't /have/ to be heap-allocated,
+/// and the convenience constructors make it easier to create string chunks.
+struct StringPrinterBufferPointer {
+public:
+  using Deleter = std::function<void(const uint8_t *)>;
+
+  StringPrinterBufferPointer(std::nullptr_t ptr)
+      : m_data(nullptr), m_size(0), m_deleter() {}
+
+  StringPrinterBufferPointer(const uint8_t *bytes, size_t size,
+                             Deleter deleter = nullptr)
+      : m_data(bytes), m_size(size), m_deleter(deleter) {}
+
+  StringPrinterBufferPointer(const char *bytes, size_t size,
+                             Deleter deleter = nullptr)
+      : m_data(reinterpret_cast<const uint8_t *>(bytes)), m_size(size),
+        m_deleter(deleter) {}
+
+  StringPrinterBufferPointer(StringPrinterBufferPointer &&rhs)
+      : m_data(rhs.m_data), m_size(rhs.m_size), m_deleter(rhs.m_deleter) {
+    rhs.m_data = nullptr;
+  }
+
+  ~StringPrinterBufferPointer() {
+    if (m_data && m_deleter)
+      m_deleter(m_data);
+    m_data = nullptr;
+  }
+
+  const uint8_t *GetBytes() const { return m_data; }
+
+  size_t GetSize() const { return m_size; }
+
+  StringPrinterBufferPointer &operator=(StringPrinterBufferPointer &&rhs) {
+    if (m_data && m_deleter)
+      m_deleter(m_data);
+    m_data = rhs.m_data;
+    m_size = rhs.m_size;
+    m_deleter = rhs.m_deleter;
+    rhs.m_data = nullptr;
+    return *this;
+  }
+
+private:
+  DISALLOW_COPY_AND_ASSIGN(StringPrinterBufferPointer);
+
+  const uint8_t *m_data;
+  size_t m_size;
+  Deleter m_deleter;
+};
+
+using EscapingHelper =
+    std::function<StringPrinterBufferPointer(uint8_t *, uint8_t *, uint8_t *&)>;
 
 // we define this for all values of type but only implement it for those we
 // care about that's good because we get linker errors for any unsupported type
-template <lldb_private::formatters::StringPrinter::StringElementType type>
-static StringPrinter::StringPrinterBufferPointer
-GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next);
+template <StringElementType type>
+static StringPrinterBufferPointer
+GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
+                 StringPrinter::EscapeStyle escape_style);
 
-// mimic isprint() for Unicode codepoints
-static bool isprint(char32_t codepoint) {
+// Mimic isprint() for Unicode codepoints.
+static bool isprint32(char32_t codepoint) {
   if (codepoint <= 0x1F || codepoint == 0x7F) // C0
   {
     return false;
   }
   if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
   {
     return false;
   }
static bool isprint32(char32_t codepoint) {
   if (codepoint >= 0xFFF9 &&
       codepoint <= 0xFFFF) // interlinears and generally specials
   {
     return false;
   }
   return true;
 }
 
-template <>
-StringPrinter::StringPrinterBufferPointer
-GetPrintableImpl<StringPrinter::StringElementType::ASCII>(uint8_t *buffer,
-                                                          uint8_t *buffer_end,
-                                                          uint8_t *&next) {
-  StringPrinter::StringPrinterBufferPointer retval = {nullptr};
-
-  switch (*buffer) {
+StringPrinterBufferPointer
+attemptASCIIEscape(char32_t c, StringPrinter::EscapeStyle escape_style) {
+  const bool is_swift_escape_style =
+      escape_style == StringPrinter::EscapeStyle::Swift;
+  switch (c) {
   case 0:
-    retval = {"\\0", 2};
-    break;
+    return {"\\0", 2};
   case '\a':
-    retval = {"\\a", 2};
-    break;
+    return {"\\a", 2};
   case '\b':
-    retval = {"\\b", 2};
-    break;
+    if (is_swift_escape_style)
+      return nullptr;
+    return {"\\b", 2};
   case '\f':
-    retval = {"\\f", 2};
-    break;
+    if (is_swift_escape_style)
+      return nullptr;
+    return {"\\f", 2};
   case '\n':
-    retval = {"\\n", 2};
-    break;
+    return {"\\n", 2};
   case '\r':
-    retval = {"\\r", 2};
-    break;
+    return {"\\r", 2};
   case '\t':
-    retval = {"\\t", 2};
-    break;
+    return {"\\t", 2};
   case '\v':
-    retval = {"\\v", 2};
-    break;
+    if (is_swift_escape_style)
+      return nullptr;
+    return {"\\v", 2};
   case '\"':
-    retval = {"\\\"", 2};
-    break;
+    return {"\\\"", 2};
+  case '\'':
+    if (is_swift_escape_style)
+      return {"\\'", 2};
+    return nullptr;
   case '\\':
-    retval = {"\\\\", 2};
-    break;
-  default:
-    if (isprint(*buffer))
-      retval = {buffer, 1};
-    else {
-      uint8_t *data = new uint8_t[5];
-      sprintf((char *)data, "\\x%02x", *buffer);
-      retval = {data, 4, [](const uint8_t *c) { delete[] c; }};
-      break;
-    }
-  }
+    return {"\\\\", 2};
+  return nullptr;
 
+template <>
+StringPrinterBufferPointer GetPrintableImpl<StringElementType::ASCII>(
+    uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
+    StringPrinter::EscapeStyle escape_style) {
+  // The ASCII helper always advances 1 byte at a time.
   next = buffer + 1;
+
+  StringPrinterBufferPointer retval = attemptASCIIEscape(*buffer, escape_style);
+  if (retval.GetSize())
     return retval;
+  if (isprint(*buffer))
+    return {buffer, 1};
+
+  unsigned escaped_len;
+  const unsigned max_buffer_size = 7;
+  uint8_t *data = new uint8_t[max_buffer_size];
+  switch (escape_style) {
+  case StringPrinter::EscapeStyle::CXX:
+    // Prints 4 characters, then a \0 terminator.
+    escaped_len = sprintf((char *)data, "\\x%02x", *buffer);
+    break;
+  case StringPrinter::EscapeStyle::Swift:
+    // Prints up to 6 characters, then a \0 terminator.
+    escaped_len = sprintf((char *)data, "\\u{%x}", *buffer);
+    break;
+  }
+  lldbassert(escaped_len > 0 && "unknown string escape style");
+  return {data, escaped_len, [](const uint8_t *c) { delete[] c; }};
 }
 
 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1) {
   return (c0 - 192) * 64 + (c1 - 128);
 }
 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
                                        unsigned char c2) {
   return (c0 - 224) * 4096 + (c1 - 128) * 64 + (c2 - 128);
 }
 static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
                                        unsigned char c2, unsigned char c3) {
   return (c0 - 240) * 262144 + (c2 - 128) * 4096 + (c2 - 128) * 64 + (c3 - 128);
 }
 
 template <>
-StringPrinter::StringPrinterBufferPointer
-GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer,
-                                                         uint8_t *buffer_end,
-                                                         uint8_t *&next) {
-  StringPrinter::StringPrinterBufferPointer retval{nullptr};
-
+StringPrinterBufferPointer GetPrintableImpl<StringElementType::UTF8>(
+    uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next,
+    StringPrinter::EscapeStyle escape_style) {
   const unsigned utf8_encoded_len = llvm::getNumBytesForUTF8(*buffer);
 
   // If the utf8 encoded length is invalid, or if there aren't enough bytes to
   // print, this is some kind of corrupted string.
   if (utf8_encoded_len == 0 || utf8_encoded_len > 4)
-    return retval;
+    return nullptr;
   if ((buffer_end - buffer) < utf8_encoded_len)
     // There's no room in the buffer for the utf8 sequence.
-    return retval;
+    return nullptr;
 
   char32_t codepoint = 0;
   switch (utf8_encoded_len) {
   case 1:
     // this is just an ASCII byte - ask ASCII
-    return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
-        buffer, buffer_end, next);
+    return GetPrintableImpl<StringElementType::ASCII>(buffer, buffer_end, next,
+                                                      escape_style);
   case 2:
     codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
                                        (unsigned char)*(buffer + 1));
     break;
   case 3:
     codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
                                        (unsigned char)*(buffer + 1),
                                        (unsigned char)*(buffer + 2));
     break;
   case 4:
     codepoint = ConvertUTF8ToCodePoint(
         (unsigned char)*buffer, (unsigned char)*(buffer + 1),
         (unsigned char)*(buffer + 2), (unsigned char)*(buffer + 3));
     break;
   }
 
-  if (codepoint) {
-    switch (codepoint) {
-    case 0:
-      retval = {"\\0", 2};
-      break;
-    case '\a':
-      retval = {"\\a", 2};
-      break;
-    case '\b':
-      retval = {"\\b", 2};
-      break;
-    case '\f':
-      retval = {"\\f", 2};
-      break;
-    case '\n':
-      retval = {"\\n", 2};
-      break;
-    case '\r':
-      retval = {"\\r", 2};
-      break;
-    case '\t':
-      retval = {"\\t", 2};
-      break;
-    case '\v':
-      retval = {"\\v", 2};
-      break;
-    case '\"':
-      retval = {"\\\"", 2};
-      break;
-    case '\\':
-      retval = {"\\\\", 2};
-      break;
-    default:
-      if (isprint(codepoint))
-        retval = {buffer, utf8_encoded_len};
-      else {
-        uint8_t *data = new uint8_t[11];
-        sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
-        retval = {data, 10, [](const uint8_t *c) { delete[] c; }};
-        break;
-      }
-    }
+  // We couldn't figure out how to print this codepoint.
+  if (!codepoint)
+    return nullptr;
 
-    next = buffer + utf8_encoded_len;
+  // The UTF8 helper always advances by the utf8 encoded length.
+  StringPrinterBufferPointer retval =
+      attemptASCIIEscape(codepoint, escape_style);
+  if (retval.GetSize())
     return retval;
-  }
+  if (isprint32(codepoint))
+    return {buffer, utf8_encoded_len};
 
-  // We couldn't figure out how to print this string.
-  return retval;
+  unsigned escaped_len;
+  const unsigned max_buffer_size = 15;
+  uint8_t *data = new uint8_t[max_buffer_size];
+  switch (escape_style) {
+  case StringPrinter::EscapeStyle::CXX:
+    // Prints 10 characters, then a \0 terminator.
+    escaped_len = sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
+    break;
+  case StringPrinter::EscapeStyle::Swift:
+    // Prints up to 14 characters, then a \0 terminator.
+    escaped_len = sprintf((char *)data, "\\u{%x}", (unsigned)codepoint);
+    break;
+  }
+  lldbassert(escaped_len > 0 && "unknown string escape style");
+  return {data, escaped_len, [](const uint8_t *c) { delete[] c; }};
 }
 
 // Given a sequence of bytes, this function returns: a sequence of bytes to
 // actually print out + a length the following unscanned position of the buffer
 // is in next
-static StringPrinter::StringPrinterBufferPointer
-GetPrintable(StringPrinter::StringElementType type, uint8_t *buffer,
-             uint8_t *buffer_end, uint8_t *&next) {
+static StringPrinterBufferPointer
+GetPrintable(StringElementType type, uint8_t *buffer, uint8_t *buffer_end,
+             uint8_t *&next, StringPrinter::EscapeStyle escape_style) {
   if (!buffer || buffer >= buffer_end)
     return {nullptr};
 
   switch (type) {
-  case StringPrinter::StringElementType::ASCII:
-    return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
-        buffer, buffer_end, next);
-  case StringPrinter::StringElementType::UTF8:
-    return GetPrintableImpl<StringPrinter::StringElementType::UTF8>(
-        buffer, buffer_end, next);
+  case StringElementType::ASCII:
+    return GetPrintableImpl<StringElementType::ASCII>(buffer, buffer_end, next,
+                                                      escape_style);
+  case StringElementType::UTF8:
+    return GetPrintableImpl<StringElementType::UTF8>(buffer, buffer_end, next,
+                                                     escape_style);
   default:
     return {nullptr};
   }
 }
 
-StringPrinter::EscapingHelper
-StringPrinter::GetDefaultEscapingHelper(GetPrintableElementType elem_type) {
+static EscapingHelper
+GetDefaultEscapingHelper(GetPrintableElementType elem_type,
+                         StringPrinter::EscapeStyle escape_style) {
   switch (elem_type) {
   case GetPrintableElementType::UTF8:
-    return [](uint8_t *buffer, uint8_t *buffer_end,
-              uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer {
-      return GetPrintable(StringPrinter::StringElementType::UTF8, buffer,
-                          buffer_end, next);
+    return [escape_style](uint8_t *buffer, uint8_t *buffer_end,
+                          uint8_t *&next) -> StringPrinterBufferPointer {
+      return GetPrintable(StringElementType::UTF8, buffer, buffer_end, next,
+                          escape_style);
     };
   case GetPrintableElementType::ASCII:
-    return [](uint8_t *buffer, uint8_t *buffer_end,
-              uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer {
-      return GetPrintable(StringPrinter::StringElementType::ASCII, buffer,
-                          buffer_end, next);
+    return [escape_style](uint8_t *buffer, uint8_t *buffer_end,
+                          uint8_t *&next) -> StringPrinterBufferPointer {
+      return GetPrintable(StringElementType::ASCII, buffer, buffer_end, next,
+                          escape_style);
     };
   }
   llvm_unreachable("bad element type");
 }
 
 // use this call if you already have an LLDB-side buffer for the data
 template <typename SourceDataType>
 static bool DumpUTFBufferToStream(
if (ConvertFunction) {
       // happy but this should only happen if we are reading UTF8 data
       utf8_data_ptr = const_cast<llvm::UTF8 *>(
           reinterpret_cast<const llvm::UTF8 *>(data_ptr));
       utf8_data_end_ptr = const_cast<llvm::UTF8 *>(
           reinterpret_cast<const llvm::UTF8 *>(data_end_ptr));
     }
 
     const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
-    lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
-    if (escape_non_printables) {
-      if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
-        escaping_callback = language->GetStringPrinterEscapingHelper(
-            lldb_private::formatters::StringPrinter::GetPrintableElementType::
-                UTF8);
-      else
-        escaping_callback =
-            lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
-                lldb_private::formatters::StringPrinter::
-                    GetPrintableElementType::UTF8);
-    }
+    EscapingHelper escaping_callback;
+    if (escape_non_printables)
+      escaping_callback = GetDefaultEscapingHelper(
+          GetPrintableElementType::UTF8, dump_options.GetEscapeStyle());
 
     // since we tend to accept partial data (and even partially malformed data)
     // we might end up with no NULL terminator before the end_ptr hence we need
     // to take a slower route and ensure we stay within boundaries
     for (; utf8_data_ptr < utf8_data_end_ptr;) {
       if (zero_is_terminator && !*utf8_data_ptr)
         break;
 
ReadBufferAndDumpToStreamOptions(
         const ReadStringAndDumpToStreamOptions &options)
     : ReadBufferAndDumpToStreamOptions() {
   SetStream(options.GetStream());
   SetPrefixToken(options.GetPrefixToken());
   SetSuffixToken(options.GetSuffixToken());
   SetQuote(options.GetQuote());
   SetEscapeNonPrintables(options.GetEscapeNonPrintables());
   SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
-  SetLanguage(options.GetLanguage());
+  SetEscapeStyle(options.GetEscapeStyle());
 }
 
 namespace lldb_private {
 
 namespace formatters {
 
+// FIXME: In practice, do we ever prefer ASCII-only formatting over UTF8
+// formatting? The NSString formatter is the only one that makes a distinction
+// between the two: if it doesn't need to, we can simply delete all this
+// duplicated ASCII-specific code.
 template <>
-bool StringPrinter::ReadStringAndDumpToStream<
-    StringPrinter::StringElementType::ASCII>(
+bool StringPrinter::ReadStringAndDumpToStream<StringElementType::ASCII>(
     const ReadStringAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
   Status my_error;
 
   ProcessSP process_sp(options.GetProcessSP());
 
   if (process_sp.get() == nullptr || options.GetLocation() == 0)
     return false;
bool StringPrinter::ReadStringAndDumpToStream<StringElementType::ASCII>(
   if (prefix_token != nullptr)
     options.GetStream()->Printf("%s%c", prefix_token, quote);
   else if (quote != 0)
     options.GetStream()->Printf("%c", quote);
 
   uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize();
 
   const bool escape_non_printables = options.GetEscapeNonPrintables();
-  lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
-  if (escape_non_printables) {
-    if (Language *language = Language::FindPlugin(options.GetLanguage()))
-      escaping_callback = language->GetStringPrinterEscapingHelper(
-          lldb_private::formatters::StringPrinter::GetPrintableElementType::
-              ASCII);
-    else
-      escaping_callback =
-          lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
-              lldb_private::formatters::StringPrinter::GetPrintableElementType::
-                  ASCII);
-  }
+  EscapingHelper escaping_callback;
+  if (escape_non_printables)
+    escaping_callback = GetDefaultEscapingHelper(GetPrintableElementType::ASCII,
+                                                 options.GetEscapeStyle());
 
   // since we tend to accept partial data (and even partially malformed data)
   // we might end up with no NULL terminator before the end_ptr hence we need
   // to take a slower route and ensure we stay within boundaries
   for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) {
     if (escape_non_printables) {
       uint8_t *next_data = nullptr;
       auto printable = escaping_callback(data, data_end, next_data);
static bool ReadUTFBufferAndDumpToStream(
   dump_options.SetData(data);
   dump_options.SetSourceSize(sourceSize);
   dump_options.SetIsTruncated(is_truncated);
 
   return DumpUTFBufferToStream(ConvertFunction, dump_options);
 }
 
 template <>
-bool StringPrinter::ReadStringAndDumpToStream<
-    StringPrinter::StringElementType::UTF8>(
+bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF8>(
     const ReadStringAndDumpToStreamOptions &options) {
   return ReadUTFBufferAndDumpToStream<llvm::UTF8>(options, nullptr);
 }
 
 template <>
-bool StringPrinter::ReadStringAndDumpToStream<
-    StringPrinter::StringElementType::UTF16>(
+bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF16>(
     const ReadStringAndDumpToStreamOptions &options) {
   return ReadUTFBufferAndDumpToStream<llvm::UTF16>(options,
                                                    llvm::ConvertUTF16toUTF8);
 }
 
 template <>
-bool StringPrinter::ReadStringAndDumpToStream<
-    StringPrinter::StringElementType::UTF32>(
+bool StringPrinter::ReadStringAndDumpToStream<StringElementType::UTF32>(
     const ReadStringAndDumpToStreamOptions &options) {
   return ReadUTFBufferAndDumpToStream<llvm::UTF32>(options,
                                                    llvm::ConvertUTF32toUTF8);
 }
 
 template <>
-bool StringPrinter::ReadBufferAndDumpToStream<
-    StringPrinter::StringElementType::UTF8>(
+bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF8>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
   return DumpUTFBufferToStream<llvm::UTF8>(nullptr, options);
 }
 
 template <>
-bool StringPrinter::ReadBufferAndDumpToStream<
-    StringPrinter::StringElementType::ASCII>(
+bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::ASCII>(
     const ReadBufferAndDumpToStreamOptions &options) {
   // treat ASCII the same as UTF8
   // FIXME: can we optimize ASCII some more?
   return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
 }
 
 template <>
-bool StringPrinter::ReadBufferAndDumpToStream<
-    StringPrinter::StringElementType::UTF16>(
+bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF16>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
   return DumpUTFBufferToStream(llvm::ConvertUTF16toUTF8, options);
 }
 
 template <>
-bool StringPrinter::ReadBufferAndDumpToStream<
-    StringPrinter::StringElementType::UTF32>(
+bool StringPrinter::ReadBufferAndDumpToStream<StringElementType::UTF32>(
     const ReadBufferAndDumpToStreamOptions &options) {
   assert(options.GetStream() && "need a Stream to print the string to");
 
   return DumpUTFBufferToStream(llvm::ConvertUTF32toUTF8, options);
 }
 
 } // namespace formatters
 
 } // namespace lldb_private

lldb/source/Plugins/Language/ObjC/NSString.cpp

if (has_explicit_length && is_unicode) {
       options.SetStream(&stream);
       options.SetQuote('"');
       options.SetSourceSize(explicit_length);
       options.SetHasSourceSize(has_explicit_length);
       options.SetNeedsZeroTermination(false);
       options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                  TypeSummaryCapping::eTypeSummaryUncapped);
       options.SetBinaryZeroIsTerminator(false);
-      options.SetLanguage(summary_options.GetLanguage());
       return StringPrinter::ReadStringAndDumpToStream<
           StringPrinter::StringElementType::UTF16>(options);
     } else {
       options.SetLocation(location + 1);
       options.SetProcessSP(process_sp);
       options.SetStream(&stream);
       options.SetSourceSize(explicit_length);
       options.SetHasSourceSize(has_explicit_length);
       options.SetNeedsZeroTermination(false);
       options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                  TypeSummaryCapping::eTypeSummaryUncapped);
       options.SetBinaryZeroIsTerminator(false);
-      options.SetLanguage(summary_options.GetLanguage());
       return StringPrinter::ReadStringAndDumpToStream<
           StringPrinter::StringElementType::ASCII>(options);
     }
   } else if (is_inline && has_explicit_length && !is_unicode &&
              !is_path_store && !is_mutable) {
     uint64_t location = 3 * ptr_size + valobj_addr;
 
     options.SetLocation(location);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetQuote('"');
     options.SetSourceSize(explicit_length);
     options.SetHasSourceSize(has_explicit_length);
     options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                TypeSummaryCapping::eTypeSummaryUncapped);
-    options.SetLanguage(summary_options.GetLanguage());
     return StringPrinter::ReadStringAndDumpToStream<
         StringPrinter::StringElementType::ASCII>(options);
   } else if (is_unicode) {
     uint64_t location = valobj_addr + 2 * ptr_size;
     if (is_inline) {
       if (!has_explicit_length) {
         return false;
       } else
         location += ptr_size;
     } else {
       location = process_sp->ReadPointerFromMemory(location, error);
       if (error.Fail())
         return false;
     }
     options.SetLocation(location);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetQuote('"');
     options.SetSourceSize(explicit_length);
     options.SetHasSourceSize(has_explicit_length);
     options.SetNeedsZeroTermination(!has_explicit_length);
     options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                TypeSummaryCapping::eTypeSummaryUncapped);
     options.SetBinaryZeroIsTerminator(!has_explicit_length);
-    options.SetLanguage(summary_options.GetLanguage());
     return StringPrinter::ReadStringAndDumpToStream<
         StringPrinter::StringElementType::UTF16>(options);
   } else if (is_path_store) {
     ProcessStructReader reader(valobj.GetProcessSP().get(),
                                valobj.GetValueAsUnsigned(0),
                                GetNSPathStore2Type(*valobj.GetTargetSP()));
     explicit_length =
         reader.GetField<uint32_t>(ConstString("lengthAndRef")) >> 20;
     lldb::addr_t location = valobj.GetValueAsUnsigned(0) + ptr_size + 4;
 
     options.SetLocation(location);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetQuote('"');
     options.SetSourceSize(explicit_length);
     options.SetHasSourceSize(has_explicit_length);
     options.SetNeedsZeroTermination(!has_explicit_length);
     options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                TypeSummaryCapping::eTypeSummaryUncapped);
     options.SetBinaryZeroIsTerminator(!has_explicit_length);
-    options.SetLanguage(summary_options.GetLanguage());
     return StringPrinter::ReadStringAndDumpToStream<
         StringPrinter::StringElementType::UTF16>(options);
   } else if (is_inline) {
     uint64_t location = valobj_addr + 2 * ptr_size;
     if (!has_explicit_length) {
       // in this kind of string, the byte before the string content is a length
       // byte so let's try and use it to handle the embedded NUL case
       Status error;
       explicit_length =
           process_sp->ReadUnsignedIntegerFromMemory(location, 1, 0, error);
       has_explicit_length = !(error.Fail() || explicit_length == 0);
       location++;
     }
     options.SetLocation(location);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetSourceSize(explicit_length);
     options.SetHasSourceSize(has_explicit_length);
     options.SetNeedsZeroTermination(!has_explicit_length);
     options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                TypeSummaryCapping::eTypeSummaryUncapped);
     options.SetBinaryZeroIsTerminator(!has_explicit_length);
-    options.SetLanguage(summary_options.GetLanguage());
     if (has_explicit_length)
       return StringPrinter::ReadStringAndDumpToStream<
           StringPrinter::StringElementType::UTF8>(options);
     else
       return StringPrinter::ReadStringAndDumpToStream<
           StringPrinter::StringElementType::ASCII>(options);
   } else {
     uint64_t location = valobj_addr + 2 * ptr_size;
     location = process_sp->ReadPointerFromMemory(location, error);
     if (error.Fail())
       return false;
     if (has_explicit_length && !has_null)
       explicit_length++; // account for the fact that there is no NULL and we
                          // need to have one added
     options.SetLocation(location);
     options.SetProcessSP(process_sp);
     options.SetStream(&stream);
     options.SetSourceSize(explicit_length);
     options.SetHasSourceSize(has_explicit_length);
     options.SetIgnoreMaxLength(summary_options.GetCapping() ==
                                TypeSummaryCapping::eTypeSummaryUncapped);
-    options.SetLanguage(summary_options.GetLanguage());
     return StringPrinter::ReadStringAndDumpToStream<
         StringPrinter::StringElementType::ASCII>(options);
   }
 }
 
 bool lldb_private::formatters::NSAttributedStringSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   TargetSP target_sp(valobj.GetTargetSP());

lldb/source/Target/Language.cpp

 }
 
 std::vector<ConstString>
 Language::GetPossibleFormattersMatches(ValueObject &valobj,
                                        lldb::DynamicValueType use_dynamic) {
   return {};
 }
 
-lldb_private::formatters::StringPrinter::EscapingHelper
-Language::GetStringPrinterEscapingHelper(
-    lldb_private::formatters::StringPrinter::GetPrintableElementType
-        elem_type) {
-  return StringPrinter::GetDefaultEscapingHelper(elem_type);
-}
-
 struct language_name_pair {
   const char *name;
   LanguageType type;
 };
 
 struct language_name_pair language_names[] = {
     // To allow GetNameForLanguageType to be a simple array lookup, the first
     // part of this array must follow enum LanguageType exactly.

lldb/unittests/DataFormatter/CMakeLists.txt

 add_lldb_unittest(LLDBFormatterTests
   FormatManagerTests.cpp
+  StringPrinterTests.cpp
 
   LINK_LIBS
     lldbCore
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
 
   LINK_COMPONENTS
     Support
   )

lldb/unittests/DataFormatter/StringPrinterTests.cpp

+//===-- StringPrinterTests.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 "lldb/DataFormatters/StringPrinter.h"
+#include "lldb/Utility/DataExtractor.h"
+#include "lldb/Utility/Endian.h"
+#include "lldb/Utility/StreamString.h"
+#include "llvm/ADT/StringRef.h"
+#include "llvm/Support/raw_ostream.h"
+#include "gtest/gtest.h"
+#include <string>
+
+using namespace lldb;
+using namespace lldb_private;
+using lldb_private::formatters::StringPrinter;
+using llvm::StringRef;
+
+#define QUOTE(x) "\"" x "\""
+
+/// Dump out "name: { <contents of str> }".
+static void dumpStr(StringRef name, StringRef str) {
+  llvm::errs() << name << ": { ";
+  for (char c : str)
+    llvm::errs() << c << " ";
+  llvm::errs() << "}\n";
+}
+
+/// Format \p input according to the options specified in the template params,
+/// then check whether the result is equal to \p reference. If not, dump the
+/// expeted vs. actual results.
+template <StringPrinter::StringElementType elem_ty,
+          StringPrinter::EscapeStyle escape_style>
+static bool isFormatCorrect(StringRef input, StringRef reference) {
+  StreamString out;
+  StringPrinter::ReadBufferAndDumpToStreamOptions opts;
+  opts.SetStream(&out);
+  opts.SetSourceSize(input.size());
+  opts.SetNeedsZeroTermination(true);
+  opts.SetEscapeNonPrintables(true);
+  opts.SetIgnoreMaxLength(false);
+  opts.SetEscapeStyle(escape_style);
+  DataExtractor extractor(input.data(), input.size(),
+                          endian::InlHostByteOrder(), sizeof(void *));
+  opts.SetData(extractor);
+  const bool success = StringPrinter::ReadBufferAndDumpToStream<elem_ty>(opts);
+  const bool matches = out.GetString() == reference;
+  if (!success || !matches) {
+    dumpStr("expected", reference);
+    dumpStr(" but got", out.GetString());
+  }
+  return matches;
+}
+
+// The "StringElementType::ASCII + EscapeStyle::CXX" combination is not tested
+// because it probably should not be supported (see FIXME in StringPrinter.cpp),
+// and because it's implemented by calling into the UTF8 logic anyway.
+
+// Test UTF8 formatting for C++.
+TEST(StringPrinterTests, CxxUTF8) {
+  auto matches = [](StringRef str, StringRef reference) {
+    return isFormatCorrect<StringPrinter::StringElementType::UTF8,
+                           StringPrinter::EscapeStyle::CXX>(str, reference);
+  };
+
+  // Special escapes.
+  EXPECT_TRUE(matches({"\0", 1}, QUOTE("")));
+  EXPECT_TRUE(matches("\a", QUOTE("\\a")));
+  EXPECT_TRUE(matches("\b", QUOTE("\\b")));
+  EXPECT_TRUE(matches("\f", QUOTE("\\f")));
+  EXPECT_TRUE(matches("\n", QUOTE("\\n")));
+  EXPECT_TRUE(matches("\r", QUOTE("\\r")));
+  EXPECT_TRUE(matches("\t", QUOTE("\\t")));
+  EXPECT_TRUE(matches("\v", QUOTE("\\v")));
+  EXPECT_TRUE(matches("\"", QUOTE("\\\"")));
+  EXPECT_TRUE(matches("\'", QUOTE("'")));
+  EXPECT_TRUE(matches("\\", QUOTE("\\\\")));
+
+  // Printable characters.
+  EXPECT_TRUE(matches("'", QUOTE("'")));
+  EXPECT_TRUE(matches("a", QUOTE("a")));
+  EXPECT_TRUE(matches("Z", QUOTE("Z")));
+  EXPECT_TRUE(matches("🥑", QUOTE("🥑")));
+
+  // Octal (\nnn), hex (\xnn), extended octal (\unnnn or \Unnnnnnnn).
+  EXPECT_TRUE(matches("\uD55C", QUOTE("한")));
+  EXPECT_TRUE(matches("\U00010348", QUOTE("𐍈")));
+
+  // FIXME: These strings are all rejected, but shouldn't be AFAICT. LLDB finds
+  // that these are not valid utf8 sequences, but that's OK, the raw values
+  // should still be printed out.
+  EXPECT_FALSE(matches("\376", QUOTE("\\xfe"))); // \376 is 254 in decimal.
+  EXPECT_FALSE(matches("\xfe", QUOTE("\\xfe"))); // \xfe is 254 in decimal.
+}
+
+// Test UTF8 formatting for Swift.
+TEST(StringPrinterTests, SwiftUTF8) {
+  auto matches = [](StringRef str, StringRef reference) {
+    return isFormatCorrect<StringPrinter::StringElementType::UTF8,
+                           StringPrinter::EscapeStyle::Swift>(str, reference);
+  };
+
+  // Special escapes.
+  EXPECT_TRUE(matches({"\0", 1}, QUOTE("")));
+  EXPECT_TRUE(matches("\a", QUOTE("\\a")));
+  EXPECT_TRUE(matches("\b", QUOTE("\\u{8}")));
+  EXPECT_TRUE(matches("\f", QUOTE("\\u{c}")));
+  EXPECT_TRUE(matches("\n", QUOTE("\\n")));
+  EXPECT_TRUE(matches("\r", QUOTE("\\r")));
+  EXPECT_TRUE(matches("\t", QUOTE("\\t")));
+  EXPECT_TRUE(matches("\v", QUOTE("\\u{b}")));
+  EXPECT_TRUE(matches("\"", QUOTE("\\\"")));
+  EXPECT_TRUE(matches("\'", QUOTE("\\'")));
+  EXPECT_TRUE(matches("\\", QUOTE("\\\\")));
+
+  // Printable characters.
+  EXPECT_TRUE(matches("'", QUOTE("\\'")));
+  EXPECT_TRUE(matches("a", QUOTE("a")));
+  EXPECT_TRUE(matches("Z", QUOTE("Z")));
+  EXPECT_TRUE(matches("🥑", QUOTE("🥑")));
+
+  // Octal (\nnn), hex (\xnn), extended octal (\unnnn or \Unnnnnnnn).
+  EXPECT_TRUE(matches("\uD55C", QUOTE("한")));
+  EXPECT_TRUE(matches("\U00010348", QUOTE("𐍈")));
+
+  // FIXME: These strings are all rejected, but shouldn't be AFAICT. LLDB finds
+  // that these are not valid utf8 sequences, but that's OK, the raw values
+  // should still be printed out.
+  EXPECT_FALSE(matches("\376", QUOTE("\\xfe"))); // \376 is 254 in decimal.
+  EXPECT_FALSE(matches("\xfe", QUOTE("\\xfe"))); // \xfe is 254 in decimal.
+}