[lldb] Change formatter helper function parameter list to remove ConstString

[bulbazord]

Summary

All of these functions take a ConstString for the type_name,
but this isn't really needed for two reasons:
1.) This parameter is always constructed from a static c-string

constant.

2.) They are passed along to to AddTypeSummary as a StringRef anyway.

[mib]

LGTM!

lldb/include/lldb/DataFormatters/FormattersHelpers.h

 #include "lldb/DataFormatters/TypeCategory.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
 
 namespace lldb_private {
 namespace formatters {
 void AddFormat(TypeCategoryImpl::SharedPointer category_sp, lldb::Format format,
-               ConstString type_name, TypeFormatImpl::Flags flags,
+               llvm::StringRef type_name, TypeFormatImpl::Flags flags,
                bool regex = false);
 
 void AddSummary(TypeCategoryImpl::SharedPointer category_sp,
-                lldb::TypeSummaryImplSP summary_sp, ConstString type_name,
+                lldb::TypeSummaryImplSP summary_sp, llvm::StringRef type_name,
                 bool regex = false);
 
 void AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
-                      const char *string, ConstString type_name,
+                      const char *string, llvm::StringRef type_name,
                       TypeSummaryImpl::Flags flags, bool regex = false);
 
 void AddOneLineSummary(TypeCategoryImpl::SharedPointer category_sp,
-                       ConstString type_name, TypeSummaryImpl::Flags flags,
+                       llvm::StringRef type_name, TypeSummaryImpl::Flags flags,
                        bool regex = false);
 
 /// Add a summary that is implemented by a C++ callback.
 void AddCXXSummary(TypeCategoryImpl::SharedPointer category_sp,
                    CXXFunctionSummaryFormat::Callback funct,
-                   const char *description, ConstString type_name,
+                   const char *description, llvm::StringRef type_name,
                    TypeSummaryImpl::Flags flags, bool regex = false);
 
 /// Add a synthetic that is implemented by a C++ callback.
 void AddCXXSynthetic(TypeCategoryImpl::SharedPointer category_sp,
                      CXXSyntheticChildren::CreateFrontEndCallback generator,
-                     const char *description, ConstString type_name,
+                     const char *description, llvm::StringRef type_name,
                      ScriptedSyntheticChildren::Flags flags,
                      bool regex = false);
 
 void AddFilter(TypeCategoryImpl::SharedPointer category_sp,
                std::vector<std::string> children, const char *description,
-               ConstString type_name, ScriptedSyntheticChildren::Flags flags,
-               bool regex = false);
+               llvm::StringRef type_name,
+               ScriptedSyntheticChildren::Flags flags, bool regex = false);
 
 size_t ExtractIndexFromString(const char *item_name);
 
 Address GetArrayAddressOrPointerValue(ValueObject &valobj);
 
 lldb::ValueObjectSP GetValueOfLibCXXCompressedPair(ValueObject &pair);
 
 time_t GetOSXEpoch();

lldb/source/DataFormatters/FormatManager.cpp

void FormatManager::LoadSystemFormatters() {
 
   sys_category_sp->AddTypeSummary("OSType", eFormatterMatchExact,
                                   ostype_summary);
 
   TypeFormatImpl::Flags fourchar_flags;
   fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
       true);
 
-  AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
+  AddFormat(sys_category_sp, lldb::eFormatOSType, "FourCharCode",
             fourchar_flags);
 }
 
 void FormatManager::LoadVectorFormatters() {
   TypeCategoryImpl::SharedPointer vectors_category_sp =
       GetCategory(m_vectortypes_category_name);
 
   TypeSummaryImpl::Flags vector_flags;
   vector_flags.SetCascades(true)
       .SetSkipPointers(true)
       .SetSkipReferences(false)
       .SetDontShowChildren(true)
       .SetDontShowValue(false)
       .SetShowMembersOneLiner(true)
       .SetHideItemNames(true);
 
-  AddStringSummary(vectors_category_sp, "${var.uint128}",
-                   ConstString("builtin_type_vec128"), vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("float[4]"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("int32_t[4]"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("int16_t[8]"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vDouble"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vFloat"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vSInt8"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vSInt16"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vSInt32"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vUInt8"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vUInt16"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vUInt32"),
-                   vector_flags);
-  AddStringSummary(vectors_category_sp, "", ConstString("vBool32"),
+  AddStringSummary(vectors_category_sp, "${var.uint128}", "builtin_type_vec128",
                    vector_flags);
+  AddStringSummary(vectors_category_sp, "", "float[4]", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "int32_t[4]", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "int16_t[8]", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vDouble", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vFloat", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vSInt8", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vSInt16", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vSInt32", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vUInt16", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vUInt8", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vUInt16", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vUInt32", vector_flags);
+  AddStringSummary(vectors_category_sp, "", "vBool32", vector_flags);
 }

lldb/source/DataFormatters/FormattersHelpers.cpp

 #include "lldb/Utility/RegularExpression.h"
 
 using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
 void lldb_private::formatters::AddFormat(
     TypeCategoryImpl::SharedPointer category_sp, lldb::Format format,
-    ConstString type_name, TypeFormatImpl::Flags flags, bool regex) {
+    llvm::StringRef type_name, TypeFormatImpl::Flags flags, bool regex) {
   lldb::TypeFormatImplSP format_sp(new TypeFormatImpl_Format(format, flags));
 
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeFormat(type_name.GetStringRef(), match_type, format_sp);
+  category_sp->AddTypeFormat(type_name, match_type, format_sp);
 }
 
 void lldb_private::formatters::AddSummary(
     TypeCategoryImpl::SharedPointer category_sp, TypeSummaryImplSP summary_sp,
-    ConstString type_name, bool regex) {
+    llvm::StringRef type_name, bool regex) {
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeSummary(type_name.GetStringRef(), match_type, summary_sp);
+  category_sp->AddTypeSummary(type_name, match_type, summary_sp);
 }
 
 void lldb_private::formatters::AddStringSummary(
     TypeCategoryImpl::SharedPointer category_sp, const char *string,
-    ConstString type_name, TypeSummaryImpl::Flags flags, bool regex) {
+    llvm::StringRef type_name, TypeSummaryImpl::Flags flags, bool regex) {
   lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, string));
 
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeSummary(type_name.GetStringRef(), match_type, summary_sp);
+  category_sp->AddTypeSummary(type_name, match_type, summary_sp);
 }
 
 void lldb_private::formatters::AddOneLineSummary(
-    TypeCategoryImpl::SharedPointer category_sp, ConstString type_name,
+    TypeCategoryImpl::SharedPointer category_sp, llvm::StringRef type_name,
     TypeSummaryImpl::Flags flags, bool regex) {
   flags.SetShowMembersOneLiner(true);
   lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, ""));
 
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeSummary(type_name.GetStringRef(), match_type, summary_sp);
+  category_sp->AddTypeSummary(type_name, match_type, summary_sp);
 }
 
 void lldb_private::formatters::AddCXXSummary(
     TypeCategoryImpl::SharedPointer category_sp,
     CXXFunctionSummaryFormat::Callback funct, const char *description,
-    ConstString type_name, TypeSummaryImpl::Flags flags, bool regex) {
+    llvm::StringRef type_name, TypeSummaryImpl::Flags flags, bool regex) {
   lldb::TypeSummaryImplSP summary_sp(
       new CXXFunctionSummaryFormat(flags, funct, description));
 
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeSummary(type_name.GetStringRef(), match_type, summary_sp);
+  category_sp->AddTypeSummary(type_name, match_type, summary_sp);
 }
 
 void lldb_private::formatters::AddCXXSynthetic(
     TypeCategoryImpl::SharedPointer category_sp,
     CXXSyntheticChildren::CreateFrontEndCallback generator,
-    const char *description, ConstString type_name,
+    const char *description, llvm::StringRef type_name,
     ScriptedSyntheticChildren::Flags flags, bool regex) {
   lldb::SyntheticChildrenSP synth_sp(
       new CXXSyntheticChildren(flags, description, generator));
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeSynthetic(type_name.GetStringRef(), match_type, synth_sp);
+  category_sp->AddTypeSynthetic(type_name, match_type, synth_sp);
 }
 
 void lldb_private::formatters::AddFilter(
     TypeCategoryImpl::SharedPointer category_sp,
     std::vector<std::string> children, const char *description,
-    ConstString type_name, ScriptedSyntheticChildren::Flags flags, bool regex) {
+    llvm::StringRef type_name, ScriptedSyntheticChildren::Flags flags,
+    bool regex) {
   TypeFilterImplSP filter_sp(new TypeFilterImpl(flags));
   for (auto child : children)
     filter_sp->AddExpressionPath(child);
   FormatterMatchType match_type =
       regex ? eFormatterMatchRegex : eFormatterMatchExact;
-  category_sp->AddTypeFilter(type_name.GetStringRef(), match_type, filter_sp);
+  category_sp->AddTypeFilter(type_name, match_type, filter_sp);
 }
 
 size_t lldb_private::formatters::ExtractIndexFromString(const char *item_name) {
   if (!item_name || !*item_name)
     return UINT32_MAX;
   if (*item_name != '[')
     return UINT32_MAX;
   item_name++;

lldb/source/Plugins/Language/CPlusPlus/CPlusPlusLanguage.cpp

stl_summary_flags.SetCascades(true)
       .SetSkipReferences(false)
       .SetDontShowChildren(true)
       .SetDontShowValue(true)
       .SetShowMembersOneLiner(false)
       .SetHideItemNames(false);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
-                "std::string summary provider",
-                ConstString("^std::__[[:alnum:]]+::string$"), stl_summary_flags,
-                true);
+                "std::string summary provider", "^std::__[[:alnum:]]+::string$",
+                stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
                 "std::string summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string<char, "
