[lldb][NFCI] Refactor Language::GetFormatterPrefixSuffix

[bulbazord]

Summary

• Remove unused parameter valobj (I checked downstream, not even swift is using it).
• Return a std::pair<StringRef, StringRef> insted of having 2 out parameter strings.
• Remove the use of ConstStrings.

This change was primarily mechanical except in
ObjCLanguage::GetFormatterPrefixSuffix. To keep this fast, we
construct an llvm::StringMap<std::pair<StringRef, StringRef>> so that we
can look things up quickly. There is some amount of cost to setting up
the map the first time it is called, but subsequent lookups should be
as fast as a hash + string comparison (the cost of looking up something
in an llvm::StringMap).

[fdeazeve]

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

1000–1001

We can make this whole map const and remove the explicit call_once by folding the insert calls into the ctor:

static constexpr llvm::StringRef empty;
static const llvm::StringMap<
    std::pair<const llvm::StringRef, const llvm::StringRef>>
    g_affix_map = {{"CFBag", std::make_pair("@", empty)},
                   {"CFBinaryHeap", std::make_pair("@", empty)},
                   ..., };

If you're so inclined, you can even get rid of the final make_pair calls:

static const llvm::StringMap<
    std::pair<const llvm::StringRef, const llvm::StringRef>>
    g_affix_map = {{"CFBag", {"@", empty}},
                   {"CFBinaryHeap", {"@", empty}}};

[Michael137]

modulo Felipe's comment, LGTM!

[bulbazord]

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

1000–1001

Oh, this looks much nicer. I'll do it this way!

[bulbazord]

Remove use of std::call_once where not needed.

[JDevlieghere]

LGTM

lldb/include/lldb/Target/Language.h

public:
 
   /// Returns true iff the given symbol name is compatible with the mangling
   /// scheme of this language.
   ///
   /// This function should only return true if there is a high confidence
   /// that the name actually belongs to this language.
   virtual bool SymbolNameFitsToLanguage(Mangled name) const { return false; }
 
-  // if an individual data formatter can apply to several types and cross a
-  // language boundary it makes sense for individual languages to want to
-  // customize the printing of values of that type by appending proper
-  // prefix/suffix information in language-specific ways
-  virtual bool GetFormatterPrefixSuffix(ValueObject &valobj,
-                                        ConstString type_hint,
-                                        std::string &prefix,
-                                        std::string &suffix);
+  /// An individual data formatter may apply to several types and cross language
+  /// boundaries. Each of those languages may want to customize the display of
+  /// values of said types by appending proper prefix/suffix information in
+  /// language-specific ways. This function returns that prefix and suffix.
+  ///
+  /// \param[in] type_hint
+  ///   A StringRef used to determine what the prefix and suffix should be. It
+  ///   is called a hint because some types may have multiple variants for which
+  ///   the prefix and/or suffix may vary.
+  ///
+  /// \return
+  ///   A std::pair<StringRef, StringRef>, the first being the prefix and the
+  ///   second being the suffix. They may be empty.
+  virtual std::pair<llvm::StringRef, llvm::StringRef>
+  GetFormatterPrefixSuffix(llvm::StringRef type_hint);
 
   // When looking up functions, we take a user provided string which may be a
   // partial match to the full demangled name and compare it to the actual
   // demangled name to see if it matches as much as the user specified.  An
   // example of this is if the user provided A::my_function, but the
   // symbol was really B::A::my_function.  We want that to be
   // a match.  But we wouldn't want this to match AnotherA::my_function.  The
   // user is specifying a truncated path, not a truncated set of characters.

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

bool lldb_private::formatters::CFAbsoluteTimeSummaryProvider(
   stream.Printf("%04d-%02d-%02d %02d:%02d:%02d %s", tm_date->tm_year + 1900,
                 tm_date->tm_mon + 1, tm_date->tm_mday, tm_date->tm_hour,
                 tm_date->tm_min, tm_date->tm_sec, buffer.c_str());
   return true;
 }
 
 bool lldb_private::formatters::CFBagSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  static ConstString g_TypeHint("CFBag");
