*** This commit represents a complete reformatting of the LLDB source code

*** to conform to clang-format’s LLVM style.  This kind of mass change has
*** two obvious implications:

Firstly, merging this particular commit into a downstream fork may be a huge
effort.  Alternatively, it may be worth merging all changes up to this commit,
performing the same reformatting operation locally, and then discarding the
merge for this particular commit.  The commands used to accomplish this
reformatting were as follows (with current working directory as the root of
the repository):

    find . \( -iname "*.c" -or -iname "*.cpp" -or -iname "*.h" -or -iname "*.mm" \) -exec clang-format -i {} +
    find . -iname "*.py" -exec autopep8 --in-place --aggressive --aggressive {} + ;

The version of clang-format used was 3.9.0, and autopep8 was 1.2.4.

Secondly, “blame” style tools will generally point to this commit instead of
a meaningful prior commit.  There are alternatives available that will attempt
to look through this change and find the appropriate prior commit.  YMMV.

llvm-svn: 280751

17 files changed, 4552 insertions, 5356 deletions

diff --git a/lldb/source/DataFormatters/CXXFunctionPointer.cpp b/lldb/source/DataFormatters/CXXFunctionPointer.cpp
index c9e0ccb..88e4444 100644
--- a/lldb/source/DataFormatters/CXXFunctionPointer.cpp
+++ b/lldb/source/DataFormatters/CXXFunctionPointer.cpp
@@ -1,4 +1,5 @@
-//===-- CXXFormatterFunctions.cpp---------------------------------*- C++ -*-===//
+//===-- CXXFormatterFunctions.cpp---------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -20,47 +21,38 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-bool
-lldb_private::formatters::CXXFunctionPointerSummaryProvider (ValueObject& valobj, Stream& stream, const TypeSummaryOptions& options)
-{
-    std::string destination;
-    StreamString sstr;
-    AddressType func_ptr_address_type = eAddressTypeInvalid;
-    addr_t func_ptr_address = valobj.GetPointerValue (&func_ptr_address_type);
-    if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS)
-    {
-        switch (func_ptr_address_type)
-        {
-            case eAddressTypeInvalid:
-            case eAddressTypeFile:
-            case eAddressTypeHost:
-                break;
-                
-            case eAddressTypeLoad:
-            {
-                ExecutionContext exe_ctx (valobj.GetExecutionContextRef());
-                
-                Address so_addr;
-                Target *target = exe_ctx.GetTargetPtr();
-                if (target && target->GetSectionLoadList().IsEmpty() == false)
-                {
-                    if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address, so_addr))
-                    {
-                        so_addr.Dump (&sstr,
-                                      exe_ctx.GetBestExecutionContextScope(),
-                                      Address::DumpStyleResolvedDescription,
-                                      Address::DumpStyleSectionNameOffset);
-                    }
-                }
-            }
-                break;
+bool lldb_private::formatters::CXXFunctionPointerSummaryProvider(
+    ValueObject &valobj, Stream &stream, const TypeSummaryOptions &options) {
+  std::string destination;
+  StreamString sstr;
+  AddressType func_ptr_address_type = eAddressTypeInvalid;
+  addr_t func_ptr_address = valobj.GetPointerValue(&func_ptr_address_type);
+  if (func_ptr_address != 0 && func_ptr_address != LLDB_INVALID_ADDRESS) {
+    switch (func_ptr_address_type) {
+    case eAddressTypeInvalid:
+    case eAddressTypeFile:
+    case eAddressTypeHost:
+      break;
+
+    case eAddressTypeLoad: {
+      ExecutionContext exe_ctx(valobj.GetExecutionContextRef());
+
+      Address so_addr;
+      Target *target = exe_ctx.GetTargetPtr();
+      if (target && target->GetSectionLoadList().IsEmpty() == false) {
+        if (target->GetSectionLoadList().ResolveLoadAddress(func_ptr_address,
+                                                            so_addr)) {
+          so_addr.Dump(&sstr, exe_ctx.GetBestExecutionContextScope(),
+                       Address::DumpStyleResolvedDescription,
+                       Address::DumpStyleSectionNameOffset);
         }
+      }
+    } break;
     }
-    if (sstr.GetSize() > 0)
-    {
-        stream.Printf("(%s)", sstr.GetData());
-        return true;
-    }
-    else
-        return false;
+  }
+  if (sstr.GetSize() > 0) {
+    stream.Printf("(%s)", sstr.GetData());
+    return true;
+  } else
+    return false;
 }
diff --git a/lldb/source/DataFormatters/DataVisualization.cpp b/lldb/source/DataFormatters/DataVisualization.cpp
index 14cf13d..2a2d4b8 100644
--- a/lldb/source/DataFormatters/DataVisualization.cpp
+++ b/lldb/source/DataFormatters/DataVisualization.cpp
@@ -1,4 +1,5 @@
-//===-- DataVisualization.cpp ---------------------------------------*- C++ -*-===//
+//===-- DataVisualization.cpp ---------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -17,264 +18,209 @@
 using namespace lldb;
 using namespace lldb_private;
 
-static FormatManager&
-GetFormatManager()
-{
-    static FormatManager g_format_manager;
-    return g_format_manager;
+static FormatManager &GetFormatManager() {
+  static FormatManager g_format_manager;
+  return g_format_manager;
 }
 
-void
-DataVisualization::ForceUpdate ()
-{
-    GetFormatManager().Changed();
-}
+void DataVisualization::ForceUpdate() { GetFormatManager().Changed(); }
 
-uint32_t
-DataVisualization::GetCurrentRevision ()
-{
-    return GetFormatManager().GetCurrentRevision();
+uint32_t DataVisualization::GetCurrentRevision() {
+  return GetFormatManager().GetCurrentRevision();
 }
 
-bool
-DataVisualization::ShouldPrintAsOneLiner (ValueObject& valobj)
-{
-    return GetFormatManager().ShouldPrintAsOneLiner(valobj);
+bool DataVisualization::ShouldPrintAsOneLiner(ValueObject &valobj) {
+  return GetFormatManager().ShouldPrintAsOneLiner(valobj);
 }
 
 lldb::TypeFormatImplSP
-DataVisualization::GetFormat (ValueObject& valobj, lldb::DynamicValueType use_dynamic)
-{
-    return GetFormatManager().GetFormat(valobj, use_dynamic);
+DataVisualization::GetFormat(ValueObject &valobj,
+                             lldb::DynamicValueType use_dynamic) {
+  return GetFormatManager().GetFormat(valobj, use_dynamic);
 }
 
 lldb::TypeFormatImplSP
-DataVisualization::GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetFormatForType(type_sp);
+DataVisualization::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetFormatForType(type_sp);
 }
 
 lldb::TypeSummaryImplSP
-DataVisualization::GetSummaryFormat (ValueObject& valobj, lldb::DynamicValueType use_dynamic)
-{
-    return GetFormatManager().GetSummaryFormat(valobj, use_dynamic);
+DataVisualization::GetSummaryFormat(ValueObject &valobj,
+                                    lldb::DynamicValueType use_dynamic) {
+  return GetFormatManager().GetSummaryFormat(valobj, use_dynamic);
 }
 
 lldb::TypeSummaryImplSP
-DataVisualization::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetSummaryForType(type_sp);
+DataVisualization::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetSummaryForType(type_sp);
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SyntheticChildrenSP
-DataVisualization::GetSyntheticChildren (ValueObject& valobj,
-                                         lldb::DynamicValueType use_dynamic)
-{
-    return GetFormatManager().GetSyntheticChildren(valobj, use_dynamic);
+DataVisualization::GetSyntheticChildren(ValueObject &valobj,
+                                        lldb::DynamicValueType use_dynamic) {
+  return GetFormatManager().GetSyntheticChildren(valobj, use_dynamic);
 }
 #endif
 
 #ifndef LLDB_DISABLE_PYTHON
-lldb::SyntheticChildrenSP
-DataVisualization::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetSyntheticChildrenForType(type_sp);
+lldb::SyntheticChildrenSP DataVisualization::GetSyntheticChildrenForType(
+    lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetSyntheticChildrenForType(type_sp);
 }
 #endif
 
 lldb::TypeFilterImplSP
-DataVisualization::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetFilterForType(type_sp);
+DataVisualization::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetFilterForType(type_sp);
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::ScriptedSyntheticChildrenSP
-DataVisualization::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetSyntheticForType(type_sp);
+DataVisualization::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetSyntheticForType(type_sp);
 }
 #endif
 
 lldb::TypeValidatorImplSP
-DataVisualization::GetValidator (ValueObject& valobj, lldb::DynamicValueType use_dynamic)
-{
-    return GetFormatManager().GetValidator(valobj, use_dynamic);
+DataVisualization::GetValidator(ValueObject &valobj,
+                                lldb::DynamicValueType use_dynamic) {
+  return GetFormatManager().GetValidator(valobj, use_dynamic);
 }
 
 lldb::TypeValidatorImplSP
-DataVisualization::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    return GetFormatManager().GetValidatorForType(type_sp);
-}
-
-bool
-DataVisualization::AnyMatches (ConstString type_name,
-                               TypeCategoryImpl::FormatCategoryItems items,
-                               bool only_enabled,
-                               const char** matching_category,
-                               TypeCategoryImpl::FormatCategoryItems* matching_type)
-{
-    return GetFormatManager().AnyMatches(type_name,
-                                         items,
-                                         only_enabled,
-                                         matching_category,
-                                         matching_type);
-}
-
-bool
-DataVisualization::Categories::GetCategory (const ConstString &category, lldb::TypeCategoryImplSP &entry,
-                                            bool allow_create)
-{
-    entry = GetFormatManager().GetCategory(category, allow_create);
-    return (entry.get() != NULL);
-}
-
-bool
-DataVisualization::Categories::GetCategory (lldb::LanguageType language, lldb::TypeCategoryImplSP &entry)
-{
-    if (LanguageCategory *lang_category = GetFormatManager().GetCategoryForLanguage(language))
-        entry = lang_category->GetCategory();
-    return (entry.get() != nullptr);
-}
-
-void
-DataVisualization::Categories::Add (const ConstString &category)
-{
-    GetFormatManager().GetCategory(category);
-}
-
-bool
-DataVisualization::Categories::Delete (const ConstString &category)
-{
-    GetFormatManager().DisableCategory(category);
-    return GetFormatManager().DeleteCategory(category);
+DataVisualization::GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  return GetFormatManager().GetValidatorForType(type_sp);
+}
+
+bool DataVisualization::AnyMatches(
+    ConstString type_name, TypeCategoryImpl::FormatCategoryItems items,
+    bool only_enabled, const char **matching_category,
+    TypeCategoryImpl::FormatCategoryItems *matching_type) {
+  return GetFormatManager().AnyMatches(type_name, items, only_enabled,
+                                       matching_category, matching_type);
+}
+
+bool DataVisualization::Categories::GetCategory(const ConstString &category,
+                                                lldb::TypeCategoryImplSP &entry,
+                                                bool allow_create) {
+  entry = GetFormatManager().GetCategory(category, allow_create);
+  return (entry.get() != NULL);
+}
+
+bool DataVisualization::Categories::GetCategory(
+    lldb::LanguageType language, lldb::TypeCategoryImplSP &entry) {
+  if (LanguageCategory *lang_category =
+          GetFormatManager().GetCategoryForLanguage(language))
+    entry = lang_category->GetCategory();
+  return (entry.get() != nullptr);
+}
+
+void DataVisualization::Categories::Add(const ConstString &category) {
+  GetFormatManager().GetCategory(category);
+}
+
+bool DataVisualization::Categories::Delete(const ConstString &category) {
+  GetFormatManager().DisableCategory(category);
+  return GetFormatManager().DeleteCategory(category);
 }
 
-void
-DataVisualization::Categories::Clear ()
-{
-    GetFormatManager().ClearCategories();
+void DataVisualization::Categories::Clear() {
+  GetFormatManager().ClearCategories();
 }
 
-void
-DataVisualization::Categories::Clear (const ConstString &category)
-{
-    GetFormatManager().GetCategory(category)->Clear(eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
+void DataVisualization::Categories::Clear(const ConstString &category) {
+  GetFormatManager().GetCategory(category)->Clear(
+      eFormatCategoryItemSummary | eFormatCategoryItemRegexSummary);
 }
 
-void
-DataVisualization::Categories::Enable (const ConstString& category,
-                                       TypeCategoryMap::Position pos)
-{
-    if (GetFormatManager().GetCategory(category)->IsEnabled())
-        GetFormatManager().DisableCategory(category);
-    GetFormatManager().EnableCategory(category, pos, std::initializer_list<lldb::LanguageType>());
+void DataVisualization::Categories::Enable(const ConstString &category,
+                                           TypeCategoryMap::Position pos) {
+  if (GetFormatManager().GetCategory(category)->IsEnabled())
+    GetFormatManager().DisableCategory(category);
+  GetFormatManager().EnableCategory(
+      category, pos, std::initializer_list<lldb::LanguageType>());
 }
 
-void
-DataVisualization::Categories::Enable (lldb::LanguageType lang_type)
-{
-    if (LanguageCategory* lang_category = GetFormatManager().GetCategoryForLanguage(lang_type))
-        lang_category->Enable();
+void DataVisualization::Categories::Enable(lldb::LanguageType lang_type) {
+  if (LanguageCategory *lang_category =
+          GetFormatManager().GetCategoryForLanguage(lang_type))
+    lang_category->Enable();
 }
 
-void
-DataVisualization::Categories::Disable (const ConstString& category)
-{
-    if (GetFormatManager().GetCategory(category)->IsEnabled() == true)
-        GetFormatManager().DisableCategory(category);
+void DataVisualization::Categories::Disable(const ConstString &category) {
+  if (GetFormatManager().GetCategory(category)->IsEnabled() == true)
+    GetFormatManager().DisableCategory(category);
 }
 
-void
-DataVisualization::Categories::Disable (lldb::LanguageType lang_type)
-{
-    if (LanguageCategory* lang_category = GetFormatManager().GetCategoryForLanguage(lang_type))
-        lang_category->Disable();
+void DataVisualization::Categories::Disable(lldb::LanguageType lang_type) {
+  if (LanguageCategory *lang_category =
+          GetFormatManager().GetCategoryForLanguage(lang_type))
+    lang_category->Disable();
 }
 
-void
-DataVisualization::Categories::Enable (const lldb::TypeCategoryImplSP& category,
-                                       TypeCategoryMap::Position pos)
-{
-    if (category.get())
-    {
-        if (category->IsEnabled())
-            GetFormatManager().DisableCategory(category);
-        GetFormatManager().EnableCategory(category, pos);
-    }
+void DataVisualization::Categories::Enable(
+    const lldb::TypeCategoryImplSP &category, TypeCategoryMap::Position pos) {
+  if (category.get()) {
+    if (category->IsEnabled())
+      GetFormatManager().DisableCategory(category);
+    GetFormatManager().EnableCategory(category, pos);
+  }
 }
 
-void
-DataVisualization::Categories::Disable (const lldb::TypeCategoryImplSP& category)
-{
-    if (category.get() && category->IsEnabled() == true)
-        GetFormatManager().DisableCategory(category);
+void DataVisualization::Categories::Disable(
+    const lldb::TypeCategoryImplSP &category) {
+  if (category.get() && category->IsEnabled() == true)
+    GetFormatManager().DisableCategory(category);
 }
 
-void
-DataVisualization::Categories::EnableStar ()
-{
-    GetFormatManager().EnableAllCategories ();
+void DataVisualization::Categories::EnableStar() {
+  GetFormatManager().EnableAllCategories();
 }
 
-void
-DataVisualization::Categories::DisableStar ()
-{
-    GetFormatManager().DisableAllCategories();
+void DataVisualization::Categories::DisableStar() {
+  GetFormatManager().DisableAllCategories();
 }
 
-void
-DataVisualization::Categories::ForEach (TypeCategoryMap::ForEachCallback callback)
-{
-    GetFormatManager().ForEachCategory(callback);
+void DataVisualization::Categories::ForEach(
+    TypeCategoryMap::ForEachCallback callback) {
+  GetFormatManager().ForEachCategory(callback);
 }
 
-uint32_t
-DataVisualization::Categories::GetCount ()
-{
-    return GetFormatManager().GetCategoriesCount();
+uint32_t DataVisualization::Categories::GetCount() {
+  return GetFormatManager().GetCategoriesCount();
 }
 
 lldb::TypeCategoryImplSP
-DataVisualization::Categories::GetCategoryAtIndex (size_t index)
-{
-    return GetFormatManager().GetCategoryAtIndex(index);
+DataVisualization::Categories::GetCategoryAtIndex(size_t index) {
+  return GetFormatManager().GetCategoryAtIndex(index);
 }
 
-bool
-DataVisualization::NamedSummaryFormats::GetSummaryFormat (const ConstString &type, lldb::TypeSummaryImplSP &entry)
-{
-    return GetFormatManager().GetNamedSummaryContainer().Get(type,entry);
+bool DataVisualization::NamedSummaryFormats::GetSummaryFormat(
+    const ConstString &type, lldb::TypeSummaryImplSP &entry) {
+  return GetFormatManager().GetNamedSummaryContainer().Get(type, entry);
 }
 
-void
-DataVisualization::NamedSummaryFormats::Add (const ConstString &type, const lldb::TypeSummaryImplSP &entry)
-{
-    GetFormatManager().GetNamedSummaryContainer().Add(FormatManager::GetValidTypeName(type),entry);
+void DataVisualization::NamedSummaryFormats::Add(
+    const ConstString &type, const lldb::TypeSummaryImplSP &entry) {
+  GetFormatManager().GetNamedSummaryContainer().Add(
+      FormatManager::GetValidTypeName(type), entry);
 }
 
-bool
-DataVisualization::NamedSummaryFormats::Delete (const ConstString &type)
-{
-    return GetFormatManager().GetNamedSummaryContainer().Delete(type);
+bool DataVisualization::NamedSummaryFormats::Delete(const ConstString &type) {
+  return GetFormatManager().GetNamedSummaryContainer().Delete(type);
 }
 
-void
-DataVisualization::NamedSummaryFormats::Clear ()
-{
-    GetFormatManager().GetNamedSummaryContainer().Clear();
+void DataVisualization::NamedSummaryFormats::Clear() {
+  GetFormatManager().GetNamedSummaryContainer().Clear();
 }
 
-void
-DataVisualization::NamedSummaryFormats::ForEach (std::function<bool(ConstString, const lldb::TypeSummaryImplSP&)> callback)
-{
-    GetFormatManager().GetNamedSummaryContainer().ForEach(callback);
+void DataVisualization::NamedSummaryFormats::ForEach(
+    std::function<bool(ConstString, const lldb::TypeSummaryImplSP &)>
+        callback) {
+  GetFormatManager().GetNamedSummaryContainer().ForEach(callback);
 }
 
-uint32_t
-DataVisualization::NamedSummaryFormats::GetCount ()
-{
-    return GetFormatManager().GetNamedSummaryContainer().GetCount();
+uint32_t DataVisualization::NamedSummaryFormats::GetCount() {
+  return GetFormatManager().GetNamedSummaryContainer().GetCount();
 }
diff --git a/lldb/source/DataFormatters/DumpValueObjectOptions.cpp b/lldb/source/DataFormatters/DumpValueObjectOptions.cpp
index e1f5320..1f5569b 100644
--- a/lldb/source/DataFormatters/DumpValueObjectOptions.cpp
+++ b/lldb/source/DataFormatters/DumpValueObjectOptions.cpp
@@ -1,4 +1,5 @@
-//===-- DumpValueObjectOptions.cpp -----------------------------------*- C++ -*-===//
+//===-- DumpValueObjectOptions.cpp -----------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -18,234 +19,182 @@
 using namespace lldb;
 using namespace lldb_private;
 
-DumpValueObjectOptions::DumpValueObjectOptions() :
-    m_summary_sp(),
-    m_root_valobj_name(),
-    m_max_ptr_depth(PointerDepth{PointerDepth::Mode::Default,0}),
-    m_decl_printing_helper(),
-    m_use_synthetic(true),
-    m_scope_already_checked(false),
-    m_flat_output(false),
-    m_ignore_cap(false),
-    m_show_types(false),
-    m_show_location(false),
-    m_use_objc(false),
-    m_hide_root_type(false),
-    m_hide_name(false),
-    m_hide_value(false),
-    m_run_validator(false),
-    m_use_type_display_name(true),
-    m_allow_oneliner_mode(true),
-    m_hide_pointer_value(false),
-    m_reveal_empty_aggregates(true)
-{}
-
-
-DumpValueObjectOptions::DumpValueObjectOptions (ValueObject& valobj) :
-    DumpValueObjectOptions()
-{
-    m_use_dynamic = valobj.GetDynamicValueType();
-    m_use_synthetic = valobj.IsSynthetic();
-    m_varformat_language = valobj.GetPreferredDisplayLanguage();
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetMaximumPointerDepth(PointerDepth depth)
-{
-    m_max_ptr_depth = depth;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetMaximumDepth(uint32_t depth)
-{
-    m_max_depth = depth;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetDeclPrintingHelper(DeclPrintingHelper helper)
-{
-    m_decl_printing_helper = helper;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetShowTypes(bool show)
-{
-    m_show_types = show;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetShowLocation(bool show)
-{
-    m_show_location = show;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetUseObjectiveC(bool use)
-{
-    m_use_objc = use;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetShowSummary(bool show)
-{
-    if (show == false)
-        SetOmitSummaryDepth(UINT32_MAX);
-    else
-        SetOmitSummaryDepth(0);
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetUseDynamicType(lldb::DynamicValueType dyn)
-{
-    m_use_dynamic = dyn;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetUseSyntheticValue(bool use_synthetic)
-{
-    m_use_synthetic = use_synthetic;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetScopeChecked(bool check)
-{
-    m_scope_already_checked = check;
-    return *this;
-}
-
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetFlatOutput(bool flat)
-{
-    m_flat_output = flat;
-    return *this;
+DumpValueObjectOptions::DumpValueObjectOptions()
+    : m_summary_sp(), m_root_valobj_name(),
+      m_max_ptr_depth(PointerDepth{PointerDepth::Mode::Default, 0}),
+      m_decl_printing_helper(), m_use_synthetic(true),
+      m_scope_already_checked(false), m_flat_output(false), m_ignore_cap(false),
+      m_show_types(false), m_show_location(false), m_use_objc(false),
+      m_hide_root_type(false), m_hide_name(false), m_hide_value(false),
+      m_run_validator(false), m_use_type_display_name(true),
+      m_allow_oneliner_mode(true), m_hide_pointer_value(false),
+      m_reveal_empty_aggregates(true) {}
+
+DumpValueObjectOptions::DumpValueObjectOptions(ValueObject &valobj)
+    : DumpValueObjectOptions() {
+  m_use_dynamic = valobj.GetDynamicValueType();
+  m_use_synthetic = valobj.IsSynthetic();
+  m_varformat_language = valobj.GetPreferredDisplayLanguage();
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetMaximumPointerDepth(PointerDepth depth) {
+  m_max_ptr_depth = depth;
+  return *this;
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetMaximumDepth(uint32_t depth) {
+  m_max_depth = depth;
+  return *this;
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetDeclPrintingHelper(DeclPrintingHelper helper) {
+  m_decl_printing_helper = helper;
+  return *this;
+}
+
+DumpValueObjectOptions &DumpValueObjectOptions::SetShowTypes(bool show) {
+  m_show_types = show;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetOmitSummaryDepth(uint32_t depth)
-{
-    m_omit_summary_depth = depth;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetShowLocation(bool show) {
+  m_show_location = show;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetIgnoreCap(bool ignore)
-{
-    m_ignore_cap = ignore;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetUseObjectiveC(bool use) {
+  m_use_objc = use;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetRawDisplay()
-{
-    SetUseSyntheticValue(false);
+DumpValueObjectOptions &DumpValueObjectOptions::SetShowSummary(bool show) {
+  if (show == false)
     SetOmitSummaryDepth(UINT32_MAX);
-    SetIgnoreCap(true);
-    SetHideName(false);
-    SetHideValue(false);
-    SetUseTypeDisplayName(false);
-    SetAllowOnelinerMode(false);
-    return *this;
+  else
+    SetOmitSummaryDepth(0);
+  return *this;
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetUseDynamicType(lldb::DynamicValueType dyn) {
+  m_use_dynamic = dyn;
+  return *this;
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetUseSyntheticValue(bool use_synthetic) {
+  m_use_synthetic = use_synthetic;
+  return *this;
+}
+
+DumpValueObjectOptions &DumpValueObjectOptions::SetScopeChecked(bool check) {
+  m_scope_already_checked = check;
+  return *this;
+}
+
+DumpValueObjectOptions &DumpValueObjectOptions::SetFlatOutput(bool flat) {
+  m_flat_output = flat;
+  return *this;
+}
+
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetOmitSummaryDepth(uint32_t depth) {
+  m_omit_summary_depth = depth;
+  return *this;
+}
+
+DumpValueObjectOptions &DumpValueObjectOptions::SetIgnoreCap(bool ignore) {
+  m_ignore_cap = ignore;
+  return *this;
+}
+
+DumpValueObjectOptions &DumpValueObjectOptions::SetRawDisplay() {
+  SetUseSyntheticValue(false);
+  SetOmitSummaryDepth(UINT32_MAX);
+  SetIgnoreCap(true);
+  SetHideName(false);
+  SetHideValue(false);
+  SetUseTypeDisplayName(false);
+  SetAllowOnelinerMode(false);
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetFormat (lldb::Format format)
-{
-    m_format = format;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetFormat(lldb::Format format) {
+  m_format = format;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetSummary (lldb::TypeSummaryImplSP summary)
-{
-    m_summary_sp = summary;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetSummary(lldb::TypeSummaryImplSP summary) {
+  m_summary_sp = summary;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetRootValueObjectName (const char* name)
-{
-    if (name)
-        m_root_valobj_name.assign(name);
-    else
-        m_root_valobj_name.clear();
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetRootValueObjectName(const char *name) {
+  if (name)
+    m_root_valobj_name.assign(name);
+  else
+    m_root_valobj_name.clear();
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetHideRootType (bool hide_root_type)
-{
-    m_hide_root_type = hide_root_type;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetHideRootType(bool hide_root_type) {
+  m_hide_root_type = hide_root_type;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetHideName (bool hide_name)
-{
-    m_hide_name = hide_name;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetHideName(bool hide_name) {
+  m_hide_name = hide_name;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetHideValue (bool hide_value)
-{
-    m_hide_value = hide_value;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetHideValue(bool hide_value) {
+  m_hide_value = hide_value;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetHidePointerValue (bool hide)
-{
-    m_hide_pointer_value = hide;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetHidePointerValue(bool hide) {
+  m_hide_pointer_value = hide;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetVariableFormatDisplayLanguage (lldb::LanguageType lang)
-{
-    m_varformat_language = lang;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetVariableFormatDisplayLanguage(
+    lldb::LanguageType lang) {
+  m_varformat_language = lang;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetRunValidator (bool run)
-{
-    m_run_validator = run;
-    return *this;
+DumpValueObjectOptions &DumpValueObjectOptions::SetRunValidator(bool run) {
+  m_run_validator = run;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetUseTypeDisplayName (bool dis)
-{
-    m_use_type_display_name = dis;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetUseTypeDisplayName(bool dis) {
+  m_use_type_display_name = dis;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetAllowOnelinerMode (bool oneliner)
-{
-    m_allow_oneliner_mode = oneliner;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetAllowOnelinerMode(bool oneliner) {
+  m_allow_oneliner_mode = oneliner;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetRevealEmptyAggregates (bool reveal)
-{
-    m_reveal_empty_aggregates = reveal;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetRevealEmptyAggregates(bool reveal) {
+  m_reveal_empty_aggregates = reveal;
+  return *this;
 }
 
-DumpValueObjectOptions&
-DumpValueObjectOptions::SetElementCount (uint32_t element_count)
-{
-    m_element_count = element_count;
-    return *this;
+DumpValueObjectOptions &
+DumpValueObjectOptions::SetElementCount(uint32_t element_count) {
+  m_element_count = element_count;
+  return *this;
 }
diff --git a/lldb/source/DataFormatters/FormatCache.cpp b/lldb/source/DataFormatters/FormatCache.cpp
index fc5becb..0f1b29f 100644
--- a/lldb/source/DataFormatters/FormatCache.cpp
+++ b/lldb/source/DataFormatters/FormatCache.cpp
@@ -1,4 +1,5 @@
-//===-- FormatCache.cpp ------------------------------------------*- C++ -*-===//
+//===-- FormatCache.cpp ------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -19,279 +20,205 @@
 using namespace lldb;
 using namespace lldb_private;
 
-FormatCache::Entry::Entry () :
-m_format_cached(false),
-m_summary_cached(false),
-m_synthetic_cached(false),
-m_validator_cached(false),
-m_format_sp(),
-m_summary_sp(),
-m_synthetic_sp(),
-m_validator_sp()
-{}
-
-FormatCache::Entry::Entry (lldb::TypeFormatImplSP format_sp) :
-m_summary_cached(false),
-m_synthetic_cached(false),
-m_validator_cached(false),
-m_summary_sp(),
-m_synthetic_sp(),
-m_validator_sp()
-{
-    SetFormat (format_sp);
-}
+FormatCache::Entry::Entry()
+    : m_format_cached(false), m_summary_cached(false),
+      m_synthetic_cached(false), m_validator_cached(false), m_format_sp(),
+      m_summary_sp(), m_synthetic_sp(), m_validator_sp() {}
 
-FormatCache::Entry::Entry (lldb::TypeSummaryImplSP summary_sp) :
-m_format_cached(false),
-m_synthetic_cached(false),
-m_validator_cached(false),
-m_format_sp(),
-m_synthetic_sp(),
-m_validator_sp()
-{
-    SetSummary (summary_sp);
+FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp)
+    : m_summary_cached(false), m_synthetic_cached(false),
+      m_validator_cached(false), m_summary_sp(), m_synthetic_sp(),
+      m_validator_sp() {
+  SetFormat(format_sp);
 }
 
-FormatCache::Entry::Entry (lldb::SyntheticChildrenSP synthetic_sp) :
-m_format_cached(false),
-m_summary_cached(false),
-m_validator_cached(false),
-m_format_sp(),
-m_summary_sp(),
-m_validator_sp()
-{
-    SetSynthetic (synthetic_sp);
+FormatCache::Entry::Entry(lldb::TypeSummaryImplSP summary_sp)
+    : m_format_cached(false), m_synthetic_cached(false),
+      m_validator_cached(false), m_format_sp(), m_synthetic_sp(),
+      m_validator_sp() {
+  SetSummary(summary_sp);
 }
 
-FormatCache::Entry::Entry (lldb::TypeValidatorImplSP validator_sp) :
-m_format_cached(false),
-m_summary_cached(false),
-m_synthetic_cached(false),
-m_format_sp(),
-m_summary_sp(),
-m_synthetic_sp()
-{
-    SetValidator (validator_sp);
+FormatCache::Entry::Entry(lldb::SyntheticChildrenSP synthetic_sp)
+    : m_format_cached(false), m_summary_cached(false),
+      m_validator_cached(false), m_format_sp(), m_summary_sp(),
+      m_validator_sp() {
+  SetSynthetic(synthetic_sp);
 }
 
-FormatCache::Entry::Entry (lldb::TypeFormatImplSP format_sp, lldb::TypeSummaryImplSP summary_sp, lldb::SyntheticChildrenSP synthetic_sp, lldb::TypeValidatorImplSP validator_sp)
-{
-    SetFormat (format_sp);
-    SetSummary (summary_sp);
-    SetSynthetic (synthetic_sp);
-    SetValidator (validator_sp);
+FormatCache::Entry::Entry(lldb::TypeValidatorImplSP validator_sp)
+    : m_format_cached(false), m_summary_cached(false),
+      m_synthetic_cached(false), m_format_sp(), m_summary_sp(),
+      m_synthetic_sp() {
+  SetValidator(validator_sp);
 }
 
-bool
-FormatCache::Entry::IsFormatCached ()
-{
-    return m_format_cached;
+FormatCache::Entry::Entry(lldb::TypeFormatImplSP format_sp,
+                          lldb::TypeSummaryImplSP summary_sp,
+                          lldb::SyntheticChildrenSP synthetic_sp,
+                          lldb::TypeValidatorImplSP validator_sp) {
+  SetFormat(format_sp);
+  SetSummary(summary_sp);
+  SetSynthetic(synthetic_sp);
+  SetValidator(validator_sp);
 }
 
-bool
-FormatCache::Entry::IsSummaryCached ()
-{
-    return m_summary_cached;
-}
+bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }
 
-bool
-FormatCache::Entry::IsSyntheticCached ()
-{
-    return m_synthetic_cached;
-}
+bool FormatCache::Entry::IsSummaryCached() { return m_summary_cached; }
 
-bool
-FormatCache::Entry::IsValidatorCached ()
-{
-    return m_validator_cached;
-}
+bool FormatCache::Entry::IsSyntheticCached() { return m_synthetic_cached; }
 
-lldb::TypeFormatImplSP
-FormatCache::Entry::GetFormat ()
-{
-    return m_format_sp;
-}
+bool FormatCache::Entry::IsValidatorCached() { return m_validator_cached; }
 
-lldb::TypeSummaryImplSP
-FormatCache::Entry::GetSummary ()
-{
-    return m_summary_sp;
+lldb::TypeFormatImplSP FormatCache::Entry::GetFormat() { return m_format_sp; }
+
+lldb::TypeSummaryImplSP FormatCache::Entry::GetSummary() {
+  return m_summary_sp;
 }
 
-lldb::SyntheticChildrenSP
-FormatCache::Entry::GetSynthetic ()
-{
-    return m_synthetic_sp;
+lldb::SyntheticChildrenSP FormatCache::Entry::GetSynthetic() {
+  return m_synthetic_sp;
 }
 
-lldb::TypeValidatorImplSP
-FormatCache::Entry::GetValidator ()
-{
-    return m_validator_sp;
+lldb::TypeValidatorImplSP FormatCache::Entry::GetValidator() {
+  return m_validator_sp;
 }
 
-void
-FormatCache::Entry::SetFormat (lldb::TypeFormatImplSP format_sp)
-{
-    m_format_cached = true;
-    m_format_sp = format_sp;
+void FormatCache::Entry::SetFormat(lldb::TypeFormatImplSP format_sp) {
+  m_format_cached = true;
+  m_format_sp = format_sp;
 }
 
-void
-FormatCache::Entry::SetSummary (lldb::TypeSummaryImplSP summary_sp)
-{
-    m_summary_cached = true;
-    m_summary_sp = summary_sp;
+void FormatCache::Entry::SetSummary(lldb::TypeSummaryImplSP summary_sp) {
+  m_summary_cached = true;
+  m_summary_sp = summary_sp;
 }
 
-void
-FormatCache::Entry::SetSynthetic (lldb::SyntheticChildrenSP synthetic_sp)
-{
-    m_synthetic_cached = true;
-    m_synthetic_sp = synthetic_sp;
+void FormatCache::Entry::SetSynthetic(lldb::SyntheticChildrenSP synthetic_sp) {
+  m_synthetic_cached = true;
+  m_synthetic_sp = synthetic_sp;
 }
 
-void
-FormatCache::Entry::SetValidator (lldb::TypeValidatorImplSP validator_sp)
-{
-    m_validator_cached = true;
-    m_validator_sp = validator_sp;
+void FormatCache::Entry::SetValidator(lldb::TypeValidatorImplSP validator_sp) {
+  m_validator_cached = true;
+  m_validator_sp = validator_sp;
 }
 
 FormatCache::FormatCache()
-    : m_map(),
-      m_mutex()
+    : m_map(), m_mutex()
 #ifdef LLDB_CONFIGURATION_DEBUG
       ,
-      m_cache_hits(0),
-      m_cache_misses(0)
+      m_cache_hits(0), m_cache_misses(0)
 #endif
 {
 }
 
-FormatCache::Entry&
-FormatCache::GetEntry (const ConstString& type)
-{
-    auto i = m_map.find(type),
-    e = m_map.end();
-    if (i != e)
-        return i->second;
-    m_map[type] = FormatCache::Entry();
-    return m_map[type];
+FormatCache::Entry &FormatCache::GetEntry(const ConstString &type) {
+  auto i = m_map.find(type), e = m_map.end();
+  if (i != e)
+    return i->second;
+  m_map[type] = FormatCache::Entry();
+  return m_map[type];
 }
 
-bool
-FormatCache::GetFormat (const ConstString& type,lldb::TypeFormatImplSP& format_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    auto entry = GetEntry(type);
-    if (entry.IsFormatCached())
-    {
+bool FormatCache::GetFormat(const ConstString &type,
+                            lldb::TypeFormatImplSP &format_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  auto entry = GetEntry(type);
+  if (entry.IsFormatCached()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
-        m_cache_hits++;
+    m_cache_hits++;
 #endif
-        format_sp = entry.GetFormat();
-        return true;
-    }
+    format_sp = entry.GetFormat();
+    return true;
+  }
 #ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_misses++;
+  m_cache_misses++;
 #endif
-    format_sp.reset();
-    return false;
+  format_sp.reset();
+  return false;
 }
 
-bool
-FormatCache::GetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    auto entry = GetEntry(type);
-    if (entry.IsSummaryCached())
-    {
+bool FormatCache::GetSummary(const ConstString &type,
+                             lldb::TypeSummaryImplSP &summary_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  auto entry = GetEntry(type);
+  if (entry.IsSummaryCached()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
-        m_cache_hits++;
+    m_cache_hits++;
 #endif
-        summary_sp = entry.GetSummary();
-        return true;
-    }
+    summary_sp = entry.GetSummary();
+    return true;
+  }
 #ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_misses++;
+  m_cache_misses++;
 #endif
-    summary_sp.reset();
-    return false;
+  summary_sp.reset();
+  return false;
 }
 
-bool
-FormatCache::GetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    auto entry = GetEntry(type);
-    if (entry.IsSyntheticCached())
-    {
+bool FormatCache::GetSynthetic(const ConstString &type,
+                               lldb::SyntheticChildrenSP &synthetic_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  auto entry = GetEntry(type);
+  if (entry.IsSyntheticCached()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
-        m_cache_hits++;
+    m_cache_hits++;
 #endif
-        synthetic_sp = entry.GetSynthetic();
-        return true;
-    }
+    synthetic_sp = entry.GetSynthetic();
+    return true;
+  }
 #ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_misses++;
+  m_cache_misses++;
 #endif
-    synthetic_sp.reset();
-    return false;
+  synthetic_sp.reset();
+  return false;
 }
 
-bool
-FormatCache::GetValidator (const ConstString& type,lldb::TypeValidatorImplSP& validator_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    auto entry = GetEntry(type);
-    if (entry.IsValidatorCached())
-    {
+bool FormatCache::GetValidator(const ConstString &type,
+                               lldb::TypeValidatorImplSP &validator_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  auto entry = GetEntry(type);
+  if (entry.IsValidatorCached()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
-        m_cache_hits++;
+    m_cache_hits++;
 #endif
-        validator_sp = entry.GetValidator();
-        return true;
-    }
+    validator_sp = entry.GetValidator();
+    return true;
+  }
 #ifdef LLDB_CONFIGURATION_DEBUG
-    m_cache_misses++;
+  m_cache_misses++;
 #endif
-    validator_sp.reset();
-    return false;
+  validator_sp.reset();
+  return false;
 }
 
-void
-FormatCache::SetFormat (const ConstString& type,lldb::TypeFormatImplSP& format_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    GetEntry(type).SetFormat(format_sp);
+void FormatCache::SetFormat(const ConstString &type,
+                            lldb::TypeFormatImplSP &format_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  GetEntry(type).SetFormat(format_sp);
 }
 
-void
-FormatCache::SetSummary (const ConstString& type,lldb::TypeSummaryImplSP& summary_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    GetEntry(type).SetSummary(summary_sp);
+void FormatCache::SetSummary(const ConstString &type,
+                             lldb::TypeSummaryImplSP &summary_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  GetEntry(type).SetSummary(summary_sp);
 }
 
-void
-FormatCache::SetSynthetic (const ConstString& type,lldb::SyntheticChildrenSP& synthetic_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    GetEntry(type).SetSynthetic(synthetic_sp);
+void FormatCache::SetSynthetic(const ConstString &type,
+                               lldb::SyntheticChildrenSP &synthetic_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  GetEntry(type).SetSynthetic(synthetic_sp);
 }
 
-void
-FormatCache::SetValidator (const ConstString& type,lldb::TypeValidatorImplSP& validator_sp)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    GetEntry(type).SetValidator(validator_sp);
+void FormatCache::SetValidator(const ConstString &type,
+                               lldb::TypeValidatorImplSP &validator_sp) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  GetEntry(type).SetValidator(validator_sp);
 }
 
-void
-FormatCache::Clear ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    m_map.clear();
+void FormatCache::Clear() {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  m_map.clear();
 }
-
diff --git a/lldb/source/DataFormatters/FormatClasses.cpp b/lldb/source/DataFormatters/FormatClasses.cpp
index 2e4acd1..f657361 100644
--- a/lldb/source/DataFormatters/FormatClasses.cpp
+++ b/lldb/source/DataFormatters/FormatClasses.cpp
@@ -1,4 +1,5 @@
-//===-- FormatClasses.cpp ----------------------------------------*- C++ -*-===//
+//===-- FormatClasses.cpp ----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -22,48 +23,32 @@
 using namespace lldb;
 using namespace lldb_private;
 
-FormattersMatchData::FormattersMatchData (ValueObject& valobj, lldb::DynamicValueType use_dynamic) :
-    m_valobj(valobj),
-    m_dynamic_value_type(use_dynamic),
-    m_formatters_match_vector({},false),
-    m_type_for_cache(),
-    m_candidate_languages()
-{
-    m_type_for_cache = FormatManager::GetTypeForCache(valobj, use_dynamic);
-    m_candidate_languages = FormatManager::GetCandidateLanguages(valobj);
+FormattersMatchData::FormattersMatchData(ValueObject &valobj,
+                                         lldb::DynamicValueType use_dynamic)
+    : m_valobj(valobj), m_dynamic_value_type(use_dynamic),
+      m_formatters_match_vector({}, false), m_type_for_cache(),
+      m_candidate_languages() {
+  m_type_for_cache = FormatManager::GetTypeForCache(valobj, use_dynamic);
+  m_candidate_languages = FormatManager::GetCandidateLanguages(valobj);
 }
 
-FormattersMatchVector
-FormattersMatchData::GetMatchesVector ()
-{
-    if (!m_formatters_match_vector.second)
-    {
-        m_formatters_match_vector.second = true;
-        m_formatters_match_vector.first = FormatManager::GetPossibleMatches(m_valobj, m_dynamic_value_type);
-    }
-    return m_formatters_match_vector.first;
+FormattersMatchVector FormattersMatchData::GetMatchesVector() {
+  if (!m_formatters_match_vector.second) {
+    m_formatters_match_vector.second = true;
+    m_formatters_match_vector.first =
+        FormatManager::GetPossibleMatches(m_valobj, m_dynamic_value_type);
+  }
+  return m_formatters_match_vector.first;
 }
 
-ConstString
-FormattersMatchData::GetTypeForCache ()
-{
-    return m_type_for_cache;
-}
+ConstString FormattersMatchData::GetTypeForCache() { return m_type_for_cache; }
 
-CandidateLanguagesVector
-FormattersMatchData::GetCandidateLanguages ()
-{
-    return m_candidate_languages;
+CandidateLanguagesVector FormattersMatchData::GetCandidateLanguages() {
+  return m_candidate_languages;
 }
 
-ValueObject&
-FormattersMatchData::GetValueObject ()
-{
-    return m_valobj;
-}
+ValueObject &FormattersMatchData::GetValueObject() { return m_valobj; }
 
-lldb::DynamicValueType
-FormattersMatchData::GetDynamicValueType ()
-{
-    return m_dynamic_value_type;
+lldb::DynamicValueType FormattersMatchData::GetDynamicValueType() {
+  return m_dynamic_value_type;
 }
diff --git a/lldb/source/DataFormatters/FormatManager.cpp b/lldb/source/DataFormatters/FormatManager.cpp
index f51243f..aa6e7a2 100644
--- a/lldb/source/DataFormatters/FormatManager.cpp
+++ b/lldb/source/DataFormatters/FormatManager.cpp
@@ -1,4 +1,5 @@
-//===-- FormatManager.cpp -------------------------------------------*- C++ -*-===//
+//===-- FormatManager.cpp -------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -27,1176 +28,1059 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-struct FormatInfo
-{
-    Format format;
-    const char format_char; // One or more format characters that can be used for this format.
-    const char *format_name;    // Long format name that can be used to specify the current format
+struct FormatInfo {
+  Format format;
+  const char format_char;  // One or more format characters that can be used for
+                           // this format.
+  const char *format_name; // Long format name that can be used to specify the
+                           // current format
 };
 
-static FormatInfo 
-g_format_infos[] = 
-{
-    { eFormatDefault        , '\0'  , "default"             },
-    { eFormatBoolean        , 'B'   , "boolean"             },
-    { eFormatBinary         , 'b'   , "binary"              },
-    { eFormatBytes          , 'y'   , "bytes"               },
-    { eFormatBytesWithASCII , 'Y'   , "bytes with ASCII"    },
-    { eFormatChar           , 'c'   , "character"           },
-    { eFormatCharPrintable  , 'C'   , "printable character" },
-    { eFormatComplexFloat   , 'F'   , "complex float"       },
-    { eFormatCString        , 's'   , "c-string"            },
-    { eFormatDecimal        , 'd'   , "decimal"             },
-    { eFormatEnum           , 'E'   , "enumeration"         },
-    { eFormatHex            , 'x'   , "hex"                 },
-    { eFormatHexUppercase   , 'X'   , "uppercase hex"       },
-    { eFormatFloat          , 'f'   , "float"               },
-    { eFormatOctal          , 'o'   , "octal"               },
-    { eFormatOSType         , 'O'   , "OSType"              },
-    { eFormatUnicode16      , 'U'   , "unicode16"           },
-    { eFormatUnicode32      , '\0'  , "unicode32"           },
-    { eFormatUnsigned       , 'u'   , "unsigned decimal"    },
-    { eFormatPointer        , 'p'   , "pointer"             },
-    { eFormatVectorOfChar   , '\0'  , "char[]"              },
-    { eFormatVectorOfSInt8  , '\0'  , "int8_t[]"            },
-    { eFormatVectorOfUInt8  , '\0'  , "uint8_t[]"           },
-    { eFormatVectorOfSInt16 , '\0'  , "int16_t[]"           },
-    { eFormatVectorOfUInt16 , '\0'  , "uint16_t[]"          },
-    { eFormatVectorOfSInt32 , '\0'  , "int32_t[]"           },
-    { eFormatVectorOfUInt32 , '\0'  , "uint32_t[]"          },
-    { eFormatVectorOfSInt64 , '\0'  , "int64_t[]"           },
-    { eFormatVectorOfUInt64 , '\0'  , "uint64_t[]"          },
-    { eFormatVectorOfFloat16, '\0'  , "float16[]"           },
-    { eFormatVectorOfFloat32, '\0'  , "float32[]"           },
-    { eFormatVectorOfFloat64, '\0'  , "float64[]"           },
-    { eFormatVectorOfUInt128, '\0'  , "uint128_t[]"         },
-    { eFormatComplexInteger , 'I'   , "complex integer"     },
-    { eFormatCharArray      , 'a'   , "character array"     },
-    { eFormatAddressInfo    , 'A'   , "address"             },
-    { eFormatHexFloat       , '\0'  , "hex float"           },
-    { eFormatInstruction    , 'i'   , "instruction"         },
-    { eFormatVoid           , 'v'   , "void"                }
-};
+static FormatInfo g_format_infos[] = {
+    {eFormatDefault, '\0', "default"},
+    {eFormatBoolean, 'B', "boolean"},
+    {eFormatBinary, 'b', "binary"},
+    {eFormatBytes, 'y', "bytes"},
+    {eFormatBytesWithASCII, 'Y', "bytes with ASCII"},
+    {eFormatChar, 'c', "character"},
+    {eFormatCharPrintable, 'C', "printable character"},
+    {eFormatComplexFloat, 'F', "complex float"},
+    {eFormatCString, 's', "c-string"},
+    {eFormatDecimal, 'd', "decimal"},
+    {eFormatEnum, 'E', "enumeration"},
+    {eFormatHex, 'x', "hex"},
+    {eFormatHexUppercase, 'X', "uppercase hex"},
+    {eFormatFloat, 'f', "float"},
+    {eFormatOctal, 'o', "octal"},
+    {eFormatOSType, 'O', "OSType"},
+    {eFormatUnicode16, 'U', "unicode16"},
+    {eFormatUnicode32, '\0', "unicode32"},
+    {eFormatUnsigned, 'u', "unsigned decimal"},
+    {eFormatPointer, 'p', "pointer"},
+    {eFormatVectorOfChar, '\0', "char[]"},
+    {eFormatVectorOfSInt8, '\0', "int8_t[]"},
+    {eFormatVectorOfUInt8, '\0', "uint8_t[]"},
+    {eFormatVectorOfSInt16, '\0', "int16_t[]"},
+    {eFormatVectorOfUInt16, '\0', "uint16_t[]"},
+    {eFormatVectorOfSInt32, '\0', "int32_t[]"},
+    {eFormatVectorOfUInt32, '\0', "uint32_t[]"},
+    {eFormatVectorOfSInt64, '\0', "int64_t[]"},
+    {eFormatVectorOfUInt64, '\0', "uint64_t[]"},
+    {eFormatVectorOfFloat16, '\0', "float16[]"},
+    {eFormatVectorOfFloat32, '\0', "float32[]"},
+    {eFormatVectorOfFloat64, '\0', "float64[]"},
+    {eFormatVectorOfUInt128, '\0', "uint128_t[]"},
+    {eFormatComplexInteger, 'I', "complex integer"},
+    {eFormatCharArray, 'a', "character array"},
+    {eFormatAddressInfo, 'A', "address"},
+    {eFormatHexFloat, '\0', "hex float"},
+    {eFormatInstruction, 'i', "instruction"},
+    {eFormatVoid, 'v', "void"}};
 
 static uint32_t g_num_format_infos = llvm::array_lengthof(g_format_infos);
 
-static bool
-GetFormatFromFormatChar (char format_char, Format &format)
-{
-    for (uint32_t i=0; i<g_num_format_infos; ++i)
-    {
-        if (g_format_infos[i].format_char == format_char)
-        {
-            format = g_format_infos[i].format;
-            return true;
-        }
+static bool GetFormatFromFormatChar(char format_char, Format &format) {
+  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
+    if (g_format_infos[i].format_char == format_char) {
+      format = g_format_infos[i].format;
+      return true;
     }
-    format = eFormatInvalid;
-    return false;
+  }
+  format = eFormatInvalid;
+  return false;
 }
 
-static bool
-GetFormatFromFormatName (const char *format_name, bool partial_match_ok, Format &format)
-{
-    uint32_t i;
-    for (i=0; i<g_num_format_infos; ++i)
-    {
-        if (strcasecmp (g_format_infos[i].format_name, format_name) == 0)
-        {
-            format = g_format_infos[i].format;
-            return true;
-        }
+static bool GetFormatFromFormatName(const char *format_name,
+                                    bool partial_match_ok, Format &format) {
+  uint32_t i;
+  for (i = 0; i < g_num_format_infos; ++i) {
+    if (strcasecmp(g_format_infos[i].format_name, format_name) == 0) {
+      format = g_format_infos[i].format;
+      return true;
     }
-    
-    if (partial_match_ok)
-    {
-        for (i=0; i<g_num_format_infos; ++i)
-        {
-            if (strcasestr (g_format_infos[i].format_name, format_name) == g_format_infos[i].format_name)
-            {
-                format = g_format_infos[i].format;
-                return true;
-            }
-        }
+  }
+
+  if (partial_match_ok) {
+    for (i = 0; i < g_num_format_infos; ++i) {
+      if (strcasestr(g_format_infos[i].format_name, format_name) ==
+          g_format_infos[i].format_name) {
+        format = g_format_infos[i].format;
+        return true;
+      }
     }
-    format = eFormatInvalid;
-    return false;
+  }
+  format = eFormatInvalid;
+  return false;
 }
 
-void
-FormatManager::Changed ()
-{
-    ++m_last_revision;
-    m_format_cache.Clear ();
-    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
-    for (auto& iter : m_language_categories_map)
-    {
-        if (iter.second)
-            iter.second->GetFormatCache().Clear();
-    }
+void FormatManager::Changed() {
+  ++m_last_revision;
+  m_format_cache.Clear();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->GetFormatCache().Clear();
+  }
 }
 
-bool
-FormatManager::GetFormatFromCString (const char *format_cstr,
-                                     bool partial_match_ok,
-                                     lldb::Format &format)
-{
-    bool success = false;
-    if (format_cstr && format_cstr[0])
-    {
-        if (format_cstr[1] == '\0')
-        {
-            success = GetFormatFromFormatChar (format_cstr[0], format);
-            if (success)
-                return true;
-        }
-        
-        success = GetFormatFromFormatName (format_cstr, partial_match_ok, format);
+bool FormatManager::GetFormatFromCString(const char *format_cstr,
+                                         bool partial_match_ok,
+                                         lldb::Format &format) {
+  bool success = false;
+  if (format_cstr && format_cstr[0]) {
+    if (format_cstr[1] == '\0') {
+      success = GetFormatFromFormatChar(format_cstr[0], format);
+      if (success)
+        return true;
     }
-    if (!success)
-        format = eFormatInvalid;
-    return success;
+
+    success = GetFormatFromFormatName(format_cstr, partial_match_ok, format);
+  }
+  if (!success)
+    format = eFormatInvalid;
+  return success;
 }
 
-char
-FormatManager::GetFormatAsFormatChar (lldb::Format format)
-{
-    for (uint32_t i=0; i<g_num_format_infos; ++i)
-    {
-        if (g_format_infos[i].format == format)
-            return g_format_infos[i].format_char;
-    }
-    return '\0';
+char FormatManager::GetFormatAsFormatChar(lldb::Format format) {
+  for (uint32_t i = 0; i < g_num_format_infos; ++i) {
+    if (g_format_infos[i].format == format)
+      return g_format_infos[i].format_char;
+  }
+  return '\0';
 }
 
-const char *
-FormatManager::GetFormatAsCString (Format format)
-{
-    if (format >= eFormatDefault && format < kNumFormats)
-        return g_format_infos[format].format_name;
-    return NULL;
+const char *FormatManager::GetFormatAsCString(Format format) {
+  if (format >= eFormatDefault && format < kNumFormats)
+    return g_format_infos[format].format_name;
+  return NULL;
 }
 
-void
-FormatManager::EnableAllCategories ()
-{
-    m_categories_map.EnableAllCategories ();
-    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
-    for (auto& iter : m_language_categories_map)
-    {
-        if (iter.second)
-            iter.second->Enable();
-    }
+void FormatManager::EnableAllCategories() {
+  m_categories_map.EnableAllCategories();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->Enable();
+  }
 }
 
-void
-FormatManager::DisableAllCategories ()
-{
-    m_categories_map.DisableAllCategories ();
-    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
-    for (auto& iter : m_language_categories_map)
-    {
-        if (iter.second)
-            iter.second->Disable();
-    }
+void FormatManager::DisableAllCategories() {
+  m_categories_map.DisableAllCategories();
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (auto &iter : m_language_categories_map) {
+    if (iter.second)
+      iter.second->Disable();
+  }
 }
 
-void
-FormatManager::GetPossibleMatches (ValueObject& valobj,
-                                   CompilerType compiler_type,
-                                   uint32_t reason,
-                                   lldb::DynamicValueType use_dynamic,
-                                   FormattersMatchVector& entries,
-                                   bool did_strip_ptr,
-                                   bool did_strip_ref,
-                                   bool did_strip_typedef,
-                                   bool root_level)
-{
-    compiler_type = compiler_type.GetTypeForFormatters();
-    ConstString type_name(compiler_type.GetConstTypeName());
-    if (valobj.GetBitfieldBitSize() > 0)
-    {
-        StreamString sstring;
-        sstring.Printf("%s:%d",type_name.AsCString(),valobj.GetBitfieldBitSize());
-        ConstString bitfieldname = ConstString(sstring.GetData());
-        entries.push_back({bitfieldname,0,did_strip_ptr,did_strip_ref,did_strip_typedef});
-        reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
-    }
+void FormatManager::GetPossibleMatches(
+    ValueObject &valobj, CompilerType compiler_type, uint32_t reason,
+    lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
+    bool did_strip_ptr, bool did_strip_ref, bool did_strip_typedef,
+    bool root_level) {
+  compiler_type = compiler_type.GetTypeForFormatters();
+  ConstString type_name(compiler_type.GetConstTypeName());
+  if (valobj.GetBitfieldBitSize() > 0) {
+    StreamString sstring;
+    sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
+    ConstString bitfieldname = ConstString(sstring.GetData());
+    entries.push_back(
+        {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
+    reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
+  }
 
-    if (!compiler_type.IsMeaninglessWithoutDynamicResolution())
-    {
-        entries.push_back({type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
+  if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
+    entries.push_back(
+        {type_name, reason, did_strip_ptr, did_strip_ref, did_strip_typedef});
 
-        ConstString display_type_name(compiler_type.GetDisplayTypeName());
-        if (display_type_name != type_name)
-            entries.push_back({display_type_name,reason,did_strip_ptr,did_strip_ref,did_strip_typedef});
-    }
+    ConstString display_type_name(compiler_type.GetDisplayTypeName());
+    if (display_type_name != type_name)
+      entries.push_back({display_type_name, reason, did_strip_ptr,
+                         did_strip_ref, did_strip_typedef});
+  }
 
-    for (bool is_rvalue_ref = true, j = true; j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false)
-    {
-        CompilerType non_ref_type = compiler_type.GetNonReferenceType();
-        GetPossibleMatches(valobj,
-                           non_ref_type,
-                           reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
-                           use_dynamic,
-                           entries,
-                           did_strip_ptr,
-                           true,
-                           did_strip_typedef);
-        if (non_ref_type.IsTypedefType())
-        {
-            CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
-            deffed_referenced_type = is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType() : deffed_referenced_type.GetLValueReferenceType();
-            GetPossibleMatches(valobj,
-                               deffed_referenced_type,
-                               reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
-                               use_dynamic,
-                               entries,
-                               did_strip_ptr,
-                               did_strip_ref,
-                               true); // this is not exactly the usual meaning of stripping typedefs
-        }
-    }
-    
-    if (compiler_type.IsPointerType())
-    {
-        CompilerType non_ptr_type = compiler_type.GetPointeeType();
-        GetPossibleMatches(valobj,
-                           non_ptr_type,
-                           reason | lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
-                           use_dynamic,
-                           entries,
-                           true,
-                           did_strip_ref,
-                           did_strip_typedef);
-        if (non_ptr_type.IsTypedefType())
-        {
-            CompilerType deffed_pointed_type = non_ptr_type.GetTypedefedType().GetPointerType();
-            GetPossibleMatches(valobj,
-                               deffed_pointed_type,
-                               reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
-                               use_dynamic,
-                               entries,
-                               did_strip_ptr,
-                               did_strip_ref,
-                               true); // this is not exactly the usual meaning of stripping typedefs
-        }
+  for (bool is_rvalue_ref = true, j = true;
+       j && compiler_type.IsReferenceType(nullptr, &is_rvalue_ref); j = false) {
+    CompilerType non_ref_type = compiler_type.GetNonReferenceType();
+    GetPossibleMatches(
+        valobj, non_ref_type,
+        reason |
+            lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
+        use_dynamic, entries, did_strip_ptr, true, did_strip_typedef);
+    if (non_ref_type.IsTypedefType()) {
+      CompilerType deffed_referenced_type = non_ref_type.GetTypedefedType();
+      deffed_referenced_type =
+          is_rvalue_ref ? deffed_referenced_type.GetRValueReferenceType()
+                        : deffed_referenced_type.GetLValueReferenceType();
+      GetPossibleMatches(
+          valobj, deffed_referenced_type,
+          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+          use_dynamic, entries, did_strip_ptr, did_strip_ref,
+          true); // this is not exactly the usual meaning of stripping typedefs
     }
-    
-    for (lldb::LanguageType language_type : GetCandidateLanguages(valobj))
-    {
-        if (Language* language = Language::FindPlugin(language_type))
-        {
-            for (ConstString candidate : language->GetPossibleFormattersMatches(valobj, use_dynamic))
-            {
-                entries.push_back({candidate,
-                                   reason | lldb_private::eFormatterChoiceCriterionLanguagePlugin,
-                                   did_strip_ptr,
-                                   did_strip_ref,
-                                   did_strip_typedef});
-            }
-        }
+  }
+
+  if (compiler_type.IsPointerType()) {
+    CompilerType non_ptr_type = compiler_type.GetPointeeType();
+    GetPossibleMatches(
+        valobj, non_ptr_type,
+        reason |
+            lldb_private::eFormatterChoiceCriterionStrippedPointerReference,
+        use_dynamic, entries, true, did_strip_ref, did_strip_typedef);
+    if (non_ptr_type.IsTypedefType()) {
+      CompilerType deffed_pointed_type =
+          non_ptr_type.GetTypedefedType().GetPointerType();
+      GetPossibleMatches(
+          valobj, deffed_pointed_type,
+          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+          use_dynamic, entries, did_strip_ptr, did_strip_ref,
+          true); // this is not exactly the usual meaning of stripping typedefs
     }
-        
-    // try to strip typedef chains
-    if (compiler_type.IsTypedefType())
-    {
-        CompilerType deffed_type = compiler_type.GetTypedefedType();
-        GetPossibleMatches(valobj,
-                           deffed_type,
-                           reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
-                           use_dynamic,
-                           entries,
-                           did_strip_ptr,
-                           did_strip_ref,
-                           true);
+  }
+
+  for (lldb::LanguageType language_type : GetCandidateLanguages(valobj)) {
+    if (Language *language = Language::FindPlugin(language_type)) {
+      for (ConstString candidate :
+           language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
+        entries.push_back(
+            {candidate,
+             reason | lldb_private::eFormatterChoiceCriterionLanguagePlugin,
+             did_strip_ptr, did_strip_ref, did_strip_typedef});
+      }
     }
-    
-    if (root_level)
-    {
-        do {
-            if (!compiler_type.IsValid())
-                break;
-            
-            CompilerType unqual_compiler_ast_type = compiler_type.GetFullyUnqualifiedType();
-            if (!unqual_compiler_ast_type.IsValid())
-                break;
-            if (unqual_compiler_ast_type.GetOpaqueQualType() != compiler_type.GetOpaqueQualType())
-                GetPossibleMatches (valobj,
-                                    unqual_compiler_ast_type,
-                                    reason,
-                                    use_dynamic,
-                                    entries,
-                                    did_strip_ptr,
-                                    did_strip_ref,
-                                    did_strip_typedef);
-        } while(false);
-        
-        
-        // if all else fails, go to static type
-        if (valobj.IsDynamic())
-        {
-            lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
-            if (static_value_sp)
-                GetPossibleMatches(*static_value_sp.get(),
-                                   static_value_sp->GetCompilerType(),
-                                   reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue,
-                                   use_dynamic,
-                                   entries,
-                                   did_strip_ptr,
-                                   did_strip_ref,
-                                   did_strip_typedef,
-                                   true);
-        }
+  }
+
+  // try to strip typedef chains
+  if (compiler_type.IsTypedefType()) {
+    CompilerType deffed_type = compiler_type.GetTypedefedType();
+    GetPossibleMatches(
+        valobj, deffed_type,
+        reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
+        use_dynamic, entries, did_strip_ptr, did_strip_ref, true);
+  }
+
+  if (root_level) {
+    do {
+      if (!compiler_type.IsValid())
+        break;
+
+      CompilerType unqual_compiler_ast_type =
+          compiler_type.GetFullyUnqualifiedType();
+      if (!unqual_compiler_ast_type.IsValid())
+        break;
+      if (unqual_compiler_ast_type.GetOpaqueQualType() !=
+          compiler_type.GetOpaqueQualType())
+        GetPossibleMatches(valobj, unqual_compiler_ast_type, reason,
+                           use_dynamic, entries, did_strip_ptr, did_strip_ref,
+                           did_strip_typedef);
+    } while (false);
+
+    // if all else fails, go to static type
+    if (valobj.IsDynamic()) {
+      lldb::ValueObjectSP static_value_sp(valobj.GetStaticValue());
+      if (static_value_sp)
+        GetPossibleMatches(
+            *static_value_sp.get(), static_value_sp->GetCompilerType(),
+            reason | lldb_private::eFormatterChoiceCriterionWentToStaticValue,
+            use_dynamic, entries, did_strip_ptr, did_strip_ref,
+            did_strip_typedef, true);
     }
+  }
 }
 
 lldb::TypeFormatImplSP
-FormatManager::GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::TypeFormatImplSP();
-    lldb::TypeFormatImplSP format_chosen_sp;
-    uint32_t num_categories = m_categories_map.GetCount();
-    lldb::TypeCategoryImplSP category_sp;
-    uint32_t prio_category = UINT32_MAX;
-    for (uint32_t category_id = 0;
-         category_id < num_categories;
-         category_id++)
-    {
-        category_sp = GetCategoryAtIndex(category_id);
-        if (category_sp->IsEnabled() == false)
-            continue;
-        lldb::TypeFormatImplSP format_current_sp = category_sp->GetFormatForType(type_sp);
-        if (format_current_sp && (format_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
-        {
-            prio_category = category_sp->GetEnabledPosition();
-            format_chosen_sp = format_current_sp;
-        }
+FormatManager::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeFormatImplSP();
+  lldb::TypeFormatImplSP format_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (category_sp->IsEnabled() == false)
+      continue;
+    lldb::TypeFormatImplSP format_current_sp =
+        category_sp->GetFormatForType(type_sp);
+    if (format_current_sp &&
+        (format_chosen_sp.get() == NULL ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      format_chosen_sp = format_current_sp;
     }
-    return format_chosen_sp;
+  }
+  return format_chosen_sp;
 }
 
 lldb::TypeSummaryImplSP
-FormatManager::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::TypeSummaryImplSP();
-    lldb::TypeSummaryImplSP summary_chosen_sp;
-    uint32_t num_categories = m_categories_map.GetCount();
-    lldb::TypeCategoryImplSP category_sp;
-    uint32_t prio_category = UINT32_MAX;
-    for (uint32_t category_id = 0;
-         category_id < num_categories;
-         category_id++)
-    {
-        category_sp = GetCategoryAtIndex(category_id);
-        if (category_sp->IsEnabled() == false)
-            continue;
-        lldb::TypeSummaryImplSP summary_current_sp = category_sp->GetSummaryForType(type_sp);
-        if (summary_current_sp && (summary_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
-        {
-            prio_category = category_sp->GetEnabledPosition();
-            summary_chosen_sp = summary_current_sp;
-        }
+FormatManager::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeSummaryImplSP();
+  lldb::TypeSummaryImplSP summary_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (category_sp->IsEnabled() == false)
+      continue;
+    lldb::TypeSummaryImplSP summary_current_sp =
+        category_sp->GetSummaryForType(type_sp);
+    if (summary_current_sp &&
+        (summary_chosen_sp.get() == NULL ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      summary_chosen_sp = summary_current_sp;
     }
-    return summary_chosen_sp;
+  }
+  return summary_chosen_sp;
 }
 
 lldb::TypeFilterImplSP
-FormatManager::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::TypeFilterImplSP();
-    lldb::TypeFilterImplSP filter_chosen_sp;
-    uint32_t num_categories = m_categories_map.GetCount();
-    lldb::TypeCategoryImplSP category_sp;
-    uint32_t prio_category = UINT32_MAX;
-    for (uint32_t category_id = 0;
-         category_id < num_categories;
-         category_id++)
-    {
-        category_sp = GetCategoryAtIndex(category_id);
-        if (category_sp->IsEnabled() == false)
-            continue;
-        lldb::TypeFilterImplSP filter_current_sp((TypeFilterImpl*)category_sp->GetFilterForType(type_sp).get());
-        if (filter_current_sp && (filter_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
-        {
-            prio_category = category_sp->GetEnabledPosition();
-            filter_chosen_sp = filter_current_sp;
-        }
+FormatManager::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeFilterImplSP();
+  lldb::TypeFilterImplSP filter_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (category_sp->IsEnabled() == false)
+      continue;
+    lldb::TypeFilterImplSP filter_current_sp(
+        (TypeFilterImpl *)category_sp->GetFilterForType(type_sp).get());
+    if (filter_current_sp &&
+        (filter_chosen_sp.get() == NULL ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      filter_chosen_sp = filter_current_sp;
     }
-    return filter_chosen_sp;
+  }
+  return filter_chosen_sp;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::ScriptedSyntheticChildrenSP
-FormatManager::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::ScriptedSyntheticChildrenSP();
-    lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
-    uint32_t num_categories = m_categories_map.GetCount();
-    lldb::TypeCategoryImplSP category_sp;
-    uint32_t prio_category = UINT32_MAX;
-    for (uint32_t category_id = 0;
-         category_id < num_categories;
-         category_id++)
-    {
-        category_sp = GetCategoryAtIndex(category_id);
-        if (category_sp->IsEnabled() == false)
-            continue;
-        lldb::ScriptedSyntheticChildrenSP synth_current_sp((ScriptedSyntheticChildren*)category_sp->GetSyntheticForType(type_sp).get());
-        if (synth_current_sp && (synth_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
-        {
-            prio_category = category_sp->GetEnabledPosition();
-            synth_chosen_sp = synth_current_sp;
-        }
+FormatManager::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::ScriptedSyntheticChildrenSP();
+  lldb::ScriptedSyntheticChildrenSP synth_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (category_sp->IsEnabled() == false)
+      continue;
+    lldb::ScriptedSyntheticChildrenSP synth_current_sp(
+        (ScriptedSyntheticChildren *)category_sp->GetSyntheticForType(type_sp)
+            .get());
+    if (synth_current_sp &&
+        (synth_chosen_sp.get() == NULL ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      synth_chosen_sp = synth_current_sp;
     }
-    return synth_chosen_sp;
+  }
+  return synth_chosen_sp;
 }
 #endif
 
 #ifndef LLDB_DISABLE_PYTHON
-lldb::SyntheticChildrenSP
-FormatManager::GetSyntheticChildrenForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::SyntheticChildrenSP();
-    lldb::TypeFilterImplSP filter_sp = GetFilterForType(type_sp);
-    lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp);
-    if (filter_sp->GetRevision() > synth_sp->GetRevision())
-        return lldb::SyntheticChildrenSP(filter_sp.get());
-    else
-        return lldb::SyntheticChildrenSP(synth_sp.get());
+lldb::SyntheticChildrenSP FormatManager::GetSyntheticChildrenForType(
+    lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::SyntheticChildrenSP();
+  lldb::TypeFilterImplSP filter_sp = GetFilterForType(type_sp);
+  lldb::ScriptedSyntheticChildrenSP synth_sp = GetSyntheticForType(type_sp);
+  if (filter_sp->GetRevision() > synth_sp->GetRevision())
+    return lldb::SyntheticChildrenSP(filter_sp.get());
+  else
+    return lldb::SyntheticChildrenSP(synth_sp.get());
 }
 #endif
 
 lldb::TypeValidatorImplSP
-FormatManager::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    if (!type_sp)
-        return lldb::TypeValidatorImplSP();
-    lldb::TypeValidatorImplSP validator_chosen_sp;
-    uint32_t num_categories = m_categories_map.GetCount();
-    lldb::TypeCategoryImplSP category_sp;
-    uint32_t prio_category = UINT32_MAX;
-    for (uint32_t category_id = 0;
-         category_id < num_categories;
-         category_id++)
-    {
-        category_sp = GetCategoryAtIndex(category_id);
-        if (category_sp->IsEnabled() == false)
-            continue;
-        lldb::TypeValidatorImplSP validator_current_sp(category_sp->GetValidatorForType(type_sp).get());
-        if (validator_current_sp && (validator_chosen_sp.get() == NULL || (prio_category > category_sp->GetEnabledPosition())))
-        {
-            prio_category = category_sp->GetEnabledPosition();
-            validator_chosen_sp = validator_current_sp;
-        }
+FormatManager::GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  if (!type_sp)
+    return lldb::TypeValidatorImplSP();
+  lldb::TypeValidatorImplSP validator_chosen_sp;
+  uint32_t num_categories = m_categories_map.GetCount();
+  lldb::TypeCategoryImplSP category_sp;
+  uint32_t prio_category = UINT32_MAX;
+  for (uint32_t category_id = 0; category_id < num_categories; category_id++) {
+    category_sp = GetCategoryAtIndex(category_id);
+    if (category_sp->IsEnabled() == false)
+      continue;
+    lldb::TypeValidatorImplSP validator_current_sp(
+        category_sp->GetValidatorForType(type_sp).get());
+    if (validator_current_sp &&
+        (validator_chosen_sp.get() == NULL ||
+         (prio_category > category_sp->GetEnabledPosition()))) {
+      prio_category = category_sp->GetEnabledPosition();
+      validator_chosen_sp = validator_current_sp;
     }
-    return validator_chosen_sp;
+  }
+  return validator_chosen_sp;
 }
 
-void
-FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback)
-{
-    m_categories_map.ForEach(callback);
-    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
-    for (const auto& entry : m_language_categories_map)
-    {
-        if (auto category_sp = entry.second->GetCategory())
-        {
-            if (!callback(category_sp))
-                break;
-        }
+void FormatManager::ForEachCategory(TypeCategoryMap::ForEachCallback callback) {
+  m_categories_map.ForEach(callback);
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  for (const auto &entry : m_language_categories_map) {
+    if (auto category_sp = entry.second->GetCategory()) {
+      if (!callback(category_sp))
+        break;
     }
+  }
 }
 
 lldb::TypeCategoryImplSP
-FormatManager::GetCategory (const ConstString& category_name,
-                            bool can_create)
-{
-    if (!category_name)
-        return GetCategory(m_default_category_name);
-    lldb::TypeCategoryImplSP category;
-    if (m_categories_map.Get(category_name, category))
-        return category;
-    
-    if (!can_create)
-        return lldb::TypeCategoryImplSP();
-    
-    m_categories_map.Add(category_name,lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
-    return GetCategory(category_name);
+FormatManager::GetCategory(const ConstString &category_name, bool can_create) {
+  if (!category_name)
+    return GetCategory(m_default_category_name);
+  lldb::TypeCategoryImplSP category;
+  if (m_categories_map.Get(category_name, category))
+    return category;
+
+  if (!can_create)
+    return lldb::TypeCategoryImplSP();
+
+  m_categories_map.Add(
+      category_name,
+      lldb::TypeCategoryImplSP(new TypeCategoryImpl(this, category_name)));
+  return GetCategory(category_name);
 }
 
-lldb::Format
-FormatManager::GetSingleItemFormat(lldb::Format vector_format)
-{
-    switch(vector_format)
-    {
-        case eFormatVectorOfChar:
-            return eFormatCharArray;
-            
-        case eFormatVectorOfSInt8:
-        case eFormatVectorOfSInt16:
-        case eFormatVectorOfSInt32:
-        case eFormatVectorOfSInt64:
-            return eFormatDecimal;
-            
-        case eFormatVectorOfUInt8:
-        case eFormatVectorOfUInt16:
-        case eFormatVectorOfUInt32:
-        case eFormatVectorOfUInt64:
-        case eFormatVectorOfUInt128:
-            return eFormatHex;
-            
-        case eFormatVectorOfFloat16:
-        case eFormatVectorOfFloat32:
-        case eFormatVectorOfFloat64:
-            return eFormatFloat;
-            
-        default:
-            return lldb::eFormatInvalid;
-    }
+lldb::Format FormatManager::GetSingleItemFormat(lldb::Format vector_format) {
+  switch (vector_format) {
+  case eFormatVectorOfChar:
+    return eFormatCharArray;
+
+  case eFormatVectorOfSInt8:
+  case eFormatVectorOfSInt16:
+  case eFormatVectorOfSInt32:
+  case eFormatVectorOfSInt64:
+    return eFormatDecimal;
+
+  case eFormatVectorOfUInt8:
+  case eFormatVectorOfUInt16:
+  case eFormatVectorOfUInt32:
+  case eFormatVectorOfUInt64:
+  case eFormatVectorOfUInt128:
+    return eFormatHex;
+
+  case eFormatVectorOfFloat16:
+  case eFormatVectorOfFloat32:
+  case eFormatVectorOfFloat64:
+    return eFormatFloat;
+
+  default:
+    return lldb::eFormatInvalid;
+  }
 }
 
-bool
-FormatManager::ShouldPrintAsOneLiner (ValueObject& valobj)
-{
-    // if settings say no oneline whatsoever
-    if (valobj.GetTargetSP().get() && valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries() == false)
-        return false; // then don't oneline
-    
-    // if this object has a summary, then ask the summary
-    if (valobj.GetSummaryFormat().get() != nullptr)
-        return valobj.GetSummaryFormat()->IsOneLiner();
-    
-    // no children, no party
-    if (valobj.GetNumChildren() == 0)
+bool FormatManager::ShouldPrintAsOneLiner(ValueObject &valobj) {
+  // if settings say no oneline whatsoever
+  if (valobj.GetTargetSP().get() &&
+      valobj.GetTargetSP()->GetDebugger().GetAutoOneLineSummaries() == false)
+    return false; // then don't oneline
+
+  // if this object has a summary, then ask the summary
+  if (valobj.GetSummaryFormat().get() != nullptr)
+    return valobj.GetSummaryFormat()->IsOneLiner();
+
+  // no children, no party
+  if (valobj.GetNumChildren() == 0)
+    return false;
+
+  // ask the type if it has any opinion about this
+  // eLazyBoolCalculate == no opinion; other values should be self explanatory
+  CompilerType compiler_type(valobj.GetCompilerType());
+  if (compiler_type.IsValid()) {
+    switch (compiler_type.ShouldPrintAsOneLiner(&valobj)) {
+    case eLazyBoolNo:
+      return false;
+    case eLazyBoolYes:
+      return true;
+    case eLazyBoolCalculate:
+      break;
+    }
+  }
+
+  size_t total_children_name_len = 0;
+
+  for (size_t idx = 0; idx < valobj.GetNumChildren(); idx++) {
+    bool is_synth_val = false;
+    ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
+    // something is wrong here - bail out
+    if (!child_sp)
+      return false;
+
+    // also ask the child's type if it has any opinion
+    CompilerType child_compiler_type(child_sp->GetCompilerType());
+    if (child_compiler_type.IsValid()) {
+      switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get())) {
+      case eLazyBoolYes:
+      // an opinion of yes is only binding for the child, so keep going
+      case eLazyBoolCalculate:
+        break;
+      case eLazyBoolNo:
+        // but if the child says no, then it's a veto on the whole thing
+        return false;
+      }
+    }
+
+    // if we decided to define synthetic children for a type, we probably care
+    // enough
+    // to show them, but avoid nesting children in children
+    if (child_sp->GetSyntheticChildren().get() != nullptr) {
+      ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
+      // wait.. wat? just get out of here..
+      if (!synth_sp)
+        return false;
+      // but if we only have them to provide a value, keep going
+      if (synth_sp->MightHaveChildren() == false &&
+          synth_sp->DoesProvideSyntheticValue())
+        is_synth_val = true;
+      else
+        return false;
+    }
+
+    total_children_name_len += child_sp->GetName().GetLength();
+
+    // 50 itself is a "randomly" chosen number - the idea is that
+    // overly long structs should not get this treatment
+    // FIXME: maybe make this a user-tweakable setting?
+    if (total_children_name_len > 50)
+      return false;
+
+    // if a summary is there..
+    if (child_sp->GetSummaryFormat()) {
+      // and it wants children, then bail out
+      if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
         return false;
-    
-    // ask the type if it has any opinion about this
-    // eLazyBoolCalculate == no opinion; other values should be self explanatory
-    CompilerType compiler_type(valobj.GetCompilerType());
-    if (compiler_type.IsValid())
-    {
-        switch (compiler_type.ShouldPrintAsOneLiner(&valobj))
-        {
-            case eLazyBoolNo:
-                return false;
-            case eLazyBoolYes:
-                return true;
-            case eLazyBoolCalculate:
-                break;
-        }
     }
-    
-    size_t total_children_name_len = 0;
-    
-    for (size_t idx = 0;
-         idx < valobj.GetNumChildren();
-         idx++)
-    {
-        bool is_synth_val = false;
-        ValueObjectSP child_sp(valobj.GetChildAtIndex(idx, true));
-        // something is wrong here - bail out
-        if (!child_sp)
-            return false;
-        
-        // also ask the child's type if it has any opinion
-        CompilerType child_compiler_type(child_sp->GetCompilerType());
-        if (child_compiler_type.IsValid())
-        {
-            switch (child_compiler_type.ShouldPrintAsOneLiner(child_sp.get()))
-            {
-                case eLazyBoolYes:
-                    // an opinion of yes is only binding for the child, so keep going
-                case eLazyBoolCalculate:
-                    break;
-                case eLazyBoolNo:
-                    // but if the child says no, then it's a veto on the whole thing
-                    return false;
-            }
-        }
-        
-        // if we decided to define synthetic children for a type, we probably care enough
-        // to show them, but avoid nesting children in children
-        if (child_sp->GetSyntheticChildren().get() != nullptr)
-        {
-            ValueObjectSP synth_sp(child_sp->GetSyntheticValue());
-            // wait.. wat? just get out of here..
-            if (!synth_sp)
-                return false;
-            // but if we only have them to provide a value, keep going
-            if (synth_sp->MightHaveChildren() == false && synth_sp->DoesProvideSyntheticValue())
-                is_synth_val = true;
-            else
-                return false;
-        }
-        
-        total_children_name_len += child_sp->GetName().GetLength();
-        
-        // 50 itself is a "randomly" chosen number - the idea is that
-        // overly long structs should not get this treatment
-        // FIXME: maybe make this a user-tweakable setting?
-        if (total_children_name_len > 50)
-            return false;
-        
-        // if a summary is there..
-        if (child_sp->GetSummaryFormat())
-        {
-            // and it wants children, then bail out
-            if (child_sp->GetSummaryFormat()->DoesPrintChildren(child_sp.get()))
-                return false;
-        }
-        
-        // if this child has children..
-        if (child_sp->GetNumChildren())
-        {
-            // ...and no summary...
-            // (if it had a summary and the summary wanted children, we would have bailed out anyway
-            //  so this only makes us bail out if this has no summary and we would then print children)
-            if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do that if not a synthetic valued child
-                return false; // then bail out
-        }
+
+    // if this child has children..
+    if (child_sp->GetNumChildren()) {
+      // ...and no summary...
+      // (if it had a summary and the summary wanted children, we would have
+      // bailed out anyway
+      //  so this only makes us bail out if this has no summary and we would
+      //  then print children)
+      if (!child_sp->GetSummaryFormat() && !is_synth_val) // but again only do
+                                                          // that if not a
+                                                          // synthetic valued
+                                                          // child
+        return false;                                     // then bail out
     }
-    return true;
+  }
+  return true;
 }
 
-ConstString
-FormatManager::GetValidTypeName (const ConstString& type)
-{
-    return ::GetValidTypeName_Impl(type);
+ConstString FormatManager::GetValidTypeName(const ConstString &type) {
+  return ::GetValidTypeName_Impl(type);
 }
 
-ConstString
-FormatManager::GetTypeForCache (ValueObject& valobj,
-                                lldb::DynamicValueType use_dynamic)
-{
-    ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(use_dynamic, valobj.IsSynthetic());
-    if (valobj_sp && valobj_sp->GetCompilerType().IsValid())
-    {
-        if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
-            return valobj_sp->GetQualifiedTypeName();
-    }
-    return ConstString();
+ConstString FormatManager::GetTypeForCache(ValueObject &valobj,
+                                           lldb::DynamicValueType use_dynamic) {
+  ValueObjectSP valobj_sp = valobj.GetQualifiedRepresentationIfAvailable(
+      use_dynamic, valobj.IsSynthetic());
+  if (valobj_sp && valobj_sp->GetCompilerType().IsValid()) {
+    if (!valobj_sp->GetCompilerType().IsMeaninglessWithoutDynamicResolution())
+      return valobj_sp->GetQualifiedTypeName();
+  }
+  return ConstString();
 }
 
 std::vector<lldb::LanguageType>
-FormatManager::GetCandidateLanguages (ValueObject& valobj)
-{
-    lldb::LanguageType lang_type = valobj.GetObjectRuntimeLanguage();
-    return GetCandidateLanguages(lang_type);
+FormatManager::GetCandidateLanguages(ValueObject &valobj) {
+  lldb::LanguageType lang_type = valobj.GetObjectRuntimeLanguage();
+  return GetCandidateLanguages(lang_type);
 }
 
 std::vector<lldb::LanguageType>
-FormatManager::GetCandidateLanguages (lldb::LanguageType lang_type)
-{
-    switch (lang_type)
-    {
-        case lldb::eLanguageTypeC:
-        case lldb::eLanguageTypeC89:
-        case lldb::eLanguageTypeC99:
-        case lldb::eLanguageTypeC11:
-        case lldb::eLanguageTypeC_plus_plus:
-        case lldb::eLanguageTypeC_plus_plus_03:
-        case lldb::eLanguageTypeC_plus_plus_11:
-        case lldb::eLanguageTypeC_plus_plus_14:
-            return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
-        default:
-            return {lang_type};
-    }
+FormatManager::GetCandidateLanguages(lldb::LanguageType lang_type) {
+  switch (lang_type) {
+  case lldb::eLanguageTypeC:
+  case lldb::eLanguageTypeC89:
+  case lldb::eLanguageTypeC99:
+  case lldb::eLanguageTypeC11:
+  case lldb::eLanguageTypeC_plus_plus:
+  case lldb::eLanguageTypeC_plus_plus_03:
+  case lldb::eLanguageTypeC_plus_plus_11:
+  case lldb::eLanguageTypeC_plus_plus_14:
+    return {lldb::eLanguageTypeC_plus_plus, lldb::eLanguageTypeObjC};
+  default:
+    return {lang_type};
+  }
 }
 
-LanguageCategory*
-FormatManager::GetCategoryForLanguage (lldb::LanguageType lang_type)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
-    auto iter = m_language_categories_map.find(lang_type), end = m_language_categories_map.end();
-    if (iter != end)
-        return iter->second.get();
-    LanguageCategory* lang_category = new LanguageCategory(lang_type);
-    m_language_categories_map[lang_type] = LanguageCategory::UniquePointer(lang_category);
-    return lang_category;
+LanguageCategory *
+FormatManager::GetCategoryForLanguage(lldb::LanguageType lang_type) {
+  std::lock_guard<std::recursive_mutex> guard(m_language_categories_mutex);
+  auto iter = m_language_categories_map.find(lang_type),
+       end = m_language_categories_map.end();
+  if (iter != end)
+    return iter->second.get();
+  LanguageCategory *lang_category = new LanguageCategory(lang_type);
+  m_language_categories_map[lang_type] =
+      LanguageCategory::UniquePointer(lang_category);
+  return lang_category;
 }
 
 lldb::TypeFormatImplSP
-FormatManager::GetHardcodedFormat (FormattersMatchData& match_data)
-{
-    TypeFormatImplSP retval_sp;
-    
-    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-    {
-        if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-        {
-            if (lang_category->GetHardcoded(*this, match_data, retval_sp))
-                break;
-        }
+FormatManager::GetHardcodedFormat(FormattersMatchData &match_data) {
+  TypeFormatImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
     }
+  }
 
-    return retval_sp;
+  return retval_sp;
 }
 
 lldb::TypeFormatImplSP
-FormatManager::GetFormat (ValueObject& valobj,
-                          lldb::DynamicValueType use_dynamic)
-{
-    FormattersMatchData match_data(valobj, use_dynamic);
-    
-    TypeFormatImplSP retval;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    if (match_data.GetTypeForCache())
-    {
-        if (log)
-            log->Printf("\n\n[FormatManager::GetFormat] Looking into cache for type %s", match_data.GetTypeForCache().AsCString("<invalid>"));
-        if (m_format_cache.GetFormat(match_data.GetTypeForCache(),retval))
-        {
-            if (log)
-            {
-                log->Printf("[FormatManager::GetFormat] Cache search success. Returning.");
-                if (log->GetDebug())
-                    log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-            }
-            return retval;
-        }
-        if (log)
-            log->Printf("[FormatManager::GetFormat] Cache search failed. Going normal route");
-    }
-    
-    retval = m_categories_map.GetFormat(match_data);
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetFormat] Search failed. Giving language a chance.");
-        for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-        {
-            if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-            {
-                if (lang_category->Get(match_data, retval))
-                    break;
-            }
-        }
-        if (retval)
-        {
-            if (log)
-                log->Printf("[FormatManager::GetFormat] Language search success. Returning.");
-            return retval;
-        }
+FormatManager::GetFormat(ValueObject &valobj,
+                         lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeFormatImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf(
+          "\n\n[FormatManager::GetFormat] Looking into cache for type %s",
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetFormat(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf(
+            "[FormatManager::GetFormat] Cache search success. Returning.");
+        if (log->GetDebug())
+          log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64
+                      " - Cache Misses: %" PRIu64,
+                      m_format_cache.GetCacheHits(),
+                      m_format_cache.GetCacheMisses());
+      }
+      return retval;
     }
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetFormat] Search failed. Giving hardcoded a chance.");
-        retval = GetHardcodedFormat(match_data);
+    if (log)
+      log->Printf(
+          "[FormatManager::GetFormat] Cache search failed. Going normal route");
+  }
+
+  retval = m_categories_map.GetFormat(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Search failed. Giving language a "
+                  "chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
     }
-    
-    if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable()))
-    {
-        if (log)
-            log->Printf("[FormatManager::GetFormat] Caching %p for type %s",
-                        static_cast<void*>(retval.get()),
-                        match_data.GetTypeForCache().AsCString("<invalid>"));
-        m_format_cache.SetFormat(match_data.GetTypeForCache(),retval);
+    if (retval) {
+      if (log)
+        log->Printf(
+            "[FormatManager::GetFormat] Language search success. Returning.");
+      return retval;
     }
-    if (log && log->GetDebug())
-        log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-    return retval;
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Search failed. Giving hardcoded "
+                  "a chance.");
+    retval = GetHardcodedFormat(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetFormat] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetFormat(match_data.GetTypeForCache(), retval);
+  }
+  if (log && log->GetDebug())
+    log->Printf("[FormatManager::GetFormat] Cache hits: %" PRIu64
+                " - Cache Misses: %" PRIu64,
+                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
 }
 
 lldb::TypeSummaryImplSP
-FormatManager::GetHardcodedSummaryFormat (FormattersMatchData& match_data)
-{
-    TypeSummaryImplSP retval_sp;
-    
-    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-    {
-        if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-        {
-            if (lang_category->GetHardcoded(*this, match_data, retval_sp))
-                break;
-        }
+FormatManager::GetHardcodedSummaryFormat(FormattersMatchData &match_data) {
+  TypeSummaryImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
     }
-    
-    return retval_sp;
+  }
+
+  return retval_sp;
 }
 
 lldb::TypeSummaryImplSP
-FormatManager::GetSummaryFormat (ValueObject& valobj,
-                                 lldb::DynamicValueType use_dynamic)
-{
-    FormattersMatchData match_data(valobj, use_dynamic);
-    
-    TypeSummaryImplSP retval;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    if (match_data.GetTypeForCache())
-    {
-        if (log)
-            log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache for type %s", match_data.GetTypeForCache().AsCString("<invalid>"));
-        if (m_format_cache.GetSummary(match_data.GetTypeForCache(),retval))
-        {
-            if (log)
-            {
-                log->Printf("[FormatManager::GetSummaryFormat] Cache search success. Returning.");
-                if (log->GetDebug())
-                    log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-            }
-            return retval;
-        }
-        if (log)
-            log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. Going normal route");
-    }
-    
-    retval = m_categories_map.GetSummaryFormat(match_data);
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving language a chance.");
-        for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-        {
-            if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-            {
-                if (lang_category->Get(match_data, retval))
-                    break;
-            }
-        }
-        if (retval)
-        {
-            if (log)
-                log->Printf("[FormatManager::GetSummaryFormat] Language search success. Returning.");
-            return retval;
-        }
+FormatManager::GetSummaryFormat(ValueObject &valobj,
+                                lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeSummaryImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf("\n\n[FormatManager::GetSummaryFormat] Looking into cache "
+                  "for type %s",
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetSummary(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf("[FormatManager::GetSummaryFormat] Cache search success. "
+                    "Returning.");
+        if (log->GetDebug())
+          log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64
+                      " - Cache Misses: %" PRIu64,
+                      m_format_cache.GetCacheHits(),
+                      m_format_cache.GetCacheMisses());
+      }
+      return retval;
     }
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving hardcoded a chance.");
-        retval = GetHardcodedSummaryFormat(match_data);
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Cache search failed. "
+                  "Going normal route");
+  }
+
+  retval = m_categories_map.GetSummaryFormat(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
     }
-    
-    if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable()))
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",
-                        static_cast<void*>(retval.get()),
-                        match_data.GetTypeForCache().AsCString("<invalid>"));
-        m_format_cache.SetSummary(match_data.GetTypeForCache(),retval);
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetSummaryFormat] Language search "
+                    "success. Returning.");
+      return retval;
     }
-    if (log && log->GetDebug())
-        log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-    return retval;
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedSummaryFormat(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetSummaryFormat] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetSummary(match_data.GetTypeForCache(), retval);
+  }
+  if (log && log->GetDebug())
+    log->Printf("[FormatManager::GetSummaryFormat] Cache hits: %" PRIu64
+                " - Cache Misses: %" PRIu64,
+                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SyntheticChildrenSP
-FormatManager::GetHardcodedSyntheticChildren (FormattersMatchData& match_data)
-{
-    SyntheticChildrenSP retval_sp;
-    
-    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-    {
-        if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-        {
-            if (lang_category->GetHardcoded(*this, match_data, retval_sp))
-                break;
-        }
+FormatManager::GetHardcodedSyntheticChildren(FormattersMatchData &match_data) {
+  SyntheticChildrenSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
     }
-    
-    return retval_sp;
+  }
+
+  return retval_sp;
 }
 
 lldb::SyntheticChildrenSP
-FormatManager::GetSyntheticChildren (ValueObject& valobj,
-                                     lldb::DynamicValueType use_dynamic)
-{
-    FormattersMatchData match_data(valobj, use_dynamic);
-    
-    SyntheticChildrenSP retval;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    if (match_data.GetTypeForCache())
-    {
-        if (log)
-            log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into cache for type %s", match_data.GetTypeForCache().AsCString("<invalid>"));
-        if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(),retval))
-        {
-            if (log)
-            {
-                log->Printf("[FormatManager::GetSyntheticChildren] Cache search success. Returning.");
-                if (log->GetDebug())
-                    log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-            }
-            return retval;
-        }
-        if (log)
-            log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. Going normal route");
-    }
-    
-    retval = m_categories_map.GetSyntheticChildren(match_data);
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving language a chance.");
-        for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-        {
-            if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-            {
-                if (lang_category->Get(match_data, retval))
-                    break;
-            }
-        }
-        if (retval)
-        {
-            if (log)
-                log->Printf("[FormatManager::GetSyntheticChildren] Language search success. Returning.");
-            return retval;
-        }
+FormatManager::GetSyntheticChildren(ValueObject &valobj,
+                                    lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  SyntheticChildrenSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf("\n\n[FormatManager::GetSyntheticChildren] Looking into "
+                  "cache for type %s",
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf("[FormatManager::GetSyntheticChildren] Cache search "
+                    "success. Returning.");
+        if (log->GetDebug())
+          log->Printf(
+              "[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64
+              " - Cache Misses: %" PRIu64,
+              m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+      }
+      return retval;
     }
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving hardcoded a chance.");
-        retval = GetHardcodedSyntheticChildren(match_data);
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Cache search failed. "
+                  "Going normal route");
+  }
+
+  retval = m_categories_map.GetSyntheticChildren(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
     }
-    
-    if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable()))
-    {
-        if (log)
-            log->Printf("[FormatManager::GetSyntheticChildren] Caching %p for type %s",
-                        static_cast<void*>(retval.get()),
-                        match_data.GetTypeForCache().AsCString("<invalid>"));
-        m_format_cache.SetSynthetic(match_data.GetTypeForCache(),retval);
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetSyntheticChildren] Language search "
+                    "success. Returning.");
+      return retval;
     }
-    if (log && log->GetDebug())
-        log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-    return retval;
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetSyntheticChildren] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedSyntheticChildren(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf(
+          "[FormatManager::GetSyntheticChildren] Caching %p for type %s",
+          static_cast<void *>(retval.get()),
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetSynthetic(match_data.GetTypeForCache(), retval);
+  }
+  if (log && log->GetDebug())
+    log->Printf("[FormatManager::GetSyntheticChildren] Cache hits: %" PRIu64
+                " - Cache Misses: %" PRIu64,
+                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
 }
 #endif
 
 lldb::TypeValidatorImplSP
-FormatManager::GetValidator (ValueObject& valobj,
-                             lldb::DynamicValueType use_dynamic)
-{
-    FormattersMatchData match_data(valobj, use_dynamic);
-    
-    TypeValidatorImplSP retval;
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    if (match_data.GetTypeForCache())
-    {
-        if (log)
-            log->Printf("\n\n[FormatManager::GetValidator] Looking into cache for type %s", match_data.GetTypeForCache().AsCString("<invalid>"));
-        if (m_format_cache.GetValidator(match_data.GetTypeForCache(),retval))
-        {
-            if (log)
-            {
-                log->Printf("[FormatManager::GetValidator] Cache search success. Returning.");
-                if (log->GetDebug())
-                    log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-            }
-            return retval;
-        }
-        if (log)
-            log->Printf("[FormatManager::GetValidator] Cache search failed. Going normal route");
-    }
-    
-    retval = m_categories_map.GetValidator(match_data);
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetValidator] Search failed. Giving language a chance.");
-        for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-        {
-            if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-            {
-                if (lang_category->Get(match_data, retval))
-                    break;
-            }
-        }
-        if (retval)
-        {
-            if (log)
-                log->Printf("[FormatManager::GetValidator] Language search success. Returning.");
-            return retval;
-        }
+FormatManager::GetValidator(ValueObject &valobj,
+                            lldb::DynamicValueType use_dynamic) {
+  FormattersMatchData match_data(valobj, use_dynamic);
+
+  TypeValidatorImplSP retval;
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+  if (match_data.GetTypeForCache()) {
+    if (log)
+      log->Printf(
+          "\n\n[FormatManager::GetValidator] Looking into cache for type %s",
+          match_data.GetTypeForCache().AsCString("<invalid>"));
+    if (m_format_cache.GetValidator(match_data.GetTypeForCache(), retval)) {
+      if (log) {
+        log->Printf(
+            "[FormatManager::GetValidator] Cache search success. Returning.");
+        if (log->GetDebug())
+          log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64
+                      " - Cache Misses: %" PRIu64,
+                      m_format_cache.GetCacheHits(),
+                      m_format_cache.GetCacheMisses());
+      }
+      return retval;
     }
-    if (!retval)
-    {
-        if (log)
-            log->Printf("[FormatManager::GetValidator] Search failed. Giving hardcoded a chance.");
-        retval = GetHardcodedValidator(match_data);
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Cache search failed. Going "
+                  "normal route");
+  }
+
+  retval = m_categories_map.GetValidator(match_data);
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Search failed. Giving "
+                  "language a chance.");
+    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+      if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+        if (lang_category->Get(match_data, retval))
+          break;
+      }
     }
-    
-    if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable()))
-    {
-        if (log)
-            log->Printf("[FormatManager::GetValidator] Caching %p for type %s",
-                        static_cast<void*>(retval.get()),
-                        match_data.GetTypeForCache().AsCString("<invalid>"));
-        m_format_cache.SetValidator(match_data.GetTypeForCache(),retval);
+    if (retval) {
+      if (log)
+        log->Printf("[FormatManager::GetValidator] Language search success. "
+                    "Returning.");
+      return retval;
     }
-    if (log && log->GetDebug())
-        log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64 " - Cache Misses: %" PRIu64, m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
-    return retval;
+  }
+  if (!retval) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Search failed. Giving "
+                  "hardcoded a chance.");
+    retval = GetHardcodedValidator(match_data);
+  }
+
+  if (match_data.GetTypeForCache() && (!retval || !retval->NonCacheable())) {
+    if (log)
+      log->Printf("[FormatManager::GetValidator] Caching %p for type %s",
+                  static_cast<void *>(retval.get()),
+                  match_data.GetTypeForCache().AsCString("<invalid>"));
+    m_format_cache.SetValidator(match_data.GetTypeForCache(), retval);
+  }
+  if (log && log->GetDebug())
+    log->Printf("[FormatManager::GetValidator] Cache hits: %" PRIu64
+                " - Cache Misses: %" PRIu64,
+                m_format_cache.GetCacheHits(), m_format_cache.GetCacheMisses());
+  return retval;
 }
 
 lldb::TypeValidatorImplSP
-FormatManager::GetHardcodedValidator (FormattersMatchData& match_data)
-{
-    TypeValidatorImplSP retval_sp;
-    
-    for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages())
-    {
-        if (LanguageCategory* lang_category = GetCategoryForLanguage(lang_type))
-        {
-            if (lang_category->GetHardcoded(*this, match_data, retval_sp))
-                break;
-        }
+FormatManager::GetHardcodedValidator(FormattersMatchData &match_data) {
+  TypeValidatorImplSP retval_sp;
+
+  for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
+    if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
+        break;
     }
-    
-    return retval_sp;
+  }
+
+  return retval_sp;
 }
 
 FormatManager::FormatManager()
-    : m_last_revision(0),
-      m_format_cache(),
-      m_language_categories_mutex(),
-      m_language_categories_map(),
-      m_named_summaries_map(this),
-      m_categories_map(this),
-      m_default_category_name(ConstString("default")),
+    : m_last_revision(0), m_format_cache(), m_language_categories_mutex(),
+      m_language_categories_map(), m_named_summaries_map(this),
+      m_categories_map(this), m_default_category_name(ConstString("default")),
       m_system_category_name(ConstString("system")),
-      m_vectortypes_category_name(ConstString("VectorTypes"))
-{
-    LoadSystemFormatters();
-    LoadVectorFormatters();
+      m_vectortypes_category_name(ConstString("VectorTypes")) {
+  LoadSystemFormatters();
+  LoadVectorFormatters();
 
-    EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
-    EnableCategory(m_system_category_name, TypeCategoryMap::Last, lldb::eLanguageTypeObjC_plus_plus);
+  EnableCategory(m_vectortypes_category_name, TypeCategoryMap::Last,
+                 lldb::eLanguageTypeObjC_plus_plus);
+  EnableCategory(m_system_category_name, TypeCategoryMap::Last,
+                 lldb::eLanguageTypeObjC_plus_plus);
 }
 
-void
-FormatManager::LoadSystemFormatters()
-{
-    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);
-    
-    lldb::TypeSummaryImplSP string_format(new StringSummaryFormat(string_flags, "${var%s}"));
-    
-    
-    lldb::TypeSummaryImplSP string_array_format(new StringSummaryFormat(string_array_flags,
-                                                                        "${var%s}"));
-    
-    lldb::RegularExpressionSP any_size_char_arr(new RegularExpression("char \\[[0-9]+\\]"));
-    lldb::RegularExpressionSP any_size_wchar_arr(new RegularExpression("wchar_t \\[[0-9]+\\]"));
-    
-    TypeCategoryImpl::SharedPointer sys_category_sp = GetCategory(m_system_category_name);
-    
-    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"), string_format);
-    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("unsigned char *"), string_format);
-    sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr, string_array_format);
-
-    lldb::TypeSummaryImplSP ostype_summary(new StringSummaryFormat(TypeSummaryImpl::Flags().SetCascades(false)
-                                                                   .SetSkipPointers(true)
-                                                                   .SetSkipReferences(true)
-                                                                   .SetDontShowChildren(true)
-                                                                   .SetDontShowValue(false)
-                                                                   .SetShowMembersOneLiner(false)
-                                                                   .SetHideItemNames(false),
-                                                                   "${var%O}"));
-    
-    sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"), ostype_summary);
-    
+void FormatManager::LoadSystemFormatters() {
+  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);
+
+  lldb::TypeSummaryImplSP string_format(
+      new StringSummaryFormat(string_flags, "${var%s}"));
+
+  lldb::TypeSummaryImplSP string_array_format(
+      new StringSummaryFormat(string_array_flags, "${var%s}"));
+
+  lldb::RegularExpressionSP any_size_char_arr(
+      new RegularExpression("char \\[[0-9]+\\]"));
+  lldb::RegularExpressionSP any_size_wchar_arr(
+      new RegularExpression("wchar_t \\[[0-9]+\\]"));
+
+  TypeCategoryImpl::SharedPointer sys_category_sp =
+      GetCategory(m_system_category_name);
+
+  sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("char *"),
+                                                    string_format);
+  sys_category_sp->GetTypeSummariesContainer()->Add(
+      ConstString("unsigned char *"), string_format);
+  sys_category_sp->GetRegexTypeSummariesContainer()->Add(any_size_char_arr,
+                                                         string_array_format);
+
+  lldb::TypeSummaryImplSP ostype_summary(
+      new StringSummaryFormat(TypeSummaryImpl::Flags()
+                                  .SetCascades(false)
+                                  .SetSkipPointers(true)
+                                  .SetSkipReferences(true)
+                                  .SetDontShowChildren(true)
+                                  .SetDontShowValue(false)
+                                  .SetShowMembersOneLiner(false)
+                                  .SetHideItemNames(false),
+                              "${var%O}"));
+
+  sys_category_sp->GetTypeSummariesContainer()->Add(ConstString("OSType"),
+                                                    ostype_summary);
+
 #ifndef LLDB_DISABLE_PYTHON
-    TypeFormatImpl::Flags fourchar_flags;
-    fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(true);
-    
-    AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"), fourchar_flags);
+  TypeFormatImpl::Flags fourchar_flags;
+  fourchar_flags.SetCascades(true).SetSkipPointers(true).SetSkipReferences(
+      true);
+
+  AddFormat(sys_category_sp, lldb::eFormatOSType, ConstString("FourCharCode"),
+            fourchar_flags);
 #endif
 }
 
-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"),
-                     vector_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"),
+                   vector_flags);
 }
diff --git a/lldb/source/DataFormatters/FormattersHelpers.cpp b/lldb/source/DataFormatters/FormattersHelpers.cpp
index c4ff75c..842237f 100644
--- a/lldb/source/DataFormatters/FormattersHelpers.cpp
+++ b/lldb/source/DataFormatters/FormattersHelpers.cpp
@@ -1,4 +1,5 @@
-//===-- FormattersHelpers.cpp -------------------------------------*- C++ -*-===//
+//===-- FormattersHelpers.cpp -------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -26,139 +27,126 @@ 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)
-{
-    lldb::TypeFormatImplSP format_sp(new TypeFormatImpl_Format(format, flags));
-    
-    if (regex)
-        category_sp->GetRegexTypeFormatsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),format_sp);
-    else
-        category_sp->GetTypeFormatsContainer()->Add(type_name, format_sp);
+void lldb_private::formatters::AddFormat(
+    TypeCategoryImpl::SharedPointer category_sp, lldb::Format format,
+    ConstString type_name, TypeFormatImpl::Flags flags, bool regex) {
+  lldb::TypeFormatImplSP format_sp(new TypeFormatImpl_Format(format, flags));
+
+  if (regex)
+    category_sp->GetRegexTypeFormatsContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        format_sp);
+  else
+    category_sp->GetTypeFormatsContainer()->Add(type_name, format_sp);
 }
 
-void
-lldb_private::formatters::AddSummary(TypeCategoryImpl::SharedPointer category_sp,
-                                     TypeSummaryImplSP summary_sp,
-                                     ConstString type_name,
-                                     bool regex)
-{
-    if (regex)
-        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
-    else
-        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
+void lldb_private::formatters::AddSummary(
+    TypeCategoryImpl::SharedPointer category_sp, TypeSummaryImplSP summary_sp,
+    ConstString type_name, bool regex) {
+  if (regex)
+    category_sp->GetRegexTypeSummariesContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        summary_sp);
+  else
+    category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 
-void
-lldb_private::formatters::AddStringSummary(TypeCategoryImpl::SharedPointer category_sp,
-                                           const char* string,
-                                           ConstString type_name,
-                                           TypeSummaryImpl::Flags flags,
-                                           bool regex)
-{
-    lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags,
-                                                               string));
-    
-    if (regex)
-        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
-    else
-        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
+void lldb_private::formatters::AddStringSummary(
+    TypeCategoryImpl::SharedPointer category_sp, const char *string,
+    ConstString type_name, TypeSummaryImpl::Flags flags, bool regex) {
+  lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, string));
+
+  if (regex)
+    category_sp->GetRegexTypeSummariesContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        summary_sp);
+  else
+    category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 
-void
-lldb_private::formatters::AddOneLineSummary (TypeCategoryImpl::SharedPointer category_sp,
-                                             ConstString type_name,
-                                             TypeSummaryImpl::Flags flags,
-                                             bool regex)
-{
-    flags.SetShowMembersOneLiner(true);
-    lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, ""));
-    
-    if (regex)
-        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
-    else
-        category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
+void lldb_private::formatters::AddOneLineSummary(
+    TypeCategoryImpl::SharedPointer category_sp, ConstString type_name,
+    TypeSummaryImpl::Flags flags, bool regex) {
+  flags.SetShowMembersOneLiner(true);
+  lldb::TypeSummaryImplSP summary_sp(new StringSummaryFormat(flags, ""));
+
+  if (regex)
+    category_sp->GetRegexTypeSummariesContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        summary_sp);
+  else
+    category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 
 #ifndef LLDB_DISABLE_PYTHON
-void
-lldb_private::formatters::AddCXXSummary (TypeCategoryImpl::SharedPointer category_sp,
-                                         CXXFunctionSummaryFormat::Callback funct,
-                                         const char* description,
-                                         ConstString type_name,
-                                         TypeSummaryImpl::Flags flags,
-                                         bool regex)
-{
-    lldb::TypeSummaryImplSP summary_sp(new CXXFunctionSummaryFormat(flags,funct,description));
-    if (regex)
-        category_sp->GetRegexTypeSummariesContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())),summary_sp);
-    else
-        category_sp->GetTypeSummariesContainer()->Add(type_name, 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) {
+  lldb::TypeSummaryImplSP summary_sp(
+      new CXXFunctionSummaryFormat(flags, funct, description));
+  if (regex)
+    category_sp->GetRegexTypeSummariesContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        summary_sp);
+  else
+    category_sp->GetTypeSummariesContainer()->Add(type_name, summary_sp);
 }
 
-void
-lldb_private::formatters::AddCXXSynthetic  (TypeCategoryImpl::SharedPointer category_sp,
-                                            CXXSyntheticChildren::CreateFrontEndCallback generator,
-                                            const char* description,
-                                            ConstString type_name,
-                                            ScriptedSyntheticChildren::Flags flags,
-                                            bool regex)
-{
-    lldb::SyntheticChildrenSP synth_sp(new CXXSyntheticChildren(flags,description,generator));
-    if (regex)
-        category_sp->GetRegexTypeSyntheticsContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), synth_sp);
-    else
-        category_sp->GetTypeSyntheticsContainer()->Add(type_name,synth_sp);
+void lldb_private::formatters::AddCXXSynthetic(
+    TypeCategoryImpl::SharedPointer category_sp,
+    CXXSyntheticChildren::CreateFrontEndCallback generator,
+    const char *description, ConstString type_name,
+    ScriptedSyntheticChildren::Flags flags, bool regex) {
+  lldb::SyntheticChildrenSP synth_sp(
+      new CXXSyntheticChildren(flags, description, generator));
+  if (regex)
+    category_sp->GetRegexTypeSyntheticsContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        synth_sp);
+  else
+    category_sp->GetTypeSyntheticsContainer()->Add(type_name, 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)
-{
-    TypeFilterImplSP filter_sp(new TypeFilterImpl(flags));
-    for (auto child : children)
-        filter_sp->AddExpressionPath(child);
-    if (regex)
-        category_sp->GetRegexTypeFiltersContainer()->Add(RegularExpressionSP(new RegularExpression(type_name.AsCString())), filter_sp);
-    else
-        category_sp->GetTypeFiltersContainer()->Add(type_name,filter_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) {
+  TypeFilterImplSP filter_sp(new TypeFilterImpl(flags));
+  for (auto child : children)
+    filter_sp->AddExpressionPath(child);
+  if (regex)
+    category_sp->GetRegexTypeFiltersContainer()->Add(
+        RegularExpressionSP(new RegularExpression(type_name.AsCString())),
+        filter_sp);
+  else
+    category_sp->GetTypeFiltersContainer()->Add(type_name, filter_sp);
 }
 #endif
 
-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++;
-    char* endptr = NULL;
-    unsigned long int idx = ::strtoul(item_name, &endptr, 0);
-    if (idx == 0 && endptr == item_name)
-        return UINT32_MAX;
-    if (idx == ULONG_MAX)
-        return UINT32_MAX;
-    return idx;
+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++;
+  char *endptr = NULL;
+  unsigned long int idx = ::strtoul(item_name, &endptr, 0);
+  if (idx == 0 && endptr == item_name)
+    return UINT32_MAX;
+  if (idx == ULONG_MAX)
+    return UINT32_MAX;
+  return idx;
 }
 
 lldb::addr_t
-lldb_private::formatters::GetArrayAddressOrPointerValue (ValueObject& valobj)
-{
-    lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
+lldb_private::formatters::GetArrayAddressOrPointerValue(ValueObject &valobj) {
+  lldb::addr_t data_addr = LLDB_INVALID_ADDRESS;
 
-    if (valobj.IsPointerType())
-        data_addr = valobj.GetValueAsUnsigned(0);
-    else if (valobj.IsArrayType())
-        data_addr = valobj.GetAddressOf();
+  if (valobj.IsPointerType())
+    data_addr = valobj.GetValueAsUnsigned(0);
+  else if (valobj.IsArrayType())
+    data_addr = valobj.GetAddressOf();
 
-    return data_addr;
+  return data_addr;
 }
diff --git a/lldb/source/DataFormatters/LanguageCategory.cpp b/lldb/source/DataFormatters/LanguageCategory.cpp
index 261c3e6..251f0c3 100644
--- a/lldb/source/DataFormatters/LanguageCategory.cpp
+++ b/lldb/source/DataFormatters/LanguageCategory.cpp
@@ -1,4 +1,5 @@
-//===-- LanguageCategory.cpp ---------------------------------------*- C++ -*-===//
+//===-- LanguageCategory.cpp ---------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -24,248 +25,208 @@
 using namespace lldb;
 using namespace lldb_private;
 
-LanguageCategory::LanguageCategory (lldb::LanguageType lang_type) :
-    m_category_sp(),
-    m_hardcoded_formats(),
-    m_hardcoded_summaries(),
-    m_hardcoded_synthetics(),
-    m_hardcoded_validators(),
-    m_format_cache(),
-    m_enabled(false)
-{
-    if (Language* language_plugin = Language::FindPlugin(lang_type))
-    {
-        m_category_sp = language_plugin->GetFormatters();
-        m_hardcoded_formats = language_plugin->GetHardcodedFormats();
-        m_hardcoded_summaries = language_plugin->GetHardcodedSummaries();
-        m_hardcoded_synthetics = language_plugin->GetHardcodedSynthetics();
-        m_hardcoded_validators = language_plugin->GetHardcodedValidators();
-    }
-    Enable();
+LanguageCategory::LanguageCategory(lldb::LanguageType lang_type)
+    : m_category_sp(), m_hardcoded_formats(), m_hardcoded_summaries(),
+      m_hardcoded_synthetics(), m_hardcoded_validators(), m_format_cache(),
+      m_enabled(false) {
+  if (Language *language_plugin = Language::FindPlugin(lang_type)) {
+    m_category_sp = language_plugin->GetFormatters();
+    m_hardcoded_formats = language_plugin->GetHardcodedFormats();
+    m_hardcoded_summaries = language_plugin->GetHardcodedSummaries();
+    m_hardcoded_synthetics = language_plugin->GetHardcodedSynthetics();
+    m_hardcoded_validators = language_plugin->GetHardcodedValidators();
+  }
+  Enable();
 }
 
-bool
-LanguageCategory::Get (FormattersMatchData& match_data,
-                       lldb::TypeFormatImplSP& format_sp)
-{
-    if (!m_category_sp)
-        return false;
-    
-    if (!IsEnabled())
-        return false;
-
-    if (match_data.GetTypeForCache())
-    {
-        if (m_format_cache.GetFormat(match_data.GetTypeForCache(), format_sp))
-            return format_sp.get() != nullptr;
-    }
-
-    ValueObject& valobj(match_data.GetValueObject());
-    bool result = m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
-    }
-    return result;
+bool LanguageCategory::Get(FormattersMatchData &match_data,
+                           lldb::TypeFormatImplSP &format_sp) {
+  if (!m_category_sp)
+    return false;
+
+  if (!IsEnabled())
+    return false;
+
+  if (match_data.GetTypeForCache()) {
+    if (m_format_cache.GetFormat(match_data.GetTypeForCache(), format_sp))
+      return format_sp.get() != nullptr;
+  }
+
+  ValueObject &valobj(match_data.GetValueObject());
+  bool result =
+      m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
+  }
+  return result;
 }
 
-bool
-LanguageCategory::Get (FormattersMatchData& match_data,
-                       lldb::TypeSummaryImplSP& format_sp)
-{
-    if (!m_category_sp)
-        return false;
-    
-    if (!IsEnabled())
-        return false;
-
-    if (match_data.GetTypeForCache())
-    {
-        if (m_format_cache.GetSummary(match_data.GetTypeForCache(), format_sp))
-            return format_sp.get() != nullptr;
-    }
-    
-    ValueObject& valobj(match_data.GetValueObject());
-    bool result = m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
-    }
-    return result;
+bool LanguageCategory::Get(FormattersMatchData &match_data,
+                           lldb::TypeSummaryImplSP &format_sp) {
+  if (!m_category_sp)
+    return false;
+
+  if (!IsEnabled())
+    return false;
+
+  if (match_data.GetTypeForCache()) {
+    if (m_format_cache.GetSummary(match_data.GetTypeForCache(), format_sp))
+      return format_sp.get() != nullptr;
+  }
+
+  ValueObject &valobj(match_data.GetValueObject());
+  bool result =
+      m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
+  }
+  return result;
 }
 
-bool
-LanguageCategory::Get (FormattersMatchData& match_data,
-                       lldb::SyntheticChildrenSP& format_sp)
-{
-    if (!m_category_sp)
-        return false;
-    
-    if (!IsEnabled())
-        return false;
-
-    if (match_data.GetTypeForCache())
-    {
-        if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), format_sp))
-            return format_sp.get() != nullptr;
-    }
-    
-    ValueObject& valobj(match_data.GetValueObject());
-    bool result = m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
-    }
-    return result;
+bool LanguageCategory::Get(FormattersMatchData &match_data,
+                           lldb::SyntheticChildrenSP &format_sp) {
+  if (!m_category_sp)
+    return false;
+
+  if (!IsEnabled())
+    return false;
+
+  if (match_data.GetTypeForCache()) {
+    if (m_format_cache.GetSynthetic(match_data.GetTypeForCache(), format_sp))
+      return format_sp.get() != nullptr;
+  }
+
+  ValueObject &valobj(match_data.GetValueObject());
+  bool result =
+      m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
+  }
+  return result;
 }
 
-bool
-LanguageCategory::Get (FormattersMatchData& match_data,
-                       lldb::TypeValidatorImplSP& format_sp)
-{
-    if (!m_category_sp)
-        return false;
-
-    if (!IsEnabled())
-        return false;
-
-    if (match_data.GetTypeForCache())
-    {
-        if (m_format_cache.GetValidator(match_data.GetTypeForCache(), format_sp))
-            return format_sp.get() != nullptr;
-    }
-    
-    ValueObject& valobj(match_data.GetValueObject());
-    bool result = m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
-    }
-    return result;
+bool LanguageCategory::Get(FormattersMatchData &match_data,
+                           lldb::TypeValidatorImplSP &format_sp) {
+  if (!m_category_sp)
+    return false;
+
+  if (!IsEnabled())
+    return false;
+
+  if (match_data.GetTypeForCache()) {
+    if (m_format_cache.GetValidator(match_data.GetTypeForCache(), format_sp))
+      return format_sp.get() != nullptr;
+  }
+
+  ValueObject &valobj(match_data.GetValueObject());
+  bool result =
+      m_category_sp->Get(valobj, match_data.GetMatchesVector(), format_sp);
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
+  }
+  return result;
 }
 
-bool
-LanguageCategory::GetHardcoded (FormatManager& fmt_mgr,
-                                FormattersMatchData& match_data,
-                                lldb::TypeFormatImplSP& format_sp)
-{
-    if (!IsEnabled())
-        return false;
-
-    ValueObject& valobj(match_data.GetValueObject());
-    lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
-    
-    for (auto& candidate : m_hardcoded_formats)
-    {
-        if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
-            break;
-    }
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
-    }
-    return format_sp.get() != nullptr;
+bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
+                                    FormattersMatchData &match_data,
+                                    lldb::TypeFormatImplSP &format_sp) {
+  if (!IsEnabled())
+    return false;
+
+  ValueObject &valobj(match_data.GetValueObject());
+  lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
+
+  for (auto &candidate : m_hardcoded_formats) {
+    if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
+      break;
+  }
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetFormat(match_data.GetTypeForCache(), format_sp);
+  }
+  return format_sp.get() != nullptr;
 }
 
-bool
-LanguageCategory::GetHardcoded (FormatManager& fmt_mgr,
-                                FormattersMatchData& match_data,
-                                lldb::TypeSummaryImplSP& format_sp)
-{
-    if (!IsEnabled())
-        return false;
-    
-    ValueObject& valobj(match_data.GetValueObject());
-    lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
-
-    for (auto& candidate : m_hardcoded_summaries)
-    {
-        if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
-            break;
-    }
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
-    }
-    return format_sp.get() != nullptr;
+bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
+                                    FormattersMatchData &match_data,
+                                    lldb::TypeSummaryImplSP &format_sp) {
+  if (!IsEnabled())
+    return false;
+
+  ValueObject &valobj(match_data.GetValueObject());
+  lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
+
+  for (auto &candidate : m_hardcoded_summaries) {
+    if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
+      break;
+  }
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetSummary(match_data.GetTypeForCache(), format_sp);
+  }
+  return format_sp.get() != nullptr;
 }
 
-bool
-LanguageCategory::GetHardcoded (FormatManager& fmt_mgr,
-                                FormattersMatchData& match_data,
-                                lldb::SyntheticChildrenSP& format_sp)
-{
-    if (!IsEnabled())
-        return false;
-
-    ValueObject& valobj(match_data.GetValueObject());
-    lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
-    
-    for (auto& candidate : m_hardcoded_synthetics)
-    {
-        if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
-            break;
-    }
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
-    }
-    return format_sp.get() != nullptr;
+bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
+                                    FormattersMatchData &match_data,
+                                    lldb::SyntheticChildrenSP &format_sp) {
+  if (!IsEnabled())
+    return false;
+
+  ValueObject &valobj(match_data.GetValueObject());
+  lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
+
+  for (auto &candidate : m_hardcoded_synthetics) {
+    if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
+      break;
+  }
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetSynthetic(match_data.GetTypeForCache(), format_sp);
+  }
+  return format_sp.get() != nullptr;
 }
 
-bool
-LanguageCategory::GetHardcoded (FormatManager& fmt_mgr,
-                                FormattersMatchData& match_data,
-                                lldb::TypeValidatorImplSP& format_sp)
-{
-    if (!IsEnabled())
-        return false;
-
-    ValueObject& valobj(match_data.GetValueObject());
-    lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
-    
-    for (auto& candidate : m_hardcoded_validators)
-    {
-        if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
-            break;
-    }
-    if (match_data.GetTypeForCache() && (!format_sp || !format_sp->NonCacheable()))
-    {
-        m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
-    }
-    return format_sp.get() != nullptr;
+bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
+                                    FormattersMatchData &match_data,
+                                    lldb::TypeValidatorImplSP &format_sp) {
+  if (!IsEnabled())
+    return false;
+
+  ValueObject &valobj(match_data.GetValueObject());
+  lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
+
+  for (auto &candidate : m_hardcoded_validators) {
+    if ((format_sp = candidate(valobj, use_dynamic, fmt_mgr)))
+      break;
+  }
+  if (match_data.GetTypeForCache() &&
+      (!format_sp || !format_sp->NonCacheable())) {
+    m_format_cache.SetValidator(match_data.GetTypeForCache(), format_sp);
+  }
+  return format_sp.get() != nullptr;
 }
 
-lldb::TypeCategoryImplSP
-LanguageCategory::GetCategory () const
-{
-    return m_category_sp;
+lldb::TypeCategoryImplSP LanguageCategory::GetCategory() const {
+  return m_category_sp;
 }
 
-FormatCache&
-LanguageCategory::GetFormatCache ()
-{
-    return m_format_cache;
-}
+FormatCache &LanguageCategory::GetFormatCache() { return m_format_cache; }
 
-void
-LanguageCategory::Enable ()
-{
-    if (m_category_sp)
-        m_category_sp->Enable(true, TypeCategoryMap::Default);
-    m_enabled = true;
+void LanguageCategory::Enable() {
+  if (m_category_sp)
+    m_category_sp->Enable(true, TypeCategoryMap::Default);
+  m_enabled = true;
 }
 
-void
-LanguageCategory::Disable ()
-{
-    if (m_category_sp)
-        m_category_sp->Disable();
-    m_enabled = false;
+void LanguageCategory::Disable() {
+  if (m_category_sp)
+    m_category_sp->Disable();
+  m_enabled = false;
 }
 
-bool
-LanguageCategory::IsEnabled ()
-{
-    return m_enabled;
-}
+bool LanguageCategory::IsEnabled() { return m_enabled; }
diff --git a/lldb/source/DataFormatters/StringPrinter.cpp b/lldb/source/DataFormatters/StringPrinter.cpp
index 8cdbb53..d373b34 100644
--- a/lldb/source/DataFormatters/StringPrinter.cpp
+++ b/lldb/source/DataFormatters/StringPrinter.cpp
@@ -1,4 +1,5 @@
-//===-- StringPrinter.cpp ----------------------------------------*- C++ -*-===//
+//===-- StringPrinter.cpp ----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -25,629 +26,622 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-// we define this for all values of type but only implement it for those we care about
+// we define this for all values of type but only implement it for those we care
+// about
 // that's good because we get linker errors for any unsupported type
 template <lldb_private::formatters::StringPrinter::StringElementType type>
 static StringPrinter::StringPrinterBufferPointer<>
-GetPrintableImpl(uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next);
+GetPrintableImpl(uint8_t *buffer, uint8_t *buffer_end, uint8_t *&next);
 
 // mimic isprint() for Unicode codepoints
-static bool
-isprint(char32_t codepoint)
-{
-    if (codepoint <= 0x1F || codepoint == 0x7F) // C0
-    {
-        return false;
-    }
-    if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
-    {
-        return false;
-    }
-    if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators
-    {
-        return false;
-    }
-    if (codepoint == 0x200E || codepoint == 0x200F || (codepoint >= 0x202A && codepoint <= 0x202E)) // bidirectional text control
-    {
-        return false;
-    }
-    if (codepoint >= 0xFFF9 && codepoint <= 0xFFFF) // interlinears and generally specials
-    {
-        return false;
-    }
-    return true;
+static bool isprint(char32_t codepoint) {
+  if (codepoint <= 0x1F || codepoint == 0x7F) // C0
+  {
+    return false;
+  }
+  if (codepoint >= 0x80 && codepoint <= 0x9F) // C1
+  {
+    return false;
+  }
+  if (codepoint == 0x2028 || codepoint == 0x2029) // line/paragraph separators
+  {
+    return false;
+  }
+  if (codepoint == 0x200E || codepoint == 0x200F ||
+      (codepoint >= 0x202A &&
+       codepoint <= 0x202E)) // bidirectional text control
+  {
+    return false;
+  }
+  if (codepoint >= 0xFFF9 &&
+      codepoint <= 0xFFFF) // interlinears and generally specials
+  {
+    return false;
+  }
+  return true;
 }
 
 template <>
 StringPrinter::StringPrinterBufferPointer<>
-GetPrintableImpl<StringPrinter::StringElementType::ASCII> (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
-{
-    StringPrinter::StringPrinterBufferPointer<> retval = {nullptr};
-    
-    switch (*buffer)
-    {
-        case 0:
-            retval = {"\\0",2};
-            break;
-        case '\a':
-            retval = {"\\a",2};
-            break;
-        case '\b':
-            retval = {"\\b",2};
-            break;
-        case '\f':
-            retval = {"\\f",2};
-            break;
-        case '\n':
-            retval = {"\\n",2};
-            break;
-        case '\r':
-            retval = {"\\r",2};
-            break;
-        case '\t':
-            retval = {"\\t",2};
-            break;
-        case '\v':
-            retval = {"\\v",2};
-            break;
-        case '\"':
-            retval = {"\\\"",2};
-            break;
-        case '\\':
-            retval = {"\\\\",2};
-            break;
-        default:
-          if (isprint(*buffer))
-              retval = {buffer,1};
-          else
-          {
-              uint8_t* data = new uint8_t[5];
-              sprintf((char*)data,"\\x%02x",*buffer);
-              retval = {data, 4, [] (const uint8_t* c) {delete[] c;} };
-              break;
-          }
+GetPrintableImpl<StringPrinter::StringElementType::ASCII>(uint8_t *buffer,
+                                                          uint8_t *buffer_end,
+                                                          uint8_t *&next) {
+  StringPrinter::StringPrinterBufferPointer<> retval = {nullptr};
+
+  switch (*buffer) {
+  case 0:
+    retval = {"\\0", 2};
+    break;
+  case '\a':
+    retval = {"\\a", 2};
+    break;
+  case '\b':
+    retval = {"\\b", 2};
+    break;
+  case '\f':
+    retval = {"\\f", 2};
+    break;
+  case '\n':
+    retval = {"\\n", 2};
+    break;
+  case '\r':
+    retval = {"\\r", 2};
+    break;
+  case '\t':
+    retval = {"\\t", 2};
+    break;
+  case '\v':
+    retval = {"\\v", 2};
+    break;
+  case '\"':
+    retval = {"\\\"", 2};
+    break;
+  case '\\':
+    retval = {"\\\\", 2};
+    break;
+  default:
+    if (isprint(*buffer))
+      retval = {buffer, 1};
+    else {
+      uint8_t *data = new uint8_t[5];
+      sprintf((char *)data, "\\x%02x", *buffer);
+      retval = {data, 4, [](const uint8_t *c) { delete[] c; }};
+      break;
     }
-    
-    next = buffer + 1;
-    return retval;
+  }
+
+  next = buffer + 1;
+  return retval;
 }
 
-static char32_t
-ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1)
-{
-    return (c0-192)*64+(c1-128);
+static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1) {
+  return (c0 - 192) * 64 + (c1 - 128);
 }
-static char32_t
-ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1, unsigned char c2)
-{
-    return (c0-224)*4096+(c1-128)*64+(c2-128);
+static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
+                                       unsigned char c2) {
+  return (c0 - 224) * 4096 + (c1 - 128) * 64 + (c2 - 128);
 }
-static char32_t
-ConvertUTF8ToCodePoint (unsigned char c0, unsigned char c1, unsigned char c2, unsigned char c3)
-{
-    return (c0-240)*262144+(c2-128)*4096+(c2-128)*64+(c3-128);
+static char32_t ConvertUTF8ToCodePoint(unsigned char c0, unsigned char c1,
+                                       unsigned char c2, unsigned char c3) {
+  return (c0 - 240) * 262144 + (c2 - 128) * 4096 + (c2 - 128) * 64 + (c3 - 128);
 }
 
 template <>
 StringPrinter::StringPrinterBufferPointer<>
-GetPrintableImpl<StringPrinter::StringElementType::UTF8> (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
-{
-    StringPrinter::StringPrinterBufferPointer<> retval {nullptr};
-    
-    unsigned utf8_encoded_len = getNumBytesForUTF8(*buffer);
-    
-    if (1+buffer_end-buffer < utf8_encoded_len)
-    {
-        // I don't have enough bytes - print whatever I have left
-        retval = {buffer,static_cast<size_t>(1+buffer_end-buffer)};
-        next = buffer_end+1;
-        return retval;
-    }
-    
-    char32_t codepoint = 0;
-    switch (utf8_encoded_len)
-    {
-        case 1:
-            // this is just an ASCII byte - ask ASCII
-            return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(buffer, buffer_end, next);
-        case 2:
-            codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1));
-            break;
-        case 3:
-            codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1), (unsigned char)*(buffer+2));
-            break;
-        case 4:
-            codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer, (unsigned char)*(buffer+1), (unsigned char)*(buffer+2), (unsigned char)*(buffer+3));
-            break;
-        default:
-            // this is probably some bogus non-character thing
-            // just print it as-is and hope to sync up again soon
-            retval = {buffer,1};
-            next = buffer+1;
-            return retval;
-    }
-    
-    if (codepoint)
-    {
-        switch (codepoint)
-        {
-            case 0:
-                retval = {"\\0",2};
-                break;
-            case '\a':
-                retval = {"\\a",2};
-                break;
-            case '\b':
-                retval = {"\\b",2};
-                break;
-            case '\f':
-                retval = {"\\f",2};
-                break;
-            case '\n':
-                retval = {"\\n",2};
-                break;
-            case '\r':
-                retval = {"\\r",2};
-                break;
-            case '\t':
-                retval = {"\\t",2};
-                break;
-            case '\v':
-                retval = {"\\v",2};
-                break;
-            case '\"':
-                retval = {"\\\"",2};
-                break;
-            case '\\':
-                retval = {"\\\\",2};
-                break;
-            default:
-                if (isprint(codepoint))
-                    retval = {buffer,utf8_encoded_len};
-                else
-                {
-                    uint8_t* data = new uint8_t[11];
-                    sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
-                    retval = { data,10,[] (const uint8_t* c) {delete[] c;} };
-                    break;
-                }
-        }
-        
-        next = buffer + utf8_encoded_len;
-        return retval;
+GetPrintableImpl<StringPrinter::StringElementType::UTF8>(uint8_t *buffer,
+                                                         uint8_t *buffer_end,
+                                                         uint8_t *&next) {
+  StringPrinter::StringPrinterBufferPointer<> retval{nullptr};
+
+  unsigned utf8_encoded_len = getNumBytesForUTF8(*buffer);
+
+  if (1 + buffer_end - buffer < utf8_encoded_len) {
+    // I don't have enough bytes - print whatever I have left
+    retval = {buffer, static_cast<size_t>(1 + buffer_end - buffer)};
+    next = buffer_end + 1;
+    return retval;
+  }
+
+  char32_t codepoint = 0;
+  switch (utf8_encoded_len) {
+  case 1:
+    // this is just an ASCII byte - ask ASCII
+    return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
+        buffer, buffer_end, next);
+  case 2:
+    codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
+                                       (unsigned char)*(buffer + 1));
+    break;
+  case 3:
+    codepoint = ConvertUTF8ToCodePoint((unsigned char)*buffer,
+                                       (unsigned char)*(buffer + 1),
+                                       (unsigned char)*(buffer + 2));
+    break;
+  case 4:
+    codepoint = ConvertUTF8ToCodePoint(
+        (unsigned char)*buffer, (unsigned char)*(buffer + 1),
+        (unsigned char)*(buffer + 2), (unsigned char)*(buffer + 3));
+    break;
+  default:
+    // this is probably some bogus non-character thing
+    // just print it as-is and hope to sync up again soon
+    retval = {buffer, 1};
+    next = buffer + 1;
+    return retval;
+  }
+
+  if (codepoint) {
+    switch (codepoint) {
+    case 0:
+      retval = {"\\0", 2};
+      break;
+    case '\a':
+      retval = {"\\a", 2};
+      break;
+    case '\b':
+      retval = {"\\b", 2};
+      break;
+    case '\f':
+      retval = {"\\f", 2};
+      break;
+    case '\n':
+      retval = {"\\n", 2};
+      break;
+    case '\r':
+      retval = {"\\r", 2};
+      break;
+    case '\t':
+      retval = {"\\t", 2};
+      break;
+    case '\v':
+      retval = {"\\v", 2};
+      break;
+    case '\"':
+      retval = {"\\\"", 2};
+      break;
+    case '\\':
+      retval = {"\\\\", 2};
+      break;
+    default:
+      if (isprint(codepoint))
+        retval = {buffer, utf8_encoded_len};
+      else {
+        uint8_t *data = new uint8_t[11];
+        sprintf((char *)data, "\\U%08x", (unsigned)codepoint);
+        retval = {data, 10, [](const uint8_t *c) { delete[] c; }};
+        break;
+      }
     }
-    
-    // this should not happen - but just in case.. try to resync at some point
-    retval = {buffer,1};
-    next = buffer+1;
+
+    next = buffer + utf8_encoded_len;
     return retval;
+  }
+
+  // this should not happen - but just in case.. try to resync at some point
+  retval = {buffer, 1};
+  next = buffer + 1;
+  return retval;
 }
 
 // Given a sequence of bytes, this function returns:
 // a sequence of bytes to actually print out + a length
 // the following unscanned position of the buffer is in next
 static StringPrinter::StringPrinterBufferPointer<>
-GetPrintable(StringPrinter::StringElementType type, uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next)
-{
-    if (!buffer)
-        return {nullptr};
-    
-    switch (type)
-    {
-        case StringPrinter::StringElementType::ASCII:
-            return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(buffer, buffer_end, next);
-        case StringPrinter::StringElementType::UTF8:
-            return GetPrintableImpl<StringPrinter::StringElementType::UTF8>(buffer, buffer_end, next);
-        default:
-            return {nullptr};
-    }
+GetPrintable(StringPrinter::StringElementType type, uint8_t *buffer,
+             uint8_t *buffer_end, uint8_t *&next) {
+  if (!buffer)
+    return {nullptr};
+
+  switch (type) {
+  case StringPrinter::StringElementType::ASCII:
+    return GetPrintableImpl<StringPrinter::StringElementType::ASCII>(
+        buffer, buffer_end, next);
+  case StringPrinter::StringElementType::UTF8:
+    return GetPrintableImpl<StringPrinter::StringElementType::UTF8>(
+        buffer, buffer_end, next);
+  default:
+    return {nullptr};
+  }
 }
 
 StringPrinter::EscapingHelper
-StringPrinter::GetDefaultEscapingHelper (GetPrintableElementType elem_type)
-{
-    switch (elem_type)
-    {
-        case GetPrintableElementType::UTF8:
-            return [] (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next) -> StringPrinter::StringPrinterBufferPointer<> {
-                return GetPrintable(StringPrinter::StringElementType::UTF8, buffer, buffer_end, next);
-            };
-        case GetPrintableElementType::ASCII:
-            return [] (uint8_t* buffer, uint8_t* buffer_end, uint8_t*& next) -> StringPrinter::StringPrinterBufferPointer<> {
-                return GetPrintable(StringPrinter::StringElementType::ASCII, buffer, buffer_end, next);
-            };
-    }
-    llvm_unreachable("bad element type");
+StringPrinter::GetDefaultEscapingHelper(GetPrintableElementType elem_type) {
+  switch (elem_type) {
+  case GetPrintableElementType::UTF8:
+    return [](uint8_t *buffer, uint8_t *buffer_end,
+              uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> {
+      return GetPrintable(StringPrinter::StringElementType::UTF8, buffer,
+                          buffer_end, next);
+    };
+  case GetPrintableElementType::ASCII:
+    return [](uint8_t *buffer, uint8_t *buffer_end,
+              uint8_t *&next) -> StringPrinter::StringPrinterBufferPointer<> {
+      return GetPrintable(StringPrinter::StringElementType::ASCII, buffer,
+                          buffer_end, next);
+    };
+  }
+  llvm_unreachable("bad element type");
 }
 
 // use this call if you already have an LLDB-side buffer for the data
-template<typename SourceDataType>
-static bool
-DumpUTFBufferToStream (ConversionResult (*ConvertFunction) (const SourceDataType**,
-                                                            const SourceDataType*,
-                                                            UTF8**,
-                                                            UTF8*,
-                                                            ConversionFlags),
-                       const StringPrinter::ReadBufferAndDumpToStreamOptions& dump_options)
-{
-    Stream &stream(*dump_options.GetStream());
-    if (dump_options.GetPrefixToken() != 0)
-        stream.Printf("%s",dump_options.GetPrefixToken());
-    if (dump_options.GetQuote() != 0)
-        stream.Printf("%c",dump_options.GetQuote());
-    auto data(dump_options.GetData());
-    auto source_size(dump_options.GetSourceSize());
-    if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd())
-    {
-        const int bufferSPSize = data.GetByteSize();
-        if (dump_options.GetSourceSize() == 0)
-        {
-            const int origin_encoding = 8*sizeof(SourceDataType);
-            source_size = bufferSPSize/(origin_encoding / 4);
-        }
-        
-        const SourceDataType *data_ptr = (const SourceDataType*)data.GetDataStart();
-        const SourceDataType *data_end_ptr = data_ptr + source_size;
-        
-        const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator();
-        
-        if (zero_is_terminator)
-        {
-            while (data_ptr < data_end_ptr)
-            {
-                if (!*data_ptr)
-                {
-                    data_end_ptr = data_ptr;
-                    break;
-                }
-                data_ptr++;
-            }
-            
-            data_ptr = (const SourceDataType*)data.GetDataStart();
-        }
-        
-        lldb::DataBufferSP utf8_data_buffer_sp;
-        UTF8* utf8_data_ptr = nullptr;
-        UTF8* utf8_data_end_ptr = nullptr;
-        
-        if (ConvertFunction)
-        {
-            utf8_data_buffer_sp.reset(new DataBufferHeap(4*bufferSPSize,0));
-            utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes();
-            utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
-            ConvertFunction ( &data_ptr, data_end_ptr, &utf8_data_ptr, utf8_data_end_ptr, lenientConversion );
-            if (false == zero_is_terminator)
-                utf8_data_end_ptr = utf8_data_ptr;
-            utf8_data_ptr = (UTF8*)utf8_data_buffer_sp->GetBytes(); // needed because the ConvertFunction will change the value of the data_ptr
-        }
-        else
-        {
-            // just copy the pointers - the cast is necessary to make the compiler happy
-            // but this should only happen if we are reading UTF8 data
-            utf8_data_ptr = const_cast<UTF8 *>(reinterpret_cast<const UTF8*>(data_ptr));
-            utf8_data_end_ptr = const_cast<UTF8 *>(reinterpret_cast<const UTF8*>(data_end_ptr));
-        }
-        
-        const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
-        lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
-        if (escape_non_printables)
-        {
-            if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
-                escaping_callback = language->GetStringPrinterEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::UTF8);
-            else
-                escaping_callback = lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::UTF8);
+template <typename SourceDataType>
+static bool DumpUTFBufferToStream(
+    ConversionResult (*ConvertFunction)(const SourceDataType **,
+                                        const SourceDataType *, UTF8 **, UTF8 *,
+                                        ConversionFlags),
+    const StringPrinter::ReadBufferAndDumpToStreamOptions &dump_options) {
+  Stream &stream(*dump_options.GetStream());
+  if (dump_options.GetPrefixToken() != 0)
+    stream.Printf("%s", dump_options.GetPrefixToken());
+  if (dump_options.GetQuote() != 0)
+    stream.Printf("%c", dump_options.GetQuote());
+  auto data(dump_options.GetData());
+  auto source_size(dump_options.GetSourceSize());
+  if (data.GetByteSize() && data.GetDataStart() && data.GetDataEnd()) {
+    const int bufferSPSize = data.GetByteSize();
+    if (dump_options.GetSourceSize() == 0) {
+      const int origin_encoding = 8 * sizeof(SourceDataType);
+      source_size = bufferSPSize / (origin_encoding / 4);
+    }
+
+    const SourceDataType *data_ptr =
+        (const SourceDataType *)data.GetDataStart();
+    const SourceDataType *data_end_ptr = data_ptr + source_size;
+
+    const bool zero_is_terminator = dump_options.GetBinaryZeroIsTerminator();
+
+    if (zero_is_terminator) {
+      while (data_ptr < data_end_ptr) {
+        if (!*data_ptr) {
+          data_end_ptr = data_ptr;
+          break;
         }
-        
-        // since we tend to accept partial data (and even partially malformed data)
-        // we might end up with no NULL terminator before the end_ptr
-        // hence we need to take a slower route and ensure we stay within boundaries
-        for (;utf8_data_ptr < utf8_data_end_ptr;)
-        {
-            if (zero_is_terminator && !*utf8_data_ptr)
-                break;
-            
-            if (escape_non_printables)
-            {
-                uint8_t* next_data = nullptr;
-                auto printable = escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data);
-                auto printable_bytes = printable.GetBytes();
-                auto printable_size = printable.GetSize();
-                if (!printable_bytes || !next_data)
-                {
-                    // GetPrintable() failed on us - print one byte in a desperate resync attempt
-                    printable_bytes = utf8_data_ptr;
-                    printable_size = 1;
-                    next_data = utf8_data_ptr+1;
-                }
-                for (unsigned c = 0; c < printable_size; c++)
-                    stream.Printf("%c", *(printable_bytes+c));
-                utf8_data_ptr = (uint8_t*)next_data;
-            }
-            else
-            {
-                stream.Printf("%c",*utf8_data_ptr);
-                utf8_data_ptr++;
-            }
+        data_ptr++;
+      }
+
+      data_ptr = (const SourceDataType *)data.GetDataStart();
+    }
+
+    lldb::DataBufferSP utf8_data_buffer_sp;
+    UTF8 *utf8_data_ptr = nullptr;
+    UTF8 *utf8_data_end_ptr = nullptr;
+
+    if (ConvertFunction) {
+      utf8_data_buffer_sp.reset(new DataBufferHeap(4 * bufferSPSize, 0));
+      utf8_data_ptr = (UTF8 *)utf8_data_buffer_sp->GetBytes();
+      utf8_data_end_ptr = utf8_data_ptr + utf8_data_buffer_sp->GetByteSize();
+      ConvertFunction(&data_ptr, data_end_ptr, &utf8_data_ptr,
+                      utf8_data_end_ptr, lenientConversion);
+      if (false == zero_is_terminator)
+        utf8_data_end_ptr = utf8_data_ptr;
+      utf8_data_ptr =
+          (UTF8 *)utf8_data_buffer_sp->GetBytes(); // needed because the
+                                                   // ConvertFunction will
+                                                   // change the value of the
+                                                   // data_ptr
+    } else {
+      // just copy the pointers - the cast is necessary to make the compiler
+      // happy
+      // but this should only happen if we are reading UTF8 data
+      utf8_data_ptr =
+          const_cast<UTF8 *>(reinterpret_cast<const UTF8 *>(data_ptr));
+      utf8_data_end_ptr =
+          const_cast<UTF8 *>(reinterpret_cast<const UTF8 *>(data_end_ptr));
+    }
+
+    const bool escape_non_printables = dump_options.GetEscapeNonPrintables();
+    lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
+    if (escape_non_printables) {
+      if (Language *language = Language::FindPlugin(dump_options.GetLanguage()))
+        escaping_callback = language->GetStringPrinterEscapingHelper(
+            lldb_private::formatters::StringPrinter::GetPrintableElementType::
+                UTF8);
+      else
+        escaping_callback =
+            lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
+                lldb_private::formatters::StringPrinter::
+                    GetPrintableElementType::UTF8);
+    }
+
+    // since we tend to accept partial data (and even partially malformed data)
+    // we might end up with no NULL terminator before the end_ptr
+    // hence we need to take a slower route and ensure we stay within boundaries
+    for (; utf8_data_ptr < utf8_data_end_ptr;) {
+      if (zero_is_terminator && !*utf8_data_ptr)
+        break;
+
+      if (escape_non_printables) {
+        uint8_t *next_data = nullptr;
+        auto printable =
+            escaping_callback(utf8_data_ptr, utf8_data_end_ptr, next_data);
+        auto printable_bytes = printable.GetBytes();
+        auto printable_size = printable.GetSize();
+        if (!printable_bytes || !next_data) {
+          // GetPrintable() failed on us - print one byte in a desperate resync
+          // attempt
+          printable_bytes = utf8_data_ptr;
+          printable_size = 1;
+          next_data = utf8_data_ptr + 1;
         }
+        for (unsigned c = 0; c < printable_size; c++)
+          stream.Printf("%c", *(printable_bytes + c));
+        utf8_data_ptr = (uint8_t *)next_data;
+      } else {
+        stream.Printf("%c", *utf8_data_ptr);
+        utf8_data_ptr++;
+      }
     }
-    if (dump_options.GetQuote() != 0)
-        stream.Printf("%c",dump_options.GetQuote());
-    if (dump_options.GetSuffixToken() != 0)
-        stream.Printf("%s",dump_options.GetSuffixToken());
-    if (dump_options.GetIsTruncated())
-        stream.Printf("...");
-    return true;
+  }
+  if (dump_options.GetQuote() != 0)
+    stream.Printf("%c", dump_options.GetQuote());
+  if (dump_options.GetSuffixToken() != 0)
+    stream.Printf("%s", dump_options.GetSuffixToken());
+  if (dump_options.GetIsTruncated())
+    stream.Printf("...");
+  return true;
 }
 
-lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions::ReadStringAndDumpToStreamOptions (ValueObject& valobj) :
-    ReadStringAndDumpToStreamOptions()
-{
-    SetEscapeNonPrintables(valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
+lldb_private::formatters::StringPrinter::ReadStringAndDumpToStreamOptions::
+    ReadStringAndDumpToStreamOptions(ValueObject &valobj)
+    : ReadStringAndDumpToStreamOptions() {
+  SetEscapeNonPrintables(
+      valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
 }
 
-lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::ReadBufferAndDumpToStreamOptions (ValueObject& valobj) :
-    ReadBufferAndDumpToStreamOptions()
-{
-    SetEscapeNonPrintables(valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
+lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
+    ReadBufferAndDumpToStreamOptions(ValueObject &valobj)
+    : ReadBufferAndDumpToStreamOptions() {
+  SetEscapeNonPrintables(
+      valobj.GetTargetSP()->GetDebugger().GetEscapeNonPrintables());
 }
 
-lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::ReadBufferAndDumpToStreamOptions (const ReadStringAndDumpToStreamOptions& options) :
-    ReadBufferAndDumpToStreamOptions()
-{
-    SetStream(options.GetStream());
-    SetPrefixToken(options.GetPrefixToken());
-    SetSuffixToken(options.GetSuffixToken());
-    SetQuote(options.GetQuote());
-    SetEscapeNonPrintables(options.GetEscapeNonPrintables());
-    SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
-    SetLanguage(options.GetLanguage());
+lldb_private::formatters::StringPrinter::ReadBufferAndDumpToStreamOptions::
+    ReadBufferAndDumpToStreamOptions(
+        const ReadStringAndDumpToStreamOptions &options)
+    : ReadBufferAndDumpToStreamOptions() {
+  SetStream(options.GetStream());
+  SetPrefixToken(options.GetPrefixToken());
+  SetSuffixToken(options.GetSuffixToken());
+  SetQuote(options.GetQuote());
+  SetEscapeNonPrintables(options.GetEscapeNonPrintables());
+  SetBinaryZeroIsTerminator(options.GetBinaryZeroIsTerminator());
+  SetLanguage(options.GetLanguage());
 }
 
+namespace lldb_private {
 
-namespace lldb_private
-{
-
-namespace formatters
-{
+namespace formatters {
 
 template <>
-bool
-StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::ASCII> (const ReadStringAndDumpToStreamOptions& options)
-{
-    assert(options.GetStream() && "need a Stream to print the string to");
-    Error my_error;
-
-    ProcessSP process_sp(options.GetProcessSP());
-
-    if (process_sp.get() == nullptr || options.GetLocation() == 0)
-        return false;
-
-    size_t size;
-    const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
-    bool is_truncated = false;
-
-    if (options.GetSourceSize() == 0)
-        size = max_size;
-    else if (!options.GetIgnoreMaxLength())
-    {
-        size = options.GetSourceSize();
-        if (size > max_size)
-        {
-            size = max_size;
-            is_truncated = true;
-        }
+bool StringPrinter::ReadStringAndDumpToStream<
+    StringPrinter::StringElementType::ASCII>(
+    const ReadStringAndDumpToStreamOptions &options) {
+  assert(options.GetStream() && "need a Stream to print the string to");
+  Error my_error;
+
+  ProcessSP process_sp(options.GetProcessSP());
+
+  if (process_sp.get() == nullptr || options.GetLocation() == 0)
+    return false;
+
+  size_t size;
+  const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
+  bool is_truncated = false;
+
+  if (options.GetSourceSize() == 0)
+    size = max_size;
+  else if (!options.GetIgnoreMaxLength()) {
+    size = options.GetSourceSize();
+    if (size > max_size) {
+      size = max_size;
+      is_truncated = true;
     }
-    else
-        size = options.GetSourceSize();
+  } else
+    size = options.GetSourceSize();
 
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(size,0));
+  lldb::DataBufferSP buffer_sp(new DataBufferHeap(size, 0));
 
-    process_sp->ReadCStringFromMemory(options.GetLocation(), (char*)buffer_sp->GetBytes(), size, my_error);
+  process_sp->ReadCStringFromMemory(
+      options.GetLocation(), (char *)buffer_sp->GetBytes(), size, my_error);
 
-    if (my_error.Fail())
-        return false;
+  if (my_error.Fail())
+    return false;
 
-    const char* prefix_token = options.GetPrefixToken();
-    char quote = options.GetQuote();
+  const char *prefix_token = options.GetPrefixToken();
+  char quote = options.GetQuote();
 
-    if (prefix_token != 0)
-        options.GetStream()->Printf("%s%c",prefix_token,quote);
-    else if (quote != 0)
-        options.GetStream()->Printf("%c",quote);
+  if (prefix_token != 0)
+    options.GetStream()->Printf("%s%c", prefix_token, quote);
+  else if (quote != 0)
+    options.GetStream()->Printf("%c", quote);
 
-    uint8_t* data_end = buffer_sp->GetBytes()+buffer_sp->GetByteSize();
+  uint8_t *data_end = buffer_sp->GetBytes() + buffer_sp->GetByteSize();
 
-    const bool escape_non_printables = options.GetEscapeNonPrintables();
-    lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
-    if (escape_non_printables)
-    {
-        if (Language *language = Language::FindPlugin(options.GetLanguage()))
-            escaping_callback = language->GetStringPrinterEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::ASCII);
-        else
-            escaping_callback = lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(lldb_private::formatters::StringPrinter::GetPrintableElementType::ASCII);
-    }
-    
-    // since we tend to accept partial data (and even partially malformed data)
-    // we might end up with no NULL terminator before the end_ptr
-    // hence we need to take a slower route and ensure we stay within boundaries
-    for (uint8_t* data = buffer_sp->GetBytes(); *data && (data < data_end);)
-    {
-        if (escape_non_printables)
-        {
-            uint8_t* next_data = nullptr;
-            auto printable = escaping_callback(data, data_end, next_data);
-            auto printable_bytes = printable.GetBytes();
-            auto printable_size = printable.GetSize();
-            if (!printable_bytes || !next_data)
-            {
-                // GetPrintable() failed on us - print one byte in a desperate resync attempt
-                printable_bytes = data;
-                printable_size = 1;
-                next_data = data+1;
-            }
-            for (unsigned c = 0; c < printable_size; c++)
-                options.GetStream()->Printf("%c", *(printable_bytes+c));
-            data = (uint8_t*)next_data;
-        }
-        else
-        {
-            options.GetStream()->Printf("%c",*data);
-            data++;
-        }
+  const bool escape_non_printables = options.GetEscapeNonPrintables();
+  lldb_private::formatters::StringPrinter::EscapingHelper escaping_callback;
+  if (escape_non_printables) {
+    if (Language *language = Language::FindPlugin(options.GetLanguage()))
+      escaping_callback = language->GetStringPrinterEscapingHelper(
+          lldb_private::formatters::StringPrinter::GetPrintableElementType::
+              ASCII);
+    else
+      escaping_callback =
+          lldb_private::formatters::StringPrinter::GetDefaultEscapingHelper(
+              lldb_private::formatters::StringPrinter::GetPrintableElementType::
+                  ASCII);
+  }
+
+  // since we tend to accept partial data (and even partially malformed data)
+  // we might end up with no NULL terminator before the end_ptr
+  // hence we need to take a slower route and ensure we stay within boundaries
+  for (uint8_t *data = buffer_sp->GetBytes(); *data && (data < data_end);) {
+    if (escape_non_printables) {
+      uint8_t *next_data = nullptr;
+      auto printable = escaping_callback(data, data_end, next_data);
+      auto printable_bytes = printable.GetBytes();
+      auto printable_size = printable.GetSize();
+      if (!printable_bytes || !next_data) {
+        // GetPrintable() failed on us - print one byte in a desperate resync
+        // attempt
+        printable_bytes = data;
+        printable_size = 1;
+        next_data = data + 1;
+      }
+      for (unsigned c = 0; c < printable_size; c++)
+        options.GetStream()->Printf("%c", *(printable_bytes + c));
+      data = (uint8_t *)next_data;
+    } else {
+      options.GetStream()->Printf("%c", *data);
+      data++;
     }
-    
-    const char* suffix_token = options.GetSuffixToken();
-    
-    if (suffix_token != 0)
-        options.GetStream()->Printf("%c%s",quote, suffix_token);
-    else if (quote != 0)
-        options.GetStream()->Printf("%c",quote);
-
-    if (is_truncated)
-        options.GetStream()->Printf("...");
-    
-    return true;
+  }
+
+  const char *suffix_token = options.GetSuffixToken();
+
+  if (suffix_token != 0)
+    options.GetStream()->Printf("%c%s", quote, suffix_token);
+  else if (quote != 0)
+    options.GetStream()->Printf("%c", quote);
+
+  if (is_truncated)
+    options.GetStream()->Printf("...");
+
+  return true;
 }
 
-template<typename SourceDataType>
-static bool
-ReadUTFBufferAndDumpToStream (const StringPrinter::ReadStringAndDumpToStreamOptions& options,
-                              ConversionResult (*ConvertFunction) (const SourceDataType**,
-                                                                   const SourceDataType*,
-                                                                   UTF8**,
-                                                                   UTF8*,
-                                                                   ConversionFlags))
-{
-    assert(options.GetStream() && "need a Stream to print the string to");
-
-    if (options.GetLocation() == 0 || options.GetLocation() == LLDB_INVALID_ADDRESS)
-        return false;
-
-    lldb::ProcessSP process_sp(options.GetProcessSP());
-
-    if (!process_sp)
-        return false;
-
-    const int type_width = sizeof(SourceDataType);
-    const int origin_encoding = 8 * type_width ;
-    if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
-        return false;
-    // if not UTF8, I need a conversion function to return proper UTF8
-    if (origin_encoding != 8 && !ConvertFunction)
-        return false;
-
-    if (!options.GetStream())
-        return false;
-
-    uint32_t sourceSize = options.GetSourceSize();
-    bool needs_zero_terminator = options.GetNeedsZeroTermination();
-    
-    bool is_truncated = false;
-    const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
-
-    if (!sourceSize)
-    {
-        sourceSize = max_size;
-        needs_zero_terminator = true;
-    }
-    else if (!options.GetIgnoreMaxLength())
-    {
-        if (sourceSize > max_size)
-        {
-            sourceSize = max_size;
-            is_truncated = true;
-        }
+template <typename SourceDataType>
+static bool ReadUTFBufferAndDumpToStream(
+    const StringPrinter::ReadStringAndDumpToStreamOptions &options,
+    ConversionResult (*ConvertFunction)(const SourceDataType **,
+                                        const SourceDataType *, UTF8 **, UTF8 *,
+                                        ConversionFlags)) {
+  assert(options.GetStream() && "need a Stream to print the string to");
+
+  if (options.GetLocation() == 0 ||
+      options.GetLocation() == LLDB_INVALID_ADDRESS)
+    return false;
+
+  lldb::ProcessSP process_sp(options.GetProcessSP());
+
+  if (!process_sp)
+    return false;
+
+  const int type_width = sizeof(SourceDataType);
+  const int origin_encoding = 8 * type_width;
+  if (origin_encoding != 8 && origin_encoding != 16 && origin_encoding != 32)
+    return false;
+  // if not UTF8, I need a conversion function to return proper UTF8
+  if (origin_encoding != 8 && !ConvertFunction)
+    return false;
+
+  if (!options.GetStream())
+    return false;
+
+  uint32_t sourceSize = options.GetSourceSize();
+  bool needs_zero_terminator = options.GetNeedsZeroTermination();
+
+  bool is_truncated = false;
+  const auto max_size = process_sp->GetTarget().GetMaximumSizeOfStringSummary();
+
+  if (!sourceSize) {
+    sourceSize = max_size;
+    needs_zero_terminator = true;
+  } else if (!options.GetIgnoreMaxLength()) {
+    if (sourceSize > max_size) {
+      sourceSize = max_size;
+      is_truncated = true;
     }
+  }
 
-    const int bufferSPSize = sourceSize * type_width;
+  const int bufferSPSize = sourceSize * type_width;
 
-    lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize,0));
+  lldb::DataBufferSP buffer_sp(new DataBufferHeap(bufferSPSize, 0));
 
-    if (!buffer_sp->GetBytes())
-        return false;
+  if (!buffer_sp->GetBytes())
+    return false;
 
-    Error error;
-    char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
+  Error error;
+  char *buffer = reinterpret_cast<char *>(buffer_sp->GetBytes());
 
-    if (needs_zero_terminator)
-        process_sp->ReadStringFromMemory(options.GetLocation(), buffer, bufferSPSize, error, type_width);
-    else
-        process_sp->ReadMemoryFromInferior(options.GetLocation(), (char*)buffer_sp->GetBytes(), bufferSPSize, error);
+  if (needs_zero_terminator)
+    process_sp->ReadStringFromMemory(options.GetLocation(), buffer,
+                                     bufferSPSize, error, type_width);
+  else
+    process_sp->ReadMemoryFromInferior(options.GetLocation(),
+                                       (char *)buffer_sp->GetBytes(),
+                                       bufferSPSize, error);
 
-    if (error.Fail())
-    {
-        options.GetStream()->Printf("unable to read data");
-        return true;
-    }
+  if (error.Fail()) {
+    options.GetStream()->Printf("unable to read data");
+    return true;
+  }
+
+  DataExtractor data(buffer_sp, process_sp->GetByteOrder(),
+                     process_sp->GetAddressByteSize());
 
-    DataExtractor data(buffer_sp, process_sp->GetByteOrder(), process_sp->GetAddressByteSize());
-    
-    StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options);
-    dump_options.SetData(data);
-    dump_options.SetSourceSize(sourceSize);
-    dump_options.SetIsTruncated(is_truncated);
+  StringPrinter::ReadBufferAndDumpToStreamOptions dump_options(options);
+  dump_options.SetData(data);
+  dump_options.SetSourceSize(sourceSize);
+  dump_options.SetIsTruncated(is_truncated);
 
-    return DumpUTFBufferToStream(ConvertFunction, dump_options);
+  return DumpUTFBufferToStream(ConvertFunction, dump_options);
 }
 
 template <>
-bool
-StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF8> (const ReadStringAndDumpToStreamOptions& options)
-{
-    return ReadUTFBufferAndDumpToStream<UTF8>(options,
-                                              nullptr);
+bool StringPrinter::ReadStringAndDumpToStream<
+    StringPrinter::StringElementType::UTF8>(
+    const ReadStringAndDumpToStreamOptions &options) {
+  return ReadUTFBufferAndDumpToStream<UTF8>(options, nullptr);
 }
 
 template <>
-bool
-StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF16> (const ReadStringAndDumpToStreamOptions& options)
-{
-    return ReadUTFBufferAndDumpToStream<UTF16>(options,
-                                               ConvertUTF16toUTF8);
+bool StringPrinter::ReadStringAndDumpToStream<
+    StringPrinter::StringElementType::UTF16>(
+    const ReadStringAndDumpToStreamOptions &options) {
+  return ReadUTFBufferAndDumpToStream<UTF16>(options, ConvertUTF16toUTF8);
 }
 
 template <>
-bool
-StringPrinter::ReadStringAndDumpToStream<StringPrinter::StringElementType::UTF32> (const ReadStringAndDumpToStreamOptions& options)
-{
-    return ReadUTFBufferAndDumpToStream<UTF32>(options,
-                                               ConvertUTF32toUTF8);
+bool StringPrinter::ReadStringAndDumpToStream<
+    StringPrinter::StringElementType::UTF32>(
+    const ReadStringAndDumpToStreamOptions &options) {
+  return ReadUTFBufferAndDumpToStream<UTF32>(options, ConvertUTF32toUTF8);
 }
 
 template <>
-bool
-StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF8> (const ReadBufferAndDumpToStreamOptions& options)
-{
-    assert(options.GetStream() && "need a Stream to print the string to");
+bool StringPrinter::ReadBufferAndDumpToStream<
+    StringPrinter::StringElementType::UTF8>(
+    const ReadBufferAndDumpToStreamOptions &options) {
+  assert(options.GetStream() && "need a Stream to print the string to");
 
-    return DumpUTFBufferToStream<UTF8>(nullptr, options);
+  return DumpUTFBufferToStream<UTF8>(nullptr, options);
 }
 
 template <>
-bool
-StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::ASCII> (const ReadBufferAndDumpToStreamOptions& options)
-{
-    // treat ASCII the same as UTF8
-    // FIXME: can we optimize ASCII some more?
-    return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
+bool StringPrinter::ReadBufferAndDumpToStream<
+    StringPrinter::StringElementType::ASCII>(
+    const ReadBufferAndDumpToStreamOptions &options) {
+  // treat ASCII the same as UTF8
+  // FIXME: can we optimize ASCII some more?
+  return ReadBufferAndDumpToStream<StringElementType::UTF8>(options);
 }
 
 template <>
-bool
-StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF16> (const ReadBufferAndDumpToStreamOptions& options)
-{
-    assert(options.GetStream() && "need a Stream to print the string to");
+bool StringPrinter::ReadBufferAndDumpToStream<
+    StringPrinter::StringElementType::UTF16>(
+    const ReadBufferAndDumpToStreamOptions &options) {
+  assert(options.GetStream() && "need a Stream to print the string to");
 
-    return DumpUTFBufferToStream(ConvertUTF16toUTF8, options);
+  return DumpUTFBufferToStream(ConvertUTF16toUTF8, options);
 }
 
 template <>
-bool
-StringPrinter::ReadBufferAndDumpToStream<StringPrinter::StringElementType::UTF32> (const ReadBufferAndDumpToStreamOptions& options)
-{
-    assert(options.GetStream() && "need a Stream to print the string to");
+bool StringPrinter::ReadBufferAndDumpToStream<
+    StringPrinter::StringElementType::UTF32>(
+    const ReadBufferAndDumpToStreamOptions &options) {
+  assert(options.GetStream() && "need a Stream to print the string to");
 
-    return DumpUTFBufferToStream(ConvertUTF32toUTF8, options);
+  return DumpUTFBufferToStream(ConvertUTF32toUTF8, options);
 }
 
 } // namespace formatters
diff --git a/lldb/source/DataFormatters/TypeCategory.cpp b/lldb/source/DataFormatters/TypeCategory.cpp
index 9df3ec6..5f4863a 100644
--- a/lldb/source/DataFormatters/TypeCategory.cpp
+++ b/lldb/source/DataFormatters/TypeCategory.cpp
@@ -1,4 +1,5 @@
-//===-- TypeCategory.cpp -------------------------------------------*- C++ -*-===//
+//===-- TypeCategory.cpp -------------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -18,690 +19,626 @@
 using namespace lldb;
 using namespace lldb_private;
 
-TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener *clist, ConstString name,
-                                   std::initializer_list<lldb::LanguageType> langs)
+TypeCategoryImpl::TypeCategoryImpl(
+    IFormatChangeListener *clist, ConstString name,
+    std::initializer_list<lldb::LanguageType> langs)
     : m_format_cont("format", "regex-format", clist),
       m_summary_cont("summary", "regex-summary", clist),
       m_filter_cont("filter", "regex-filter", clist),
 #ifndef LLDB_DISABLE_PYTHON
       m_synth_cont("synth", "regex-synth", clist),
 #endif
-      m_validator_cont("validator", "regex-validator", clist),
-      m_enabled(false),
-      m_change_listener(clist),
-      m_mutex(),
-      m_name(name),
-      m_languages()
-{
-    for (const lldb::LanguageType lang : langs)
-        AddLanguage(lang);
-}
-
-static bool
-IsApplicable(lldb::LanguageType category_lang,
-             lldb::LanguageType valobj_lang)
-{
-    switch (category_lang)
-    {
-            // these are not languages that LLDB would ordinarily deal with
-            // only allow an exact equality here, since we really don't know
-            // any better
-        case eLanguageTypeAda83:
-        case eLanguageTypeCobol74:
-        case eLanguageTypeCobol85:
-        case eLanguageTypeFortran77:
-        case eLanguageTypeFortran90:
-        case eLanguageTypePascal83:
-        case eLanguageTypeModula2:
-        case eLanguageTypeJava:
-        case eLanguageTypeAda95:
-        case eLanguageTypeFortran95:
-        case eLanguageTypePLI:
-        case eLanguageTypeUPC:
-        case eLanguageTypeD:
-        case eLanguageTypePython:
-            return category_lang == valobj_lang;
-            
-            // the C family, we consider it as one
-        case eLanguageTypeC89:
-        case eLanguageTypeC:
-        case eLanguageTypeC99:
-            return valobj_lang == eLanguageTypeC89 ||
-            valobj_lang == eLanguageTypeC ||
-            valobj_lang == eLanguageTypeC99;
-            
-            // ObjC knows about C and itself
-        case eLanguageTypeObjC:
-            return valobj_lang == eLanguageTypeC89 ||
-            valobj_lang == eLanguageTypeC ||
-            valobj_lang == eLanguageTypeC99 ||
-            valobj_lang == eLanguageTypeObjC;
-            
-            // C++ knows about C and C++
-        case eLanguageTypeC_plus_plus:
-            return valobj_lang == eLanguageTypeC89 ||
-            valobj_lang == eLanguageTypeC ||
-            valobj_lang == eLanguageTypeC99 ||
-            valobj_lang == eLanguageTypeC_plus_plus;
-            
-            // ObjC++ knows about C,C++,ObjC and ObjC++
-        case eLanguageTypeObjC_plus_plus:
-            return valobj_lang == eLanguageTypeC89 ||
-            valobj_lang == eLanguageTypeC ||
-            valobj_lang == eLanguageTypeC99 ||
-            valobj_lang == eLanguageTypeC_plus_plus ||
-            valobj_lang == eLanguageTypeObjC;
-            
-        default:
-        case eLanguageTypeUnknown:
-            return true;
-    }
-}
-
-bool
-TypeCategoryImpl::IsApplicable (ValueObject& valobj)
-{
-    lldb::LanguageType valobj_lang = valobj.GetObjectRuntimeLanguage();
-    for (size_t idx = 0;
-         idx < GetNumLanguages();
-         idx++)
-    {
-        const lldb::LanguageType category_lang = GetLanguageAtIndex(idx);
-        if (::IsApplicable(category_lang,valobj_lang))
-            return true;
-    }
+      m_validator_cont("validator", "regex-validator", clist), m_enabled(false),
+      m_change_listener(clist), m_mutex(), m_name(name), m_languages() {
+  for (const lldb::LanguageType lang : langs)
+    AddLanguage(lang);
+}
+
+static bool IsApplicable(lldb::LanguageType category_lang,
+                         lldb::LanguageType valobj_lang) {
+  switch (category_lang) {
+  // these are not languages that LLDB would ordinarily deal with
+  // only allow an exact equality here, since we really don't know
+  // any better
+  case eLanguageTypeAda83:
+  case eLanguageTypeCobol74:
+  case eLanguageTypeCobol85:
+  case eLanguageTypeFortran77:
+  case eLanguageTypeFortran90:
+  case eLanguageTypePascal83:
+  case eLanguageTypeModula2:
+  case eLanguageTypeJava:
+  case eLanguageTypeAda95:
+  case eLanguageTypeFortran95:
+  case eLanguageTypePLI:
+  case eLanguageTypeUPC:
+  case eLanguageTypeD:
+  case eLanguageTypePython:
+    return category_lang == valobj_lang;
+
+  // the C family, we consider it as one
+  case eLanguageTypeC89:
+  case eLanguageTypeC:
+  case eLanguageTypeC99:
+    return valobj_lang == eLanguageTypeC89 || valobj_lang == eLanguageTypeC ||
+           valobj_lang == eLanguageTypeC99;
+
+  // ObjC knows about C and itself
+  case eLanguageTypeObjC:
+    return valobj_lang == eLanguageTypeC89 || valobj_lang == eLanguageTypeC ||
+           valobj_lang == eLanguageTypeC99 || valobj_lang == eLanguageTypeObjC;
+
+  // C++ knows about C and C++
+  case eLanguageTypeC_plus_plus:
+    return valobj_lang == eLanguageTypeC89 || valobj_lang == eLanguageTypeC ||
+           valobj_lang == eLanguageTypeC99 ||
+           valobj_lang == eLanguageTypeC_plus_plus;
+
+  // ObjC++ knows about C,C++,ObjC and ObjC++
+  case eLanguageTypeObjC_plus_plus:
+    return valobj_lang == eLanguageTypeC89 || valobj_lang == eLanguageTypeC ||
+           valobj_lang == eLanguageTypeC99 ||
+           valobj_lang == eLanguageTypeC_plus_plus ||
+           valobj_lang == eLanguageTypeObjC;
+
+  default:
+  case eLanguageTypeUnknown:
+    return true;
+  }
+}
+
+bool TypeCategoryImpl::IsApplicable(ValueObject &valobj) {
+  lldb::LanguageType valobj_lang = valobj.GetObjectRuntimeLanguage();
+  for (size_t idx = 0; idx < GetNumLanguages(); idx++) {
+    const lldb::LanguageType category_lang = GetLanguageAtIndex(idx);
+    if (::IsApplicable(category_lang, valobj_lang))
+      return true;
+  }
+  return false;
+}
+
+size_t TypeCategoryImpl::GetNumLanguages() {
+  if (m_languages.empty())
+    return 1;
+  return m_languages.size();
+}
+
+lldb::LanguageType TypeCategoryImpl::GetLanguageAtIndex(size_t idx) {
+  if (m_languages.empty())
+    return lldb::eLanguageTypeUnknown;
+  return m_languages[idx];
+}
+
+void TypeCategoryImpl::AddLanguage(lldb::LanguageType lang) {
+  m_languages.push_back(lang);
+}
+
+bool TypeCategoryImpl::HasLanguage(lldb::LanguageType lang) {
+  const auto iter = std::find(m_languages.begin(), m_languages.end(), lang),
+             end = m_languages.end();
+  return (iter != end);
+}
+
+bool TypeCategoryImpl::Get(ValueObject &valobj,
+                           const FormattersMatchVector &candidates,
+                           lldb::TypeFormatImplSP &entry, uint32_t *reason) {
+  if (!IsEnabled() || !IsApplicable(valobj))
     return false;
-}
+  if (GetTypeFormatsContainer()->Get(candidates, entry, reason))
+    return true;
+  bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry, reason);
+  if (regex && reason)
+    *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+  return regex;
+}
+
+bool TypeCategoryImpl::Get(ValueObject &valobj,
+                           const FormattersMatchVector &candidates,
+                           lldb::TypeSummaryImplSP &entry, uint32_t *reason) {
+  if (!IsEnabled() || !IsApplicable(valobj))
+    return false;
+  if (GetTypeSummariesContainer()->Get(candidates, entry, reason))
+    return true;
+  bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry, reason);
+  if (regex && reason)
+    *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+  return regex;
+}
+
+bool TypeCategoryImpl::Get(ValueObject &valobj,
+                           const FormattersMatchVector &candidates,
+                           lldb::SyntheticChildrenSP &entry, uint32_t *reason) {
+  if (!IsEnabled() || !IsApplicable(valobj))
+    return false;
+  TypeFilterImpl::SharedPointer filter_sp;
+  uint32_t reason_filter = 0;
+  bool regex_filter = false;
+  // first find both Filter and Synth, and then check which is most recent
+
+  if (!GetTypeFiltersContainer()->Get(candidates, filter_sp, &reason_filter))
+    regex_filter = GetRegexTypeFiltersContainer()->Get(candidates, filter_sp,
+                                                       &reason_filter);
 
-size_t
-TypeCategoryImpl::GetNumLanguages ()
-{
-    if (m_languages.empty())
-        return 1;
-    return m_languages.size();
-}
-
-lldb::LanguageType
-TypeCategoryImpl::GetLanguageAtIndex (size_t idx)
-{
-    if (m_languages.empty())
-        return lldb::eLanguageTypeUnknown;
-    return m_languages[idx];
-}
-
-void
-TypeCategoryImpl::AddLanguage (lldb::LanguageType lang)
-{
-    m_languages.push_back(lang);
-}
-
-bool
-TypeCategoryImpl::HasLanguage (lldb::LanguageType lang)
-{
-    const auto iter = std::find(m_languages.begin(), m_languages.end(), lang),
-               end = m_languages.end();
-    return (iter != end);
-}
-
-bool
-TypeCategoryImpl::Get (ValueObject& valobj,
-                       const FormattersMatchVector& candidates,
-                       lldb::TypeFormatImplSP& entry,
-                       uint32_t* reason)
-{
-    if (!IsEnabled() || !IsApplicable(valobj))
-        return false;
-    if (GetTypeFormatsContainer()->Get(candidates, entry, reason))
-        return true;
-    bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry, reason);
-    if (regex && reason)
-        *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
-    return regex;
-}
-
-bool
-TypeCategoryImpl::Get (ValueObject& valobj,
-                       const FormattersMatchVector& candidates,
-                       lldb::TypeSummaryImplSP& entry,
-                       uint32_t* reason)
-{
-    if (!IsEnabled() || !IsApplicable(valobj))
-        return false;
-    if (GetTypeSummariesContainer()->Get(candidates, entry, reason))
-        return true;
-    bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry, reason);
-    if (regex && reason)
-        *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
-    return regex;
-}
-
-bool
-TypeCategoryImpl::Get (ValueObject& valobj,
-                       const FormattersMatchVector& candidates,
-                       lldb::SyntheticChildrenSP& entry,
-                       uint32_t* reason)
-{
-    if (!IsEnabled() || !IsApplicable(valobj))
-        return false;
-    TypeFilterImpl::SharedPointer filter_sp;
-    uint32_t reason_filter = 0;
-    bool regex_filter = false;
-    // first find both Filter and Synth, and then check which is most recent
-    
-    if (!GetTypeFiltersContainer()->Get(candidates, filter_sp, &reason_filter))
-        regex_filter = GetRegexTypeFiltersContainer()->Get (candidates, filter_sp, &reason_filter);
-    
 #ifndef LLDB_DISABLE_PYTHON
-    bool regex_synth = false;
-    uint32_t reason_synth = 0;
-    bool pick_synth = false;
-    ScriptedSyntheticChildren::SharedPointer synth;
-    if (!GetTypeSyntheticsContainer()->Get(candidates, synth, &reason_synth))
-        regex_synth = GetRegexTypeSyntheticsContainer()->Get (candidates, synth, &reason_synth);
-    if (!filter_sp.get() && !synth.get())
-        return false;
-    else if (!filter_sp.get() && synth.get())
-        pick_synth = true;
-    
-    else if (filter_sp.get() && !synth.get())
-        pick_synth = false;
-    
-    else /*if (filter_sp.get() && synth.get())*/
-    {
-        if (filter_sp->GetRevision() > synth->GetRevision())
-            pick_synth = false;
-        else
-            pick_synth = true;
-    }
-    if (pick_synth)
-    {
-        if (regex_synth && reason)
-            *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
-        entry = synth;
-        return true;
-    }
+  bool regex_synth = false;
+  uint32_t reason_synth = 0;
+  bool pick_synth = false;
+  ScriptedSyntheticChildren::SharedPointer synth;
+  if (!GetTypeSyntheticsContainer()->Get(candidates, synth, &reason_synth))
+    regex_synth = GetRegexTypeSyntheticsContainer()->Get(candidates, synth,
+                                                         &reason_synth);
+  if (!filter_sp.get() && !synth.get())
+    return false;
+  else if (!filter_sp.get() && synth.get())
+    pick_synth = true;
+
+  else if (filter_sp.get() && !synth.get())
+    pick_synth = false;
+
+  else /*if (filter_sp.get() && synth.get())*/
+  {
+    if (filter_sp->GetRevision() > synth->GetRevision())
+      pick_synth = false;
     else
-    {
-        if (regex_filter && reason)
-            *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
-        entry = filter_sp;
-        return true;
-    }
-    
+      pick_synth = true;
+  }
+  if (pick_synth) {
+    if (regex_synth && reason)
+      *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
+    entry = synth;
+    return true;
+  } else {
+    if (regex_filter && reason)
+      *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
+    entry = filter_sp;
+    return true;
+  }
+
 #else
-    if (filter_sp)
-    {
-        entry = filter_sp;
-        return true;
-    }
+  if (filter_sp) {
+    entry = filter_sp;
+    return true;
+  }
 #endif
-    
-    return false;
+
+  return false;
 }
 
-bool
-TypeCategoryImpl::Get (ValueObject& valobj,
-                       const FormattersMatchVector& candidates,
-                       lldb::TypeValidatorImplSP& entry,
-                       uint32_t* reason)
-{
-    if (!IsEnabled())
-        return false;
-    if (GetTypeValidatorsContainer()->Get(candidates, entry, reason))
-        return true;
-    bool regex = GetRegexTypeValidatorsContainer()->Get(candidates, entry, reason);
-    if (regex && reason)
-        *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
-    return regex;
-}
-
-void
-TypeCategoryImpl::Clear (FormatCategoryItems items)
-{
-    if ( (items & eFormatCategoryItemValue)  == eFormatCategoryItemValue )
-        GetTypeFormatsContainer()->Clear();
-    if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        GetRegexTypeFormatsContainer()->Clear();
-
-    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        GetTypeSummariesContainer()->Clear();
-    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        GetRegexTypeSummariesContainer()->Clear();
-
-    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        GetTypeFiltersContainer()->Clear();
-    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        GetRegexTypeFiltersContainer()->Clear();
+bool TypeCategoryImpl::Get(ValueObject &valobj,
+                           const FormattersMatchVector &candidates,
+                           lldb::TypeValidatorImplSP &entry, uint32_t *reason) {
+  if (!IsEnabled())
+    return false;
+  if (GetTypeValidatorsContainer()->Get(candidates, entry, reason))
+    return true;
+  bool regex =
+      GetRegexTypeValidatorsContainer()->Get(candidates, entry, reason);
+  if (regex && reason)
+    *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+  return regex;
+}
+
+void TypeCategoryImpl::Clear(FormatCategoryItems items) {
+  if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue)
+    GetTypeFormatsContainer()->Clear();
+  if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
+    GetRegexTypeFormatsContainer()->Clear();
+
+  if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary)
+    GetTypeSummariesContainer()->Clear();
+  if ((items & eFormatCategoryItemRegexSummary) ==
+      eFormatCategoryItemRegexSummary)
+    GetRegexTypeSummariesContainer()->Clear();
+
+  if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter)
+    GetTypeFiltersContainer()->Clear();
+  if ((items & eFormatCategoryItemRegexFilter) ==
+      eFormatCategoryItemRegexFilter)
+    GetRegexTypeFiltersContainer()->Clear();
 
 #ifndef LLDB_DISABLE_PYTHON
-    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        GetTypeSyntheticsContainer()->Clear();
-    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        GetRegexTypeSyntheticsContainer()->Clear();
+  if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
+    GetTypeSyntheticsContainer()->Clear();
+  if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
+    GetRegexTypeSyntheticsContainer()->Clear();
 #endif
-    
-    if ( (items & eFormatCategoryItemValidator)  == eFormatCategoryItemValidator )
-        GetTypeValidatorsContainer()->Clear();
-    if ( (items & eFormatCategoryItemRegexValidator) == eFormatCategoryItemRegexValidator )
-        GetRegexTypeValidatorsContainer()->Clear();
-}
-
-bool
-TypeCategoryImpl::Delete (ConstString name,
-                          FormatCategoryItems items)
-{
-    bool success = false;
-    
-    if ( (items & eFormatCategoryItemValue)  == eFormatCategoryItemValue )
-        success = GetTypeFormatsContainer()->Delete(name) || success;
-    if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        success = GetRegexTypeFormatsContainer()->Delete(name) || success;
-
-    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        success = GetTypeSummariesContainer()->Delete(name) || success;
-    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        success = GetRegexTypeSummariesContainer()->Delete(name) || success;
-
-    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        success = GetTypeFiltersContainer()->Delete(name) || success;
-    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        success = GetRegexTypeFiltersContainer()->Delete(name) || success;
+
+  if ((items & eFormatCategoryItemValidator) == eFormatCategoryItemValidator)
+    GetTypeValidatorsContainer()->Clear();
+  if ((items & eFormatCategoryItemRegexValidator) ==
+      eFormatCategoryItemRegexValidator)
+    GetRegexTypeValidatorsContainer()->Clear();
+}
+
+bool TypeCategoryImpl::Delete(ConstString name, FormatCategoryItems items) {
+  bool success = false;
+
+  if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue)
+    success = GetTypeFormatsContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
+    success = GetRegexTypeFormatsContainer()->Delete(name) || success;
+
+  if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary)
+    success = GetTypeSummariesContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemRegexSummary) ==
+      eFormatCategoryItemRegexSummary)
+    success = GetRegexTypeSummariesContainer()->Delete(name) || success;
+
+  if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter)
+    success = GetTypeFiltersContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemRegexFilter) ==
+      eFormatCategoryItemRegexFilter)
+    success = GetRegexTypeFiltersContainer()->Delete(name) || success;
 
 #ifndef LLDB_DISABLE_PYTHON
-    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        success = GetTypeSyntheticsContainer()->Delete(name) || success;
-    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        success = GetRegexTypeSyntheticsContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
+    success = GetTypeSyntheticsContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
+    success = GetRegexTypeSyntheticsContainer()->Delete(name) || success;
 #endif
-    
-    if ( (items & eFormatCategoryItemValidator)  == eFormatCategoryItemValidator )
-        success = GetTypeValidatorsContainer()->Delete(name) || success;
-    if ( (items & eFormatCategoryItemRegexValidator) == eFormatCategoryItemRegexValidator )
-        success = GetRegexTypeValidatorsContainer()->Delete(name) || success;
-    
-    return success;
-}
-
-uint32_t
-TypeCategoryImpl::GetCount (FormatCategoryItems items)
-{
-    uint32_t count = 0;
-
-    if ( (items & eFormatCategoryItemValue) == eFormatCategoryItemValue )
-        count += GetTypeFormatsContainer()->GetCount();
-    if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-        count += GetRegexTypeFormatsContainer()->GetCount();
-    
-    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-        count += GetTypeSummariesContainer()->GetCount();
-    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-        count += GetRegexTypeSummariesContainer()->GetCount();
-
-    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-        count += GetTypeFiltersContainer()->GetCount();
-    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-        count += GetRegexTypeFiltersContainer()->GetCount();
+
+  if ((items & eFormatCategoryItemValidator) == eFormatCategoryItemValidator)
+    success = GetTypeValidatorsContainer()->Delete(name) || success;
+  if ((items & eFormatCategoryItemRegexValidator) ==
+      eFormatCategoryItemRegexValidator)
+    success = GetRegexTypeValidatorsContainer()->Delete(name) || success;
+
+  return success;
+}
+
+uint32_t TypeCategoryImpl::GetCount(FormatCategoryItems items) {
+  uint32_t count = 0;
+
+  if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue)
+    count += GetTypeFormatsContainer()->GetCount();
+  if ((items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue)
+    count += GetRegexTypeFormatsContainer()->GetCount();
+
+  if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary)
+    count += GetTypeSummariesContainer()->GetCount();
+  if ((items & eFormatCategoryItemRegexSummary) ==
+      eFormatCategoryItemRegexSummary)
+    count += GetRegexTypeSummariesContainer()->GetCount();
+
+  if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter)
+    count += GetTypeFiltersContainer()->GetCount();
+  if ((items & eFormatCategoryItemRegexFilter) ==
+      eFormatCategoryItemRegexFilter)
+    count += GetRegexTypeFiltersContainer()->GetCount();
 
 #ifndef LLDB_DISABLE_PYTHON
-    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-        count += GetTypeSyntheticsContainer()->GetCount();
-    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-        count += GetRegexTypeSyntheticsContainer()->GetCount();
+  if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
+    count += GetTypeSyntheticsContainer()->GetCount();
+  if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
+    count += GetRegexTypeSyntheticsContainer()->GetCount();
 #endif
-    
-    if ( (items & eFormatCategoryItemValidator)  == eFormatCategoryItemValidator )
-        count += GetTypeValidatorsContainer()->GetCount();
-    if ( (items & eFormatCategoryItemRegexValidator) == eFormatCategoryItemRegexValidator )
-        count += GetRegexTypeValidatorsContainer()->GetCount();
-    
-    return count;
-}
-
-bool
-TypeCategoryImpl::AnyMatches(ConstString type_name,
-                             FormatCategoryItems items,
-                             bool only_enabled,
-                             const char** matching_category,
-                             FormatCategoryItems* matching_type)
-{
-    if (!IsEnabled() && only_enabled)
-        return false;
-    
-    lldb::TypeFormatImplSP format_sp;
-    lldb::TypeSummaryImplSP summary_sp;
-    TypeFilterImpl::SharedPointer filter_sp;
+
+  if ((items & eFormatCategoryItemValidator) == eFormatCategoryItemValidator)
+    count += GetTypeValidatorsContainer()->GetCount();
+  if ((items & eFormatCategoryItemRegexValidator) ==
+      eFormatCategoryItemRegexValidator)
+    count += GetRegexTypeValidatorsContainer()->GetCount();
+
+  return count;
+}
+
+bool TypeCategoryImpl::AnyMatches(ConstString type_name,
+                                  FormatCategoryItems items, bool only_enabled,
+                                  const char **matching_category,
+                                  FormatCategoryItems *matching_type) {
+  if (!IsEnabled() && only_enabled)
+    return false;
+
+  lldb::TypeFormatImplSP format_sp;
+  lldb::TypeSummaryImplSP summary_sp;
+  TypeFilterImpl::SharedPointer filter_sp;
 #ifndef LLDB_DISABLE_PYTHON
-    ScriptedSyntheticChildren::SharedPointer synth_sp;
+  ScriptedSyntheticChildren::SharedPointer synth_sp;
 #endif
-    TypeValidatorImpl::SharedPointer validator_sp;
-    
-    if ( (items & eFormatCategoryItemValue) == eFormatCategoryItemValue )
-    {
-        if (GetTypeFormatsContainer()->Get(type_name, format_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemValue;
-            return true;
-        }
+  TypeValidatorImpl::SharedPointer validator_sp;
+
+  if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue) {
+    if (GetTypeFormatsContainer()->Get(type_name, format_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemValue;
+      return true;
     }
-    if ( (items & eFormatCategoryItemRegexValue) == eFormatCategoryItemRegexValue )
-    {
-        if (GetRegexTypeFormatsContainer()->Get(type_name, format_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemRegexValue;
-            return true;
-        }
+  }
+  if ((items & eFormatCategoryItemRegexValue) ==
+      eFormatCategoryItemRegexValue) {
+    if (GetRegexTypeFormatsContainer()->Get(type_name, format_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemRegexValue;
+      return true;
     }
-    
-    if ( (items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary )
-    {
-        if (GetTypeSummariesContainer()->Get(type_name, summary_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemSummary;
-            return true;
-        }
+  }
+
+  if ((items & eFormatCategoryItemSummary) == eFormatCategoryItemSummary) {
+    if (GetTypeSummariesContainer()->Get(type_name, summary_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemSummary;
+      return true;
     }
-    if ( (items & eFormatCategoryItemRegexSummary) == eFormatCategoryItemRegexSummary )
-    {
-        if (GetRegexTypeSummariesContainer()->Get(type_name, summary_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemRegexSummary;
-            return true;
-        }
+  }
+  if ((items & eFormatCategoryItemRegexSummary) ==
+      eFormatCategoryItemRegexSummary) {
+    if (GetRegexTypeSummariesContainer()->Get(type_name, summary_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemRegexSummary;
+      return true;
     }
-    
-    if ( (items & eFormatCategoryItemFilter)  == eFormatCategoryItemFilter )
-    {
-        if (GetTypeFiltersContainer()->Get(type_name, filter_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemFilter;
-            return true;
-        }
+  }
+
+  if ((items & eFormatCategoryItemFilter) == eFormatCategoryItemFilter) {
+    if (GetTypeFiltersContainer()->Get(type_name, filter_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemFilter;
+      return true;
     }
-    if ( (items & eFormatCategoryItemRegexFilter) == eFormatCategoryItemRegexFilter )
-    {
-        if (GetRegexTypeFiltersContainer()->Get(type_name, filter_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemRegexFilter;
-            return true;
-        }
+  }
+  if ((items & eFormatCategoryItemRegexFilter) ==
+      eFormatCategoryItemRegexFilter) {
+    if (GetRegexTypeFiltersContainer()->Get(type_name, filter_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemRegexFilter;
+      return true;
     }
-    
+  }
+
 #ifndef LLDB_DISABLE_PYTHON
-    if ( (items & eFormatCategoryItemSynth)  == eFormatCategoryItemSynth )
-    {
-        if (GetTypeSyntheticsContainer()->Get(type_name, synth_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemSynth;
-            return true;
-        }
+  if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth) {
+    if (GetTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemSynth;
+      return true;
     }
-    if ( (items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth )
-    {
-        if (GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemRegexSynth;
-            return true;
-        }
+  }
+  if ((items & eFormatCategoryItemRegexSynth) ==
+      eFormatCategoryItemRegexSynth) {
+    if (GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemRegexSynth;
+      return true;
     }
+  }
 #endif
-    
-    if ( (items & eFormatCategoryItemValidator)  == eFormatCategoryItemValidator )
-    {
-        if (GetTypeValidatorsContainer()->Get(type_name, validator_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemValidator;
-            return true;
-        }
+
+  if ((items & eFormatCategoryItemValidator) == eFormatCategoryItemValidator) {
+    if (GetTypeValidatorsContainer()->Get(type_name, validator_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemValidator;
+      return true;
     }
-    if ( (items & eFormatCategoryItemRegexValidator) == eFormatCategoryItemRegexValidator )
-    {
-        if (GetRegexTypeValidatorsContainer()->Get(type_name, validator_sp))
-        {
-            if (matching_category)
-                *matching_category = m_name.GetCString();
-            if (matching_type)
-                *matching_type = eFormatCategoryItemRegexValidator;
-            return true;
-        }
+  }
+  if ((items & eFormatCategoryItemRegexValidator) ==
+      eFormatCategoryItemRegexValidator) {
+    if (GetRegexTypeValidatorsContainer()->Get(type_name, validator_sp)) {
+      if (matching_category)
+        *matching_category = m_name.GetCString();
+      if (matching_type)
+        *matching_type = eFormatCategoryItemRegexValidator;
+      return true;
     }
-    
-    return false;
+  }
+
+  return false;
 }
 
 TypeCategoryImpl::FormatContainer::MapValueType
-TypeCategoryImpl::GetFormatForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    FormatContainer::MapValueType retval;
-    
-    if (type_sp)
-    {
-        if (type_sp->IsRegex())
-            GetRegexTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-        else
-            GetTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-    }
-    
-    return retval;
+TypeCategoryImpl::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  FormatContainer::MapValueType retval;
+
+  if (type_sp) {
+    if (type_sp->IsRegex())
+      GetRegexTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
+                                               retval);
+    else
+      GetTypeFormatsContainer()->GetExact(ConstString(type_sp->GetName()),
+                                          retval);
+  }
+
+  return retval;
 }
 
 TypeCategoryImpl::SummaryContainer::MapValueType
-TypeCategoryImpl::GetSummaryForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    SummaryContainer::MapValueType retval;
-    
-    if (type_sp)
-    {
-        if (type_sp->IsRegex())
-            GetRegexTypeSummariesContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-        else
-            GetTypeSummariesContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-    }
-    
-    return retval;
+TypeCategoryImpl::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  SummaryContainer::MapValueType retval;
+
+  if (type_sp) {
+    if (type_sp->IsRegex())
+      GetRegexTypeSummariesContainer()->GetExact(
+          ConstString(type_sp->GetName()), retval);
+    else
+      GetTypeSummariesContainer()->GetExact(ConstString(type_sp->GetName()),
+                                            retval);
+  }
+
+  return retval;
 }
 
 TypeCategoryImpl::FilterContainer::MapValueType
-TypeCategoryImpl::GetFilterForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    FilterContainer::MapValueType retval;
-    
-    if (type_sp)
-    {
-        if (type_sp->IsRegex())
-            GetRegexTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-        else
-            GetTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-    }
-    
-    return retval;
+TypeCategoryImpl::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  FilterContainer::MapValueType retval;
+
+  if (type_sp) {
+    if (type_sp->IsRegex())
+      GetRegexTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
+                                               retval);
+    else
+      GetTypeFiltersContainer()->GetExact(ConstString(type_sp->GetName()),
+                                          retval);
+  }
+
+  return retval;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 TypeCategoryImpl::SynthContainer::MapValueType
-TypeCategoryImpl::GetSyntheticForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    SynthContainer::MapValueType retval;
-    
-    if (type_sp)
-    {
-        if (type_sp->IsRegex())
-            GetRegexTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-        else
-            GetTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-    }
-    
-    return retval;
+TypeCategoryImpl::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  SynthContainer::MapValueType retval;
+
+  if (type_sp) {
+    if (type_sp->IsRegex())
+      GetRegexTypeSyntheticsContainer()->GetExact(
+          ConstString(type_sp->GetName()), retval);
+    else
+      GetTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),
+                                             retval);
+  }
+
+  return retval;
 }
 #endif
 
 TypeCategoryImpl::ValidatorContainer::MapValueType
-TypeCategoryImpl::GetValidatorForType (lldb::TypeNameSpecifierImplSP type_sp)
-{
-    ValidatorContainer::MapValueType retval;
-    
-    if (type_sp)
-    {
-        if (type_sp->IsRegex())
-            GetRegexTypeValidatorsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-        else
-            GetTypeValidatorsContainer()->GetExact(ConstString(type_sp->GetName()),retval);
-    }
-    
-    return retval;
+TypeCategoryImpl::GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp) {
+  ValidatorContainer::MapValueType retval;
+
+  if (type_sp) {
+    if (type_sp->IsRegex())
+      GetRegexTypeValidatorsContainer()->GetExact(
+          ConstString(type_sp->GetName()), retval);
+    else
+      GetTypeValidatorsContainer()->GetExact(ConstString(type_sp->GetName()),
+                                             retval);
+  }
+
+  return retval;
 }
 
 lldb::TypeNameSpecifierImplSP
-TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex (size_t index)
-{
-    if (index < GetTypeSummariesContainer()->GetCount())
-        return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index);
-    else
-        return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index-GetTypeSummariesContainer()->GetCount());
+TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex(size_t index) {
+  if (index < GetTypeSummariesContainer()->GetCount())
+    return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index);
+  else
+    return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(
+        index - GetTypeSummariesContainer()->GetCount());
 }
 
 TypeCategoryImpl::FormatContainer::MapValueType
-TypeCategoryImpl::GetFormatAtIndex (size_t index)
-{
-    if (index < GetTypeFormatsContainer()->GetCount())
-        return GetTypeFormatsContainer()->GetAtIndex(index);
-    else
-        return GetRegexTypeFormatsContainer()->GetAtIndex(index-GetTypeFormatsContainer()->GetCount());
+TypeCategoryImpl::GetFormatAtIndex(size_t index) {
+  if (index < GetTypeFormatsContainer()->GetCount())
+    return GetTypeFormatsContainer()->GetAtIndex(index);
+  else
+    return GetRegexTypeFormatsContainer()->GetAtIndex(
+        index - GetTypeFormatsContainer()->GetCount());
 }
 
 TypeCategoryImpl::SummaryContainer::MapValueType
-TypeCategoryImpl::GetSummaryAtIndex (size_t index)
-{
-    if (index < GetTypeSummariesContainer()->GetCount())
-        return GetTypeSummariesContainer()->GetAtIndex(index);
-    else
-        return GetRegexTypeSummariesContainer()->GetAtIndex(index-GetTypeSummariesContainer()->GetCount());
+TypeCategoryImpl::GetSummaryAtIndex(size_t index) {
+  if (index < GetTypeSummariesContainer()->GetCount())
+    return GetTypeSummariesContainer()->GetAtIndex(index);
+  else
+    return GetRegexTypeSummariesContainer()->GetAtIndex(
+        index - GetTypeSummariesContainer()->GetCount());
 }
 
 TypeCategoryImpl::FilterContainer::MapValueType
-TypeCategoryImpl::GetFilterAtIndex (size_t index)
-{
-    if (index < GetTypeFiltersContainer()->GetCount())
-        return GetTypeFiltersContainer()->GetAtIndex(index);
-    else
-        return GetRegexTypeFiltersContainer()->GetAtIndex(index-GetTypeFiltersContainer()->GetCount());
+TypeCategoryImpl::GetFilterAtIndex(size_t index) {
+  if (index < GetTypeFiltersContainer()->GetCount())
+    return GetTypeFiltersContainer()->GetAtIndex(index);
+  else
+    return GetRegexTypeFiltersContainer()->GetAtIndex(
+        index - GetTypeFiltersContainer()->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
-TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex (size_t index)
-{
-    if (index < GetTypeFormatsContainer()->GetCount())
-        return GetTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index);
-    else
-        return GetRegexTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index-GetTypeFormatsContainer()->GetCount());
+TypeCategoryImpl::GetTypeNameSpecifierForFormatAtIndex(size_t index) {
+  if (index < GetTypeFormatsContainer()->GetCount())
+    return GetTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(index);
+  else
+    return GetRegexTypeFormatsContainer()->GetTypeNameSpecifierAtIndex(
+        index - GetTypeFormatsContainer()->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
-TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex (size_t index)
-{
-    if (index < GetTypeFiltersContainer()->GetCount())
-        return GetTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index);
-    else
-        return GetRegexTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index-GetTypeFiltersContainer()->GetCount());
+TypeCategoryImpl::GetTypeNameSpecifierForFilterAtIndex(size_t index) {
+  if (index < GetTypeFiltersContainer()->GetCount())
+    return GetTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(index);
+  else
+    return GetRegexTypeFiltersContainer()->GetTypeNameSpecifierAtIndex(
+        index - GetTypeFiltersContainer()->GetCount());
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 TypeCategoryImpl::SynthContainer::MapValueType
-TypeCategoryImpl::GetSyntheticAtIndex (size_t index)
-{
-    if (index < GetTypeSyntheticsContainer()->GetCount())
-        return GetTypeSyntheticsContainer()->GetAtIndex(index);
-    else
-        return GetRegexTypeSyntheticsContainer()->GetAtIndex(index-GetTypeSyntheticsContainer()->GetCount());
+TypeCategoryImpl::GetSyntheticAtIndex(size_t index) {
+  if (index < GetTypeSyntheticsContainer()->GetCount())
+    return GetTypeSyntheticsContainer()->GetAtIndex(index);
+  else
+    return GetRegexTypeSyntheticsContainer()->GetAtIndex(
+        index - GetTypeSyntheticsContainer()->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
-TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex (size_t index)
-{
-    if (index < GetTypeSyntheticsContainer()->GetCount())
-        return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index);
-    else
-        return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index - GetTypeSyntheticsContainer()->GetCount());
+TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex(size_t index) {
+  if (index < GetTypeSyntheticsContainer()->GetCount())
+    return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index);
+  else
+    return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(
+        index - GetTypeSyntheticsContainer()->GetCount());
 }
 #endif
 
 TypeCategoryImpl::ValidatorContainer::MapValueType
-TypeCategoryImpl::GetValidatorAtIndex (size_t index)
-{
-    if (index < GetTypeValidatorsContainer()->GetCount())
-        return GetTypeValidatorsContainer()->GetAtIndex(index);
-    else
-        return GetRegexTypeValidatorsContainer()->GetAtIndex(index-GetTypeValidatorsContainer()->GetCount());
+TypeCategoryImpl::GetValidatorAtIndex(size_t index) {
+  if (index < GetTypeValidatorsContainer()->GetCount())
+    return GetTypeValidatorsContainer()->GetAtIndex(index);
+  else
+    return GetRegexTypeValidatorsContainer()->GetAtIndex(
+        index - GetTypeValidatorsContainer()->GetCount());
 }
 
 lldb::TypeNameSpecifierImplSP
-TypeCategoryImpl::GetTypeNameSpecifierForValidatorAtIndex (size_t index)
-{
-    if (index < GetTypeValidatorsContainer()->GetCount())
-        return GetTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index);
-    else
-        return GetRegexTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index - GetTypeValidatorsContainer()->GetCount());
-}
-
-void
-TypeCategoryImpl::Enable (bool value, uint32_t position)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_mutex);
-    if ( (m_enabled = value) )
-        m_enabled_position = position;
-    if (m_change_listener)
-        m_change_listener->Changed();
-}
-
-std::string
-TypeCategoryImpl::GetDescription ()
-{
-    StreamString stream;
-    stream.Printf("%s (%s",
-                  GetName(),
-                  (IsEnabled() ? "enabled" : "disabled"));
-    StreamString lang_stream;
-    lang_stream.Printf(", applicable for language(s): ");
-    bool print_lang = false;
-    for (size_t idx = 0;
-         idx < GetNumLanguages();
-         idx++)
-    {
-        const lldb::LanguageType lang = GetLanguageAtIndex(idx);
-        if (lang != lldb::eLanguageTypeUnknown)
-            print_lang = true;
-        lang_stream.Printf("%s%s",
-                           Language::GetNameForLanguageType(lang),
-                           idx+1<GetNumLanguages() ? ", " : "");
-    }
-    if (print_lang)
-        stream.Printf("%s",lang_stream.GetData());
-    stream.PutChar(')');
-    return stream.GetData();
+TypeCategoryImpl::GetTypeNameSpecifierForValidatorAtIndex(size_t index) {
+  if (index < GetTypeValidatorsContainer()->GetCount())
+    return GetTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(index);
+  else
+    return GetRegexTypeValidatorsContainer()->GetTypeNameSpecifierAtIndex(
+        index - GetTypeValidatorsContainer()->GetCount());
+}
+
+void TypeCategoryImpl::Enable(bool value, uint32_t position) {
+  std::lock_guard<std::recursive_mutex> guard(m_mutex);
+  if ((m_enabled = value))
+    m_enabled_position = position;
+  if (m_change_listener)
+    m_change_listener->Changed();
+}
+
+std::string TypeCategoryImpl::GetDescription() {
+  StreamString stream;
+  stream.Printf("%s (%s", GetName(), (IsEnabled() ? "enabled" : "disabled"));
+  StreamString lang_stream;
+  lang_stream.Printf(", applicable for language(s): ");
+  bool print_lang = false;
+  for (size_t idx = 0; idx < GetNumLanguages(); idx++) {
+    const lldb::LanguageType lang = GetLanguageAtIndex(idx);
+    if (lang != lldb::eLanguageTypeUnknown)
+      print_lang = true;
+    lang_stream.Printf("%s%s", Language::GetNameForLanguageType(lang),
+                       idx + 1 < GetNumLanguages() ? ", " : "");
+  }
+  if (print_lang)
+    stream.Printf("%s", lang_stream.GetData());
+  stream.PutChar(')');
+  return stream.GetData();
 }
diff --git a/lldb/source/DataFormatters/TypeCategoryMap.cpp b/lldb/source/DataFormatters/TypeCategoryMap.cpp
index fc28783..cc85288 100644
--- a/lldb/source/DataFormatters/TypeCategoryMap.cpp
+++ b/lldb/source/DataFormatters/TypeCategoryMap.cpp
@@ -1,4 +1,5 @@
-//===-- TypeCategoryMap.cpp ----------------------------------------*- C++ -*-===//
+//===-- TypeCategoryMap.cpp ----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -21,401 +22,361 @@ using namespace lldb;
 using namespace lldb_private;
 
 TypeCategoryMap::TypeCategoryMap(IFormatChangeListener *lst)
-    : m_map_mutex(), listener(lst), m_map(), m_active_categories()
-{
-    ConstString default_cs("default");
-    lldb::TypeCategoryImplSP default_sp = lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
-    Add(default_cs, default_sp);
-    Enable(default_cs, First);
+    : m_map_mutex(), listener(lst), m_map(), m_active_categories() {
+  ConstString default_cs("default");
+  lldb::TypeCategoryImplSP default_sp =
+      lldb::TypeCategoryImplSP(new TypeCategoryImpl(listener, default_cs));
+  Add(default_cs, default_sp);
+  Enable(default_cs, First);
 }
 
-void
-TypeCategoryMap::Add (KeyType name, const ValueSP& entry)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    m_map[name] = entry;
-    if (listener)
-        listener->Changed();
-}
-
-bool
-TypeCategoryMap::Delete (KeyType name)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    MapIterator iter = m_map.find(name);
-    if (iter == m_map.end())
-        return false;
-    m_map.erase(name);
-    Disable(name);
-    if (listener)
-        listener->Changed();
-    return true;
+void TypeCategoryMap::Add(KeyType name, const ValueSP &entry) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  m_map[name] = entry;
+  if (listener)
+    listener->Changed();
 }
 
-bool
-TypeCategoryMap::Enable (KeyType category_name, Position pos)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    ValueSP category;
-    if (!Get(category_name,category))
-        return false;
-    return Enable(category, pos);
+bool TypeCategoryMap::Delete(KeyType name) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  MapIterator iter = m_map.find(name);
+  if (iter == m_map.end())
+    return false;
+  m_map.erase(name);
+  Disable(name);
+  if (listener)
+    listener->Changed();
+  return true;
 }
 
-bool
-TypeCategoryMap::Disable (KeyType category_name)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    ValueSP category;
-    if (!Get(category_name,category))
-        return false;
-    return Disable(category);
+bool TypeCategoryMap::Enable(KeyType category_name, Position pos) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  ValueSP category;
+  if (!Get(category_name, category))
+    return false;
+  return Enable(category, pos);
 }
 
-bool
-TypeCategoryMap::Enable (ValueSP category, Position pos)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    if (category.get())
-    {
-        Position pos_w = pos;
-        if (pos == First || m_active_categories.size() == 0)
-            m_active_categories.push_front(category);
-        else if (pos == Last || pos == m_active_categories.size())
-            m_active_categories.push_back(category);
-        else if (pos < m_active_categories.size())
-        {
-            ActiveCategoriesList::iterator iter = m_active_categories.begin();
-            while (pos_w)
-            {
-                pos_w--,iter++;
-            }
-            m_active_categories.insert(iter,category);
-        }
-        else
-            return false;
-        category->Enable(true,
-                         pos);
-        return true;
-    }
+bool TypeCategoryMap::Disable(KeyType category_name) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  ValueSP category;
+  if (!Get(category_name, category))
     return false;
+  return Disable(category);
 }
 
-bool
-TypeCategoryMap::Disable (ValueSP category)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    if (category.get())
-    {
-        m_active_categories.remove_if(delete_matching_categories(category));
-        category->Disable();
-        return true;
-    }
-    return false;
+bool TypeCategoryMap::Enable(ValueSP category, Position pos) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  if (category.get()) {
+    Position pos_w = pos;
+    if (pos == First || m_active_categories.size() == 0)
+      m_active_categories.push_front(category);
+    else if (pos == Last || pos == m_active_categories.size())
+      m_active_categories.push_back(category);
+    else if (pos < m_active_categories.size()) {
+      ActiveCategoriesList::iterator iter = m_active_categories.begin();
+      while (pos_w) {
+        pos_w--, iter++;
+      }
+      m_active_categories.insert(iter, category);
+    } else
+      return false;
+    category->Enable(true, pos);
+    return true;
+  }
+  return false;
 }
 
-void
-TypeCategoryMap::EnableAllCategories ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    std::vector<ValueSP> sorted_categories(m_map.size(), ValueSP());
-    MapType::iterator iter = m_map.begin(), end = m_map.end();
-    for (; iter != end; ++iter)
-    {
-        if (iter->second->IsEnabled())
-            continue;
-        auto pos = iter->second->GetLastEnabledPosition();
-        if (pos >= sorted_categories.size())
-        {
-            auto iter = std::find_if(sorted_categories.begin(),
-                                     sorted_categories.end(),
-                                     [] (const ValueSP& sp) -> bool {
-                                         return sp.get() == nullptr;
-                                     });
-            pos = std::distance(sorted_categories.begin(), iter);
-        }
-        sorted_categories.at(pos) = iter->second;
-    }
-    decltype(sorted_categories)::iterator viter = sorted_categories.begin(), vend = sorted_categories.end();
-    for (; viter != vend; viter++)
-        if (viter->get())
-            Enable(*viter, Last);
+bool TypeCategoryMap::Disable(ValueSP category) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  if (category.get()) {
+    m_active_categories.remove_if(delete_matching_categories(category));
+    category->Disable();
+    return true;
+  }
+  return false;
 }
 
-void
-TypeCategoryMap::DisableAllCategories ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    Position p = First;
-    for (; false == m_active_categories.empty(); p++)
-    {
-        m_active_categories.front()->SetEnabledPosition(p);
-        Disable(m_active_categories.front());
+void TypeCategoryMap::EnableAllCategories() {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  std::vector<ValueSP> sorted_categories(m_map.size(), ValueSP());
+  MapType::iterator iter = m_map.begin(), end = m_map.end();
+  for (; iter != end; ++iter) {
+    if (iter->second->IsEnabled())
+      continue;
+    auto pos = iter->second->GetLastEnabledPosition();
+    if (pos >= sorted_categories.size()) {
+      auto iter = std::find_if(
+          sorted_categories.begin(), sorted_categories.end(),
+          [](const ValueSP &sp) -> bool { return sp.get() == nullptr; });
+      pos = std::distance(sorted_categories.begin(), iter);
     }
+    sorted_categories.at(pos) = iter->second;
+  }
+  decltype(sorted_categories)::iterator viter = sorted_categories.begin(),
+                                        vend = sorted_categories.end();
+  for (; viter != vend; viter++)
+    if (viter->get())
+      Enable(*viter, Last);
 }
 
-void
-TypeCategoryMap::Clear ()
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    m_map.clear();
-    m_active_categories.clear();
-    if (listener)
-        listener->Changed();
+void TypeCategoryMap::DisableAllCategories() {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  Position p = First;
+  for (; false == m_active_categories.empty(); p++) {
+    m_active_categories.front()->SetEnabledPosition(p);
+    Disable(m_active_categories.front());
+  }
 }
 
-bool
-TypeCategoryMap::Get (KeyType name, ValueSP& entry)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    MapIterator iter = m_map.find(name);
-    if (iter == m_map.end())
-        return false;
-    entry = iter->second;
-    return true;
+void TypeCategoryMap::Clear() {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  m_map.clear();
+  m_active_categories.clear();
+  if (listener)
+    listener->Changed();
 }
 
-bool
-TypeCategoryMap::Get (uint32_t pos, ValueSP& entry)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-    MapIterator iter = m_map.begin();
-    MapIterator end = m_map.end();
-    while (pos > 0)
-    {
-        iter++;
-        pos--;
-        if (iter == end)
-            return false;
-    }
-    entry = iter->second;
+bool TypeCategoryMap::Get(KeyType name, ValueSP &entry) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  MapIterator iter = m_map.find(name);
+  if (iter == m_map.end())
     return false;
+  entry = iter->second;
+  return true;
 }
 
-bool
-TypeCategoryMap::AnyMatches (ConstString type_name,
-                             TypeCategoryImpl::FormatCategoryItems items,
-                             bool only_enabled,
-                             const char** matching_category,
-                             TypeCategoryImpl::FormatCategoryItems* matching_type)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+bool TypeCategoryMap::Get(uint32_t pos, ValueSP &entry) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+  MapIterator iter = m_map.begin();
+  MapIterator end = m_map.end();
+  while (pos > 0) {
+    iter++;
+    pos--;
+    if (iter == end)
+      return false;
+  }
+  entry = iter->second;
+  return false;
+}
 
-    MapIterator pos, end = m_map.end();
-    for (pos = m_map.begin(); pos != end; pos++)
-    {
-        if (pos->second->AnyMatches(type_name,
-                                    items,
-                                    only_enabled,
-                                    matching_category,
-                                    matching_type))
-            return true;
-    }
-    return false;
+bool TypeCategoryMap::AnyMatches(
+    ConstString type_name, TypeCategoryImpl::FormatCategoryItems items,
+    bool only_enabled, const char **matching_category,
+    TypeCategoryImpl::FormatCategoryItems *matching_type) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+
+  MapIterator pos, end = m_map.end();
+  for (pos = m_map.begin(); pos != end; pos++) {
+    if (pos->second->AnyMatches(type_name, items, only_enabled,
+                                matching_category, matching_type))
+      return true;
+  }
+  return false;
 }
 
 lldb::TypeFormatImplSP
-TypeCategoryMap::GetFormat (FormattersMatchData& match_data)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-
-    uint32_t reason_why;
-    ActiveCategoriesIterator begin, end = m_active_categories.end();
-    
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    
-    if (log)
-    {
-        for (auto match : match_data.GetMatchesVector())
-        {
-            log->Printf("[CategoryMap::GetFormat] candidate match = %s %s %s %s reason = %" PRIu32,
-                        match.GetTypeName().GetCString(),
-                        match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
-                        match.DidStripReference() ? "strip-reference" : "no-strip-reference",
-                        match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
-                        match.GetReason());
-        }
+TypeCategoryMap::GetFormat(FormattersMatchData &match_data) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+
+  uint32_t reason_why;
+  ActiveCategoriesIterator begin, end = m_active_categories.end();
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+
+  if (log) {
+    for (auto match : match_data.GetMatchesVector()) {
+      log->Printf(
+          "[CategoryMap::GetFormat] candidate match = %s %s %s %s reason = "
+          "%" PRIu32,
+          match.GetTypeName().GetCString(),
+          match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
+          match.DidStripReference() ? "strip-reference" : "no-strip-reference",
+          match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
+          match.GetReason());
     }
+  }
 
-    for (begin = m_active_categories.begin(); begin != end; begin++)
-    {
-        lldb::TypeCategoryImplSP category_sp = *begin;
-        lldb::TypeFormatImplSP current_format;
-        if (log)
-            log->Printf("[TypeCategoryMap::GetFormat] Trying to use category %s", category_sp->GetName());
-        if (!category_sp->Get(match_data.GetValueObject(), match_data.GetMatchesVector(), current_format, &reason_why))
-            continue;
-        return current_format;
-    }
+  for (begin = m_active_categories.begin(); begin != end; begin++) {
+    lldb::TypeCategoryImplSP category_sp = *begin;
+    lldb::TypeFormatImplSP current_format;
     if (log)
-        log->Printf("[TypeCategoryMap::GetFormat] nothing found - returning empty SP");
-    return lldb::TypeFormatImplSP();
+      log->Printf("[TypeCategoryMap::GetFormat] Trying to use category %s",
+                  category_sp->GetName());
+    if (!category_sp->Get(match_data.GetValueObject(),
+                          match_data.GetMatchesVector(), current_format,
+                          &reason_why))
+      continue;
+    return current_format;
+  }
+  if (log)
+    log->Printf(
+        "[TypeCategoryMap::GetFormat] nothing found - returning empty SP");
+  return lldb::TypeFormatImplSP();
 }
 
 lldb::TypeSummaryImplSP
-TypeCategoryMap::GetSummaryFormat (FormattersMatchData& match_data)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-
-    uint32_t reason_why;
-    ActiveCategoriesIterator begin, end = m_active_categories.end();
-    
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    
-    if (log)
-    {
-        for (auto match : match_data.GetMatchesVector())
-        {
-            log->Printf("[CategoryMap::GetSummaryFormat] candidate match = %s %s %s %s reason = %" PRIu32,
-                        match.GetTypeName().GetCString(),
-                        match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
-                        match.DidStripReference() ? "strip-reference" : "no-strip-reference",
-                        match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
-                        match.GetReason());
-        }
+TypeCategoryMap::GetSummaryFormat(FormattersMatchData &match_data) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+
+  uint32_t reason_why;
+  ActiveCategoriesIterator begin, end = m_active_categories.end();
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+
+  if (log) {
+    for (auto match : match_data.GetMatchesVector()) {
+      log->Printf(
+          "[CategoryMap::GetSummaryFormat] candidate match = %s %s %s %s "
+          "reason = %" PRIu32,
+          match.GetTypeName().GetCString(),
+          match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
+          match.DidStripReference() ? "strip-reference" : "no-strip-reference",
+          match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
+          match.GetReason());
     }
+  }
 
-    for (begin = m_active_categories.begin(); begin != end; begin++)
-    {
-        lldb::TypeCategoryImplSP category_sp = *begin;
-        lldb::TypeSummaryImplSP current_format;
-        if (log)
-            log->Printf("[CategoryMap::GetSummaryFormat] Trying to use category %s", category_sp->GetName());
-        if (!category_sp->Get(match_data.GetValueObject(), match_data.GetMatchesVector(), current_format, &reason_why))
-            continue;
-        return current_format;
-    }
+  for (begin = m_active_categories.begin(); begin != end; begin++) {
+    lldb::TypeCategoryImplSP category_sp = *begin;
+    lldb::TypeSummaryImplSP current_format;
     if (log)
-        log->Printf("[CategoryMap::GetSummaryFormat] nothing found - returning empty SP");
-    return lldb::TypeSummaryImplSP();
+      log->Printf("[CategoryMap::GetSummaryFormat] Trying to use category %s",
+                  category_sp->GetName());
+    if (!category_sp->Get(match_data.GetValueObject(),
+                          match_data.GetMatchesVector(), current_format,
+                          &reason_why))
+      continue;
+    return current_format;
+  }
+  if (log)
+    log->Printf(
+        "[CategoryMap::GetSummaryFormat] nothing found - returning empty SP");
+  return lldb::TypeSummaryImplSP();
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 lldb::SyntheticChildrenSP
-TypeCategoryMap::GetSyntheticChildren (FormattersMatchData& match_data)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+TypeCategoryMap::GetSyntheticChildren(FormattersMatchData &match_data) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
 
-    uint32_t reason_why;
-    
-    ActiveCategoriesIterator begin, end = m_active_categories.end();
-    
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    
-    if (log)
-    {
-        for (auto match : match_data.GetMatchesVector())
-        {
-            log->Printf("[CategoryMap::GetSyntheticChildren] candidate match = %s %s %s %s reason = %" PRIu32,
-                        match.GetTypeName().GetCString(),
-                        match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
-                        match.DidStripReference() ? "strip-reference" : "no-strip-reference",
-                        match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
-                        match.GetReason());
-        }
-    }
+  uint32_t reason_why;
 
-    for (begin = m_active_categories.begin(); begin != end; begin++)
-    {
-        lldb::TypeCategoryImplSP category_sp = *begin;
-        lldb::SyntheticChildrenSP current_format;
-        if (log)
-            log->Printf("[CategoryMap::GetSyntheticChildren] Trying to use category %s", category_sp->GetName());
-        if (!category_sp->Get(match_data.GetValueObject(), match_data.GetMatchesVector(), current_format, &reason_why))
-            continue;
-        return current_format;
+  ActiveCategoriesIterator begin, end = m_active_categories.end();
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+
+  if (log) {
+    for (auto match : match_data.GetMatchesVector()) {
+      log->Printf(
+          "[CategoryMap::GetSyntheticChildren] candidate match = %s %s %s %s "
+          "reason = %" PRIu32,
+          match.GetTypeName().GetCString(),
+          match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
+          match.DidStripReference() ? "strip-reference" : "no-strip-reference",
+          match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
+          match.GetReason());
     }
+  }
+
+  for (begin = m_active_categories.begin(); begin != end; begin++) {
+    lldb::TypeCategoryImplSP category_sp = *begin;
+    lldb::SyntheticChildrenSP current_format;
     if (log)
-        log->Printf("[CategoryMap::GetSyntheticChildren] nothing found - returning empty SP");
-    return lldb::SyntheticChildrenSP();
+      log->Printf(
+          "[CategoryMap::GetSyntheticChildren] Trying to use category %s",
+          category_sp->GetName());
+    if (!category_sp->Get(match_data.GetValueObject(),
+                          match_data.GetMatchesVector(), current_format,
+                          &reason_why))
+      continue;
+    return current_format;
+  }
+  if (log)
+    log->Printf("[CategoryMap::GetSyntheticChildren] nothing found - returning "
+                "empty SP");
+  return lldb::SyntheticChildrenSP();
 }
 #endif
 
 lldb::TypeValidatorImplSP
-TypeCategoryMap::GetValidator (FormattersMatchData& match_data)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+TypeCategoryMap::GetValidator(FormattersMatchData &match_data) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+
+  uint32_t reason_why;
+  ActiveCategoriesIterator begin, end = m_active_categories.end();
+
+  Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_DATAFORMATTERS));
+
+  if (log) {
+    for (auto match : match_data.GetMatchesVector()) {
+      log->Printf(
+          "[CategoryMap::GetValidator] candidate match = %s %s %s %s reason = "
+          "%" PRIu32,
+          match.GetTypeName().GetCString(),
+          match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
+          match.DidStripReference() ? "strip-reference" : "no-strip-reference",
+          match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
+          match.GetReason());
+    }
+  }
 
-    uint32_t reason_why;
-    ActiveCategoriesIterator begin, end = m_active_categories.end();
-    
-    Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_DATAFORMATTERS));
-    
+  for (begin = m_active_categories.begin(); begin != end; begin++) {
+    lldb::TypeCategoryImplSP category_sp = *begin;
+    lldb::TypeValidatorImplSP current_format;
     if (log)
-    {
-        for (auto match : match_data.GetMatchesVector())
-        {
-            log->Printf("[CategoryMap::GetValidator] candidate match = %s %s %s %s reason = %" PRIu32,
-                        match.GetTypeName().GetCString(),
-                        match.DidStripPointer() ? "strip-pointers" : "no-strip-pointers",
-                        match.DidStripReference() ? "strip-reference" : "no-strip-reference",
-                        match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef",
-                        match.GetReason());
-        }
-    }
+      log->Printf("[CategoryMap::GetValidator] Trying to use category %s",
+                  category_sp->GetName());
+    if (!category_sp->Get(match_data.GetValueObject(),
+                          match_data.GetMatchesVector(), current_format,
+                          &reason_why))
+      continue;
+    return current_format;
+  }
+  if (log)
+    log->Printf(
+        "[CategoryMap::GetValidator] nothing found - returning empty SP");
+  return lldb::TypeValidatorImplSP();
+}
 
-    for (begin = m_active_categories.begin(); begin != end; begin++)
+void TypeCategoryMap::ForEach(ForEachCallback callback) {
+  if (callback) {
+    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+
+    // loop through enabled categories in respective order
     {
-        lldb::TypeCategoryImplSP category_sp = *begin;
-        lldb::TypeValidatorImplSP current_format;
-        if (log)
-            log->Printf("[CategoryMap::GetValidator] Trying to use category %s", category_sp->GetName());
-        if (!category_sp->Get(match_data.GetValueObject(), match_data.GetMatchesVector(), current_format, &reason_why))
-            continue;
-        return current_format;
+      ActiveCategoriesIterator begin, end = m_active_categories.end();
+      for (begin = m_active_categories.begin(); begin != end; begin++) {
+        lldb::TypeCategoryImplSP category = *begin;
+        if (!callback(category))
+          break;
+      }
     }
-    if (log)
-        log->Printf("[CategoryMap::GetValidator] nothing found - returning empty SP");
-    return lldb::TypeValidatorImplSP();
-}
 
-void
-TypeCategoryMap::ForEach(ForEachCallback callback)
-{
-    if (callback)
+    // loop through disabled categories in just any order
     {
-        std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
-
-        // loop through enabled categories in respective order
-        {
-            ActiveCategoriesIterator begin, end = m_active_categories.end();
-            for (begin = m_active_categories.begin(); begin != end; begin++)
-            {
-                lldb::TypeCategoryImplSP category = *begin;
-                if (!callback(category))
-                    break;
-            }
-        }
-        
-        // loop through disabled categories in just any order
-        {
-            MapIterator pos, end = m_map.end();
-            for (pos = m_map.begin(); pos != end; pos++)
-            {
-                if (pos->second->IsEnabled())
-                    continue;
-                if (!callback(pos->second))
-                    break;
-            }
-        }
+      MapIterator pos, end = m_map.end();
+      for (pos = m_map.begin(); pos != end; pos++) {
+        if (pos->second->IsEnabled())
+          continue;
+        if (!callback(pos->second))
+          break;
+      }
     }
+  }
 }
 
-TypeCategoryImplSP
-TypeCategoryMap::GetAtIndex (uint32_t index)
-{
-    std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
+TypeCategoryImplSP TypeCategoryMap::GetAtIndex(uint32_t index) {
+  std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
 
-    if (index < m_map.size())
-    {
-        MapIterator pos, end = m_map.end();
-        for (pos = m_map.begin(); pos != end; pos++)
-        {
-            if (index == 0)
-                return pos->second;
-            index--;
-        }
+  if (index < m_map.size()) {
+    MapIterator pos, end = m_map.end();
+    for (pos = m_map.begin(); pos != end; pos++) {
+      if (index == 0)
+        return pos->second;
+      index--;
     }
-    
-    return TypeCategoryImplSP();
+  }
+
+  return TypeCategoryImplSP();
 }
diff --git a/lldb/source/DataFormatters/TypeFormat.cpp b/lldb/source/DataFormatters/TypeFormat.cpp
index 2409ddb..1ec5208 100644
--- a/lldb/source/DataFormatters/TypeFormat.cpp
+++ b/lldb/source/DataFormatters/TypeFormat.cpp
@@ -16,8 +16,8 @@
 // Other libraries and framework includes
 
 // Project includes
-#include "lldb/lldb-public.h"
 #include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-public.h"
 
 #include "lldb/Core/StreamString.h"
 #include "lldb/DataFormatters/FormatManager.h"
@@ -30,225 +30,181 @@
 using namespace lldb;
 using namespace lldb_private;
 
-TypeFormatImpl::TypeFormatImpl (const Flags& flags) :
-m_flags(flags),
-m_my_revision(0)
-{
-}
+TypeFormatImpl::TypeFormatImpl(const Flags &flags)
+    : m_flags(flags), m_my_revision(0) {}
 
-TypeFormatImpl::~TypeFormatImpl ()
-{
-}
+TypeFormatImpl::~TypeFormatImpl() {}
 
-TypeFormatImpl_Format::TypeFormatImpl_Format (lldb::Format f,
-                                              const TypeFormatImpl::Flags& flags) :
-TypeFormatImpl(flags),
-m_format (f)
-{
-}
+TypeFormatImpl_Format::TypeFormatImpl_Format(lldb::Format f,
+                                             const TypeFormatImpl::Flags &flags)
+    : TypeFormatImpl(flags), m_format(f) {}
 
-TypeFormatImpl_Format::~TypeFormatImpl_Format ()
-{
-}
+TypeFormatImpl_Format::~TypeFormatImpl_Format() {}
 
-bool
-TypeFormatImpl_Format::FormatObject (ValueObject *valobj,
-                                     std::string& dest) const
-{
-    if (!valobj)
-        return false;
-    if (valobj->CanProvideValue())
-    {
-        Value& value(valobj->GetValue());
-        const Value::ContextType context_type = value.GetContextType();
-        ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
-        DataExtractor data;
-        
-        if (context_type == Value::eContextTypeRegisterInfo)
-        {
-            const RegisterInfo *reg_info = value.GetRegisterInfo();
-            if (reg_info)
-            {
-                Error error;
-                valobj->GetData(data, error);
-                if (error.Fail())
-                    return false;
-                
-                StreamString reg_sstr;
-                data.Dump (&reg_sstr,
-                           0,
-                           GetFormat(),
-                           reg_info->byte_size,
-                           1,
-                           UINT32_MAX,
-                           LLDB_INVALID_ADDRESS,
-                           0,
-                           0,
-                           exe_ctx.GetBestExecutionContextScope());
-                dest.swap(reg_sstr.GetString());
+bool TypeFormatImpl_Format::FormatObject(ValueObject *valobj,
+                                         std::string &dest) const {
+  if (!valobj)
+    return false;
+  if (valobj->CanProvideValue()) {
+    Value &value(valobj->GetValue());
+    const Value::ContextType context_type = value.GetContextType();
+    ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
+    DataExtractor data;
+
+    if (context_type == Value::eContextTypeRegisterInfo) {
+      const RegisterInfo *reg_info = value.GetRegisterInfo();
+      if (reg_info) {
+        Error error;
+        valobj->GetData(data, error);
+        if (error.Fail())
+          return false;
+
+        StreamString reg_sstr;
+        data.Dump(&reg_sstr, 0, GetFormat(), reg_info->byte_size, 1, UINT32_MAX,
+                  LLDB_INVALID_ADDRESS, 0, 0,
+                  exe_ctx.GetBestExecutionContextScope());
+        dest.swap(reg_sstr.GetString());
+      }
+    } else {
+      CompilerType compiler_type = value.GetCompilerType();
+      if (compiler_type) {
+        // put custom bytes to display in the DataExtractor to override the
+        // default value logic
+        if (GetFormat() == eFormatCString) {
+          lldb_private::Flags type_flags(compiler_type.GetTypeInfo(
+              NULL)); // disambiguate w.r.t. TypeFormatImpl::Flags
+          if (type_flags.Test(eTypeIsPointer) &&
+              !type_flags.Test(eTypeIsObjC)) {
+            // if we are dumping a pointer as a c-string, get the pointee data
+            // as a string
+            TargetSP target_sp(valobj->GetTargetSP());
+            if (target_sp) {
+              size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
+              Error error;
+              DataBufferSP buffer_sp(new DataBufferHeap(max_len + 1, 0));
+              Address address(valobj->GetPointerValue());
+              if (target_sp->ReadCStringFromMemory(
+                      address, (char *)buffer_sp->GetBytes(), max_len, error) &&
+                  error.Success())
+                data.SetData(buffer_sp);
             }
+          }
+        } else {
+          Error error;
+          valobj->GetData(data, error);
+          if (error.Fail())
+            return false;
         }
+
+        StreamString sstr;
+        ExecutionContextScope *exe_scope(
+            exe_ctx.GetBestExecutionContextScope());
+        compiler_type.DumpTypeValue(
+            &sstr,       // The stream to use for display
+            GetFormat(), // Format to display this type with
+            data,        // Data to extract from
+            0,           // Byte offset into "m_data"
+            compiler_type.GetByteSize(
+                exe_scope),                 // Byte size of item in "m_data"
+            valobj->GetBitfieldBitSize(),   // Bitfield bit size
+            valobj->GetBitfieldBitOffset(), // Bitfield bit offset
+            exe_scope);
+        // Given that we do not want to set the ValueObject's m_error
+        // for a formatting error (or else we wouldn't be able to reformat
+        // until a next update), an empty string is treated as a "false"
+        // return from here, but that's about as severe as we get
+        // CompilerType::DumpTypeValue() should always return
+        // something, even if that something is an error message
+        if (sstr.GetString().empty())
+          dest.clear();
         else
-        {
-            CompilerType compiler_type = value.GetCompilerType ();
-            if (compiler_type)
-            {
-                // put custom bytes to display in the DataExtractor to override the default value logic
-                if (GetFormat() == eFormatCString)
-                {
-                    lldb_private::Flags type_flags(compiler_type.GetTypeInfo(NULL)); // disambiguate w.r.t. TypeFormatImpl::Flags
-                    if (type_flags.Test(eTypeIsPointer) && !type_flags.Test(eTypeIsObjC))
-                    {
-                        // if we are dumping a pointer as a c-string, get the pointee data as a string
-                        TargetSP target_sp(valobj->GetTargetSP());
-                        if (target_sp)
-                        {
-                            size_t max_len = target_sp->GetMaximumSizeOfStringSummary();
-                            Error error;
-                            DataBufferSP buffer_sp(new DataBufferHeap(max_len+1,0));
-                            Address address(valobj->GetPointerValue());
-                            if (target_sp->ReadCStringFromMemory(address, (char*)buffer_sp->GetBytes(), max_len, error) && error.Success())
-                                data.SetData(buffer_sp);
-                        }
-                    }
-                }
-                else
-                {
-                    Error error;
-                    valobj->GetData(data, error);
-                    if (error.Fail())
-                        return false;
-                }
-                
-                StreamString sstr;
-                ExecutionContextScope *exe_scope(exe_ctx.GetBestExecutionContextScope());
-                compiler_type.DumpTypeValue (&sstr,                                 // The stream to use for display
-                                             GetFormat(),                           // Format to display this type with
-                                             data,                                  // Data to extract from
-                                             0,                                     // Byte offset into "m_data"
-                                             compiler_type.GetByteSize(exe_scope),  // Byte size of item in "m_data"
-                                             valobj->GetBitfieldBitSize(),          // Bitfield bit size
-                                             valobj->GetBitfieldBitOffset(),        // Bitfield bit offset
-                                             exe_scope);
-                // Given that we do not want to set the ValueObject's m_error
-                // for a formatting error (or else we wouldn't be able to reformat
-                // until a next update), an empty string is treated as a "false"
-                // return from here, but that's about as severe as we get
-                // CompilerType::DumpTypeValue() should always return
-                // something, even if that something is an error message
-                if (sstr.GetString().empty())
-                    dest.clear();
-                else
-                    dest.swap(sstr.GetString());
-            }
-        }
-        return !dest.empty();
+          dest.swap(sstr.GetString());
+      }
     }
-    else
-        return false;
-}
-
-std::string
-TypeFormatImpl_Format::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf ("%s%s%s%s",
-                 FormatManager::GetFormatAsCString (GetFormat()),
-                 Cascades() ? "" : " (not cascading)",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "");
-    return sstr.GetString();
-}
-
-TypeFormatImpl_EnumType::TypeFormatImpl_EnumType (ConstString type_name,
-                                                  const TypeFormatImpl::Flags& flags) :
-TypeFormatImpl(flags),
-m_enum_type(type_name),
-m_types()
-{
+    return !dest.empty();
+  } else
+    return false;
 }
 
-TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType ()
-{
+std::string TypeFormatImpl_Format::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s%s", FormatManager::GetFormatAsCString(GetFormat()),
+              Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "");
+  return sstr.GetString();
 }
 
-bool
-TypeFormatImpl_EnumType::FormatObject (ValueObject *valobj,
-                                       std::string& dest) const
-{
-    dest.clear();
-    if (!valobj)
-        return false;
-    if (!valobj->CanProvideValue())
-        return false;
-    ProcessSP process_sp;
-    TargetSP target_sp;
-    void* valobj_key = (process_sp = valobj->GetProcessSP()).get();
-    if (!valobj_key)
-        valobj_key = (target_sp = valobj->GetTargetSP()).get();
-    else
-        target_sp = process_sp->GetTarget().shared_from_this();
-    if (!valobj_key)
-        return false;
-    auto iter = m_types.find(valobj_key),
-    end = m_types.end();
-    CompilerType valobj_enum_type;
-    if (iter == end)
-    {
-        // probably a redundant check
-        if (!target_sp)
-            return false;
-        const ModuleList& images(target_sp->GetImages());
-        SymbolContext sc;
-        TypeList types;
-        llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
-        images.FindTypes(sc, m_enum_type, false, UINT32_MAX, searched_symbol_files, types);
-        if (types.GetSize() == 0)
-            return false;
-        for (lldb::TypeSP type_sp : types.Types())
-        {
-            if (!type_sp)
-                continue;
-            if ( (type_sp->GetForwardCompilerType().GetTypeInfo() & eTypeIsEnumeration) == eTypeIsEnumeration)
-            {
-                valobj_enum_type = type_sp->GetFullCompilerType ();
-                m_types.emplace(valobj_key,valobj_enum_type);
-                break;
-            }
-        }
+TypeFormatImpl_EnumType::TypeFormatImpl_EnumType(
+    ConstString type_name, const TypeFormatImpl::Flags &flags)
+    : TypeFormatImpl(flags), m_enum_type(type_name), m_types() {}
+
+TypeFormatImpl_EnumType::~TypeFormatImpl_EnumType() {}
+
+bool TypeFormatImpl_EnumType::FormatObject(ValueObject *valobj,
+                                           std::string &dest) const {
+  dest.clear();
+  if (!valobj)
+    return false;
+  if (!valobj->CanProvideValue())
+    return false;
+  ProcessSP process_sp;
+  TargetSP target_sp;
+  void *valobj_key = (process_sp = valobj->GetProcessSP()).get();
+  if (!valobj_key)
+    valobj_key = (target_sp = valobj->GetTargetSP()).get();
+  else
+    target_sp = process_sp->GetTarget().shared_from_this();
+  if (!valobj_key)
+    return false;
+  auto iter = m_types.find(valobj_key), end = m_types.end();
+  CompilerType valobj_enum_type;
+  if (iter == end) {
+    // probably a redundant check
+    if (!target_sp)
+      return false;
+    const ModuleList &images(target_sp->GetImages());
+    SymbolContext sc;
+    TypeList types;
+    llvm::DenseSet<lldb_private::SymbolFile *> searched_symbol_files;
+    images.FindTypes(sc, m_enum_type, false, UINT32_MAX, searched_symbol_files,
+                     types);
+    if (types.GetSize() == 0)
+      return false;
+    for (lldb::TypeSP type_sp : types.Types()) {
+      if (!type_sp)
+        continue;
+      if ((type_sp->GetForwardCompilerType().GetTypeInfo() &
+           eTypeIsEnumeration) == eTypeIsEnumeration) {
+        valobj_enum_type = type_sp->GetFullCompilerType();
+        m_types.emplace(valobj_key, valobj_enum_type);
+        break;
+      }
     }
-    else
-        valobj_enum_type = iter->second;
-    if (valobj_enum_type.IsValid() == false)
-        return false;
-    DataExtractor data;
-    Error error;
-    valobj->GetData(data, error);
-    if (error.Fail())
-        return false;
-    ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
-    StreamString sstr;
-    valobj_enum_type.DumpTypeValue(&sstr,
-                                   lldb::eFormatEnum,
-                                   data,
-                                   0,
-                                   data.GetByteSize(),
-                                   0,
-                                   0,
-                                   exe_ctx.GetBestExecutionContextScope());
-    if (!sstr.GetString().empty())
-        dest.swap(sstr.GetString());
-    return !dest.empty();
+  } else
+    valobj_enum_type = iter->second;
+  if (valobj_enum_type.IsValid() == false)
+    return false;
+  DataExtractor data;
+  Error error;
+  valobj->GetData(data, error);
+  if (error.Fail())
+    return false;
+  ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
+  StreamString sstr;
+  valobj_enum_type.DumpTypeValue(&sstr, lldb::eFormatEnum, data, 0,
+                                 data.GetByteSize(), 0, 0,
+                                 exe_ctx.GetBestExecutionContextScope());
+  if (!sstr.GetString().empty())
+    dest.swap(sstr.GetString());
+  return !dest.empty();
 }
 
-std::string
-TypeFormatImpl_EnumType::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf ("as type %s%s%s%s",
-                 m_enum_type.AsCString("<invalid type>"),
-                 Cascades() ? "" : " (not cascading)",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "");
-    return sstr.GetString();
+std::string TypeFormatImpl_EnumType::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("as type %s%s%s%s", m_enum_type.AsCString("<invalid type>"),
+              Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "");
+  return sstr.GetString();
 }
diff --git a/lldb/source/DataFormatters/TypeSummary.cpp b/lldb/source/DataFormatters/TypeSummary.cpp
index dd4cd97..f77f524 100644
--- a/lldb/source/DataFormatters/TypeSummary.cpp
+++ b/lldb/source/DataFormatters/TypeSummary.cpp
@@ -16,8 +16,8 @@
 // Other libraries and framework includes
 
 // Project includes
-#include "lldb/lldb-public.h"
 #include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-public.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamString.h"
@@ -31,252 +31,186 @@
 using namespace lldb;
 using namespace lldb_private;
 
-TypeSummaryOptions::TypeSummaryOptions () :
-    m_lang(eLanguageTypeUnknown),
-    m_capping(eTypeSummaryCapped)
-{}
-
-TypeSummaryOptions::TypeSummaryOptions (const TypeSummaryOptions& rhs) :
-    m_lang(rhs.m_lang),
-    m_capping(rhs.m_capping)
-{}
-
-TypeSummaryOptions&
-TypeSummaryOptions::operator = (const TypeSummaryOptions& rhs)
-{
-    m_lang = rhs.m_lang;
-    m_capping = rhs.m_capping;
-    return *this;
-}
+TypeSummaryOptions::TypeSummaryOptions()
+    : m_lang(eLanguageTypeUnknown), m_capping(eTypeSummaryCapped) {}
 
-lldb::LanguageType
-TypeSummaryOptions::GetLanguage () const
-{
-    return m_lang;
-}
+TypeSummaryOptions::TypeSummaryOptions(const TypeSummaryOptions &rhs)
+    : m_lang(rhs.m_lang), m_capping(rhs.m_capping) {}
 
-lldb::TypeSummaryCapping
-TypeSummaryOptions::GetCapping () const
-{
-    return m_capping;
+TypeSummaryOptions &TypeSummaryOptions::
+operator=(const TypeSummaryOptions &rhs) {
+  m_lang = rhs.m_lang;
+  m_capping = rhs.m_capping;
+  return *this;
 }
 
-TypeSummaryOptions&
-TypeSummaryOptions::SetLanguage (lldb::LanguageType lang)
-{
-    m_lang = lang;
-    return *this;
-}
-
-TypeSummaryOptions&
-TypeSummaryOptions::SetCapping (lldb::TypeSummaryCapping cap)
-{
-    m_capping = cap;
-    return *this;
-}
+lldb::LanguageType TypeSummaryOptions::GetLanguage() const { return m_lang; }
 
-TypeSummaryImpl::TypeSummaryImpl (Kind kind,
-                                  const TypeSummaryImpl::Flags& flags) :
-    m_flags(flags),
-    m_kind(kind)
-{
-}
-
-
-StringSummaryFormat::StringSummaryFormat (const TypeSummaryImpl::Flags& flags,
-                                          const char *format_cstr) :
-    TypeSummaryImpl(Kind::eSummaryString,flags),
-    m_format_str()
-{
-    SetSummaryString (format_cstr);
-}
-
-void
-StringSummaryFormat::SetSummaryString (const char* format_cstr)
-{
-    m_format.Clear();
-    if (format_cstr && format_cstr[0])
-    {
-        m_format_str = format_cstr;
-        m_error = FormatEntity::Parse(format_cstr, m_format);
-    }
-    else
-    {
-        m_format_str.clear();
-        m_error.Clear();
-    }
+lldb::TypeSummaryCapping TypeSummaryOptions::GetCapping() const {
+  return m_capping;
 }
 
-
-
-bool
-StringSummaryFormat::FormatObject (ValueObject *valobj,
-                                   std::string& retval,
-                                   const TypeSummaryOptions& options)
-{
-    if (!valobj)
-    {
-        retval.assign("NULL ValueObject");
-        return false;
-    }
-    
-    StreamString s;
-    ExecutionContext exe_ctx (valobj->GetExecutionContextRef());
-    SymbolContext sc;
-    StackFrame *frame = exe_ctx.GetFramePtr();
-    if (frame)
-        sc = frame->GetSymbolContext(lldb::eSymbolContextEverything);
-    
-    if (IsOneLiner())
-    {
-        ValueObjectPrinter printer(valobj,&s,DumpValueObjectOptions());
-        printer.PrintChildrenOneLiner(HideNames(valobj));
-        retval.assign(s.GetData());
-        return true;
-    }
-    else
-    {
-        if (FormatEntity::Format(m_format, s, &sc, &exe_ctx, &sc.line_entry.range.GetBaseAddress(), valobj, false, false))
-        {
-            retval.assign(s.GetString());
-            return true;
-        }
-        else
-        {
-            retval.assign("error: summary string parsing error");
-            return false;
-        }
-    }
+TypeSummaryOptions &TypeSummaryOptions::SetLanguage(lldb::LanguageType lang) {
+  m_lang = lang;
+  return *this;
 }
 
-std::string
-StringSummaryFormat::GetDescription ()
-{
-    StreamString sstr;
-    
-    sstr.Printf ("`%s`%s%s%s%s%s%s%s%s%s",
-                 m_format_str.c_str(),
-                 m_error.Fail() ? " error: " : "",
-                 m_error.Fail() ? m_error.AsCString() : "",
-                 Cascades() ? "" : " (not cascading)",
-                 !DoesPrintChildren(nullptr) ? "" : " (show children)",
-                 !DoesPrintValue(nullptr) ? " (hide value)" : "",
-                 IsOneLiner() ? " (one-line printout)" : "",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "",
-                 HideNames(nullptr) ? " (hide member names)" : "");
-    return sstr.GetString();
+TypeSummaryOptions &
+TypeSummaryOptions::SetCapping(lldb::TypeSummaryCapping cap) {
+  m_capping = cap;
+  return *this;
 }
 
-CXXFunctionSummaryFormat::CXXFunctionSummaryFormat (const TypeSummaryImpl::Flags& flags,
-                                                    Callback impl,
-                                                    const char* description) :
-    TypeSummaryImpl(Kind::eCallback,flags),
-    m_impl(impl),
-    m_description(description ? description : "")
-{
-}
+TypeSummaryImpl::TypeSummaryImpl(Kind kind, const TypeSummaryImpl::Flags &flags)
+    : m_flags(flags), m_kind(kind) {}
 
-bool
-CXXFunctionSummaryFormat::FormatObject (ValueObject *valobj,
-                                        std::string& dest,
-                                        const TypeSummaryOptions& options)
-{
-    dest.clear();
-    StreamString stream;
-    if (!m_impl || m_impl(*valobj,stream,options) == false)
-        return false;
-    dest.assign(stream.GetData());
-    return true;
+StringSummaryFormat::StringSummaryFormat(const TypeSummaryImpl::Flags &flags,
+                                         const char *format_cstr)
+    : TypeSummaryImpl(Kind::eSummaryString, flags), m_format_str() {
+  SetSummaryString(format_cstr);
 }
 
-std::string
-CXXFunctionSummaryFormat::GetDescription ()
-{
-    StreamString sstr;
-    sstr.Printf ("%s%s%s%s%s%s%s %s",
-                 Cascades() ? "" : " (not cascading)",
-                 !DoesPrintChildren(nullptr) ? "" : " (show children)",
-                 !DoesPrintValue(nullptr) ? " (hide value)" : "",
-                 IsOneLiner() ? " (one-line printout)" : "",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "",
-                 HideNames(nullptr) ? " (hide member names)" : "",
-                 m_description.c_str());
-    return sstr.GetString();
+void StringSummaryFormat::SetSummaryString(const char *format_cstr) {
+  m_format.Clear();
+  if (format_cstr && format_cstr[0]) {
+    m_format_str = format_cstr;
+    m_error = FormatEntity::Parse(format_cstr, m_format);
+  } else {
+    m_format_str.clear();
+    m_error.Clear();
+  }
 }
 
-ScriptSummaryFormat::ScriptSummaryFormat (const TypeSummaryImpl::Flags& flags,
-                                          const char * function_name,
-                                          const char * python_script) :
-    TypeSummaryImpl(Kind::eScript,flags),
-    m_function_name(),
-    m_python_script(),
-    m_script_function_sp()
-{
-    if (function_name)
-        m_function_name.assign(function_name);
-    if (python_script)
-        m_python_script.assign(python_script);
-}
+bool StringSummaryFormat::FormatObject(ValueObject *valobj, std::string &retval,
+                                       const TypeSummaryOptions &options) {
+  if (!valobj) {
+    retval.assign("NULL ValueObject");
+    return false;
+  }
 
-bool
-ScriptSummaryFormat::FormatObject (ValueObject *valobj,
-                                   std::string& retval,
-                                   const TypeSummaryOptions& options)
-{
-    if (!valobj)
-        return false;
-    
-    TargetSP target_sp(valobj->GetTargetSP());
-    
-    if (!target_sp)
-    {
-        retval.assign("error: no target");
-        return false;
-    }
-    
-    ScriptInterpreter *script_interpreter = target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
-    
-    if (!script_interpreter)
-    {
-        retval.assign("error: no ScriptInterpreter");
-        return false;
-    }
-    
-    return script_interpreter->GetScriptedSummary(m_function_name.c_str(),
-                                                  valobj->GetSP(),
-                                                  m_script_function_sp,
-                                                  options,
-                                                  retval);
-    
-}
+  StreamString s;
+  ExecutionContext exe_ctx(valobj->GetExecutionContextRef());
+  SymbolContext sc;
+  StackFrame *frame = exe_ctx.GetFramePtr();
+  if (frame)
+    sc = frame->GetSymbolContext(lldb::eSymbolContextEverything);
 
-std::string
-ScriptSummaryFormat::GetDescription ()
-{
-    StreamString sstr;
-    sstr.Printf ("%s%s%s%s%s%s%s\n  ",       Cascades() ? "" : " (not cascading)",
-                 !DoesPrintChildren(nullptr) ? "" : " (show children)",
-                 !DoesPrintValue(nullptr) ? " (hide value)" : "",
-                 IsOneLiner() ? " (one-line printout)" : "",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "",
-                 HideNames(nullptr) ? " (hide member names)" : "");
-    if (m_python_script.empty())
-    {
-        if (m_function_name.empty())
-        {
-            sstr.PutCString("no backing script");
-        }
-        else
-        {
-            sstr.PutCString(m_function_name.c_str());
-        }
+  if (IsOneLiner()) {
+    ValueObjectPrinter printer(valobj, &s, DumpValueObjectOptions());
+    printer.PrintChildrenOneLiner(HideNames(valobj));
+    retval.assign(s.GetData());
+    return true;
+  } else {
+    if (FormatEntity::Format(m_format, s, &sc, &exe_ctx,
+                             &sc.line_entry.range.GetBaseAddress(), valobj,
+                             false, false)) {
+      retval.assign(s.GetString());
+      return true;
+    } else {
+      retval.assign("error: summary string parsing error");
+      return false;
     }
-    else
-    {
-        sstr.PutCString(m_python_script.c_str());
+  }
+}
+
+std::string StringSummaryFormat::GetDescription() {
+  StreamString sstr;
+
+  sstr.Printf("`%s`%s%s%s%s%s%s%s%s%s", m_format_str.c_str(),
+              m_error.Fail() ? " error: " : "",
+              m_error.Fail() ? m_error.AsCString() : "",
+              Cascades() ? "" : " (not cascading)",
+              !DoesPrintChildren(nullptr) ? "" : " (show children)",
+              !DoesPrintValue(nullptr) ? " (hide value)" : "",
+              IsOneLiner() ? " (one-line printout)" : "",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "",
+              HideNames(nullptr) ? " (hide member names)" : "");
+  return sstr.GetString();
+}
+
+CXXFunctionSummaryFormat::CXXFunctionSummaryFormat(
+    const TypeSummaryImpl::Flags &flags, Callback impl, const char *description)
+    : TypeSummaryImpl(Kind::eCallback, flags), m_impl(impl),
+      m_description(description ? description : "") {}
+
+bool CXXFunctionSummaryFormat::FormatObject(ValueObject *valobj,
+                                            std::string &dest,
+                                            const TypeSummaryOptions &options) {
+  dest.clear();
+  StreamString stream;
+  if (!m_impl || m_impl(*valobj, stream, options) == false)
+    return false;
+  dest.assign(stream.GetData());
+  return true;
+}
+
+std::string CXXFunctionSummaryFormat::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s%s%s%s%s %s", Cascades() ? "" : " (not cascading)",
+              !DoesPrintChildren(nullptr) ? "" : " (show children)",
+              !DoesPrintValue(nullptr) ? " (hide value)" : "",
+              IsOneLiner() ? " (one-line printout)" : "",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "",
+              HideNames(nullptr) ? " (hide member names)" : "",
+              m_description.c_str());
+  return sstr.GetString();
+}
+
+ScriptSummaryFormat::ScriptSummaryFormat(const TypeSummaryImpl::Flags &flags,
+                                         const char *function_name,
+                                         const char *python_script)
+    : TypeSummaryImpl(Kind::eScript, flags), m_function_name(),
+      m_python_script(), m_script_function_sp() {
+  if (function_name)
+    m_function_name.assign(function_name);
+  if (python_script)
+    m_python_script.assign(python_script);
+}
+
+bool ScriptSummaryFormat::FormatObject(ValueObject *valobj, std::string &retval,
+                                       const TypeSummaryOptions &options) {
+  if (!valobj)
+    return false;
+
+  TargetSP target_sp(valobj->GetTargetSP());
+
+  if (!target_sp) {
+    retval.assign("error: no target");
+    return false;
+  }
+
+  ScriptInterpreter *script_interpreter =
+      target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+
+  if (!script_interpreter) {
+    retval.assign("error: no ScriptInterpreter");
+    return false;
+  }
+
+  return script_interpreter->GetScriptedSummary(
+      m_function_name.c_str(), valobj->GetSP(), m_script_function_sp, options,
+      retval);
+}
+
+std::string ScriptSummaryFormat::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s%s%s%s%s\n  ", Cascades() ? "" : " (not cascading)",
+              !DoesPrintChildren(nullptr) ? "" : " (show children)",
+              !DoesPrintValue(nullptr) ? " (hide value)" : "",
+              IsOneLiner() ? " (one-line printout)" : "",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "",
+              HideNames(nullptr) ? " (hide member names)" : "");
+  if (m_python_script.empty()) {
+    if (m_function_name.empty()) {
+      sstr.PutCString("no backing script");
+    } else {
+      sstr.PutCString(m_function_name.c_str());
     }
-    return sstr.GetString();
+  } else {
+    sstr.PutCString(m_python_script.c_str());
+  }
+  return sstr.GetString();
 }
diff --git a/lldb/source/DataFormatters/TypeSynthetic.cpp b/lldb/source/DataFormatters/TypeSynthetic.cpp
index c8de1759..7bfc879 100644
--- a/lldb/source/DataFormatters/TypeSynthetic.cpp
+++ b/lldb/source/DataFormatters/TypeSynthetic.cpp
@@ -1,4 +1,5 @@
-//===-- TypeSynthetic.cpp ----------------------------------------*- C++ -*-===//
+//===-- TypeSynthetic.cpp ----------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -14,8 +15,8 @@
 // Other libraries and framework includes
 
 // Project includes
-#include "lldb/lldb-public.h"
 #include "lldb/lldb-enumerations.h"
+#include "lldb/lldb-public.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/StreamString.h"
@@ -28,244 +29,198 @@
 using namespace lldb;
 using namespace lldb_private;
 
-void
-TypeFilterImpl::AddExpressionPath (const std::string& path)
-{
-    bool need_add_dot = true;
-    if (path[0] == '.' ||
-        (path[0] == '-' && path[1] == '>') ||
-        path[0] == '[')
-        need_add_dot = false;
-    // add a '.' symbol to help forgetful users
-    if(!need_add_dot)
-        m_expression_paths.push_back(path);
-    else
-        m_expression_paths.push_back(std::string(".") + path);
-}
-
-bool
-TypeFilterImpl::SetExpressionPathAtIndex (size_t i, const std::string& path)
-{
-    if (i >= GetCount())
-        return false;
-    bool need_add_dot = true;
-    if (path[0] == '.' ||
-        (path[0] == '-' && path[1] == '>') ||
-        path[0] == '[')
-        need_add_dot = false;
-    // add a '.' symbol to help forgetful users
-    if(!need_add_dot)
-        m_expression_paths[i] = path;
-    else
-        m_expression_paths[i] = std::string(".") + path;
-    return true;
+void TypeFilterImpl::AddExpressionPath(const std::string &path) {
+  bool need_add_dot = true;
+  if (path[0] == '.' || (path[0] == '-' && path[1] == '>') || path[0] == '[')
+    need_add_dot = false;
+  // add a '.' symbol to help forgetful users
+  if (!need_add_dot)
+    m_expression_paths.push_back(path);
+  else
+    m_expression_paths.push_back(std::string(".") + path);
+}
+
+bool TypeFilterImpl::SetExpressionPathAtIndex(size_t i,
+                                              const std::string &path) {
+  if (i >= GetCount())
+    return false;
+  bool need_add_dot = true;
+  if (path[0] == '.' || (path[0] == '-' && path[1] == '>') || path[0] == '[')
+    need_add_dot = false;
+  // add a '.' symbol to help forgetful users
+  if (!need_add_dot)
+    m_expression_paths[i] = path;
+  else
+    m_expression_paths[i] = std::string(".") + path;
+  return true;
 }
 
 size_t
-TypeFilterImpl::FrontEnd::GetIndexOfChildWithName (const ConstString &name)
-{
-    const char* name_cstr = name.GetCString();
-    if (name_cstr)
-    {
-        for (size_t i = 0; i < filter->GetCount(); i++)
-        {
-            const char* expr_cstr = filter->GetExpressionPathAtIndex(i);
-            if (expr_cstr)
-            {
-                if (*expr_cstr == '.')
-                    expr_cstr++;
-                else if (*expr_cstr == '-' && *(expr_cstr+1) == '>')
-                    expr_cstr += 2;
-            }
-            if (expr_cstr)
-            {
-                if (!::strcmp(name_cstr, expr_cstr))
-                    return i;
-            }
-        }
+TypeFilterImpl::FrontEnd::GetIndexOfChildWithName(const ConstString &name) {
+  const char *name_cstr = name.GetCString();
+  if (name_cstr) {
+    for (size_t i = 0; i < filter->GetCount(); i++) {
+      const char *expr_cstr = filter->GetExpressionPathAtIndex(i);
+      if (expr_cstr) {
+        if (*expr_cstr == '.')
+          expr_cstr++;
+        else if (*expr_cstr == '-' && *(expr_cstr + 1) == '>')
+          expr_cstr += 2;
+      }
+      if (expr_cstr) {
+        if (!::strcmp(name_cstr, expr_cstr))
+          return i;
+      }
     }
-    return UINT32_MAX;
+  }
+  return UINT32_MAX;
 }
 
-std::string
-TypeFilterImpl::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf("%s%s%s {\n",
-                Cascades() ? "" : " (not cascading)",
-                SkipsPointers() ? " (skip pointers)" : "",
-                SkipsReferences() ? " (skip references)" : "");
-    
-    for (size_t i = 0; i < GetCount(); i++)
-    {
-        sstr.Printf("    %s\n",
-                    GetExpressionPathAtIndex(i));
-    }
-    
-    sstr.Printf("}");
-    return sstr.GetString();
+std::string TypeFilterImpl::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s {\n", Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "");
+
+  for (size_t i = 0; i < GetCount(); i++) {
+    sstr.Printf("    %s\n", GetExpressionPathAtIndex(i));
+  }
+
+  sstr.Printf("}");
+  return sstr.GetString();
 }
 
-std::string
-CXXSyntheticChildren::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf("%s%s%s %s",
-                Cascades() ? "" : " (not cascading)",
-                SkipsPointers() ? " (skip pointers)" : "",
-                SkipsReferences() ? " (skip references)" : "",
-                m_description.c_str());
-
-    return sstr.GetString();
+std::string CXXSyntheticChildren::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s %s", Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "",
+              m_description.c_str());
+
+  return sstr.GetString();
 }
 
-lldb::ValueObjectSP
-SyntheticChildrenFrontEnd::CreateValueObjectFromExpression (const char* name,
-                                                            const char* expression,
-                                                            const ExecutionContext& exe_ctx)
-{
-    ValueObjectSP valobj_sp(ValueObject::CreateValueObjectFromExpression(name, expression, exe_ctx));
-    if (valobj_sp)
-        valobj_sp->SetSyntheticChildrenGenerated(true);
-    return valobj_sp;
+lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromExpression(
+    const char *name, const char *expression, const ExecutionContext &exe_ctx) {
+  ValueObjectSP valobj_sp(
+      ValueObject::CreateValueObjectFromExpression(name, expression, exe_ctx));
+  if (valobj_sp)
+    valobj_sp->SetSyntheticChildrenGenerated(true);
+  return valobj_sp;
 }
 
-lldb::ValueObjectSP
-SyntheticChildrenFrontEnd::CreateValueObjectFromAddress (const char* name,
-                                                         uint64_t address,
-                                                         const ExecutionContext& exe_ctx,
-                                                         CompilerType type)
-{
-    ValueObjectSP valobj_sp(ValueObject::CreateValueObjectFromAddress(name, address, exe_ctx, type));
-    if (valobj_sp)
-        valobj_sp->SetSyntheticChildrenGenerated(true);
-    return valobj_sp;
+lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromAddress(
+    const char *name, uint64_t address, const ExecutionContext &exe_ctx,
+    CompilerType type) {
+  ValueObjectSP valobj_sp(
+      ValueObject::CreateValueObjectFromAddress(name, address, exe_ctx, type));
+  if (valobj_sp)
+    valobj_sp->SetSyntheticChildrenGenerated(true);
+  return valobj_sp;
 }
 
-lldb::ValueObjectSP
-SyntheticChildrenFrontEnd::CreateValueObjectFromData (const char* name,
-                                                      const DataExtractor& data,
-                                                      const ExecutionContext& exe_ctx,
-                                                      CompilerType type)
-{
-    ValueObjectSP valobj_sp(ValueObject::CreateValueObjectFromData(name, data, exe_ctx, type));
-    if (valobj_sp)
-        valobj_sp->SetSyntheticChildrenGenerated(true);
-    return valobj_sp;
+lldb::ValueObjectSP SyntheticChildrenFrontEnd::CreateValueObjectFromData(
+    const char *name, const DataExtractor &data,
+    const ExecutionContext &exe_ctx, CompilerType type) {
+  ValueObjectSP valobj_sp(
+      ValueObject::CreateValueObjectFromData(name, data, exe_ctx, type));
+  if (valobj_sp)
+    valobj_sp->SetSyntheticChildrenGenerated(true);
+  return valobj_sp;
 }
 
 #ifndef LLDB_DISABLE_PYTHON
 
-ScriptedSyntheticChildren::FrontEnd::FrontEnd(std::string pclass, ValueObject &backend) :
-SyntheticChildrenFrontEnd(backend),
-m_python_class(pclass),
-m_wrapper_sp(),
-m_interpreter(NULL)
-{
-    if (backend == LLDB_INVALID_UID)
-        return;
-    
-    TargetSP target_sp = backend.GetTargetSP();
-    
-    if (!target_sp)
-        return;
-    
-    m_interpreter = target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
-    
-    if (m_interpreter != NULL)
-        m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(m_python_class.c_str(), backend.GetSP());
-}
+ScriptedSyntheticChildren::FrontEnd::FrontEnd(std::string pclass,
+                                              ValueObject &backend)
+    : SyntheticChildrenFrontEnd(backend), m_python_class(pclass),
+      m_wrapper_sp(), m_interpreter(NULL) {
+  if (backend == LLDB_INVALID_UID)
+    return;
+
+  TargetSP target_sp = backend.GetTargetSP();
 
-ScriptedSyntheticChildren::FrontEnd::~FrontEnd()
-{
+  if (!target_sp)
+    return;
+
+  m_interpreter =
+      target_sp->GetDebugger().GetCommandInterpreter().GetScriptInterpreter();
+
+  if (m_interpreter != NULL)
+    m_wrapper_sp = m_interpreter->CreateSyntheticScriptedProvider(
+        m_python_class.c_str(), backend.GetSP());
 }
 
+ScriptedSyntheticChildren::FrontEnd::~FrontEnd() {}
+
 lldb::ValueObjectSP
-ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex (size_t idx)
-{
-    if (!m_wrapper_sp || !m_interpreter)
-        return lldb::ValueObjectSP();
-    
-    return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
+ScriptedSyntheticChildren::FrontEnd::GetChildAtIndex(size_t idx) {
+  if (!m_wrapper_sp || !m_interpreter)
+    return lldb::ValueObjectSP();
+
+  return m_interpreter->GetChildAtIndex(m_wrapper_sp, idx);
 }
 
-bool
-ScriptedSyntheticChildren::FrontEnd::IsValid ()
-{
-    return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);
+bool ScriptedSyntheticChildren::FrontEnd::IsValid() {
+  return (m_wrapper_sp && m_wrapper_sp->IsValid() && m_interpreter);
 }
 
-size_t
-ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren ()
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return 0;
-    return m_interpreter->CalculateNumChildren(m_wrapper_sp, UINT32_MAX);
+size_t ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren() {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return 0;
+  return m_interpreter->CalculateNumChildren(m_wrapper_sp, UINT32_MAX);
 }
 
-size_t
-ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren (uint32_t max)
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return 0;
-    return m_interpreter->CalculateNumChildren(m_wrapper_sp, max);
+size_t ScriptedSyntheticChildren::FrontEnd::CalculateNumChildren(uint32_t max) {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return 0;
+  return m_interpreter->CalculateNumChildren(m_wrapper_sp, max);
 }
 
-bool
-ScriptedSyntheticChildren::FrontEnd::Update ()
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return false;
-    
-    return m_interpreter->UpdateSynthProviderInstance(m_wrapper_sp);
+bool ScriptedSyntheticChildren::FrontEnd::Update() {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return false;
+
+  return m_interpreter->UpdateSynthProviderInstance(m_wrapper_sp);
 }
 
-bool
-ScriptedSyntheticChildren::FrontEnd::MightHaveChildren ()
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return false;
-    
-    return m_interpreter->MightHaveChildrenSynthProviderInstance(m_wrapper_sp);
+bool ScriptedSyntheticChildren::FrontEnd::MightHaveChildren() {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return false;
+
+  return m_interpreter->MightHaveChildrenSynthProviderInstance(m_wrapper_sp);
 }
 
-size_t
-ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName (const ConstString &name)
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return UINT32_MAX;
-    return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp, name.GetCString());
+size_t ScriptedSyntheticChildren::FrontEnd::GetIndexOfChildWithName(
+    const ConstString &name) {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return UINT32_MAX;
+  return m_interpreter->GetIndexOfChildWithName(m_wrapper_sp,
+                                                name.GetCString());
 }
 
-lldb::ValueObjectSP
-ScriptedSyntheticChildren::FrontEnd::GetSyntheticValue ()
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return nullptr;
-    
-    return m_interpreter->GetSyntheticValue(m_wrapper_sp);
+lldb::ValueObjectSP ScriptedSyntheticChildren::FrontEnd::GetSyntheticValue() {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return nullptr;
+
+  return m_interpreter->GetSyntheticValue(m_wrapper_sp);
 }
 
-ConstString
-ScriptedSyntheticChildren::FrontEnd::GetSyntheticTypeName ()
-{
-    if (!m_wrapper_sp || m_interpreter == NULL)
-        return ConstString();
-    
-    return m_interpreter->GetSyntheticTypeName(m_wrapper_sp);
+ConstString ScriptedSyntheticChildren::FrontEnd::GetSyntheticTypeName() {
+  if (!m_wrapper_sp || m_interpreter == NULL)
+    return ConstString();
+
+  return m_interpreter->GetSyntheticTypeName(m_wrapper_sp);
 }
 
-std::string
-ScriptedSyntheticChildren::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf("%s%s%s Python class %s",
-                Cascades() ? "" : " (not cascading)",
-                SkipsPointers() ? " (skip pointers)" : "",
-                SkipsReferences() ? " (skip references)" : "",
-                m_python_class.c_str());
-    
-    return sstr.GetString();
+std::string ScriptedSyntheticChildren::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s Python class %s", Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "",
+              m_python_class.c_str());
+
+  return sstr.GetString();
 }
 
 #endif // #ifndef LLDB_DISABLE_PYTHON
diff --git a/lldb/source/DataFormatters/TypeValidator.cpp b/lldb/source/DataFormatters/TypeValidator.cpp
index b5efac8..2affd73 100644
--- a/lldb/source/DataFormatters/TypeValidator.cpp
+++ b/lldb/source/DataFormatters/TypeValidator.cpp
@@ -20,56 +20,39 @@
 using namespace lldb;
 using namespace lldb_private;
 
-TypeValidatorImpl::TypeValidatorImpl(const Flags &flags) :
-    m_flags(flags),
-    m_my_revision(0)
-{
-}
+TypeValidatorImpl::TypeValidatorImpl(const Flags &flags)
+    : m_flags(flags), m_my_revision(0) {}
 
-TypeValidatorImpl::~TypeValidatorImpl()
-{
-}
+TypeValidatorImpl::~TypeValidatorImpl() {}
 
-TypeValidatorImpl::ValidationResult
-TypeValidatorImpl::Success ()
-{
-    return ValidationResult { TypeValidatorResult::Success, "" };
+TypeValidatorImpl::ValidationResult TypeValidatorImpl::Success() {
+  return ValidationResult{TypeValidatorResult::Success, ""};
 }
 
 TypeValidatorImpl::ValidationResult
-TypeValidatorImpl::Failure (std::string message)
-{
-    return ValidationResult { TypeValidatorResult::Failure, message };
+TypeValidatorImpl::Failure(std::string message) {
+  return ValidationResult{TypeValidatorResult::Failure, message};
 }
 
-TypeValidatorImpl_CXX::TypeValidatorImpl_CXX (ValidatorFunction f, std::string d, const TypeValidatorImpl::Flags& flags) :
-    TypeValidatorImpl(flags),
-    m_description(d),
-    m_validator_function(f)
-{
-}
+TypeValidatorImpl_CXX::TypeValidatorImpl_CXX(
+    ValidatorFunction f, std::string d, const TypeValidatorImpl::Flags &flags)
+    : TypeValidatorImpl(flags), m_description(d), m_validator_function(f) {}
 
-TypeValidatorImpl_CXX::~TypeValidatorImpl_CXX()
-{
-}
+TypeValidatorImpl_CXX::~TypeValidatorImpl_CXX() {}
 
 TypeValidatorImpl::ValidationResult
-TypeValidatorImpl_CXX::FormatObject (ValueObject *valobj) const
-{
-    if (!valobj)
-        return Success(); // I guess there's nothing wrong with a null valueobject..
-    
-    return m_validator_function(valobj);
+TypeValidatorImpl_CXX::FormatObject(ValueObject *valobj) const {
+  if (!valobj)
+    return Success(); // I guess there's nothing wrong with a null valueobject..
+
+  return m_validator_function(valobj);
 }
 
-std::string
-TypeValidatorImpl_CXX::GetDescription()
-{
-    StreamString sstr;
-    sstr.Printf ("%s%s%s%s",
-                 m_description.c_str(),
-                 Cascades() ? "" : " (not cascading)",
-                 SkipsPointers() ? " (skip pointers)" : "",
-                 SkipsReferences() ? " (skip references)" : "");
-    return sstr.GetString();
+std::string TypeValidatorImpl_CXX::GetDescription() {
+  StreamString sstr;
+  sstr.Printf("%s%s%s%s", m_description.c_str(),
+              Cascades() ? "" : " (not cascading)",
+              SkipsPointers() ? " (skip pointers)" : "",
+              SkipsReferences() ? " (skip references)" : "");
+  return sstr.GetString();
 }
diff --git a/lldb/source/DataFormatters/ValueObjectPrinter.cpp b/lldb/source/DataFormatters/ValueObjectPrinter.cpp
index 167afca7f..b8ccc7a 100644
--- a/lldb/source/DataFormatters/ValueObjectPrinter.cpp
+++ b/lldb/source/DataFormatters/ValueObjectPrinter.cpp
@@ -1,4 +1,5 @@
-//===-- ValueObjectPrinter.cpp -------------------------------------*- C++ -*-===//
+//===-- ValueObjectPrinter.cpp -------------------------------------*- C++
+//-*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
@@ -23,952 +24,824 @@
 using namespace lldb;
 using namespace lldb_private;
 
-ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
-                                        Stream* s)
-{
-    if (valobj)
-    {
-        DumpValueObjectOptions options(*valobj);
-        Init (valobj,s,options,m_options.m_max_ptr_depth,0, nullptr);
-    }
-    else
-    {
-        DumpValueObjectOptions options;
-        Init (valobj,s,options,m_options.m_max_ptr_depth,0, nullptr);
-    }
-}
+ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s) {
+  if (valobj) {
+    DumpValueObjectOptions options(*valobj);
+    Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
+  } else {
+    DumpValueObjectOptions options;
+    Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
+  }
+}
+
+ValueObjectPrinter::ValueObjectPrinter(ValueObject *valobj, Stream *s,
+                                       const DumpValueObjectOptions &options) {
+  Init(valobj, s, options, m_options.m_max_ptr_depth, 0, nullptr);
+}
+
+ValueObjectPrinter::ValueObjectPrinter(
+    ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
+    const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
+    InstancePointersSetSP printed_instance_pointers) {
+  Init(valobj, s, options, ptr_depth, curr_depth, printed_instance_pointers);
+}
+
+void ValueObjectPrinter::Init(
+    ValueObject *valobj, Stream *s, const DumpValueObjectOptions &options,
+    const DumpValueObjectOptions::PointerDepth &ptr_depth, uint32_t curr_depth,
+    InstancePointersSetSP printed_instance_pointers) {
+  m_orig_valobj = valobj;
+  m_valobj = nullptr;
+  m_stream = s;
+  m_options = options;
+  m_ptr_depth = ptr_depth;
+  m_curr_depth = curr_depth;
+  assert(m_orig_valobj && "cannot print a NULL ValueObject");
+  assert(m_stream && "cannot print to a NULL Stream");
+  m_should_print = eLazyBoolCalculate;
+  m_is_nil = eLazyBoolCalculate;
+  m_is_uninit = eLazyBoolCalculate;
+  m_is_ptr = eLazyBoolCalculate;
+  m_is_ref = eLazyBoolCalculate;
+  m_is_aggregate = eLazyBoolCalculate;
+  m_is_instance_ptr = eLazyBoolCalculate;
+  m_summary_formatter = {nullptr, false};
+  m_value.assign("");
+  m_summary.assign("");
+  m_error.assign("");
+  m_val_summary_ok = false;
+  m_printed_instance_pointers =
+      printed_instance_pointers
+          ? printed_instance_pointers
+          : InstancePointersSetSP(new InstancePointersSet());
+}
+
+bool ValueObjectPrinter::PrintValueObject() {
+  if (!GetMostSpecializedValue() || m_valobj == nullptr)
+    return false;
 
-ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
-                                        Stream* s,
-                                        const DumpValueObjectOptions& options)
-{
-    Init(valobj,s,options,m_options.m_max_ptr_depth,0, nullptr);
-}
-
-ValueObjectPrinter::ValueObjectPrinter (ValueObject* valobj,
-                                        Stream* s,
-                                        const DumpValueObjectOptions& options,
-                                        const DumpValueObjectOptions::PointerDepth& ptr_depth,
-                                        uint32_t curr_depth,
-                                        InstancePointersSetSP printed_instance_pointers)
-{
-    Init(valobj,s,options,ptr_depth,curr_depth, printed_instance_pointers);
-}
-
-void
-ValueObjectPrinter::Init (ValueObject* valobj,
-                          Stream* s,
-                          const DumpValueObjectOptions& options,
-                          const DumpValueObjectOptions::PointerDepth& ptr_depth,
-                          uint32_t curr_depth,
-                          InstancePointersSetSP printed_instance_pointers)
-{
-    m_orig_valobj = valobj;
-    m_valobj = nullptr;
-    m_stream = s;
-    m_options = options;
-    m_ptr_depth = ptr_depth;
-    m_curr_depth = curr_depth;
-    assert (m_orig_valobj && "cannot print a NULL ValueObject");
-    assert (m_stream && "cannot print to a NULL Stream");
-    m_should_print = eLazyBoolCalculate;
-    m_is_nil = eLazyBoolCalculate;
-    m_is_uninit = eLazyBoolCalculate;
-    m_is_ptr = eLazyBoolCalculate;
-    m_is_ref = eLazyBoolCalculate;
-    m_is_aggregate = eLazyBoolCalculate;
-    m_is_instance_ptr = eLazyBoolCalculate;
-    m_summary_formatter = {nullptr,false};
-    m_value.assign("");
-    m_summary.assign("");
-    m_error.assign("");
-    m_val_summary_ok = false;
-    m_printed_instance_pointers = printed_instance_pointers ? printed_instance_pointers : InstancePointersSetSP(new InstancePointersSet());
-}
-
-bool
-ValueObjectPrinter::PrintValueObject ()
-{
-    if (!GetMostSpecializedValue () || m_valobj == nullptr)
-        return false;
-    
-    if (ShouldPrintValueObject())
-    {
-        PrintValidationMarkerIfNeeded();
-        
-        PrintLocationIfNeeded();
-        m_stream->Indent();
-        
-        PrintDecl();
-    }
+  if (ShouldPrintValueObject()) {
+    PrintValidationMarkerIfNeeded();
 
-    bool value_printed = false;
-    bool summary_printed = false;
-    
-    m_val_summary_ok = PrintValueAndSummaryIfNeeded (value_printed,summary_printed);
+    PrintLocationIfNeeded();
+    m_stream->Indent();
 
-    if (m_val_summary_ok)
-        PrintChildrenIfNeeded (value_printed, summary_printed);
-    else
-        m_stream->EOL();
-    
-    PrintValidationErrorIfNeeded();
-    
-    return true;
+    PrintDecl();
+  }
+
+  bool value_printed = false;
+  bool summary_printed = false;
+
+  m_val_summary_ok =
+      PrintValueAndSummaryIfNeeded(value_printed, summary_printed);
+
+  if (m_val_summary_ok)
+    PrintChildrenIfNeeded(value_printed, summary_printed);
+  else
+    m_stream->EOL();
+
+  PrintValidationErrorIfNeeded();
+
+  return true;
 }
 
-bool
-ValueObjectPrinter::GetMostSpecializedValue ()
-{
-    if (m_valobj)
-        return true;
-    bool update_success = m_orig_valobj->UpdateValueIfNeeded (true);
-    if (!update_success)
-    {
-        m_valobj = m_orig_valobj;
-    }
-    else
-    {
-        if (m_orig_valobj->IsDynamic())
-        {
-            if (m_options.m_use_dynamic == eNoDynamicValues)
-            {
-                ValueObject *static_value = m_orig_valobj->GetStaticValue().get();
-                if (static_value)
-                    m_valobj = static_value;
-                else
-                    m_valobj = m_orig_valobj;
-            }
-            else
-                m_valobj = m_orig_valobj;
-        }
+bool ValueObjectPrinter::GetMostSpecializedValue() {
+  if (m_valobj)
+    return true;
+  bool update_success = m_orig_valobj->UpdateValueIfNeeded(true);
+  if (!update_success) {
+    m_valobj = m_orig_valobj;
+  } else {
+    if (m_orig_valobj->IsDynamic()) {
+      if (m_options.m_use_dynamic == eNoDynamicValues) {
+        ValueObject *static_value = m_orig_valobj->GetStaticValue().get();
+        if (static_value)
+          m_valobj = static_value;
         else
-        {
-            if (m_options.m_use_dynamic != eNoDynamicValues)
-            {
-                ValueObject *dynamic_value = m_orig_valobj->GetDynamicValue(m_options.m_use_dynamic).get();
-                if (dynamic_value)
-                    m_valobj = dynamic_value;
-                else
-                    m_valobj = m_orig_valobj;
-            }
-            else
-                m_valobj = m_orig_valobj;
-        }
-        
-        if (m_valobj->IsSynthetic())
-        {
-            if (m_options.m_use_synthetic == false)
-            {
-                ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get();
-                if (non_synthetic)
-                    m_valobj = non_synthetic;
-            }
-        }
+          m_valobj = m_orig_valobj;
+      } else
+        m_valobj = m_orig_valobj;
+    } else {
+      if (m_options.m_use_dynamic != eNoDynamicValues) {
+        ValueObject *dynamic_value =
+            m_orig_valobj->GetDynamicValue(m_options.m_use_dynamic).get();
+        if (dynamic_value)
+          m_valobj = dynamic_value;
         else
-        {
-            if (m_options.m_use_synthetic == true)
-            {
-                ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
-                if (synthetic)
-                    m_valobj = synthetic;
-            }
-        }
+          m_valobj = m_orig_valobj;
+      } else
+        m_valobj = m_orig_valobj;
     }
-    m_compiler_type = m_valobj->GetCompilerType();
-    m_type_flags = m_compiler_type.GetTypeInfo ();
-    return true;
-}
 
-const char*
-ValueObjectPrinter::GetDescriptionForDisplay ()
-{
-    const char* str = m_valobj->GetObjectDescription();
-    if (!str)
-        str = m_valobj->GetSummaryAsCString();
-    if (!str)
-        str = m_valobj->GetValueAsCString();
-    return str;
-}
-
-const char*
-ValueObjectPrinter::GetRootNameForDisplay (const char* if_fail)
-{
-    const char *root_valobj_name = m_options.m_root_valobj_name.empty() ?
-        m_valobj->GetName().AsCString() :
-        m_options.m_root_valobj_name.c_str();
-    return root_valobj_name ? root_valobj_name : if_fail;
-}
-
-bool
-ValueObjectPrinter::ShouldPrintValueObject ()
-{
-    if (m_should_print == eLazyBoolCalculate)
-        m_should_print = (m_options.m_flat_output == false || m_type_flags.Test (eTypeHasValue)) ? eLazyBoolYes : eLazyBoolNo;
-    return m_should_print == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsNil ()
-{
-    if (m_is_nil == eLazyBoolCalculate)
-        m_is_nil = m_valobj->IsNilReference() ? eLazyBoolYes : eLazyBoolNo;
-    return m_is_nil == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsUninitialized ()
-{
-    if (m_is_uninit == eLazyBoolCalculate)
-        m_is_uninit = m_valobj->IsUninitializedReference() ? eLazyBoolYes : eLazyBoolNo;
-    return m_is_uninit == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsPtr ()
-{
-    if (m_is_ptr == eLazyBoolCalculate)
-        m_is_ptr = m_type_flags.Test (eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
-    return m_is_ptr == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsRef ()
-{
-    if (m_is_ref == eLazyBoolCalculate)
-        m_is_ref = m_type_flags.Test (eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
-    return m_is_ref == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsAggregate ()
-{
-    if (m_is_aggregate == eLazyBoolCalculate)
-        m_is_aggregate = m_type_flags.Test (eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
-    return m_is_aggregate == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::IsInstancePointer ()
-{
-    // you need to do this check on the value's clang type
-    if (m_is_instance_ptr == eLazyBoolCalculate)
-        m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() & eTypeInstanceIsPointer) != 0 ? eLazyBoolYes : eLazyBoolNo;
-    if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
-        m_is_instance_ptr = eLazyBoolNo;
-    return m_is_instance_ptr == eLazyBoolYes;
-}
-
-bool
-ValueObjectPrinter::PrintLocationIfNeeded ()
-{
-    if (m_options.m_show_location)
-    {
-        m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
-        return true;
+    if (m_valobj->IsSynthetic()) {
+      if (m_options.m_use_synthetic == false) {
+        ValueObject *non_synthetic = m_valobj->GetNonSyntheticValue().get();
+        if (non_synthetic)
+          m_valobj = non_synthetic;
+      }
+    } else {
+      if (m_options.m_use_synthetic == true) {
+        ValueObject *synthetic = m_valobj->GetSyntheticValue().get();
+        if (synthetic)
+          m_valobj = synthetic;
+      }
     }
-    return false;
+  }
+  m_compiler_type = m_valobj->GetCompilerType();
+  m_type_flags = m_compiler_type.GetTypeInfo();
+  return true;
 }
 
-void
-ValueObjectPrinter::PrintDecl ()
-{
-    bool show_type = true;
-    // if we are at the root-level and been asked to hide the root's type, then hide it
-    if (m_curr_depth == 0 && m_options.m_hide_root_type)
-        show_type = false;
-    else
-        // otherwise decide according to the usual rules (asked to show types - always at the root level)
-        show_type = m_options.m_show_types || (m_curr_depth == 0 && !m_options.m_flat_output);
-    
-    StreamString typeName;
-    
-    // always show the type at the root level if it is invalid
-    if (show_type)
-    {
-        // Some ValueObjects don't have types (like registers sets). Only print
-        // the type if there is one to print
-        ConstString type_name;
-        if (m_compiler_type.IsValid())
-        {
-            if (m_options.m_use_type_display_name)
-                type_name = m_valobj->GetDisplayTypeName();
-            else
-                type_name = m_valobj->GetQualifiedTypeName();
-        }
-        else
-        {
-            // only show an invalid type name if the user explicitly triggered show_type
-            if (m_options.m_show_types)
-                type_name = ConstString("<invalid type>");
-            else
-                type_name.Clear();
-        }
-        
-        if (type_name)
-        {
-            std::string type_name_str(type_name.GetCString());
-            if (m_options.m_hide_pointer_value)
-            {
-                for(auto iter = type_name_str.find(" *");
-                    iter != std::string::npos;
-                    iter = type_name_str.find(" *"))
-                {
-                    type_name_str.erase(iter, 2);
-                }
-            }
-            typeName.Printf("%s", type_name_str.c_str());
-        }
-    }
-    
-    StreamString varName;
-    
-    if (m_options.m_flat_output)
-    {
-        // If we are showing types, also qualify the C++ base classes
-        const bool qualify_cxx_base_classes = show_type;
-        if (!m_options.m_hide_name)
-        {
-            m_valobj->GetExpressionPath(varName, qualify_cxx_base_classes);
-        }
-    }
-    else if (!m_options.m_hide_name)
-    {
-        const char *name_cstr = GetRootNameForDisplay("");
-        varName.Printf ("%s", name_cstr);
-    }
-    
-    bool decl_printed = false;
-    if (!m_options.m_decl_printing_helper)
-    {
-        // if the user didn't give us a custom helper, pick one based upon the language, either the one that this printer is bound to, or the preferred one for the ValueObject
-        lldb::LanguageType lang_type = (m_options.m_varformat_language == lldb::eLanguageTypeUnknown) ? m_valobj->GetPreferredDisplayLanguage() : m_options.m_varformat_language;
-        if (Language *lang_plugin = Language::FindPlugin(lang_type))
-        {
-            m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper();
-        }
-    }
-    
-    if (m_options.m_decl_printing_helper)
-    {
-        ConstString type_name_cstr(typeName.GetData());
-        ConstString var_name_cstr(varName.GetData());
-        
-        StreamString dest_stream;
-        if (m_options.m_decl_printing_helper (type_name_cstr,
-                                              var_name_cstr,
-                                              m_options,
-                                              dest_stream))
-        {
-            decl_printed = true;
-            m_stream->Printf("%s", dest_stream.GetData());
-        }
-    }
-    
-    // if the helper failed, or there is none, do a default thing
-    if (!decl_printed)
-    {
-        if (typeName.GetSize())
-            m_stream->Printf("(%s) ", typeName.GetData());
-        if (varName.GetSize())
-            m_stream->Printf("%s =", varName.GetData());
-        else if (!m_options.m_hide_name)
-            m_stream->Printf(" =");
-    }
+const char *ValueObjectPrinter::GetDescriptionForDisplay() {
+  const char *str = m_valobj->GetObjectDescription();
+  if (!str)
+    str = m_valobj->GetSummaryAsCString();
+  if (!str)
+    str = m_valobj->GetValueAsCString();
+  return str;
 }
 
-bool
-ValueObjectPrinter::CheckScopeIfNeeded ()
-{
-    if (m_options.m_scope_already_checked)
-        return true;
-    return m_valobj->IsInScope();
-}
-
-TypeSummaryImpl*
-ValueObjectPrinter::GetSummaryFormatter (bool null_if_omitted)
-{
-    if (m_summary_formatter.second == false)
-    {
-        TypeSummaryImpl* entry = m_options.m_summary_sp ? m_options.m_summary_sp.get() : m_valobj->GetSummaryFormat().get();
-        
-        if (m_options.m_omit_summary_depth > 0)
-            entry = NULL;
-        m_summary_formatter.first = entry;
-        m_summary_formatter.second = true;
-    }
-    if (m_options.m_omit_summary_depth > 0 && null_if_omitted)
-        return nullptr;
-    return m_summary_formatter.first;
+const char *ValueObjectPrinter::GetRootNameForDisplay(const char *if_fail) {
+  const char *root_valobj_name = m_options.m_root_valobj_name.empty()
+                                     ? m_valobj->GetName().AsCString()
+                                     : m_options.m_root_valobj_name.c_str();
+  return root_valobj_name ? root_valobj_name : if_fail;
 }
 
-static bool
-IsPointerValue (const CompilerType &type)
-{
-    Flags type_flags(type.GetTypeInfo());
-    if (type_flags.AnySet(eTypeInstanceIsPointer | eTypeIsPointer))
-        return type_flags.AllClear(eTypeIsBuiltIn);
-    return false;
+bool ValueObjectPrinter::ShouldPrintValueObject() {
+  if (m_should_print == eLazyBoolCalculate)
+    m_should_print =
+        (m_options.m_flat_output == false || m_type_flags.Test(eTypeHasValue))
+            ? eLazyBoolYes
+            : eLazyBoolNo;
+  return m_should_print == eLazyBoolYes;
 }
 
-void
-ValueObjectPrinter::GetValueSummaryError (std::string& value,
-                                          std::string& summary,
-                                          std::string& error)
-{
-    lldb::Format format = m_options.m_format;
-    // if I am printing synthetized elements, apply the format to those elements only
-    if (m_options.m_element_count > 0)
-        m_valobj->GetValueAsCString(lldb::eFormatDefault, value);
-    else if (format != eFormatDefault && format != m_valobj->GetFormat())
-        m_valobj->GetValueAsCString(format, value);
-    else
-    {
-        const char* val_cstr = m_valobj->GetValueAsCString();
-        if (val_cstr)
-            value.assign(val_cstr);
-    }
-    const char* err_cstr = m_valobj->GetError().AsCString();
-    if (err_cstr)
-        error.assign(err_cstr);
-    
-    if (ShouldPrintValueObject())
-    {
-        if (IsNil())
-            summary.assign("nil");
-        else if (IsUninitialized())
-            summary.assign("<uninitialized>");
-        else if (m_options.m_omit_summary_depth == 0)
-        {
-            TypeSummaryImpl* entry = GetSummaryFormatter();
-            if (entry)
-                m_valobj->GetSummaryAsCString(entry, summary, m_options.m_varformat_language);
-            else
-            {
-                const char* sum_cstr = m_valobj->GetSummaryAsCString(m_options.m_varformat_language);
-                if (sum_cstr)
-                    summary.assign(sum_cstr);
-            }
-        }
-    }
+bool ValueObjectPrinter::IsNil() {
+  if (m_is_nil == eLazyBoolCalculate)
+    m_is_nil = m_valobj->IsNilReference() ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_nil == eLazyBoolYes;
 }
 
-bool
-ValueObjectPrinter::PrintValueAndSummaryIfNeeded (bool& value_printed,
-                                                  bool& summary_printed)
-{
-    bool error_printed = false;
-    if (ShouldPrintValueObject())
-    {
-        if (!CheckScopeIfNeeded())
-            m_error.assign("out of scope");
-        if (m_error.empty())
-        {
-            GetValueSummaryError(m_value, m_summary, m_error);
-        }
-        if (m_error.size())
-        {
-            // we need to support scenarios in which it is actually fine for a value to have no type
-            // but - on the other hand - if we get an error *AND* have no type, we try to get out
-            // gracefully, since most often that combination means "could not resolve a type"
-            // and the default failure mode is quite ugly
-            if (!m_compiler_type.IsValid())
-            {
-                m_stream->Printf(" <could not resolve type>");
-                return false;
-            }
-            
-            error_printed = true;
-            m_stream->Printf (" <%s>\n", m_error.c_str());
-        }
-        else
-        {
-            // Make sure we have a value and make sure the summary didn't
-            // specify that the value should not be printed - and do not print
-            // the value if this thing is nil
-            // (but show the value if the user passes a format explicitly)
-            TypeSummaryImpl* entry = GetSummaryFormatter();
-            if (!IsNil() && !IsUninitialized() && !m_value.empty() && (entry == NULL || (entry->DoesPrintValue(m_valobj) || m_options.m_format != eFormatDefault) || m_summary.empty()) && !m_options.m_hide_value)
-            {
-                if (m_options.m_hide_pointer_value && IsPointerValue(m_valobj->GetCompilerType())) {}
-                else
-                {
-                    m_stream->Printf(" %s", m_value.c_str());
-                    value_printed = true;
-                }
-            }
-            
-            if (m_summary.size())
-            {
-                m_stream->Printf(" %s", m_summary.c_str());
-                summary_printed = true;
-            }
-        }
-    }
-    return !error_printed;
+bool ValueObjectPrinter::IsUninitialized() {
+  if (m_is_uninit == eLazyBoolCalculate)
+    m_is_uninit =
+        m_valobj->IsUninitializedReference() ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_uninit == eLazyBoolYes;
 }
 
-bool
-ValueObjectPrinter::PrintObjectDescriptionIfNeeded (bool value_printed,
-                                                    bool summary_printed)
-{
-    if (ShouldPrintValueObject())
-    {
-        // let's avoid the overly verbose no description error for a nil thing
-        if (m_options.m_use_objc && !IsNil() && !IsUninitialized() && (m_options.m_element_count == 0))
-        {
-            if (!m_options.m_hide_value || !m_options.m_hide_name)
-                m_stream->Printf(" ");
-            const char *object_desc = nullptr;
-            if (value_printed || summary_printed)
-                object_desc = m_valobj->GetObjectDescription();
-            else
-                object_desc = GetDescriptionForDisplay();
-            if (object_desc && *object_desc)
-            {
-                m_stream->Printf("%s\n", object_desc);
-                return true;
-            }
-            else if (value_printed == false && summary_printed == false)
-                return true;
-            else
-                return false;
-        }
-    }
-    return true;
+bool ValueObjectPrinter::IsPtr() {
+  if (m_is_ptr == eLazyBoolCalculate)
+    m_is_ptr = m_type_flags.Test(eTypeIsPointer) ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_ptr == eLazyBoolYes;
 }
 
-bool
-DumpValueObjectOptions::PointerDepth::CanAllowExpansion (bool is_root,
-                                                         TypeSummaryImpl* entry,
-                                                         ValueObject *valobj,
-                                                         const std::string& summary)
-{
-    switch (m_mode)
-    {
-        case Mode::Always:
-            return (m_count > 0);
-        case Mode::Never:
-            return false;
-        case Mode::Default:
-            if (is_root)
-                m_count = std::min<decltype(m_count)>(m_count,1);
-            return m_count > 0;
-        case Mode::Formatters:
-            if (!entry || entry->DoesPrintChildren(valobj) || summary.empty())
-                return m_count > 0;
-            return false;
-    }
-    return false;
+bool ValueObjectPrinter::IsRef() {
+  if (m_is_ref == eLazyBoolCalculate)
+    m_is_ref = m_type_flags.Test(eTypeIsReference) ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_ref == eLazyBoolYes;
 }
 
-bool
-DumpValueObjectOptions::PointerDepth::CanAllowExpansion () const
-{
-    switch (m_mode)
-    {
-        case Mode::Always:
-        case Mode::Default:
-        case Mode::Formatters:
-            return (m_count > 0);
-        case Mode::Never:
-            return false;
-    }
-    return false;
+bool ValueObjectPrinter::IsAggregate() {
+  if (m_is_aggregate == eLazyBoolCalculate)
+    m_is_aggregate =
+        m_type_flags.Test(eTypeHasChildren) ? eLazyBoolYes : eLazyBoolNo;
+  return m_is_aggregate == eLazyBoolYes;
+}
+
+bool ValueObjectPrinter::IsInstancePointer() {
+  // you need to do this check on the value's clang type
+  if (m_is_instance_ptr == eLazyBoolCalculate)
+    m_is_instance_ptr = (m_valobj->GetValue().GetCompilerType().GetTypeInfo() &
+                         eTypeInstanceIsPointer) != 0
+                            ? eLazyBoolYes
+                            : eLazyBoolNo;
+  if ((eLazyBoolYes == m_is_instance_ptr) && m_valobj->IsBaseClass())
+    m_is_instance_ptr = eLazyBoolNo;
+  return m_is_instance_ptr == eLazyBoolYes;
+}
+
+bool ValueObjectPrinter::PrintLocationIfNeeded() {
+  if (m_options.m_show_location) {
+    m_stream->Printf("%s: ", m_valobj->GetLocationAsCString());
+    return true;
+  }
+  return false;
+}
+
+void ValueObjectPrinter::PrintDecl() {
+  bool show_type = true;
+  // if we are at the root-level and been asked to hide the root's type, then
+  // hide it
+  if (m_curr_depth == 0 && m_options.m_hide_root_type)
+    show_type = false;
+  else
+    // otherwise decide according to the usual rules (asked to show types -
+    // always at the root level)
+    show_type = m_options.m_show_types ||
+                (m_curr_depth == 0 && !m_options.m_flat_output);
+
+  StreamString typeName;
+
+  // always show the type at the root level if it is invalid
+  if (show_type) {
+    // Some ValueObjects don't have types (like registers sets). Only print
+    // the type if there is one to print
+    ConstString type_name;
+    if (m_compiler_type.IsValid()) {
+      if (m_options.m_use_type_display_name)
+        type_name = m_valobj->GetDisplayTypeName();
+      else
+        type_name = m_valobj->GetQualifiedTypeName();
+    } else {
+      // only show an invalid type name if the user explicitly triggered
+      // show_type
+      if (m_options.m_show_types)
+        type_name = ConstString("<invalid type>");
+      else
+        type_name.Clear();
+    }
+
+    if (type_name) {
+      std::string type_name_str(type_name.GetCString());
+      if (m_options.m_hide_pointer_value) {
+        for (auto iter = type_name_str.find(" *"); iter != std::string::npos;
+             iter = type_name_str.find(" *")) {
+          type_name_str.erase(iter, 2);
+        }
+      }
+      typeName.Printf("%s", type_name_str.c_str());
+    }
+  }
+
+  StreamString varName;
+
+  if (m_options.m_flat_output) {
+    // If we are showing types, also qualify the C++ base classes
+    const bool qualify_cxx_base_classes = show_type;
+    if (!m_options.m_hide_name) {
+      m_valobj->GetExpressionPath(varName, qualify_cxx_base_classes);
+    }
+  } else if (!m_options.m_hide_name) {
+    const char *name_cstr = GetRootNameForDisplay("");
+    varName.Printf("%s", name_cstr);
+  }
+
+  bool decl_printed = false;
+  if (!m_options.m_decl_printing_helper) {
+    // if the user didn't give us a custom helper, pick one based upon the
+    // language, either the one that this printer is bound to, or the preferred
+    // one for the ValueObject
+    lldb::LanguageType lang_type =
+        (m_options.m_varformat_language == lldb::eLanguageTypeUnknown)
+            ? m_valobj->GetPreferredDisplayLanguage()
+            : m_options.m_varformat_language;
+    if (Language *lang_plugin = Language::FindPlugin(lang_type)) {
+      m_options.m_decl_printing_helper = lang_plugin->GetDeclPrintingHelper();
+    }
+  }
+
+  if (m_options.m_decl_printing_helper) {
+    ConstString type_name_cstr(typeName.GetData());
+    ConstString var_name_cstr(varName.GetData());
+
+    StreamString dest_stream;
+    if (m_options.m_decl_printing_helper(type_name_cstr, var_name_cstr,
+                                         m_options, dest_stream)) {
+      decl_printed = true;
+      m_stream->Printf("%s", dest_stream.GetData());
+    }
+  }
+
+  // if the helper failed, or there is none, do a default thing
+  if (!decl_printed) {
+    if (typeName.GetSize())
+      m_stream->Printf("(%s) ", typeName.GetData());
+    if (varName.GetSize())
+      m_stream->Printf("%s =", varName.GetData());
+    else if (!m_options.m_hide_name)
+      m_stream->Printf(" =");
+  }
 }
 
-bool
-ValueObjectPrinter::ShouldPrintChildren (bool is_failed_description,
-                                         DumpValueObjectOptions::PointerDepth& curr_ptr_depth)
-{
-    const bool is_ref = IsRef ();
-    const bool is_ptr = IsPtr ();
-    const bool is_uninit = IsUninitialized();
-    
-    if (is_uninit)
+bool ValueObjectPrinter::CheckScopeIfNeeded() {
+  if (m_options.m_scope_already_checked)
+    return true;
+  return m_valobj->IsInScope();
+}
+
+TypeSummaryImpl *ValueObjectPrinter::GetSummaryFormatter(bool null_if_omitted) {
+  if (m_summary_formatter.second == false) {
+    TypeSummaryImpl *entry = m_options.m_summary_sp
+                                 ? m_options.m_summary_sp.get()
+                                 : m_valobj->GetSummaryFormat().get();
+
+    if (m_options.m_omit_summary_depth > 0)
+      entry = NULL;
+    m_summary_formatter.first = entry;
+    m_summary_formatter.second = true;
+  }
+  if (m_options.m_omit_summary_depth > 0 && null_if_omitted)
+    return nullptr;
+  return m_summary_formatter.first;
+}
+
+static bool IsPointerValue(const CompilerType &type) {
+  Flags type_flags(type.GetTypeInfo());
+  if (type_flags.AnySet(eTypeInstanceIsPointer | eTypeIsPointer))
+    return type_flags.AllClear(eTypeIsBuiltIn);
+  return false;
+}
+
+void ValueObjectPrinter::GetValueSummaryError(std::string &value,
+                                              std::string &summary,
+                                              std::string &error) {
+  lldb::Format format = m_options.m_format;
+  // if I am printing synthetized elements, apply the format to those elements
+  // only
+  if (m_options.m_element_count > 0)
+    m_valobj->GetValueAsCString(lldb::eFormatDefault, value);
+  else if (format != eFormatDefault && format != m_valobj->GetFormat())
+    m_valobj->GetValueAsCString(format, value);
+  else {
+    const char *val_cstr = m_valobj->GetValueAsCString();
+    if (val_cstr)
+      value.assign(val_cstr);
+  }
+  const char *err_cstr = m_valobj->GetError().AsCString();
+  if (err_cstr)
+    error.assign(err_cstr);
+
+  if (ShouldPrintValueObject()) {
+    if (IsNil())
+      summary.assign("nil");
+    else if (IsUninitialized())
+      summary.assign("<uninitialized>");
+    else if (m_options.m_omit_summary_depth == 0) {
+      TypeSummaryImpl *entry = GetSummaryFormatter();
+      if (entry)
+        m_valobj->GetSummaryAsCString(entry, summary,
+                                      m_options.m_varformat_language);
+      else {
+        const char *sum_cstr =
+            m_valobj->GetSummaryAsCString(m_options.m_varformat_language);
+        if (sum_cstr)
+          summary.assign(sum_cstr);
+      }
+    }
+  }
+}
+
+bool ValueObjectPrinter::PrintValueAndSummaryIfNeeded(bool &value_printed,
+                                                      bool &summary_printed) {
+  bool error_printed = false;
+  if (ShouldPrintValueObject()) {
+    if (!CheckScopeIfNeeded())
+      m_error.assign("out of scope");
+    if (m_error.empty()) {
+      GetValueSummaryError(m_value, m_summary, m_error);
+    }
+    if (m_error.size()) {
+      // we need to support scenarios in which it is actually fine for a value
+      // to have no type
+      // but - on the other hand - if we get an error *AND* have no type, we try
+      // to get out
+      // gracefully, since most often that combination means "could not resolve
+      // a type"
+      // and the default failure mode is quite ugly
+      if (!m_compiler_type.IsValid()) {
+        m_stream->Printf(" <could not resolve type>");
         return false;
-    
-    // if the user has specified an element count, always print children
-    // as it is explicit user demand being honored
-    if (m_options.m_element_count > 0)
+      }
+
+      error_printed = true;
+      m_stream->Printf(" <%s>\n", m_error.c_str());
+    } else {
+      // Make sure we have a value and make sure the summary didn't
+      // specify that the value should not be printed - and do not print
+      // the value if this thing is nil
+      // (but show the value if the user passes a format explicitly)
+      TypeSummaryImpl *entry = GetSummaryFormatter();
+      if (!IsNil() && !IsUninitialized() && !m_value.empty() &&
+          (entry == NULL || (entry->DoesPrintValue(m_valobj) ||
+                             m_options.m_format != eFormatDefault) ||
+           m_summary.empty()) &&
+          !m_options.m_hide_value) {
+        if (m_options.m_hide_pointer_value &&
+            IsPointerValue(m_valobj->GetCompilerType())) {
+        } else {
+          m_stream->Printf(" %s", m_value.c_str());
+          value_printed = true;
+        }
+      }
+
+      if (m_summary.size()) {
+        m_stream->Printf(" %s", m_summary.c_str());
+        summary_printed = true;
+      }
+    }
+  }
+  return !error_printed;
+}
+
+bool ValueObjectPrinter::PrintObjectDescriptionIfNeeded(bool value_printed,
+                                                        bool summary_printed) {
+  if (ShouldPrintValueObject()) {
+    // let's avoid the overly verbose no description error for a nil thing
+    if (m_options.m_use_objc && !IsNil() && !IsUninitialized() &&
+        (m_options.m_element_count == 0)) {
+      if (!m_options.m_hide_value || !m_options.m_hide_name)
+        m_stream->Printf(" ");
+      const char *object_desc = nullptr;
+      if (value_printed || summary_printed)
+        object_desc = m_valobj->GetObjectDescription();
+      else
+        object_desc = GetDescriptionForDisplay();
+      if (object_desc && *object_desc) {
+        m_stream->Printf("%s\n", object_desc);
+        return true;
+      } else if (value_printed == false && summary_printed == false)
         return true;
-    
-    TypeSummaryImpl* entry = GetSummaryFormatter();
-    
-    if (m_options.m_use_objc)
+      else
         return false;
-    
-    if (is_failed_description || m_curr_depth < m_options.m_max_depth)
-    {
-        // We will show children for all concrete types. We won't show
-        // pointer contents unless a pointer depth has been specified.
-        // We won't reference contents unless the reference is the
-        // root object (depth of zero).
-        
-        // Use a new temporary pointer depth in case we override the
-        // current pointer depth below...
-        
-        if (is_ptr || is_ref)
-        {
-            // We have a pointer or reference whose value is an address.
-            // Make sure that address is not NULL
-            AddressType ptr_address_type;
-            if (m_valobj->GetPointerValue (&ptr_address_type) == 0)
-                return false;
-            
-            const bool is_root_level = m_curr_depth == 0;
-            
-            if (is_ref &&
-                is_root_level)
-            {
-                // If this is the root object (depth is zero) that we are showing
-                // and it is a reference, and no pointer depth has been supplied
-                // print out what it references. Don't do this at deeper depths
-                // otherwise we can end up with infinite recursion...
-                return true;
-            }
-            
-            return curr_ptr_depth.CanAllowExpansion(false, entry, m_valobj, m_summary);
-        }
-        
-        return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
     }
-    return false;
+  }
+  return true;
 }
 
-bool
-ValueObjectPrinter::ShouldExpandEmptyAggregates ()
-{
-    TypeSummaryImpl* entry = GetSummaryFormatter();
-    
-    if (!entry)
-        return true;
-    
-    return entry->DoesPrintEmptyAggregates();
+bool DumpValueObjectOptions::PointerDepth::CanAllowExpansion(
+    bool is_root, TypeSummaryImpl *entry, ValueObject *valobj,
+    const std::string &summary) {
+  switch (m_mode) {
+  case Mode::Always:
+    return (m_count > 0);
+  case Mode::Never:
+    return false;
+  case Mode::Default:
+    if (is_root)
+      m_count = std::min<decltype(m_count)>(m_count, 1);
+    return m_count > 0;
+  case Mode::Formatters:
+    if (!entry || entry->DoesPrintChildren(valobj) || summary.empty())
+      return m_count > 0;
+    return false;
+  }
+  return false;
 }
 
-ValueObject*
-ValueObjectPrinter::GetValueObjectForChildrenGeneration ()
-{
-    return m_valobj;
+bool DumpValueObjectOptions::PointerDepth::CanAllowExpansion() const {
+  switch (m_mode) {
+  case Mode::Always:
+  case Mode::Default:
+  case Mode::Formatters:
+    return (m_count > 0);
+  case Mode::Never:
+    return false;
+  }
+  return false;
 }
 
-void
-ValueObjectPrinter::PrintChildrenPreamble ()
-{
-    if (m_options.m_flat_output)
-    {
-        if (ShouldPrintValueObject())
-            m_stream->EOL();
-    }
-    else
-    {
-        if (ShouldPrintValueObject())
-            m_stream->PutCString(IsRef () ? ": {\n" : " {\n");
-        m_stream->IndentMore();
+bool ValueObjectPrinter::ShouldPrintChildren(
+    bool is_failed_description,
+    DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
+  const bool is_ref = IsRef();
+  const bool is_ptr = IsPtr();
+  const bool is_uninit = IsUninitialized();
+
+  if (is_uninit)
+    return false;
+
+  // if the user has specified an element count, always print children
+  // as it is explicit user demand being honored
+  if (m_options.m_element_count > 0)
+    return true;
+
+  TypeSummaryImpl *entry = GetSummaryFormatter();
+
+  if (m_options.m_use_objc)
+    return false;
+
+  if (is_failed_description || m_curr_depth < m_options.m_max_depth) {
+    // We will show children for all concrete types. We won't show
+    // pointer contents unless a pointer depth has been specified.
+    // We won't reference contents unless the reference is the
+    // root object (depth of zero).
+
+    // Use a new temporary pointer depth in case we override the
+    // current pointer depth below...
+
+    if (is_ptr || is_ref) {
+      // We have a pointer or reference whose value is an address.
+      // Make sure that address is not NULL
+      AddressType ptr_address_type;
+      if (m_valobj->GetPointerValue(&ptr_address_type) == 0)
+        return false;
+
+      const bool is_root_level = m_curr_depth == 0;
+
+      if (is_ref && is_root_level) {
+        // If this is the root object (depth is zero) that we are showing
+        // and it is a reference, and no pointer depth has been supplied
+        // print out what it references. Don't do this at deeper depths
+        // otherwise we can end up with infinite recursion...
+        return true;
+      }
+
+      return curr_ptr_depth.CanAllowExpansion(false, entry, m_valobj,
+                                              m_summary);
     }
+
+    return (!entry || entry->DoesPrintChildren(m_valobj) || m_summary.empty());
+  }
+  return false;
 }
 
-void
-ValueObjectPrinter::PrintChild (ValueObjectSP child_sp,
-                                const DumpValueObjectOptions::PointerDepth& curr_ptr_depth)
-{
-    const uint32_t consumed_depth = (m_options.m_element_count == 0) ? 1 : 0;
-    const bool does_consume_ptr_depth = ((IsPtr() && m_options.m_element_count == 0) || IsRef());
-
-    DumpValueObjectOptions child_options(m_options);
-    child_options.SetFormat(m_options.m_format).SetSummary().SetRootValueObjectName();
-    child_options.SetScopeChecked(true).SetHideName(m_options.m_hide_name).SetHideValue(m_options.m_hide_value)
-    .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1 ? child_options.m_omit_summary_depth - consumed_depth : 0)
-    .SetElementCount(0);
-    
-    if (child_sp.get())
-    {
-        ValueObjectPrinter child_printer(child_sp.get(),
-                                         m_stream,
-                                         child_options,
-                                         does_consume_ptr_depth ? --curr_ptr_depth : curr_ptr_depth,
-                                         m_curr_depth + consumed_depth,
-                                         m_printed_instance_pointers);
-        child_printer.PrintValueObject();
-    }
+bool ValueObjectPrinter::ShouldExpandEmptyAggregates() {
+  TypeSummaryImpl *entry = GetSummaryFormatter();
+
+  if (!entry)
+    return true;
+
+  return entry->DoesPrintEmptyAggregates();
 }
 
-uint32_t
-ValueObjectPrinter::GetMaxNumChildrenToPrint (bool& print_dotdotdot)
-{
-    ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
-    
-    if (m_options.m_element_count > 0)
-        return m_options.m_element_count;
-    
-    size_t num_children = synth_m_valobj->GetNumChildren();
-    print_dotdotdot = false;
-    if (num_children)
-    {
-        const size_t max_num_children = m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
-        
-        if (num_children > max_num_children && !m_options.m_ignore_cap)
-        {
-            print_dotdotdot = true;
-            return max_num_children;
-        }
-    }
-    return num_children;
-}
-
-void
-ValueObjectPrinter::PrintChildrenPostamble (bool print_dotdotdot)
-{
-    if (!m_options.m_flat_output)
-    {
-        if (print_dotdotdot)
-        {
-            m_valobj->GetTargetSP()->GetDebugger().GetCommandInterpreter().ChildrenTruncated();
-            m_stream->Indent("...\n");
-        }
-        m_stream->IndentLess();
-        m_stream->Indent("}\n");
-    }
+ValueObject *ValueObjectPrinter::GetValueObjectForChildrenGeneration() {
+  return m_valobj;
 }
 
-bool
-ValueObjectPrinter::ShouldPrintEmptyBrackets (bool value_printed,
-                                              bool summary_printed)
-{
-    ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
-    
-    if (!IsAggregate())
-        return false;
-    
-    if (m_options.m_reveal_empty_aggregates == false)
-    {
-        if (value_printed || summary_printed)
-            return false;
-    }
-    
-    if (synth_m_valobj->MightHaveChildren())
-        return true;
-    
-    if (m_val_summary_ok)
-        return false;
-    
+void ValueObjectPrinter::PrintChildrenPreamble() {
+  if (m_options.m_flat_output) {
+    if (ShouldPrintValueObject())
+      m_stream->EOL();
+  } else {
+    if (ShouldPrintValueObject())
+      m_stream->PutCString(IsRef() ? ": {\n" : " {\n");
+    m_stream->IndentMore();
+  }
+}
+
+void ValueObjectPrinter::PrintChild(
+    ValueObjectSP child_sp,
+    const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
+  const uint32_t consumed_depth = (m_options.m_element_count == 0) ? 1 : 0;
+  const bool does_consume_ptr_depth =
+      ((IsPtr() && m_options.m_element_count == 0) || IsRef());
+
+  DumpValueObjectOptions child_options(m_options);
+  child_options.SetFormat(m_options.m_format)
+      .SetSummary()
+      .SetRootValueObjectName();
+  child_options.SetScopeChecked(true)
+      .SetHideName(m_options.m_hide_name)
+      .SetHideValue(m_options.m_hide_value)
+      .SetOmitSummaryDepth(child_options.m_omit_summary_depth > 1
+                               ? child_options.m_omit_summary_depth -
+                                     consumed_depth
+                               : 0)
+      .SetElementCount(0);
+
+  if (child_sp.get()) {
+    ValueObjectPrinter child_printer(
+        child_sp.get(), m_stream, child_options,
+        does_consume_ptr_depth ? --curr_ptr_depth : curr_ptr_depth,
+        m_curr_depth + consumed_depth, m_printed_instance_pointers);
+    child_printer.PrintValueObject();
+  }
+}
+
+uint32_t ValueObjectPrinter::GetMaxNumChildrenToPrint(bool &print_dotdotdot) {
+  ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+  if (m_options.m_element_count > 0)
+    return m_options.m_element_count;
+
+  size_t num_children = synth_m_valobj->GetNumChildren();
+  print_dotdotdot = false;
+  if (num_children) {
+    const size_t max_num_children =
+        m_valobj->GetTargetSP()->GetMaximumNumberOfChildrenToDisplay();
+
+    if (num_children > max_num_children && !m_options.m_ignore_cap) {
+      print_dotdotdot = true;
+      return max_num_children;
+    }
+  }
+  return num_children;
+}
+
+void ValueObjectPrinter::PrintChildrenPostamble(bool print_dotdotdot) {
+  if (!m_options.m_flat_output) {
+    if (print_dotdotdot) {
+      m_valobj->GetTargetSP()
+          ->GetDebugger()
+          .GetCommandInterpreter()
+          .ChildrenTruncated();
+      m_stream->Indent("...\n");
+    }
+    m_stream->IndentLess();
+    m_stream->Indent("}\n");
+  }
+}
+
+bool ValueObjectPrinter::ShouldPrintEmptyBrackets(bool value_printed,
+                                                  bool summary_printed) {
+  ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+  if (!IsAggregate())
+    return false;
+
+  if (m_options.m_reveal_empty_aggregates == false) {
+    if (value_printed || summary_printed)
+      return false;
+  }
+
+  if (synth_m_valobj->MightHaveChildren())
     return true;
+
+  if (m_val_summary_ok)
+    return false;
+
+  return true;
 }
 
-ValueObjectSP
-ValueObjectPrinter::GenerateChild (ValueObject* synth_valobj, size_t idx)
-{
-    if (m_options.m_element_count > 0)
-    {
-        // if generating pointer-as-array children, use GetSyntheticArrayMember
-        return synth_valobj->GetSyntheticArrayMember(idx, true);
-    }
-    else
-    {
-        // otherwise, do the usual thing
-        return synth_valobj->GetChildAtIndex(idx, true);
-    }
+ValueObjectSP ValueObjectPrinter::GenerateChild(ValueObject *synth_valobj,
+                                                size_t idx) {
+  if (m_options.m_element_count > 0) {
+    // if generating pointer-as-array children, use GetSyntheticArrayMember
+    return synth_valobj->GetSyntheticArrayMember(idx, true);
+  } else {
+    // otherwise, do the usual thing
+    return synth_valobj->GetChildAtIndex(idx, true);
+  }
 }
 
-void
-ValueObjectPrinter::PrintChildren (bool value_printed,
-                                   bool summary_printed,
-                                   const DumpValueObjectOptions::PointerDepth& curr_ptr_depth)
-{
-    ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
-    
-    bool print_dotdotdot = false;
-    size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
-    if (num_children)
-    {
-        bool any_children_printed = false;
-        
-        for (size_t idx=0; idx<num_children; ++idx)
-        {
-            if (ValueObjectSP child_sp = GenerateChild(synth_m_valobj, idx))
-            {
-                if (!any_children_printed)
-                {
-                    PrintChildrenPreamble ();
-                    any_children_printed = true;
-                }
-                PrintChild (child_sp, curr_ptr_depth);
-            }
-        }
-        
-        if (any_children_printed)
-            PrintChildrenPostamble (print_dotdotdot);
-        else
-        {
-            if (ShouldPrintEmptyBrackets(value_printed, summary_printed))
-            {
-                if (ShouldPrintValueObject())
-                    m_stream->PutCString(" {}\n");
-                else
-                    m_stream->EOL();
-            }
-            else
-                m_stream->EOL();
-        }
-    }
-    else if (ShouldPrintEmptyBrackets(value_printed, summary_printed))
-    {
-        // Aggregate, no children...
-        if (ShouldPrintValueObject())
-        {
-            // if it has a synthetic value, then don't print {}, the synthetic children are probably only being used to vend a value
-            if (m_valobj->DoesProvideSyntheticValue() || !ShouldExpandEmptyAggregates())
-                m_stream->PutCString( "\n");
-            else
-                m_stream->PutCString(" {}\n");
+void ValueObjectPrinter::PrintChildren(
+    bool value_printed, bool summary_printed,
+    const DumpValueObjectOptions::PointerDepth &curr_ptr_depth) {
+  ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+  bool print_dotdotdot = false;
+  size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
+  if (num_children) {
+    bool any_children_printed = false;
+
+    for (size_t idx = 0; idx < num_children; ++idx) {
+      if (ValueObjectSP child_sp = GenerateChild(synth_m_valobj, idx)) {
+        if (!any_children_printed) {
+          PrintChildrenPreamble();
+          any_children_printed = true;
         }
+        PrintChild(child_sp, curr_ptr_depth);
+      }
     }
-    else
-    {
-        if (ShouldPrintValueObject())
-            m_stream->EOL();
-    }
-}
 
-bool
-ValueObjectPrinter::PrintChildrenOneLiner (bool hide_names)
-{
-    if (!GetMostSpecializedValue () || m_valobj == nullptr)
-        return false;
-    
-    ValueObject* synth_m_valobj = GetValueObjectForChildrenGeneration();
-    
-    bool print_dotdotdot = false;
-    size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
-    
-    if (num_children)
-    {
-        m_stream->PutChar('(');
-        
-        for (uint32_t idx=0; idx<num_children; ++idx)
-        {
-            lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
-            if (child_sp)
-                child_sp = child_sp->GetQualifiedRepresentationIfAvailable(m_options.m_use_dynamic, m_options.m_use_synthetic);
-            if (child_sp)
-            {
-                if (idx)
-                    m_stream->PutCString(", ");
-                if (!hide_names)
-                {
-                    const char* name = child_sp.get()->GetName().AsCString();
-                    if (name && *name)
-                    {
-                        m_stream->PutCString(name);
-                        m_stream->PutCString(" = ");
-                    }
-                }
-                child_sp->DumpPrintableRepresentation(*m_stream,
-                                                      ValueObject::eValueObjectRepresentationStyleSummary,
-                                                      m_options.m_format,
-                                                      ValueObject::ePrintableRepresentationSpecialCasesDisable);
-            }
-        }
-        
-        if (print_dotdotdot)
-            m_stream->PutCString(", ...)");
+    if (any_children_printed)
+      PrintChildrenPostamble(print_dotdotdot);
+    else {
+      if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
+        if (ShouldPrintValueObject())
+          m_stream->PutCString(" {}\n");
         else
-            m_stream->PutChar(')');
+          m_stream->EOL();
+      } else
+        m_stream->EOL();
     }
-    return true;
+  } else if (ShouldPrintEmptyBrackets(value_printed, summary_printed)) {
+    // Aggregate, no children...
+    if (ShouldPrintValueObject()) {
+      // if it has a synthetic value, then don't print {}, the synthetic
+      // children are probably only being used to vend a value
+      if (m_valobj->DoesProvideSyntheticValue() ||
+          !ShouldExpandEmptyAggregates())
+        m_stream->PutCString("\n");
+      else
+        m_stream->PutCString(" {}\n");
+    }
+  } else {
+    if (ShouldPrintValueObject())
+      m_stream->EOL();
+  }
 }
 
-void
-ValueObjectPrinter::PrintChildrenIfNeeded (bool value_printed,
-                                           bool summary_printed)
-{
-    // this flag controls whether we tried to display a description for this object and failed
-    // if that happens, we want to display the children, if any
-    bool is_failed_description = !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
-    
-    auto curr_ptr_depth = m_ptr_depth;
-    bool print_children = ShouldPrintChildren (is_failed_description,curr_ptr_depth);
-    bool print_oneline = (curr_ptr_depth.CanAllowExpansion() ||
-                          m_options.m_show_types ||
-                          !m_options.m_allow_oneliner_mode ||
-                          m_options.m_flat_output ||
-                          (m_options.m_element_count > 0) ||
-                          m_options.m_show_location) ? false : DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
-    bool is_instance_ptr = IsInstancePointer();
-    uint64_t instance_ptr_value = LLDB_INVALID_ADDRESS;
-    
-    if (print_children && is_instance_ptr)
-    {
-        instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
-        if (m_printed_instance_pointers->count(instance_ptr_value))
-        {
-            // we already printed this instance-is-pointer thing, so don't expand it
-            m_stream->PutCString(" {...}\n");
-            
-            // we're done here - get out fast
-            return;
-        }
-        else
-            m_printed_instance_pointers->emplace(instance_ptr_value); // remember this guy for future reference
-    }
-    
-    if (print_children)
-    {
-        if (print_oneline)
-        {
-            m_stream->PutChar(' ');
-            PrintChildrenOneLiner (false);
-            m_stream->EOL();
+bool ValueObjectPrinter::PrintChildrenOneLiner(bool hide_names) {
+  if (!GetMostSpecializedValue() || m_valobj == nullptr)
+    return false;
+
+  ValueObject *synth_m_valobj = GetValueObjectForChildrenGeneration();
+
+  bool print_dotdotdot = false;
+  size_t num_children = GetMaxNumChildrenToPrint(print_dotdotdot);
+
+  if (num_children) {
+    m_stream->PutChar('(');
+
+    for (uint32_t idx = 0; idx < num_children; ++idx) {
+      lldb::ValueObjectSP child_sp(synth_m_valobj->GetChildAtIndex(idx, true));
+      if (child_sp)
+        child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
+            m_options.m_use_dynamic, m_options.m_use_synthetic);
+      if (child_sp) {
+        if (idx)
+          m_stream->PutCString(", ");
+        if (!hide_names) {
+          const char *name = child_sp.get()->GetName().AsCString();
+          if (name && *name) {
+            m_stream->PutCString(name);
+            m_stream->PutCString(" = ");
+          }
         }
-        else
-            PrintChildren (value_printed, summary_printed, curr_ptr_depth);
-    }
-    else if (m_curr_depth >= m_options.m_max_depth && IsAggregate() && ShouldPrintValueObject())
-    {
-        m_stream->PutCString("{...}\n");
+        child_sp->DumpPrintableRepresentation(
+            *m_stream, ValueObject::eValueObjectRepresentationStyleSummary,
+            m_options.m_format,
+            ValueObject::ePrintableRepresentationSpecialCasesDisable);
+      }
     }
+
+    if (print_dotdotdot)
+      m_stream->PutCString(", ...)");
     else
-        m_stream->EOL();
+      m_stream->PutChar(')');
+  }
+  return true;
+}
+
+void ValueObjectPrinter::PrintChildrenIfNeeded(bool value_printed,
+                                               bool summary_printed) {
+  // this flag controls whether we tried to display a description for this
+  // object and failed
+  // if that happens, we want to display the children, if any
+  bool is_failed_description =
+      !PrintObjectDescriptionIfNeeded(value_printed, summary_printed);
+
+  auto curr_ptr_depth = m_ptr_depth;
+  bool print_children =
+      ShouldPrintChildren(is_failed_description, curr_ptr_depth);
+  bool print_oneline =
+      (curr_ptr_depth.CanAllowExpansion() || m_options.m_show_types ||
+       !m_options.m_allow_oneliner_mode || m_options.m_flat_output ||
+       (m_options.m_element_count > 0) || m_options.m_show_location)
+          ? false
+          : DataVisualization::ShouldPrintAsOneLiner(*m_valobj);
+  bool is_instance_ptr = IsInstancePointer();
+  uint64_t instance_ptr_value = LLDB_INVALID_ADDRESS;
+
+  if (print_children && is_instance_ptr) {
+    instance_ptr_value = m_valobj->GetValueAsUnsigned(0);
+    if (m_printed_instance_pointers->count(instance_ptr_value)) {
+      // we already printed this instance-is-pointer thing, so don't expand it
+      m_stream->PutCString(" {...}\n");
+
+      // we're done here - get out fast
+      return;
+    } else
+      m_printed_instance_pointers->emplace(
+          instance_ptr_value); // remember this guy for future reference
+  }
+
+  if (print_children) {
+    if (print_oneline) {
+      m_stream->PutChar(' ');
+      PrintChildrenOneLiner(false);
+      m_stream->EOL();
+    } else
+      PrintChildren(value_printed, summary_printed, curr_ptr_depth);
+  } else if (m_curr_depth >= m_options.m_max_depth && IsAggregate() &&
+             ShouldPrintValueObject()) {
+    m_stream->PutCString("{...}\n");
+  } else
+    m_stream->EOL();
 }
 
-bool
-ValueObjectPrinter::ShouldPrintValidation ()
-{
-    return m_options.m_run_validator;
+bool ValueObjectPrinter::ShouldPrintValidation() {
+  return m_options.m_run_validator;
 }
 
-bool
-ValueObjectPrinter::PrintValidationMarkerIfNeeded ()
-{
-    if (!ShouldPrintValidation())
-        return false;
-    
-    m_validation = m_valobj->GetValidationStatus();
-    
-    if (TypeValidatorResult::Failure == m_validation.first)
-    {
-        m_stream->Printf("! ");
-        return true;
-    }
-    
+bool ValueObjectPrinter::PrintValidationMarkerIfNeeded() {
+  if (!ShouldPrintValidation())
     return false;
-}
 
-bool
-ValueObjectPrinter::PrintValidationErrorIfNeeded ()
-{
-    if (!ShouldPrintValidation())
-        return false;
-    
-    if (TypeValidatorResult::Success == m_validation.first)
-        return false;
-    
-    if (m_validation.second.empty())
-        m_validation.second.assign("unknown error");
-    
-    m_stream->Printf(" ! validation error: %s", m_validation.second.c_str());
-    m_stream->EOL();
-    
+  m_validation = m_valobj->GetValidationStatus();
+
+  if (TypeValidatorResult::Failure == m_validation.first) {
+    m_stream->Printf("! ");
     return true;
+  }
+
+  return false;
+}
+
+bool ValueObjectPrinter::PrintValidationErrorIfNeeded() {
+  if (!ShouldPrintValidation())
+    return false;
+
+  if (TypeValidatorResult::Success == m_validation.first)
+    return false;
+
+  if (m_validation.second.empty())
+    m_validation.second.assign("unknown error");
+
+  m_stream->Printf(" ! validation error: %s", m_validation.second.c_str());
+  m_stream->EOL();
+
+  return true;
 }
diff --git a/lldb/source/DataFormatters/VectorType.cpp b/lldb/source/DataFormatters/VectorType.cpp
index 347afa5..7769461 100644
--- a/lldb/source/DataFormatters/VectorType.cpp
+++ b/lldb/source/DataFormatters/VectorType.cpp
@@ -25,306 +25,277 @@ using namespace lldb;
 using namespace lldb_private;
 using namespace lldb_private::formatters;
 
-static CompilerType
-GetCompilerTypeForFormat (lldb::Format format,
-                          CompilerType element_type,
-                          TypeSystem *type_system)
-{
-    lldbassert(type_system && "type_system needs to be not NULL");
-    
-    switch (format)
-    {
-        case lldb::eFormatAddressInfo:
-        case lldb::eFormatPointer:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 8*type_system->GetPointerByteSize());
-            
-        case lldb::eFormatBoolean:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeBool);
-            
-        case lldb::eFormatBytes:
-        case lldb::eFormatBytesWithASCII:
-        case lldb::eFormatChar:
-        case lldb::eFormatCharArray:
-        case lldb::eFormatCharPrintable:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
-
-        case lldb::eFormatComplex /* lldb::eFormatComplexFloat */:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloatComplex);
-
-        case lldb::eFormatCString:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar).GetPointerType();
-
-        case lldb::eFormatFloat:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
-            
-        case lldb::eFormatHex:
-        case lldb::eFormatHexUppercase:
-        case lldb::eFormatOctal:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeInt);
-
-        case lldb::eFormatHexFloat:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
-
-        case lldb::eFormatUnicode16:
-        case lldb::eFormatUnicode32:
-
-        case lldb::eFormatUnsigned:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt);
-
-        case lldb::eFormatVectorOfChar:
-            return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
-            
-        case lldb::eFormatVectorOfFloat32:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754, 32);
-            
-        case lldb::eFormatVectorOfFloat64:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754, 64);
-            
-        case lldb::eFormatVectorOfSInt16:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingSint, 16);
-            
-        case lldb::eFormatVectorOfSInt32:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingSint, 32);
-
-        case lldb::eFormatVectorOfSInt64:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingSint, 64);
-            
-        case lldb::eFormatVectorOfSInt8:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingSint, 8);
-
-        case lldb::eFormatVectorOfUInt128:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 128);
-
-        case lldb::eFormatVectorOfUInt16:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 16);
-
-        case lldb::eFormatVectorOfUInt32:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 32);
-
-        case lldb::eFormatVectorOfUInt64:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 64);
-
-        case lldb::eFormatVectorOfUInt8:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 8);
-            
-        case lldb::eFormatDefault:
-            return element_type;
-        
-        case lldb::eFormatBinary:
-        case lldb::eFormatComplexInteger:
-        case lldb::eFormatDecimal:
-        case lldb::eFormatEnum:
-        case lldb::eFormatInstruction:
-        case lldb::eFormatOSType:
-        case lldb::eFormatVoid:
-        default:
-            return type_system->GetBuiltinTypeForEncodingAndBitSize (eEncodingUint, 8);
-    }
+static CompilerType GetCompilerTypeForFormat(lldb::Format format,
+                                             CompilerType element_type,
+                                             TypeSystem *type_system) {
+  lldbassert(type_system && "type_system needs to be not NULL");
+
+  switch (format) {
+  case lldb::eFormatAddressInfo:
+  case lldb::eFormatPointer:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(
+        eEncodingUint, 8 * type_system->GetPointerByteSize());
+
+  case lldb::eFormatBoolean:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeBool);
+
+  case lldb::eFormatBytes:
+  case lldb::eFormatBytesWithASCII:
+  case lldb::eFormatChar:
+  case lldb::eFormatCharArray:
+  case lldb::eFormatCharPrintable:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
+
+  case lldb::eFormatComplex /* lldb::eFormatComplexFloat */:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloatComplex);
+
+  case lldb::eFormatCString:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar)
+        .GetPointerType();
+
+  case lldb::eFormatFloat:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
+
+  case lldb::eFormatHex:
+  case lldb::eFormatHexUppercase:
+  case lldb::eFormatOctal:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeInt);
+
+  case lldb::eFormatHexFloat:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeFloat);
+
+  case lldb::eFormatUnicode16:
+  case lldb::eFormatUnicode32:
+
+  case lldb::eFormatUnsigned:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeUnsignedInt);
+
+  case lldb::eFormatVectorOfChar:
+    return type_system->GetBasicTypeFromAST(lldb::eBasicTypeChar);
+
+  case lldb::eFormatVectorOfFloat32:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754,
+                                                            32);
+
+  case lldb::eFormatVectorOfFloat64:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingIEEE754,
+                                                            64);
+
+  case lldb::eFormatVectorOfSInt16:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 16);
+
+  case lldb::eFormatVectorOfSInt32:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 32);
+
+  case lldb::eFormatVectorOfSInt64:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 64);
+
+  case lldb::eFormatVectorOfSInt8:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingSint, 8);
+
+  case lldb::eFormatVectorOfUInt128:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 128);
+
+  case lldb::eFormatVectorOfUInt16:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 16);
+
+  case lldb::eFormatVectorOfUInt32:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 32);
+
+  case lldb::eFormatVectorOfUInt64:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 64);
+
+  case lldb::eFormatVectorOfUInt8:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8);
+
+  case lldb::eFormatDefault:
+    return element_type;
+
+  case lldb::eFormatBinary:
+  case lldb::eFormatComplexInteger:
+  case lldb::eFormatDecimal:
+  case lldb::eFormatEnum:
+  case lldb::eFormatInstruction:
+  case lldb::eFormatOSType:
+  case lldb::eFormatVoid:
+  default:
+    return type_system->GetBuiltinTypeForEncodingAndBitSize(eEncodingUint, 8);
+  }
 }
 
-static lldb::Format
-GetItemFormatForFormat (lldb::Format format,
-                        CompilerType element_type)
-{
-    switch (format)
-    {
-        case lldb::eFormatVectorOfChar:
-            return lldb::eFormatChar;
-            
-        case lldb::eFormatVectorOfFloat32:
-        case lldb::eFormatVectorOfFloat64:
-            return lldb::eFormatFloat;
-            
-        case lldb::eFormatVectorOfSInt16:
-        case lldb::eFormatVectorOfSInt32:
-        case lldb::eFormatVectorOfSInt64:
-        case lldb::eFormatVectorOfSInt8:
-            return lldb::eFormatDecimal;
-            
-        case lldb::eFormatVectorOfUInt128:
-        case lldb::eFormatVectorOfUInt16:
-        case lldb::eFormatVectorOfUInt32:
-        case lldb::eFormatVectorOfUInt64:
-        case lldb::eFormatVectorOfUInt8:
-            return lldb::eFormatUnsigned;
-            
-        case lldb::eFormatBinary:
-        case lldb::eFormatComplexInteger:
-        case lldb::eFormatDecimal:
-        case lldb::eFormatEnum:
-        case lldb::eFormatInstruction:
-        case lldb::eFormatOSType:
-        case lldb::eFormatVoid:
-            return eFormatHex;
-
-        case lldb::eFormatDefault:
-        {
-            // special case the (default, char) combination to actually display as an integer value
-            // most often, you won't want to see the ASCII characters... (and if you do, eFormatChar is a keystroke away)
-            bool is_char = element_type.IsCharType();
-            bool is_signed = false;
-            element_type.IsIntegerType(is_signed);
-            return is_char ? (is_signed ? lldb::eFormatDecimal : eFormatHex) : format;
-        }
-            break;
-            
-        default:
-            return format;
-    }
+static lldb::Format GetItemFormatForFormat(lldb::Format format,
+                                           CompilerType element_type) {
+  switch (format) {
+  case lldb::eFormatVectorOfChar:
+    return lldb::eFormatChar;
+
+  case lldb::eFormatVectorOfFloat32:
+  case lldb::eFormatVectorOfFloat64:
+    return lldb::eFormatFloat;
+
+  case lldb::eFormatVectorOfSInt16:
+  case lldb::eFormatVectorOfSInt32:
+  case lldb::eFormatVectorOfSInt64:
+  case lldb::eFormatVectorOfSInt8:
+    return lldb::eFormatDecimal;
+
+  case lldb::eFormatVectorOfUInt128:
+  case lldb::eFormatVectorOfUInt16:
+  case lldb::eFormatVectorOfUInt32:
+  case lldb::eFormatVectorOfUInt64:
+  case lldb::eFormatVectorOfUInt8:
+    return lldb::eFormatUnsigned;
+
+  case lldb::eFormatBinary:
+  case lldb::eFormatComplexInteger:
+  case lldb::eFormatDecimal:
+  case lldb::eFormatEnum:
+  case lldb::eFormatInstruction:
+  case lldb::eFormatOSType:
+  case lldb::eFormatVoid:
+    return eFormatHex;
+
+  case lldb::eFormatDefault: {
+    // special case the (default, char) combination to actually display as an
+    // integer value
+    // most often, you won't want to see the ASCII characters... (and if you do,
+    // eFormatChar is a keystroke away)
+    bool is_char = element_type.IsCharType();
+    bool is_signed = false;
+    element_type.IsIntegerType(is_signed);
+    return is_char ? (is_signed ? lldb::eFormatDecimal : eFormatHex) : format;
+  } break;
+
+  default:
+    return format;
+  }
 }
 
-static size_t
-CalculateNumChildren (CompilerType container_type,
-                      CompilerType element_type,
-                      lldb_private::ExecutionContextScope *exe_scope = nullptr // does not matter here because all we trade in are basic types
-                      )
-{
-    auto container_size = container_type.GetByteSize(exe_scope);
-    auto element_size = element_type.GetByteSize(exe_scope);
-    
-    if (element_size)
-    {
-        if (container_size % element_size)
-            return 0;
-        return container_size / element_size;
-    }
-    return 0;
+static size_t CalculateNumChildren(
+    CompilerType container_type, CompilerType element_type,
+    lldb_private::ExecutionContextScope *exe_scope =
+        nullptr // does not matter here because all we trade in are basic types
+    ) {
+  auto container_size = container_type.GetByteSize(exe_scope);
+  auto element_size = element_type.GetByteSize(exe_scope);
+
+  if (element_size) {
+    if (container_size % element_size)
+      return 0;
+    return container_size / element_size;
+  }
+  return 0;
 }
 
 namespace lldb_private {
-    namespace formatters {
-
-        class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd
-        {
-        public:
-            VectorTypeSyntheticFrontEnd (lldb::ValueObjectSP valobj_sp) :
-            SyntheticChildrenFrontEnd(*valobj_sp),
-            m_parent_format (eFormatInvalid),
-            m_item_format(eFormatInvalid),
-            m_child_type(),
-            m_num_children(0)
-            {}
-
-            ~VectorTypeSyntheticFrontEnd() override = default;
-
-            size_t
-            CalculateNumChildren() override
-            {
-                return m_num_children;
-            }
-
-            lldb::ValueObjectSP
-            GetChildAtIndex(size_t idx) override
-            {
-                if (idx >= CalculateNumChildren())
-                    return lldb::ValueObjectSP();
-                auto offset = idx * m_child_type.GetByteSize(nullptr);
-                ValueObjectSP child_sp(m_backend.GetSyntheticChildAtOffset(offset, m_child_type, true));
-                if (!child_sp)
-                    return child_sp;
-                
-                StreamString idx_name;
-                idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
-                child_sp->SetName( ConstString( idx_name.GetData() ) );
-                
-                child_sp->SetFormat(m_item_format);
-                
-                return child_sp;
-            }
-
-            bool
-            Update() override
-            {
-                m_parent_format = m_backend.GetFormat();
-                CompilerType parent_type(m_backend.GetCompilerType());
-                CompilerType element_type;
-                parent_type.IsVectorType(&element_type, nullptr);
-                TargetSP target_sp(m_backend.GetTargetSP());
-                m_child_type = ::GetCompilerTypeForFormat(m_parent_format,
-                                                          element_type,
-                                                          target_sp ? target_sp->GetScratchTypeSystemForLanguage(nullptr, lldb::eLanguageTypeC) : nullptr);
-                m_num_children = ::CalculateNumChildren(parent_type,
-                                                        m_child_type);
-                m_item_format = GetItemFormatForFormat(m_parent_format,
-                                                       m_child_type);
-                return false;
-            }
-
-            bool
-            MightHaveChildren() override
-            {
-                return true;
-            }
-
-            size_t
-            GetIndexOfChildWithName(const ConstString &name) override
-            {
-                const char* item_name = name.GetCString();
-                uint32_t idx = ExtractIndexFromString(item_name);
-                if (idx < UINT32_MAX && idx >= CalculateNumChildren())
-                    return UINT32_MAX;
-                return idx;
-            }
-
-        private:
-            lldb::Format m_parent_format;
-            lldb::Format m_item_format;
-            CompilerType m_child_type;
-            size_t m_num_children;
-        };
-
-    } // namespace formatters
+namespace formatters {
+
+class VectorTypeSyntheticFrontEnd : public SyntheticChildrenFrontEnd {
+public:
+  VectorTypeSyntheticFrontEnd(lldb::ValueObjectSP valobj_sp)
+      : SyntheticChildrenFrontEnd(*valobj_sp), m_parent_format(eFormatInvalid),
+        m_item_format(eFormatInvalid), m_child_type(), m_num_children(0) {}
+
+  ~VectorTypeSyntheticFrontEnd() override = default;
+
+  size_t CalculateNumChildren() override { return m_num_children; }
+
+  lldb::ValueObjectSP GetChildAtIndex(size_t idx) override {
+    if (idx >= CalculateNumChildren())
+      return lldb::ValueObjectSP();
+    auto offset = idx * m_child_type.GetByteSize(nullptr);
+    ValueObjectSP child_sp(
+        m_backend.GetSyntheticChildAtOffset(offset, m_child_type, true));
+    if (!child_sp)
+      return child_sp;
+
+    StreamString idx_name;
+    idx_name.Printf("[%" PRIu64 "]", (uint64_t)idx);
+    child_sp->SetName(ConstString(idx_name.GetData()));
+
+    child_sp->SetFormat(m_item_format);
+
+    return child_sp;
+  }
+
+  bool Update() override {
+    m_parent_format = m_backend.GetFormat();
+    CompilerType parent_type(m_backend.GetCompilerType());
+    CompilerType element_type;
+    parent_type.IsVectorType(&element_type, nullptr);
+    TargetSP target_sp(m_backend.GetTargetSP());
+    m_child_type = ::GetCompilerTypeForFormat(
+        m_parent_format, element_type,
+        target_sp
+            ? target_sp->GetScratchTypeSystemForLanguage(nullptr,
+                                                         lldb::eLanguageTypeC)
+            : nullptr);
+    m_num_children = ::CalculateNumChildren(parent_type, m_child_type);
+    m_item_format = GetItemFormatForFormat(m_parent_format, m_child_type);
+    return false;
+  }
+
+  bool MightHaveChildren() override { return true; }
+
+  size_t GetIndexOfChildWithName(const ConstString &name) override {
+    const char *item_name = name.GetCString();
+    uint32_t idx = ExtractIndexFromString(item_name);
+    if (idx < UINT32_MAX && idx >= CalculateNumChildren())
+      return UINT32_MAX;
+    return idx;
+  }
+
+private:
+  lldb::Format m_parent_format;
+  lldb::Format m_item_format;
+  CompilerType m_child_type;
+  size_t m_num_children;
+};
+
+} // namespace formatters
 } // namespace lldb_private
 
-bool
-lldb_private::formatters::VectorTypeSummaryProvider (ValueObject& valobj,
-                                                     Stream& s,
-                                                     const TypeSummaryOptions&)
-{
-    auto synthetic_children = VectorTypeSyntheticFrontEndCreator(nullptr, valobj.GetSP());
-    if (!synthetic_children)
-        return false;
-    
-    synthetic_children->Update();
-    
-    s.PutChar('(');
-    bool first = true;
-    
-    size_t idx = 0, len = synthetic_children->CalculateNumChildren();
-    
-    for (;
-         idx < len;
-         idx++)
-    {
-        auto child_sp = synthetic_children->GetChildAtIndex(idx);
-        if (!child_sp)
-            continue;
-        child_sp = child_sp->GetQualifiedRepresentationIfAvailable(lldb::eDynamicDontRunTarget, true);
-        
-        const char* child_value = child_sp->GetValueAsCString();
-        if (child_value && *child_value)
-        {
-            if (first)
-            {
-                s.Printf("%s", child_value);
-                first = false;
-            }
-            else
-            {
-                s.Printf(", %s", child_value);
-            }
-        }
+bool lldb_private::formatters::VectorTypeSummaryProvider(
+    ValueObject &valobj, Stream &s, const TypeSummaryOptions &) {
+  auto synthetic_children =
+      VectorTypeSyntheticFrontEndCreator(nullptr, valobj.GetSP());
+  if (!synthetic_children)
+    return false;
+
+  synthetic_children->Update();
+
+  s.PutChar('(');
+  bool first = true;
+
+  size_t idx = 0, len = synthetic_children->CalculateNumChildren();
+
+  for (; idx < len; idx++) {
+    auto child_sp = synthetic_children->GetChildAtIndex(idx);
+    if (!child_sp)
+      continue;
+    child_sp = child_sp->GetQualifiedRepresentationIfAvailable(
+        lldb::eDynamicDontRunTarget, true);
+
+    const char *child_value = child_sp->GetValueAsCString();
+    if (child_value && *child_value) {
+      if (first) {
+        s.Printf("%s", child_value);
+        first = false;
+      } else {
+        s.Printf(", %s", child_value);
+      }
     }
-    
-    s.PutChar(')');
-    
-    return true;
+  }
+
+  s.PutChar(')');
+
+  return true;
 }
 
-lldb_private::SyntheticChildrenFrontEnd*
-lldb_private::formatters::VectorTypeSyntheticFrontEndCreator (CXXSyntheticChildren*, lldb::ValueObjectSP valobj_sp)
-{
-    if (!valobj_sp)
-        return nullptr;
-    return new VectorTypeSyntheticFrontEnd(valobj_sp);
+lldb_private::SyntheticChildrenFrontEnd *
+lldb_private::formatters::VectorTypeSyntheticFrontEndCreator(
+    CXXSyntheticChildren *, lldb::ValueObjectSP valobj_sp) {
+  if (!valobj_sp)
+    return nullptr;
+  return new VectorTypeSyntheticFrontEnd(valobj_sp);
 }