-                            "std::__[[:alnum:]]+::char_traits<char>, "
-                            "std::__[[:alnum:]]+::allocator<char> >$"),
+                "^std::__[[:alnum:]]+::basic_string<char, "
+                "std::__[[:alnum:]]+::allocator<char> >$",
                 stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringSummaryProviderASCII,
                 "std::string summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string<unsigned char, "
-                            "std::__[[:alnum:]]+::char_traits<unsigned char>, "
-                            "std::__[[:alnum:]]+::allocator<unsigned char> >$"),
+                "^std::__[[:alnum:]]+::basic_string<unsigned char, "
+                "std::__[[:alnum:]]+::allocator<unsigned char> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringSummaryProviderUTF16,
                 "std::u16string summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string<char16_t, "
-                            "std::__[[:alnum:]]+::char_traits<char16_t>, "
-                            "std::__[[:alnum:]]+::allocator<char16_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string<char16_t, "
+                "std::__[[:alnum:]]+::allocator<char16_t> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringSummaryProviderUTF32,
                 "std::u32string summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string<char32_t, "
-                            "std::__[[:alnum:]]+::char_traits<char32_t>, "
-                            "std::__[[:alnum:]]+::allocator<char32_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string<char32_t, "
+                "std::__[[:alnum:]]+::allocator<char32_t> >$",
                 stl_summary_flags, true);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::LibcxxWStringSummaryProvider,
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::LibcxxWStringSummaryProvider,
                 "std::wstring summary provider",
-      ConstString("^std::__[[:alnum:]]+::wstring$"), stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::wstring$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxWStringSummaryProvider,
                 "std::wstring summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string<wchar_t, "
-                            "std::__[[:alnum:]]+::char_traits<wchar_t>, "
-                            "std::__[[:alnum:]]+::allocator<wchar_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string<wchar_t, "
+                "std::__[[:alnum:]]+::allocator<wchar_t> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
                 "std::string_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::string_view$"),
-                stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::string_view$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
                 "std::string_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string_view<char, "
-                            "std::__[[:alnum:]]+::char_traits<char> >$"),
+                "^std::__[[:alnum:]]+::basic_string_view<char, "
+                "std::__[[:alnum:]]+::char_traits<char> >$",
                 stl_summary_flags, true);
-  AddCXXSummary(
-      cpp_category_sp,
+  AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringViewSummaryProviderASCII,
                 "std::string_view summary provider",
-      ConstString("^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
-                  "std::__[[:alnum:]]+::char_traits<unsigned char> >$"),
+                "^std::__[[:alnum:]]+::basic_string_view<unsigned char, "
+                "std::__[[:alnum:]]+::char_traits<unsigned char> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF16,
                 "std::u16string_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string_view<char16_t, "
-                            "std::__[[:alnum:]]+::char_traits<char16_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string_view<char16_t, "
+                "std::__[[:alnum:]]+::char_traits<char16_t> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxStringViewSummaryProviderUTF32,
                 "std::u32string_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string_view<char32_t, "
-                            "std::__[[:alnum:]]+::char_traits<char32_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string_view<char32_t, "
+                "std::__[[:alnum:]]+::char_traits<char32_t> >$",
                 stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
                 "std::wstring_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::wstring_view$"),
-                stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::wstring_view$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxWStringViewSummaryProvider,
                 "std::wstring_view summary provider",
-                ConstString("^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
-                            "std::__[[:alnum:]]+::char_traits<wchar_t> >$"),
+                "^std::__[[:alnum:]]+::basic_string_view<wchar_t, "
+                "std::__[[:alnum:]]+::char_traits<wchar_t> >$",
                 stl_summary_flags, true);
 
   SyntheticChildren::Flags stl_synth_flags;
   stl_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
       false);
   SyntheticChildren::Flags stl_deref_flags = stl_synth_flags;
   stl_deref_flags.SetFrontEndWantsDereference();
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxBitsetSyntheticFrontEndCreator,
       "libc++ std::bitset synthetic children",
-      ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"), stl_deref_flags,
-      true);
+      "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdVectorSyntheticFrontEndCreator,
       "libc++ std::vector synthetic children",
-      ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"), stl_deref_flags,
-      true);
+      "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdForwardListSyntheticFrontEndCreator,
       "libc++ std::forward_list synthetic children",
-      ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
-      stl_synth_flags, true);
+      "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$", stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdListSyntheticFrontEndCreator,
       "libc++ std::list synthetic children",
       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
-      ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
-                  "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
+      "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
+      "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$",
       stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::map synthetic children",
-      ConstString("^std::__[[:alnum:]]+::map<.+> >(( )?&)?$"), stl_synth_flags,
-      true);
+      "^std::__[[:alnum:]]+::map<.+> >(( )?&)?$", stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::set synthetic children",
-      ConstString("^std::__[[:alnum:]]+::set<.+> >(( )?&)?$"), stl_deref_flags,
-      true);
+      "^std::__[[:alnum:]]+::set<.+> >(( )?&)?$", stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::multiset synthetic children",
-      ConstString("^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$"),
-      stl_deref_flags, true);
+      "^std::__[[:alnum:]]+::multiset<.+> >(( )?&)?$", stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdMapSyntheticFrontEndCreator,
       "libc++ std::multimap synthetic children",
-      ConstString("^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$"),
-      stl_synth_flags, true);
+      "^std::__[[:alnum:]]+::multimap<.+> >(( )?&)?$", stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdUnorderedMapSyntheticFrontEndCreator,
       "libc++ std::unordered containers synthetic children",
-      ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
+      "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$",
       stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxInitializerListSyntheticFrontEndCreator,
       "libc++ std::initializer_list synthetic children",
-      ConstString("^std::initializer_list<.+>(( )?&)?$"), stl_synth_flags,
-      true);
+      "^std::initializer_list<.+>(( )?&)?$", stl_synth_flags, true);
   AddCXXSynthetic(cpp_category_sp, LibcxxQueueFrontEndCreator,
                   "libc++ std::queue synthetic children",
-                  ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
-                  stl_synth_flags, true);
+                  "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_synth_flags,
+                  true);
   AddCXXSynthetic(cpp_category_sp, LibcxxTupleFrontEndCreator,
                   "libc++ std::tuple synthetic children",
-                  ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
-                  stl_synth_flags, true);
+                  "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_synth_flags,
+                  true);
   AddCXXSynthetic(cpp_category_sp, LibcxxOptionalSyntheticFrontEndCreator,
                   "libc++ std::optional synthetic children",
-                  ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
+                  "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$",
                   stl_synth_flags, true);
   AddCXXSynthetic(cpp_category_sp, LibcxxVariantFrontEndCreator,
                   "libc++ std::variant synthetic children",
-                  ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
-                  stl_synth_flags, true);
+                  "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_synth_flags,
+                  true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxAtomicSyntheticFrontEndCreator,
       "libc++ std::atomic synthetic children",