+  static constexpr llvm::StringLiteral g_TypeHint("CFBag");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
if (is_type_ok) {
     lldb::addr_t offset = 2 * ptr_size + 4 + valobj_addr;
     Status error;
     count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);
     if (error.Fail())
       return false;
   } else
     return false;
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s\"%u value%s\"%s", prefix.c_str(), count,
-                (count == 1 ? "" : "s"), suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("\"%u value%s\"", count, (count == 1 ? "" : "s"));
+  stream << suffix;
   return true;
 }
 
 bool lldb_private::formatters::CFBitVectorSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
for (uint64_t byte_idx = 0; byte_idx < num_bytes - 1; byte_idx++) {
     if (count)
       stream.Printf("%c", bit0 ? '1' : '0');
   }
   return true;
 }
 
 bool lldb_private::formatters::CFBinaryHeapSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  static ConstString g_TypeHint("CFBinaryHeap");
+  static constexpr llvm::StringLiteral g_TypeHint("CFBinaryHeap");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
if (is_type_ok) {
     lldb::addr_t offset = 2 * ptr_size + valobj_addr;
     Status error;
     count = process_sp->ReadUnsignedIntegerFromMemory(offset, 4, 0, error);
     if (error.Fail())
       return false;
   } else
     return false;
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s\"%u item%s\"%s", prefix.c_str(), count,
-                (count == 1 ? "" : "s"), suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("\"%u item%s\"", count, (count == 1 ? "" : "s"));
+  stream << suffix;
   return true;
 }

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