-      ConstString("^std::__[[:alnum:]]+::atomic<.+>$"), stl_synth_flags, true);
+      "^std::__[[:alnum:]]+::atomic<.+>$", stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdSpanSyntheticFrontEndCreator,
       "libc++ std::span synthetic children",
-      ConstString("^std::__[[:alnum:]]+::span<.+>(( )?&)?$"), stl_deref_flags,
-      true);
+      "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_deref_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxStdRangesRefViewSyntheticFrontEndCreator,
       "libc++ std::ranges::ref_view synthetic children",
-      ConstString("^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$"),
-      stl_deref_flags, true);
+      "^std::__[[:alnum:]]+::ranges::ref_view<.+>(( )?&)?$", stl_deref_flags,
+      true);
 
   cpp_category_sp->AddTypeSynthetic(
       "^(std::__[[:alnum:]]+::)deque<.+>(( )?&)?$", eFormatterMatchRegex,
       SyntheticChildrenSP(new ScriptedSyntheticChildren(
           stl_synth_flags,
           "lldb.formatters.cpp.libcxx.stddeque_SynthProvider")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
       "shared_ptr synthetic children",
-      ConstString("^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$"),
-      stl_synth_flags, true);
+      "^(std::__[[:alnum:]]+::)shared_ptr<.+>(( )?&)?$", stl_synth_flags, true);
 
-  ConstString libcxx_std_unique_ptr_regex(
-      "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$");
+  static constexpr const char *const libcxx_std_unique_ptr_regex =
+      "^std::__[[:alnum:]]+::unique_ptr<.+>(( )?&)?$";
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxUniquePtrSyntheticFrontEndCreator,
       "unique_ptr synthetic children", libcxx_std_unique_ptr_regex,
       stl_synth_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibcxxSharedPtrSyntheticFrontEndCreator,
       "weak_ptr synthetic children",
-      ConstString("^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$"),
-      stl_synth_flags, true);
+      "^(std::__[[:alnum:]]+::)weak_ptr<.+>(( )?&)?$", stl_synth_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxFunctionSummaryProvider,
                 "libc++ std::function summary provider",
-                ConstString("^std::__[[:alnum:]]+::function<.+>$"),
-                stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::function<.+>$", stl_summary_flags, true);
 
-  ConstString libcxx_std_coroutine_handle_regex(
-      "^std::__[[:alnum:]]+::coroutine_handle<.+>(( )?&)?$");
+  static constexpr const char *const libcxx_std_coroutine_handle_regex =
+      "^std::__[[:alnum:]]+::coroutine_handle<.+>(( )?&)?$";
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator,
       "coroutine_handle synthetic children", libcxx_std_coroutine_handle_regex,
       stl_deref_flags, true);
 
   stl_summary_flags.SetDontShowChildren(false);
   stl_summary_flags.SetSkipPointers(false);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::bitset summary provider",
-                ConstString("^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::vector summary provider",
-                ConstString("^std::__[[:alnum:]]+::vector<.+>(( )?&)?$"),
-                stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::bitset<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::vector<.+>(( )?&)?$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxContainerSummaryProvider,
                 "libc++ std::list summary provider",
-                ConstString("^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$"),
+                "^std::__[[:alnum:]]+::forward_list<.+>(( )?&)?$",
                 stl_summary_flags, true);
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
       "libc++ std::list summary provider",
       // A POSIX variant of: "^std::__(?!cxx11:)[[:alnum:]]+::list<.+>(( )?&)?$"
       // so that it does not clash with: "^std::(__cxx11::)?list<.+>(( )?&)?$"
-      ConstString("^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
-                  "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$"),
+      "^std::__([A-Zabd-z0-9]|cx?[A-Za-wyz0-9]|cxx1?[A-Za-z02-9]|"
+      "cxx11[[:alnum:]])[[:alnum:]]*::list<.+>(( )?&)?$",
       stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::map summary provider",
-                ConstString("^std::__[[:alnum:]]+::map<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::deque summary provider",
-                ConstString("^std::__[[:alnum:]]+::deque<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::queue summary provider",
-                ConstString("^std::__[[:alnum:]]+::queue<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::set summary provider",
-                ConstString("^std::__[[:alnum:]]+::set<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::multiset summary provider",
-                ConstString("^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::multimap summary provider",
-                ConstString("^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$"),
-                stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::map<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::deque<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::queue<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::set<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::multiset<.+>(( )?&)?$", stl_summary_flags, true);
   AddCXXSummary(
       cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "libc++ std::multimap summary provider",
+      "^std::__[[:alnum:]]+::multimap<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::LibcxxContainerSummaryProvider,
                 "libc++ std::unordered containers summary provider",
-      ConstString("^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$"),
+                "^(std::__[[:alnum:]]+::)unordered_(multi)?(map|set)<.+> >$",
                 stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp, LibcxxContainerSummaryProvider,
                 "libc++ std::tuple summary provider",
-                ConstString("^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$"),
-                stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::tuple<.*>(( )?&)?$", stl_summary_flags,
+                true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibCxxAtomicSummaryProvider,
                 "libc++ std::atomic summary provider",
-                ConstString("^std::__[[:alnum:]]+::atomic<.+>$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::GenericOptionalSummaryProvider,
-                "libc++ std::optional summary provider",
-                ConstString("^std::__[[:alnum:]]+::optional<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxVariantSummaryProvider,
-                "libc++ std::variant summary provider",
-                ConstString("^std::__[[:alnum:]]+::variant<.+>(( )?&)?$"),
-                stl_summary_flags, true);
-  AddCXXSummary(cpp_category_sp,
-                lldb_private::formatters::LibcxxContainerSummaryProvider,
-                "libc++ std::span summary provider",
-                ConstString("^std::__[[:alnum:]]+::span<.+>(( )?&)?$"),
-                stl_summary_flags, true);
+                "^std::__[[:alnum:]]+::atomic<.+>$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::GenericOptionalSummaryProvider,
+      "^std::__[[:alnum:]]+::optional<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxVariantSummaryProvider,
+      "^std::__[[:alnum:]]+::variant<.+>(( )?&)?$", stl_summary_flags, true);
+  AddCXXSummary(
+      cpp_category_sp, lldb_private::formatters::LibcxxContainerSummaryProvider,
+      "^std::__[[:alnum:]]+::span<.+>(( )?&)?$", stl_summary_flags, true);
 
   stl_summary_flags.SetSkipPointers(true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
                 "libc++ std::shared_ptr summary provider",
-                ConstString("^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$"),
+                "^std::__[[:alnum:]]+::shared_ptr<.+>(( )?&)?$",
                 stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxSmartPointerSummaryProvider,
                 "libc++ std::weak_ptr summary provider",
-                ConstString("^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$"),
+                "^std::__[[:alnum:]]+::weak_ptr<.+>(( )?&)?$",
                 stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibcxxUniquePointerSummaryProvider,
                 "libc++ std::unique_ptr summary provider",
                 libcxx_std_unique_ptr_regex, stl_summary_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::StdlibCoroutineHandleSummaryProvider,
                 "libc++ std::coroutine_handle summary provider",
                 libcxx_std_coroutine_handle_regex, stl_summary_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibCxxVectorIteratorSyntheticFrontEndCreator,
       "std::vector iterator synthetic children",
-      ConstString("^std::__[[:alnum:]]+::__wrap_iter<.+>$"), stl_synth_flags,
-      true);
+      "^std::__[[:alnum:]]+::__wrap_iter<.+>$", stl_synth_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibCxxMapIteratorSyntheticFrontEndCreator,
       "std::map iterator synthetic children",
-      ConstString("^std::__[[:alnum:]]+::__map_(const_)?iterator<.+>$"), stl_synth_flags,
+      "^std::__[[:alnum:]]+::__map_(const_)?iterator<.+>$", stl_synth_flags,
       true);
 
-  AddCXXSynthetic(
-      cpp_category_sp,
+  AddCXXSynthetic(cpp_category_sp,
                   lldb_private::formatters::
                       LibCxxUnorderedMapIteratorSyntheticFrontEndCreator,
                   "std::unordered_map iterator synthetic children",
-      ConstString("^std::__[[:alnum:]]+::__hash_map_(const_)?iterator<.+>$"),
+                  "^std::__[[:alnum:]]+::__hash_map_(const_)?iterator<.+>$",
                   stl_synth_flags, true);
 }
 
 static void LoadLibStdcppFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
 
   TypeSummaryImpl::Flags stl_summary_flags;
   stl_summary_flags.SetCascades(true)
cpp_category_sp->AddTypeSummary(
       TypeSummaryImplSP(new ScriptSummaryFormat(
           stl_summary_flags,
           "lldb.formatters.cpp.gnu_libstdcpp.ForwardListSummaryProvider")));
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppVectorIteratorSyntheticFrontEndCreator,
       "std::vector iterator synthetic children",
-      ConstString("^__gnu_cxx::__normal_iterator<.+>$"), stl_synth_flags, true);
+      "^__gnu_cxx::__normal_iterator<.+>$", stl_synth_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibstdcppMapIteratorSyntheticFrontEndCreator,
-      "std::map iterator synthetic children",
-      ConstString("^std::_Rb_tree_iterator<.+>$"), stl_synth_flags, true);
+      "std::map iterator synthetic children", "^std::_Rb_tree_iterator<.+>$",
+      stl_synth_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppUniquePtrSyntheticFrontEndCreator,
-      "std::unique_ptr synthetic children",
-      ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
+      "std::unique_ptr synthetic children", "^std::unique_ptr<.+>(( )?&)?$",
+      stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
-      "std::shared_ptr synthetic children",
-      ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
+      "std::shared_ptr synthetic children", "^std::shared_ptr<.+>(( )?&)?$",
+      stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppSharedPtrSyntheticFrontEndCreator,
-      "std::weak_ptr synthetic children",
-      ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_synth_flags, true);
+      "std::weak_ptr synthetic children", "^std::weak_ptr<.+>(( )?&)?$",
+      stl_synth_flags, true);
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppTupleSyntheticFrontEndCreator,
-      "std::tuple synthetic children", ConstString("^std::tuple<.+>(( )?&)?$"),
+      "std::tuple synthetic children", "^std::tuple<.+>(( )?&)?$",
       stl_synth_flags, true);
 
-  ConstString libstdcpp_std_coroutine_handle_regex(
-      "^std::coroutine_handle<.+>(( )?&)?$");
+  static constexpr const char *const libstdcpp_std_coroutine_handle_regex =
+      "^std::coroutine_handle<.+>(( )?&)?$";
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::StdlibCoroutineHandleSyntheticFrontEndCreator,
       "std::coroutine_handle synthetic children",
       libstdcpp_std_coroutine_handle_regex, stl_deref_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppBitsetSyntheticFrontEndCreator,
-      "std::bitset synthetic child", ConstString("^std::bitset<.+>(( )?&)?$"),
+      "std::bitset synthetic child", "^std::bitset<.+>(( )?&)?$",
       stl_deref_flags, true);
 
   AddCXXSynthetic(
       cpp_category_sp,
       lldb_private::formatters::LibStdcppOptionalSyntheticFrontEndCreator,
-      "std::optional synthetic child",
-      ConstString("^std::optional<.+>(( )?&)?$"), stl_deref_flags, true);
+      "std::optional synthetic child", "^std::optional<.+>(( )?&)?$",
+      stl_deref_flags, true);
 
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibStdcppUniquePointerSummaryProvider,
                 "libstdc++ std::unique_ptr summary provider",
-                ConstString("^std::unique_ptr<.+>(( )?&)?$"), stl_summary_flags,
-                true);
+                "^std::unique_ptr<.+>(( )?&)?$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
                 "libstdc++ std::shared_ptr summary provider",
-                ConstString("^std::shared_ptr<.+>(( )?&)?$"), stl_summary_flags,
-                true);
+                "^std::shared_ptr<.+>(( )?&)?$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::LibStdcppSmartPointerSummaryProvider,
                 "libstdc++ std::weak_ptr summary provider",
-                ConstString("^std::weak_ptr<.+>(( )?&)?$"), stl_summary_flags,
-                true);
+                "^std::weak_ptr<.+>(( )?&)?$", stl_summary_flags, true);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::StdlibCoroutineHandleSummaryProvider,
                 "libstdc++ std::coroutine_handle summary provider",
                 libstdcpp_std_coroutine_handle_regex, stl_summary_flags, true);
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::GenericOptionalSummaryProvider,
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::GenericOptionalSummaryProvider,
                 "libstd++ std::optional summary provider",
-      ConstString("^std::optional<.+>(( )?&)?$"), stl_summary_flags, true);
+                "^std::optional<.+>(( )?&)?$", stl_summary_flags, true);
 }
 
 static void LoadSystemFormatters(lldb::TypeCategoryImplSP cpp_category_sp) {
   if (!cpp_category_sp)
     return;
 
   TypeSummaryImpl::Flags string_flags;
   string_flags.SetCascades(true)
       .SetSkipPointers(true)
       .SetSkipReferences(false)
       .SetDontShowChildren(true)
       .SetDontShowValue(false)
       .SetShowMembersOneLiner(false)
       .SetHideItemNames(false);
 
   TypeSummaryImpl::Flags string_array_flags;
   string_array_flags.SetCascades(true)
       .SetSkipPointers(true)
       .SetSkipReferences(false)
       .SetDontShowChildren(true)
       .SetDontShowValue(true)
       .SetShowMembersOneLiner(false)
       .SetHideItemNames(false);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char8StringSummaryProvider,
-      "char8_t * summary provider", ConstString("char8_t *"), string_flags);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::Char8StringSummaryProvider,
-                "char8_t [] summary provider",
-                ConstString("char8_t ?\\[[0-9]+\\]"), string_array_flags, true);
+                "char8_t * summary provider", "char8_t *", string_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char8StringSummaryProvider,
+                "char8_t [] summary provider", "char8_t ?\\[[0-9]+\\]",
+                string_array_flags, true);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
-      "char16_t * summary provider", ConstString("char16_t *"), string_flags);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::Char16StringSummaryProvider,
-                "char16_t [] summary provider",
-                ConstString("char16_t ?\\[[0-9]+\\]"), string_array_flags, true);
+                "char16_t * summary provider", "char16_t *", string_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char16StringSummaryProvider,
+                "char16_t [] summary provider", "char16_t ?\\[[0-9]+\\]",
+                string_array_flags, true);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char32StringSummaryProvider,
-      "char32_t * summary provider", ConstString("char32_t *"), string_flags);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::Char32StringSummaryProvider,
-                "char32_t [] summary provider",
-                ConstString("char32_t ?\\[[0-9]+\\]"), string_array_flags, true);
+                "char32_t * summary provider", "char32_t *", string_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char32StringSummaryProvider,
+                "char32_t [] summary provider", "char32_t ?\\[[0-9]+\\]",
+                string_array_flags, true);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::WCharStringSummaryProvider,
-      "wchar_t * summary provider", ConstString("wchar_t *"), string_flags);
   AddCXXSummary(cpp_category_sp,
                 lldb_private::formatters::WCharStringSummaryProvider,
-                "wchar_t * summary provider",
-                ConstString("wchar_t ?\\[[0-9]+\\]"), string_array_flags, true);
+                "wchar_t * summary provider", "wchar_t *", string_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::WCharStringSummaryProvider,
+                "wchar_t * summary provider", "wchar_t ?\\[[0-9]+\\]",
+                string_array_flags, true);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char16StringSummaryProvider,
-      "unichar * summary provider", ConstString("unichar *"), string_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char16StringSummaryProvider,
+                "unichar * summary provider", "unichar *", string_flags);
 
   TypeSummaryImpl::Flags widechar_flags;
   widechar_flags.SetDontShowValue(true)
       .SetSkipPointers(true)
       .SetSkipReferences(false)
       .SetCascades(true)
       .SetDontShowChildren(true)
       .SetHideItemNames(true)
       .SetShowMembersOneLiner(false);
 
   AddCXXSummary(cpp_category_sp, lldb_private::formatters::Char8SummaryProvider,
-                "char8_t summary provider", ConstString("char8_t"),
-                widechar_flags);
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
-      "char16_t summary provider", ConstString("char16_t"), widechar_flags);
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char32SummaryProvider,
-      "char32_t summary provider", ConstString("char32_t"), widechar_flags);
+                "char8_t summary provider", "char8_t", widechar_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char16SummaryProvider,
+                "char16_t summary provider", "char16_t", widechar_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char32SummaryProvider,
+                "char32_t summary provider", "char32_t", widechar_flags);
   AddCXXSummary(cpp_category_sp, lldb_private::formatters::WCharSummaryProvider,
-                "wchar_t summary provider", ConstString("wchar_t"),
-                widechar_flags);
+                "wchar_t summary provider", "wchar_t", widechar_flags);
 