if (class_name == "NSIndexSet" || class_name == "NSMutableIndexSet") {
       return false;
   } while (false);
   stream.Printf("%" PRIu64 " index%s", count, (count == 1 ? "" : "es"));
   return true;
 }
 
 static void NSNumber_FormatChar(ValueObject &valobj, Stream &stream, char value,
                                 lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:char");
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:char");
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s%hhd%s", prefix.c_str(), value, suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%hhd", value);
+  stream << suffix;
 }
 
 static void NSNumber_FormatShort(ValueObject &valobj, Stream &stream,
                                  short value, lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:short");
-
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:short");
 
-  stream.Printf("%s%hd%s", prefix.c_str(), value, suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%hd", value);
+  stream << suffix;
 }
 
 static void NSNumber_FormatInt(ValueObject &valobj, Stream &stream, int value,
                                lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:int");
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:int");
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
 
-  stream.Printf("%s%d%s", prefix.c_str(), value, suffix.c_str());
+  stream << prefix;
+  stream.Printf("%d", value);
+  stream << suffix;
 }
 
 static void NSNumber_FormatLong(ValueObject &valobj, Stream &stream,
                                 int64_t value, lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:long");
-
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:long");
 
-  stream.Printf("%s%" PRId64 "%s", prefix.c_str(), value, suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%" PRId64 "", value);
+  stream << suffix;
 }
 
 static void NSNumber_FormatInt128(ValueObject &valobj, Stream &stream,
                                   const llvm::APInt &value,
                                   lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:int128_t");
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:int128_t");
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
 
-  stream.PutCString(prefix.c_str());
+  stream << prefix;
   const int radix = 10;
   const bool isSigned = true;
   std::string str = llvm::toString(value, radix, isSigned);
   stream.PutCString(str.c_str());
-  stream.PutCString(suffix.c_str());
+  stream << suffix;
 }
 
 static void NSNumber_FormatFloat(ValueObject &valobj, Stream &stream,
                                  float value, lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:float");
-
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:float");
 
-  stream.Printf("%s%f%s", prefix.c_str(), value, suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%f", value);
+  stream << suffix;
 }
 
 static void NSNumber_FormatDouble(ValueObject &valobj, Stream &stream,
                                   double value, lldb::LanguageType lang) {
-  static ConstString g_TypeHint("NSNumber:double");
+  static constexpr llvm::StringLiteral g_TypeHint("NSNumber:double");
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(lang)) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s%g%s", prefix.c_str(), value, suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(lang))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%g", value);
+  stream << suffix;
 }
 
 bool lldb_private::formatters::NSNumberSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
bool lldb_private::formatters::NSURLSummaryProvider(
   }
   if (base_summary.Empty())
     return NSStringSummaryProvider(*text, stream, options);
 
   StreamString summary;
   if (!NSStringSummaryProvider(*text, summary, options) || summary.Empty())
     return false;
 
-  const char quote_char = '"';
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(*text, ConstString("NSString"),
-                                            prefix, suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  static constexpr llvm::StringLiteral quote_char("\"");
+  static constexpr llvm::StringLiteral g_TypeHint("NSString");
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
   // @"A" -> @"A
   llvm::StringRef summary_str = summary.GetString();
-  bool back_consumed = summary_str.consume_back(quote_char + suffix);
+  bool back_consumed =
+      summary_str.consume_back(suffix) && summary_str.consume_back(quote_char);
   assert(back_consumed);
   UNUSED_IF_ASSERT_DISABLED(back_consumed);
   // @"B" -> B"
   llvm::StringRef base_summary_str = base_summary.GetString();
-  bool front_consumed = base_summary_str.consume_front(prefix + quote_char);
+  bool front_consumed = base_summary_str.consume_front(prefix) &&
+                        base_summary_str.consume_front(quote_char);
   assert(front_consumed);
   UNUSED_IF_ASSERT_DISABLED(front_consumed);
   // @"A -- B"
   if (!summary_str.empty() && !base_summary_str.empty()) {
-    stream.Printf("%s -- %s", summary_str.str().c_str(),
-                  base_summary_str.str().c_str());
+    stream << summary_str << " -- " << base_summary_str;
     return true;
   }
 
   return false;
 }
 
 /// Bias value for tagged pointer exponents.
 /// Recommended values:

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

public:
 
   size_t GetIndexOfChildWithName(ConstString name) override;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 bool lldb_private::formatters::NSArraySummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  static ConstString g_TypeHint("NSArray");
+  static constexpr llvm::StringLiteral g_TypeHint("NSArray");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
if (class_name == g_NSArrayI) {
     auto &map(NSArray_Additionals::GetAdditionalSummaries());
     auto iter = map.find(class_name), end = map.end();
     if (iter != end)
       return iter->second(valobj, stream, options);
     else
       return false;
   }
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
-                value == 1 ? "" : "s", suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%" PRIu64 " %s%s", value, "element", value == 1 ? "" : "s");
+  stream << suffix;
   return true;
 }
 
 lldb_private::formatters::NSArrayMSyntheticFrontEndBase::
     NSArrayMSyntheticFrontEndBase(lldb::ValueObjectSP valobj_sp)
     : SyntheticChildrenFrontEnd(*valobj_sp), m_exe_ctx_ref(), m_id_type() {
   if (valobj_sp) {
     TypeSystemClangSP scratch_ts_sp = ScratchTypeSystemClang::GetForTarget(

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

 
 }
 } // namespace formatters
 } // namespace lldb_private
 
 template <bool name_entries>
 bool lldb_private::formatters::NSDictionarySummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  static ConstString g_TypeHint("NSDictionary");
+  static constexpr llvm::StringLiteral g_TypeHint("NSDictionary");
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
     return false;
if (class_name == g_DictionaryI || class_name == g_DictionaryMImmutable) {
     auto &map(NSDictionary_Additionals::GetAdditionalSummaries());
     for (auto &candidate : map) {
       if (candidate.first && candidate.first->Match(class_name))
         return candidate.second(valobj, stream, options);
     }
     return false;
   }
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "key/value pair",
-                value == 1 ? "" : "s", suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%" PRIu64 " %s%s", value, "key/value pair",
+                value == 1 ? "" : "s");
+  stream << suffix;
   return true;
 }
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSDictionarySyntheticFrontEndCreator(
     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)

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