-  AddCXXSummary(
-      cpp_category_sp, lldb_private::formatters::Char16SummaryProvider,
-      "unichar summary provider", ConstString("unichar"), widechar_flags);
+  AddCXXSummary(cpp_category_sp,
+                lldb_private::formatters::Char16SummaryProvider,
+                "unichar summary provider", "unichar", widechar_flags);
 }
 
 std::unique_ptr<Language::TypeScavenger> CPlusPlusLanguage::GetTypeScavenger() {
   class CPlusPlusTypeScavenger : public Language::ImageListTypeScavenger {
   public:
     CompilerType AdjustForInclusion(CompilerType &candidate) override {
       LanguageType lang_type(candidate.GetMinimumLanguage());
       if (!Language::LanguageIsC(lang_type) &&

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

static void LoadObjCFormatters(TypeCategoryImplSP objc_category_sp) {
   objc_category_sp->AddTypeSummary("BOOL *", eFormatterMatchExact,
                                    ObjC_BOOL_summary);
 
   // we need to skip pointers here since we are special casing a SEL* when
   // retrieving its value
   objc_flags.SetSkipPointers(true);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::ObjCSELSummaryProvider<false>,
-                "SEL summary provider", ConstString("SEL"), objc_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>,
-      "SEL summary provider", ConstString("struct objc_selector"), objc_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<false>,
-      "SEL summary provider", ConstString("objc_selector"), objc_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::ObjCSELSummaryProvider<true>,
-      "SEL summary provider", ConstString("objc_selector *"), objc_flags);
+                "SEL summary provider", "SEL", objc_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::ObjCSELSummaryProvider<false>,
+                "SEL summary provider", "struct objc_selector", objc_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::ObjCSELSummaryProvider<false>,
+                "SEL summary provider", "objc_selector", objc_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::ObjCSELSummaryProvider<true>,
-                "SEL summary provider", ConstString("SEL *"), objc_flags);
+                "SEL summary provider", "objc_selector *", objc_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::ObjCSELSummaryProvider<true>,
+                "SEL summary provider", "SEL *", objc_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::ObjCClassSummaryProvider,
-                "Class summary provider", ConstString("Class"), objc_flags);
+                "Class summary provider", "Class", objc_flags);
 
   SyntheticChildren::Flags class_synth_flags;
   class_synth_flags.SetCascades(true).SetSkipPointers(false).SetSkipReferences(
       false);
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::ObjCClassSyntheticFrontEndCreator,
-                  "Class synthetic children", ConstString("Class"),
-                  class_synth_flags);
+                  "Class synthetic children", "Class", class_synth_flags);
 
   objc_flags.SetSkipPointers(false);
   objc_flags.SetCascades(true);
   objc_flags.SetSkipReferences(false);
 
   AddStringSummary(objc_category_sp, "${var.__FuncPtr%A}",
-                   ConstString("__block_literal_generic"), objc_flags);
+                   "__block_literal_generic", objc_flags);
 
-  AddStringSummary(objc_category_sp, "${var.years} years, ${var.months} "
-                                     "months, ${var.days} days, ${var.hours} "
-                                     "hours, ${var.minutes} minutes "
-                                     "${var.seconds} seconds",
-                   ConstString("CFGregorianUnits"), objc_flags);
+  AddStringSummary(objc_category_sp,
+                   "${var.years} years, ${var.months} "
+                   "CFGregorianUnits", objc_flags);
   AddStringSummary(objc_category_sp,
-                   "location=${var.location} length=${var.length}",
-                   ConstString("CFRange"), objc_flags);
+                   "location=${var.location} length=${var.length}", "CFRange",
+                   objc_flags);
 
   AddStringSummary(objc_category_sp,
-                   "location=${var.location}, length=${var.length}",
-                   ConstString("NSRange"), objc_flags);
+                   "location=${var.location}, length=${var.length}", "NSRange",
+                   objc_flags);
   AddStringSummary(objc_category_sp, "(${var.origin}, ${var.size}), ...",
-                   ConstString("NSRectArray"), objc_flags);
+                   "NSRectArray", objc_flags);
 
-  AddOneLineSummary(objc_category_sp, ConstString("NSPoint"), objc_flags);
-  AddOneLineSummary(objc_category_sp, ConstString("NSSize"), objc_flags);
-  AddOneLineSummary(objc_category_sp, ConstString("NSRect"), objc_flags);
-
-  AddOneLineSummary(objc_category_sp, ConstString("CGSize"), objc_flags);
-  AddOneLineSummary(objc_category_sp, ConstString("CGPoint"), objc_flags);
-  AddOneLineSummary(objc_category_sp, ConstString("CGRect"), objc_flags);
+  AddOneLineSummary(objc_category_sp, "NSPoint", objc_flags);
+  AddOneLineSummary(objc_category_sp, "NSSize", objc_flags);
+  AddOneLineSummary(objc_category_sp, "NSRect", objc_flags);
+
+  AddOneLineSummary(objc_category_sp, "CGSize", objc_flags);
+  AddOneLineSummary(objc_category_sp, "CGPoint", objc_flags);
+  AddOneLineSummary(objc_category_sp, "CGRect", objc_flags);
 
   AddStringSummary(objc_category_sp,
                    "red=${var.red} green=${var.green} blue=${var.blue}",
-                   ConstString("RGBColor"), objc_flags);
+                   "RGBColor", objc_flags);
   AddStringSummary(
       objc_category_sp,
-      "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})",
-      ConstString("Rect"), objc_flags);
-  AddStringSummary(objc_category_sp, "{(v=${var.v}, h=${var.h})}",
-                   ConstString("Point"), objc_flags);
+      "(t=${var.top}, l=${var.left}, b=${var.bottom}, r=${var.right})", "Rect",
+      objc_flags);
+  AddStringSummary(objc_category_sp, "{(v=${var.v}, h=${var.h})}", "Point",
+                   objc_flags);
   AddStringSummary(objc_category_sp,
                    "${var.month}/${var.day}/${var.year}  ${var.hour} "
                    ":${var.minute} :${var.second} dayOfWeek:${var.dayOfWeek}",
-                   ConstString("DateTimeRect *"), objc_flags);
-  AddStringSummary(objc_category_sp, "${var.ld.month}/${var.ld.day}/"
-                                     "${var.ld.year} ${var.ld.hour} "
-                                     ":${var.ld.minute} :${var.ld.second} "
-                                     "dayOfWeek:${var.ld.dayOfWeek}",
-                   ConstString("LongDateRect"), objc_flags);
-  AddStringSummary(objc_category_sp, "(x=${var.x}, y=${var.y})",
-                   ConstString("HIPoint"), objc_flags);
+                   "DateTimeRect *", objc_flags);
+  AddStringSummary(objc_category_sp,
+                   "${var.ld.month}/${var.ld.day}/"
+                   "LongDateRect", objc_flags);
+  AddStringSummary(objc_category_sp, "(x=${var.x}, y=${var.y})", "HIPoint",
+                   objc_flags);
   AddStringSummary(objc_category_sp, "origin=${var.origin} size=${var.size}",
-                   ConstString("HIRect"), objc_flags);
+                   "HIRect", objc_flags);
 
   TypeSummaryImpl::Flags appkit_flags;
   appkit_flags.SetCascades(true)
       .SetSkipPointers(false)
       .SetSkipReferences(false)
       .SetDontShowChildren(true)
       .SetDontShowValue(false)
       .SetShowMembersOneLiner(false)
       .SetHideItemNames(false);
 
   appkit_flags.SetDontShowChildren(false);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("NSArray"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("NSConstantArray"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("NSMutableArray"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("__NSArrayI"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("__NSArray0"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSArraySummaryProvider,
-                "NSArray summary provider",
-                ConstString("__NSSingleObjectArrayI"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("__NSArrayM"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("__NSCFArray"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("_NSCallStackArray"), appkit_flags);
+                "NSArray summary provider", "NSArray", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "NSConstantArray", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "NSMutableArray", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "__NSArrayI", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "__NSArray0", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSArraySummaryProvider,
-      "NSArray summary provider", ConstString("CFArrayRef"), appkit_flags);
+      "NSArray summary provider", "__NSSingleObjectArrayI", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSArraySummaryProvider,
-                "NSArray summary provider", ConstString("CFMutableArrayRef"),
-                appkit_flags);
+                "NSArray summary provider", "__NSArrayM", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "__NSCFArray", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "_NSCallStackArray", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "CFArrayRef", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSArraySummaryProvider,
+                "NSArray summary provider", "CFMutableArrayRef", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider", ConstString("NSDictionary"),
-                appkit_flags);
+                "NSDictionary summary provider", "NSDictionary", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider",
-                ConstString("NSConstantDictionary"), appkit_flags);
+                "NSDictionary summary provider", "NSConstantDictionary",
+                appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider",
-                ConstString("NSMutableDictionary"), appkit_flags);
+                "NSDictionary summary provider", "NSMutableDictionary",
+                appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider",
-                ConstString("__NSCFDictionary"), appkit_flags);
+                "NSDictionary summary provider", "__NSCFDictionary",
+                appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider", ConstString("__NSDictionaryI"),
+                "NSDictionary summary provider", "__NSDictionaryI",
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider",
-                ConstString("__NSSingleEntryDictionaryI"), appkit_flags);
+                "NSDictionary summary provider", "__NSSingleEntryDictionaryI",
+                appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<false>,
-                "NSDictionary summary provider", ConstString("__NSDictionaryM"),
+                "NSDictionary summary provider", "__NSDictionaryM",
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<true>,
-                "NSDictionary summary provider", ConstString("CFDictionaryRef"),
+                "NSDictionary summary provider", "CFDictionaryRef",
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<true>,
-                "NSDictionary summary provider", ConstString("__CFDictionary"),
+                "NSDictionary summary provider", "__CFDictionary",
                 appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDictionarySummaryProvider<true>,
-                "NSDictionary summary provider",
-                ConstString("CFMutableDictionaryRef"), appkit_flags);
+                "NSDictionary summary provider", "CFMutableDictionaryRef",
+                appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
-                "NSSet summary", ConstString("NSSet"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags);
+                "NSSet summary", "NSSet", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "NSMutableSet summary", "NSMutableSet", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<true>,
-                "CFSetRef summary", ConstString("CFSetRef"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<true>,
-      "CFMutableSetRef summary", ConstString("CFMutableSetRef"), appkit_flags);
+                "CFSetRef summary", "CFSetRef", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<true>,
+                "CFMutableSetRef summary", "CFMutableSetRef", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
-                "__NSCFSet summary", ConstString("__NSCFSet"), appkit_flags);
+                "__NSCFSet summary", "__NSCFSet", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
-                "__CFSet summary", ConstString("__CFSet"), appkit_flags);
+                "__CFSet summary", "__CFSet", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
-                "__NSSetI summary", ConstString("__NSSetI"), appkit_flags);
+                "__NSSetI summary", "__NSSetI", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSSetSummaryProvider<false>,
-                "__NSSetM summary", ConstString("__NSSetM"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "NSCountedSet summary", ConstString("NSCountedSet"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "NSMutableSet summary", ConstString("NSMutableSet"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "NSOrderedSet summary", ConstString("NSOrderedSet"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "__NSOrderedSetI summary", ConstString("__NSOrderedSetI"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSSetSummaryProvider<false>,
-      "__NSOrderedSetM summary", ConstString("__NSOrderedSetM"), appkit_flags);
+                "__NSSetM summary", "__NSSetM", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "NSCountedSet summary", "NSCountedSet", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "NSMutableSet summary", "NSMutableSet", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "NSOrderedSet summary", "NSOrderedSet", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "__NSOrderedSetI summary", "__NSOrderedSetI", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSSetSummaryProvider<false>,
+                "__NSOrderedSetM summary", "__NSOrderedSetM", appkit_flags);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSError_SummaryProvider,
-      "NSError summary provider", ConstString("NSError"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSException_SummaryProvider,
-      "NSException summary provider", ConstString("NSException"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSError_SummaryProvider,
+                "NSError summary provider", "NSError", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSException_SummaryProvider,
+                "NSException summary provider", "NSException", appkit_flags);
 
   // AddSummary(appkit_category_sp, "${var.key%@} -> ${var.value%@}",
   // ConstString("$_lldb_typegen_nspair"), appkit_flags);
 
   appkit_flags.SetDontShowChildren(true);
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("__NSArrayM"),
+                  "NSArray synthetic children", "__NSArrayM",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("__NSArrayI"),
+                  "NSArray synthetic children", "__NSArrayI",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("__NSArray0"),
+                  "NSArray synthetic children", "__NSArray0",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children",
-                  ConstString("__NSSingleObjectArrayI"),
+                  "NSArray synthetic children", "__NSSingleObjectArrayI",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("NSArray"),
+                  "NSArray synthetic children", "NSArray",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("NSConstantArray"),
+                  "NSArray synthetic children", "NSConstantArray",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("NSMutableArray"),
+                  "NSArray synthetic children", "NSMutableArray",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("__NSCFArray"),
+                  "NSArray synthetic children", "__NSCFArray",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("_NSCallStackArray"),
+                  "NSArray synthetic children", "_NSCallStackArray",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children",
-                  ConstString("CFMutableArrayRef"),
+                  "NSArray synthetic children", "CFMutableArrayRef",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSArraySyntheticFrontEndCreator,
-                  "NSArray synthetic children", ConstString("CFArrayRef"),
+                  "NSArray synthetic children", "CFArrayRef",
                   ScriptedSyntheticChildren::Flags());
 
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("__NSDictionaryM"),
+      "NSDictionary synthetic children", "__NSDictionaryM",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("NSConstantDictionary"),
+      "NSDictionary synthetic children", "NSConstantDictionary",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("__NSDictionaryI"),
+      "NSDictionary synthetic children", "__NSDictionaryI",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children",
-      ConstString("__NSSingleEntryDictionaryI"),
+      "NSDictionary synthetic children", "__NSSingleEntryDictionaryI",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("__NSCFDictionary"),
+      "NSDictionary synthetic children", "__NSCFDictionary",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("NSDictionary"),
+      "NSDictionary synthetic children", "NSDictionary",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("NSMutableDictionary"),
+      "NSDictionary synthetic children", "NSMutableDictionary",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("CFDictionaryRef"),
+      "NSDictionary synthetic children", "CFDictionaryRef",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("CFMutableDictionaryRef"),
+      "NSDictionary synthetic children", "CFMutableDictionaryRef",
       ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(
       objc_category_sp,
       lldb_private::formatters::NSDictionarySyntheticFrontEndCreator,
-      "NSDictionary synthetic children", ConstString("__CFDictionary"),
+      "NSDictionary synthetic children", "__CFDictionary",
       ScriptedSyntheticChildren::Flags());
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSErrorSyntheticFrontEndCreator,
-                  "NSError synthetic children", ConstString("NSError"),
+                  "NSError synthetic children", "NSError",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSExceptionSyntheticFrontEndCreator,
-                  "NSException synthetic children", ConstString("NSException"),
+                  "NSException synthetic children", "NSException",
                   ScriptedSyntheticChildren::Flags());
 
+  AddCXXSynthetic(
+      objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+      "NSSet synthetic children", "NSSet", ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "NSSet synthetic children", ConstString("NSSet"),
+                  "__NSSetI synthetic children", "__NSSetI",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "__NSSetI synthetic children", ConstString("__NSSetI"),
+                  "__NSSetM synthetic children", "__NSSetM",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "__NSSetM synthetic children", ConstString("__NSSetM"),
+                  "__NSCFSet synthetic children", "__NSCFSet",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "__NSCFSet synthetic children", ConstString("__NSCFSet"),
+                  "CFSetRef synthetic children", "CFSetRef",
                   ScriptedSyntheticChildren::Flags());
+
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "CFSetRef synthetic children", ConstString("CFSetRef"),
-                  ScriptedSyntheticChildren::Flags());
-
-  AddCXXSynthetic(
-      objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-      "NSMutableSet synthetic children", ConstString("NSMutableSet"),
+                  "NSMutableSet synthetic children", "NSMutableSet",
                   ScriptedSyntheticChildren::Flags());
-  AddCXXSynthetic(
-      objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-      "NSOrderedSet synthetic children", ConstString("NSOrderedSet"),
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+                  "NSOrderedSet synthetic children", "NSOrderedSet",
                   ScriptedSyntheticChildren::Flags());
-  AddCXXSynthetic(
-      objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-      "__NSOrderedSetI synthetic children", ConstString("__NSOrderedSetI"),
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+                  "__NSOrderedSetI synthetic children", "__NSOrderedSetI",
                   ScriptedSyntheticChildren::Flags());
-  AddCXXSynthetic(
-      objc_category_sp, lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-      "__NSOrderedSetM synthetic children", ConstString("__NSOrderedSetM"),
+  AddCXXSynthetic(objc_category_sp,
+                  lldb_private::formatters::NSSetSyntheticFrontEndCreator,
+                  "__NSOrderedSetM synthetic children", "__NSOrderedSetM",
                   ScriptedSyntheticChildren::Flags());
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSSetSyntheticFrontEndCreator,
-                  "__CFSet synthetic children", ConstString("__CFSet"),
+                  "__CFSet synthetic children", "__CFSet",
                   ScriptedSyntheticChildren::Flags());
 
   AddCXXSynthetic(objc_category_sp,
                   lldb_private::formatters::NSIndexPathSyntheticFrontEndCreator,
-                  "NSIndexPath synthetic children", ConstString("NSIndexPath"),
+                  "NSIndexPath synthetic children", "NSIndexPath",
                   ScriptedSyntheticChildren::Flags());
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::CFBagSummaryProvider,
-      "CFBag summary provider", ConstString("CFBagRef"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CFBagSummaryProvider,
-                "CFBag summary provider", ConstString("__CFBag"), appkit_flags);
+                "CFBag summary provider", "CFBagRef", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CFBagSummaryProvider,
-                "CFBag summary provider", ConstString("const struct __CFBag"),
-                appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::CFBagSummaryProvider,
-      "CFBag summary provider", ConstString("CFMutableBagRef"), appkit_flags);
-
+                "CFBag summary provider", "__CFBag", appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::CFBinaryHeapSummaryProvider,
-                "CFBinaryHeap summary provider", ConstString("CFBinaryHeapRef"),
-                appkit_flags);
+                lldb_private::formatters::CFBagSummaryProvider,
+                "CFBag summary provider", "const struct __CFBag", appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::CFBinaryHeapSummaryProvider,
-                "CFBinaryHeap summary provider", ConstString("__CFBinaryHeap"),
-                appkit_flags);
+                lldb_private::formatters::CFBagSummaryProvider,
+                "CFBag summary provider", "CFMutableBagRef", appkit_flags);
 
   AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("NSString"), appkit_flags);