public:
   size_t GetIndexOfChildWithName(ConstString name) override;
 };
 } // namespace formatters
 } // namespace lldb_private
 
 template <bool cf_style>
 bool lldb_private::formatters::NSSetSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
-  static ConstString g_TypeHint("NSSet");
+  static constexpr llvm::StringLiteral g_TypeHint("NSSet");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
if (class_name == g_SetI || class_name == g_OrderedSetI) {
     auto &map(NSSet_Additionals::GetAdditionalSummaries());
     auto iter = map.find(class_name), end = map.end();
     if (iter != end)
       return iter->second(valobj, stream, options);
     else
       return false;
   }
 
-  std::string prefix, suffix;
-  if (Language *language = Language::FindPlugin(options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
-
-  stream.Printf("%s%" PRIu64 " %s%s%s", prefix.c_str(), value, "element",
-                value == 1 ? "" : "s", suffix.c_str());
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
+
+  stream << prefix;
+  stream.Printf("%" PRIu64 " %s%s", value, "element", value == 1 ? "" : "s");
+  stream << suffix;
   return true;
 }
 
 SyntheticChildrenFrontEnd *
 lldb_private::formatters::NSSetSyntheticFrontEndCreator(
     CXXSyntheticChildren *synth, lldb::ValueObjectSP valobj_sp) {
   lldb::ProcessSP process_sp(valobj_sp->GetProcessSP());
   if (!process_sp)

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

 NSString_Additionals::GetAdditionalSummaries() {
   static std::map<ConstString, CXXFunctionSummaryFormat::Callback> g_map;
   return g_map;
 }
 
 bool lldb_private::formatters::NSStringSummaryProvider(
     ValueObject &valobj, Stream &stream,
     const TypeSummaryOptions &summary_options) {
-  static ConstString g_TypeHint("NSString");
+  static constexpr llvm::StringLiteral g_TypeHint("NSString");
 
   ProcessSP process_sp = valobj.GetProcessSP();
   if (!process_sp)
     return false;
 
   ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
 
   if (!runtime)
const llvm::StringSet<> supported_string_classes = {
       "__NSCFString", "NSCFConstantString",
       "NSCFString",   "NSPathStore2"};
   if (supported_string_classes.count(class_name) == 0) {
     // not one of us - but tell me class name
     stream.Printf("class name = %s", class_name_cs.GetCString());
     return true;
   }
 
-  std::string prefix, suffix;
-  if (Language *language =
-          Language::FindPlugin(summary_options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(summary_options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
 
   StringPrinter::ReadStringAndDumpToStreamOptions options(valobj);
-  options.SetPrefixToken(prefix);
-  options.SetSuffixToken(suffix);
+  options.SetPrefixToken(prefix.str());
+  options.SetSuffixToken(suffix.str());
 
   if (is_mutable) {
     uint64_t location = 2 * ptr_size + valobj_addr;
     location = process_sp->ReadPointerFromMemory(location, error);
     if (error.Fail())
       return false;
     if (has_explicit_length && is_unicode) {
       options.SetLocation(location);

 bool lldb_private::formatters::NSMutableAttributedStringSummaryProvider(
     ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
   return NSAttributedStringSummaryProvider(valobj, stream, options);
 }
 
 bool lldb_private::formatters::NSTaggedString_SummaryProvider(
     ValueObject &valobj, ObjCLanguageRuntime::ClassDescriptorSP descriptor,
     Stream &stream, const TypeSummaryOptions &summary_options) {
-  static ConstString g_TypeHint("NSString");
+  static constexpr llvm::StringLiteral g_TypeHint("NSString");
 
   if (!descriptor)
     return false;
   uint64_t len_bits = 0, data_bits = 0;
   if (!descriptor->GetTaggedPointerInfo(&len_bits, &data_bits, nullptr))
     return false;
 
   static const int g_MaxNonBitmaskedLen = 7; // TAGGED_STRING_UNPACKED_MAXLEN
   static const int g_SixbitMaxLen = 9;
   static const int g_fiveBitMaxLen = 11;
 
   static const char *sixBitToCharLookup = "eilotrm.apdnsIc ufkMShjTRxgC4013"
                                           "bDNvwyUL2O856P-B79AFKEWV_zGJ/HYX";
 
   if (len_bits > g_fiveBitMaxLen)
     return false;
 
-  std::string prefix, suffix;
-  if (Language *language =
-          Language::FindPlugin(summary_options.GetLanguage())) {
-    if (!language->GetFormatterPrefixSuffix(valobj, g_TypeHint, prefix,
-                                            suffix)) {
-      prefix.clear();
-      suffix.clear();
-    }
-  }
+  llvm::StringRef prefix, suffix;
+  if (Language *language = Language::FindPlugin(summary_options.GetLanguage()))
+    std::tie(prefix, suffix) = language->GetFormatterPrefixSuffix(g_TypeHint);
 
   // this is a fairly ugly trick - pretend that the numeric value is actually a
   // char* this works under a few assumptions: little endian architecture
   // sizeof(uint64_t) > g_MaxNonBitmaskedLen
   if (len_bits <= g_MaxNonBitmaskedLen) {
-    stream.Printf("%s", prefix.c_str());
+    stream << prefix;
     stream.Printf("\"%s\"", (const char *)&data_bits);
-    stream.Printf("%s", suffix.c_str());
+    stream << suffix;
     return true;
   }
 
   // if the data is bitmasked, we need to actually process the bytes
   uint8_t bitmask = 0;
   uint8_t shift_offset = 0;
 
   if (len_bits <= g_SixbitMaxLen) {
     bitmask = 0x03f;
     shift_offset = 6;
   } else {
     bitmask = 0x01f;
     shift_offset = 5;
   }
 
   std::vector<uint8_t> bytes;
   bytes.resize(len_bits);
   for (; len_bits > 0; data_bits >>= shift_offset, --len_bits) {
     uint8_t packed = data_bits & bitmask;
     bytes.insert(bytes.begin(), sixBitToCharLookup[packed]);
   }
 
-  stream.Printf("%s", prefix.c_str());
+  stream << prefix;
   stream.Printf("\"%s\"", &bytes[0]);
-  stream.Printf("%s", suffix.c_str());
+  stream << suffix;
   return true;
 }

lldb/source/Plugins/Language/ObjC/ObjCLanguage.h

public:
   lldb::TypeCategoryImplSP GetFormatters() override;
 
   std::vector<FormattersMatchCandidate>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic) override;
 
   std::unique_ptr<TypeScavenger> GetTypeScavenger() override;
 
-  bool GetFormatterPrefixSuffix(ValueObject &valobj, ConstString type_hint,
-                                std::string &prefix,
-                                std::string &suffix) override;
+  std::pair<llvm::StringRef, llvm::StringRef>
+  GetFormatterPrefixSuffix(llvm::StringRef type_hint) override;
 
   bool IsNilReference(ValueObject &valobj) override;
 
   llvm::StringRef GetNilReferenceSummaryString() override { return "nil"; }
 
   bool IsSourceFile(llvm::StringRef file_path) const override;
 
   const Highlighter *GetHighlighter() const override { return &m_highlighter; }

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

public:
     }
   };
 
   return std::unique_ptr<TypeScavenger>(
       new Language::EitherTypeScavenger<ObjCModulesScavenger,
                                         ObjCRuntimeScavenger,
                                         ObjCDebugInfoScavenger>());
 }
 
-bool ObjCLanguage::GetFormatterPrefixSuffix(ValueObject &valobj,
-                                            ConstString type_hint,
-                                            std::string &prefix,
-                                            std::string &suffix) {
-  static ConstString g_CFBag("CFBag");
-  static ConstString g_CFBinaryHeap("CFBinaryHeap");
-
-  static ConstString g_NSNumberChar("NSNumber:char");
-  static ConstString g_NSNumberShort("NSNumber:short");
-  static ConstString g_NSNumberInt("NSNumber:int");
-  static ConstString g_NSNumberLong("NSNumber:long");
-  static ConstString g_NSNumberInt128("NSNumber:int128_t");
-  static ConstString g_NSNumberFloat("NSNumber:float");
-  static ConstString g_NSNumberDouble("NSNumber:double");
-
-  static ConstString g_NSData("NSData");
-  static ConstString g_NSArray("NSArray");
-  static ConstString g_NSString("NSString");
-  static ConstString g_NSStringStar("NSString*");
-
-  if (type_hint.IsEmpty())
-    return false;
-
-  prefix.clear();
-  suffix.clear();
-
-  if (type_hint == g_CFBag || type_hint == g_CFBinaryHeap) {
-    prefix = "@";
-    return true;
-  }
-
-  if (type_hint == g_NSNumberChar) {
-    prefix = "(char)";
-    return true;
-  }
-  if (type_hint == g_NSNumberShort) {
-    prefix = "(short)";
-    return true;
-  }
-  if (type_hint == g_NSNumberInt) {
-    prefix = "(int)";
-    return true;
-  }
-  if (type_hint == g_NSNumberLong) {
-    prefix = "(long)";
-    return true;
-  }
-  if (type_hint == g_NSNumberInt128) {
-    prefix = "(int128_t)";
-    return true;
-  }
-  if (type_hint == g_NSNumberFloat) {
-    prefix = "(float)";
-    return true;
-  }
-  if (type_hint == g_NSNumberDouble) {
-    prefix = "(double)";
-    return true;
-  }
-
-  if (type_hint == g_NSData || type_hint == g_NSArray) {
-    prefix = "@\"";
-    suffix = "\"";
-    return true;
-  }
-
-  if (type_hint == g_NSString || type_hint == g_NSStringStar) {
-    prefix = "@";
-    return true;
-  }
-
-  return false;
+std::pair<llvm::StringRef, llvm::StringRef>
+ObjCLanguage::GetFormatterPrefixSuffix(llvm::StringRef type_hint) {
+  static constexpr llvm::StringRef empty;
+  static const llvm::StringMap<
+      std::pair<const llvm::StringRef, const llvm::StringRef>>
+      g_affix_map = {
+          {"CFBag", {"@", empty}},
+          {"CFBinaryHeap", {"@", empty}},
+          {"NSString", {"@", empty}},
+          {"NSString*", {"@", empty}},
+          {"NSNumber:char", {"(char)", empty}},
+          {"NSNumber:short", {"(short)", empty}},
+          {"NSNumber:int", {"(int)", empty}},
+          {"NSNumber:long", {"(long)", empty}},
+          {"NSNumber:int128_t", {"(int128_t)", empty}},
+          {"NSNumber:float", {"(float)", empty}},
+          {"NSNumber:double", {"(double)", empty}},
+          {"NSData", {"@\"", "\""}},
+          {"NSArray", {"@\"", "\""}},
+      };
+  return g_affix_map.lookup(type_hint);
 }
 
 bool ObjCLanguage::IsNilReference(ValueObject &valobj) {
   const uint32_t mask = eTypeIsObjC | eTypeIsPointer;
   bool isObjCpointer =
       (((valobj.GetCompilerType().GetTypeInfo(nullptr)) & mask) == mask);
   if (!isObjCpointer)
     return false;

lldb/source/Target/Language.cpp

for (const auto &match : matches.Types()) {
         result = true;
       }
     }
   }
 
   return result;
 }
 
-bool Language::GetFormatterPrefixSuffix(ValueObject &valobj,
-                                        ConstString type_hint,
-                                        std::string &prefix,
-                                        std::string &suffix) {
-  return false;
+std::pair<llvm::StringRef, llvm::StringRef>
+Language::GetFormatterPrefixSuffix(llvm::StringRef type_hint) {
+  return std::pair<llvm::StringRef, llvm::StringRef>();
 }
 
 bool Language::DemangledNameContainsPath(llvm::StringRef path, 
                                          ConstString demangled) const {
   // The base implementation does a simple contains comparision:
   if (path.empty())
     return false;
   return demangled.GetStringRef().contains(path);