+      objc_category_sp, lldb_private::formatters::CFBinaryHeapSummaryProvider,
+      "CFBinaryHeap summary provider", "CFBinaryHeapRef", appkit_flags);
   AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("CFStringRef"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("__CFString"), appkit_flags);
+      objc_category_sp, lldb_private::formatters::CFBinaryHeapSummaryProvider,
+      "CFBinaryHeap summary provider", "__CFBinaryHeap", appkit_flags);
+
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSStringSummaryProvider,
-                "NSString summary provider", ConstString("CFMutableStringRef"),
-                appkit_flags);
+                "NSString summary provider", "NSString", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSStringSummaryProvider,
-                "NSString summary provider", ConstString("NSMutableString"),
-                appkit_flags);
+                "NSString summary provider", "CFStringRef", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSStringSummaryProvider,
-                "NSString summary provider",
-                ConstString("__NSCFConstantString"), appkit_flags);
+                "NSString summary provider", "__CFString", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("__NSCFString"), appkit_flags);
+      "NSString summary provider", "CFMutableStringRef", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSStringSummaryProvider,
-                "NSString summary provider", ConstString("NSCFConstantString"),
-                appkit_flags);
+                "NSString summary provider", "NSMutableString", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("NSCFString"), appkit_flags);
+      "NSString summary provider", "__NSCFConstantString", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSStringSummaryProvider,
+                "NSString summary provider", "__NSCFString", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
-      "NSString summary provider", ConstString("NSPathStore2"), appkit_flags);
+      "NSString summary provider", "NSCFConstantString", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSStringSummaryProvider,
-                "NSString summary provider",
-                ConstString("NSTaggedPointerString"), appkit_flags);
+                "NSString summary provider", "NSCFString", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSStringSummaryProvider,
+                "NSString summary provider", "NSPathStore2", appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::NSStringSummaryProvider,
+      "NSString summary provider", "NSTaggedPointerString", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSAttributedStringSummaryProvider,
-                "NSAttributedString summary provider",
-                ConstString("NSAttributedString"), appkit_flags);
+                "NSAttributedString summary provider", "NSAttributedString",
+                appkit_flags);
   AddCXXSummary(
       objc_category_sp,
       lldb_private::formatters::NSMutableAttributedStringSummaryProvider,
-      "NSMutableAttributedString summary provider",
-      ConstString("NSMutableAttributedString"), appkit_flags);
+      "NSMutableAttributedString summary provider", "NSMutableAttributedString",
+      appkit_flags);
   AddCXXSummary(
       objc_category_sp,
       lldb_private::formatters::NSMutableAttributedStringSummaryProvider,
       "NSMutableAttributedString summary provider",
-      ConstString("NSConcreteMutableAttributedString"), appkit_flags);
+      "NSConcreteMutableAttributedString", appkit_flags);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSBundleSummaryProvider,
-      "NSBundle summary provider", ConstString("NSBundle"), appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSBundleSummaryProvider,
+                "NSBundle summary provider", "NSBundle", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDataSummaryProvider<false>,
-                "NSData summary provider", ConstString("NSData"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>,
-      "NSData summary provider", ConstString("_NSInlineData"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>,
-      "NSData summary provider", ConstString("NSConcreteData"), appkit_flags);
+                "NSData summary provider", "NSData", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDataSummaryProvider<false>,
-                "NSData summary provider", ConstString("NSConcreteMutableData"),
-                appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>,
-      "NSData summary provider", ConstString("NSMutableData"), appkit_flags);
+                "NSData summary provider", "_NSInlineData", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDataSummaryProvider<false>,
+                "NSData summary provider", "NSConcreteData", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<false>,
-      "NSData summary provider", ConstString("__NSCFData"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>,
-      "NSData summary provider", ConstString("CFDataRef"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDataSummaryProvider<true>,
-      "NSData summary provider", ConstString("CFMutableDataRef"), appkit_flags);
-
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSMachPortSummaryProvider,
-      "NSMachPort summary provider", ConstString("NSMachPort"), appkit_flags);
-
+      "NSData summary provider", "NSConcreteMutableData", appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::NSNotificationSummaryProvider,
-                "NSNotification summary provider",
-                ConstString("NSNotification"), appkit_flags);
+                lldb_private::formatters::NSDataSummaryProvider<false>,
+                "NSData summary provider", "NSMutableData", appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::NSNotificationSummaryProvider,
-                "NSNotification summary provider",
-                ConstString("NSConcreteNotification"), appkit_flags);
+                lldb_private::formatters::NSDataSummaryProvider<false>,
+                "NSData summary provider", "__NSCFData", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDataSummaryProvider<true>,
+                "NSData summary provider", "CFDataRef", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDataSummaryProvider<true>,
+                "NSData summary provider", "CFMutableDataRef", appkit_flags);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "NSNumber summary provider", ConstString("NSNumber"), appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::NSNumberSummaryProvider,
-                "NSNumber summary provider",
-                ConstString("NSConstantIntegerNumber"), appkit_flags);
+                lldb_private::formatters::NSMachPortSummaryProvider,
+                "NSMachPort summary provider", "NSMachPort", appkit_flags);
+
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::NSNotificationSummaryProvider,
+      "NSNotification summary provider", "NSNotification", appkit_flags);
   AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::NSNumberSummaryProvider,
-                "NSNumber summary provider",
-                ConstString("NSConstantDoubleNumber"), appkit_flags);
+                lldb_private::formatters::NSNotificationSummaryProvider,
+                "NSNotification summary provider", "NSConcreteNotification",
+                appkit_flags);
+
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSNumberSummaryProvider,
-                "NSNumber summary provider",
-                ConstString("NSConstantFloatNumber"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "CFNumberRef summary provider", ConstString("CFNumberRef"), appkit_flags);
+                "NSNumber summary provider", "NSNumber", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "NSNumber summary provider", ConstString("__NSCFBoolean"), appkit_flags);
+      "NSNumber summary provider", "NSConstantIntegerNumber", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "NSNumber summary provider", ConstString("__NSCFNumber"), appkit_flags);
+      "NSNumber summary provider", "NSConstantDoubleNumber", appkit_flags);
   AddCXXSummary(
       objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "NSNumber summary provider", ConstString("NSCFBoolean"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
-      "NSNumber summary provider", ConstString("NSCFNumber"), appkit_flags);
+      "NSNumber summary provider", "NSConstantFloatNumber", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "CFNumberRef summary provider", "CFNumberRef", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider", "__NSCFBoolean", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider", "__NSCFNumber", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSNumberSummaryProvider,
+                "NSNumber summary provider", "NSCFBoolean", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSNumberSummaryProvider,
-                "NSDecimalNumber summary provider",
-                ConstString("NSDecimalNumber"), appkit_flags);
+                "NSNumber summary provider", "NSCFNumber", appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::NSNumberSummaryProvider,
+      "NSDecimalNumber summary provider", "NSDecimalNumber", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSURLSummaryProvider,
-                "NSURL summary provider", ConstString("NSURL"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSURLSummaryProvider,
-      "NSURL summary provider", ConstString("CFURLRef"), appkit_flags);
+                "NSURL summary provider", "NSURL", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSURLSummaryProvider,
+                "NSURL summary provider", "CFURLRef", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSDateSummaryProvider,
-                "NSDate summary provider", ConstString("NSDate"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDateSummaryProvider,
-      "NSDate summary provider", ConstString("__NSDate"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDateSummaryProvider,
-      "NSDate summary provider", ConstString("__NSTaggedDate"), appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSDateSummaryProvider,
-      "NSDate summary provider", ConstString("NSCalendarDate"), appkit_flags);
+                "NSDate summary provider", "NSDate", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDateSummaryProvider,
+                "NSDate summary provider", "__NSDate", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDateSummaryProvider,
+                "NSDate summary provider", "__NSTaggedDate", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSDateSummaryProvider,
+                "NSDate summary provider", "NSCalendarDate", appkit_flags);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider,
-      "NSTimeZone summary provider", ConstString("NSTimeZone"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSTimeZoneSummaryProvider,
-                "NSTimeZone summary provider", ConstString("CFTimeZoneRef"),
-                appkit_flags);
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSTimeZoneSummaryProvider,
-      "NSTimeZone summary provider", ConstString("__NSTimeZone"), appkit_flags);
+                "NSTimeZone summary provider", "NSTimeZone", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSTimeZoneSummaryProvider,
+                "NSTimeZone summary provider", "CFTimeZoneRef", appkit_flags);
+  AddCXXSummary(objc_category_sp,
+                lldb_private::formatters::NSTimeZoneSummaryProvider,
+                "NSTimeZone summary provider", "__NSTimeZone", appkit_flags);
 
   // CFAbsoluteTime is actually a double rather than a pointer to an object we
   // do not care about the numeric value, since it is probably meaningless to
   // users
   appkit_flags.SetDontShowValue(true);
-  AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::CFAbsoluteTimeSummaryProvider,
-                "CFAbsoluteTime summary provider",
-                ConstString("CFAbsoluteTime"), appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::CFAbsoluteTimeSummaryProvider,
+      "CFAbsoluteTime summary provider", "CFAbsoluteTime", appkit_flags);
   appkit_flags.SetDontShowValue(false);
 
-  AddCXXSummary(
-      objc_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider,
-      "NSIndexSet summary provider", ConstString("NSIndexSet"), appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::NSIndexSetSummaryProvider,
-                "NSIndexSet summary provider", ConstString("NSMutableIndexSet"),
-                appkit_flags);
+                "NSIndexSet summary provider", "NSIndexSet", appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::NSIndexSetSummaryProvider,
+      "NSIndexSet summary provider", "NSMutableIndexSet", appkit_flags);
 
   AddStringSummary(objc_category_sp,
                    "@\"${var.month%d}/${var.day%d}/${var.year%d} "
                    "${var.hour%d}:${var.minute%d}:${var.second}\"",
-                   ConstString("CFGregorianDate"), appkit_flags);
+                   "CFGregorianDate", appkit_flags);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CFBitVectorSummaryProvider,
-                "CFBitVector summary provider", ConstString("CFBitVectorRef"),
-                appkit_flags);
-  AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::CFBitVectorSummaryProvider,
-                "CFBitVector summary provider",
-                ConstString("CFMutableBitVectorRef"), appkit_flags);
-  AddCXXSummary(objc_category_sp,
-                lldb_private::formatters::CFBitVectorSummaryProvider,
-                "CFBitVector summary provider", ConstString("__CFBitVector"),
-                appkit_flags);
+                "CFBitVector summary provider", "CFBitVectorRef", appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider,
+      "CFBitVector summary provider", "CFMutableBitVectorRef", appkit_flags);
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CFBitVectorSummaryProvider,
-                "CFBitVector summary provider",
-                ConstString("__CFMutableBitVector"), appkit_flags);
+                "CFBitVector summary provider", "__CFBitVector", appkit_flags);
+  AddCXXSummary(
+      objc_category_sp, lldb_private::formatters::CFBitVectorSummaryProvider,
+      "CFBitVector summary provider", "__CFMutableBitVector", appkit_flags);
 }
 
 static void LoadCoreMediaFormatters(TypeCategoryImplSP objc_category_sp) {
   if (!objc_category_sp)
     return;
 
   TypeSummaryImpl::Flags cm_flags;
   cm_flags.SetCascades(true)
       .SetDontShowChildren(false)
       .SetDontShowValue(false)
       .SetHideItemNames(false)
       .SetShowMembersOneLiner(false)
       .SetSkipPointers(false)
       .SetSkipReferences(false);
 
   AddCXXSummary(objc_category_sp,
                 lldb_private::formatters::CMTimeSummaryProvider,
-                "CMTime summary provider", ConstString("CMTime"), cm_flags);
+                "CMTime summary provider", "CMTime", cm_flags);
 }
 
 lldb::TypeCategoryImplSP ObjCLanguage::GetFormatters() {
   static llvm::once_flag g_initialize;
   static TypeCategoryImplSP g_category;
 
   llvm::call_once(g_initialize, [this]() -> void {
     DataVisualization::Categories::GetCategory(ConstString(GetPluginName()),