[lldb][NFC] Remove FormatterChoiceCriterion

[teemperor]

Summary

The formatters code has a lot of 'reason' or 'why' values that we keep or-ing FormatterChoiceCriterion
enum values into. These values are only read by a single log statement and don't have any functional
purpose. It also seems the implementation is not finished (for example, display names and type
names don't have any dedicated enum values). Also everything is of course not tested or documented.

Let's just remove all of this.

[JDevlieghere]

Looks like a good cleanup.

[labath]

nuke it from orbit

[vsk]

Thanks!

lldb/include/lldb/DataFormatters/FormatClasses.h

public:
 
   typedef HardcodedFormatterFinders<TypeFormatImpl> HardcodedFormatFinder;
   typedef HardcodedFormatterFinders<TypeSummaryImpl> HardcodedSummaryFinder;
   typedef HardcodedFormatterFinders<SyntheticChildren> HardcodedSyntheticFinder;
 };
 
 class FormattersMatchCandidate {
 public:
-  FormattersMatchCandidate(ConstString name, uint32_t reason, bool strip_ptr,
+  FormattersMatchCandidate(ConstString name, bool strip_ptr,
                            bool strip_ref, bool strip_tydef)
-      : m_type_name(name), m_reason(reason), m_stripped_pointer(strip_ptr),
+      : m_type_name(name), m_stripped_pointer(strip_ptr),
         m_stripped_reference(strip_ref), m_stripped_typedef(strip_tydef) {}
 
   ~FormattersMatchCandidate() = default;
 
   ConstString GetTypeName() const { return m_type_name; }
 
-  uint32_t GetReason() const { return m_reason; }
-
   bool DidStripPointer() const { return m_stripped_pointer; }
 
   bool DidStripReference() const { return m_stripped_reference; }
 
   bool DidStripTypedef() const { return m_stripped_typedef; }
 
   template <class Formatter>
   bool IsMatch(const std::shared_ptr<Formatter> &formatter_sp) const {
     if (!formatter_sp)
       return false;
     if (formatter_sp->Cascades() == false && DidStripTypedef())
       return false;
     if (formatter_sp->SkipsPointers() && DidStripPointer())
       return false;
     if (formatter_sp->SkipsReferences() && DidStripReference())
       return false;
     return true;
   }
 
 private:
   ConstString m_type_name;
-  uint32_t m_reason;
   bool m_stripped_pointer;
   bool m_stripped_reference;
   bool m_stripped_typedef;
 };
 
 typedef std::vector<FormattersMatchCandidate> FormattersMatchVector;
 typedef std::vector<lldb::LanguageType> CandidateLanguagesVector;
 

lldb/include/lldb/DataFormatters/FormatManager.h

public:
   void Changed() override;
 
   uint32_t GetCurrentRevision() override { return m_last_revision; }
 
   static FormattersMatchVector
   GetPossibleMatches(ValueObject &valobj, lldb::DynamicValueType use_dynamic) {
     FormattersMatchVector matches;
     GetPossibleMatches(valobj, valobj.GetCompilerType(),
-                       lldb_private::eFormatterChoiceCriterionDirectChoice,
                        use_dynamic, matches, false, false, false, true);
     return matches;
   }
 
   static ConstString GetTypeForCache(ValueObject &, lldb::DynamicValueType);
 
   LanguageCategory *GetCategoryForLanguage(lldb::LanguageType lang_type);
 
   static std::vector<lldb::LanguageType>
   GetCandidateLanguages(lldb::LanguageType lang_type);
 
 private:
   static void GetPossibleMatches(ValueObject &valobj,
-                                 CompilerType compiler_type, uint32_t reason,
+                                 CompilerType compiler_type,
                                  lldb::DynamicValueType use_dynamic,
                                  FormattersMatchVector &entries,
                                  bool did_strip_ptr, bool did_strip_ref,
                                  bool did_strip_typedef,
                                  bool root_level = false);
 
   std::atomic<uint32_t> m_last_revision;
   FormatCache m_format_cache;

lldb/include/lldb/DataFormatters/FormattersContainer.h

void Add(MapKeyType type, const MapValueType &entry) {
     Add_Impl(std::move(type), entry, static_cast<KeyType *>(nullptr));
   }
 
   bool Delete(ConstString type) {
     return Delete_Impl(type, static_cast<KeyType *>(nullptr));
   }
 
   bool Get(ValueObject &valobj, MapValueType &entry,
-           lldb::DynamicValueType use_dynamic, uint32_t *why = nullptr) {
-    uint32_t value = lldb_private::eFormatterChoiceCriterionDirectChoice;
+           lldb::DynamicValueType use_dynamic) {
     CompilerType ast_type(valobj.GetCompilerType());
-    bool ret = Get(valobj, ast_type, entry, use_dynamic, value);
+    bool ret = Get(valobj, ast_type, entry, use_dynamic);
     if (ret)
       entry = MapValueType(entry);
     else
       entry = MapValueType();
-    if (why)
-      *why = value;
     return ret;
   }
 
   bool Get(ConstString type, MapValueType &entry) {
     return Get_Impl(type, entry, static_cast<KeyType *>(nullptr));
   }
 
   bool GetExact(ConstString type, MapValueType &entry) {
for (const auto &pos : m_format_map.map()) {
       if (regex.GetText() == key.GetStringRef()) {
         value = pos.second;
         return true;
       }
     }
     return false;
   }
 
-  bool Get(const FormattersMatchVector &candidates, MapValueType &entry,
-           uint32_t *reason) {
+  bool Get(const FormattersMatchVector &candidates, MapValueType &entry) {
     for (const FormattersMatchCandidate &candidate : candidates) {
       if (Get(candidate.GetTypeName(), entry)) {
         if (candidate.IsMatch(entry) == false) {
           entry.reset();
           continue;
         } else {
-          if (reason)
-            *reason = candidate.GetReason();
           return true;
         }
       }
     }
     return false;
   }
 };
 
 } // namespace lldb_private
 
 #endif // LLDB_DATAFORMATTERS_FORMATTERSCONTAINER_H

lldb/include/lldb/DataFormatters/TypeCategory.h

public:
   uint32_t GetEnabledPosition() {
     if (!m_enabled)
       return UINT32_MAX;
     else
       return m_enabled_position;
   }
 
   bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
-           lldb::TypeFormatImplSP &entry, uint32_t *reason = nullptr);
+           lldb::TypeFormatImplSP &entry);
 
   bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
-           lldb::TypeSummaryImplSP &entry, uint32_t *reason = nullptr);
+           lldb::TypeSummaryImplSP &entry);
 
   bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
-           lldb::SyntheticChildrenSP &entry, uint32_t *reason = nullptr);
+           lldb::SyntheticChildrenSP &entry);
 
   void Clear(FormatCategoryItems items = ALL_ITEM_TYPES);
 
   bool Delete(ConstString name, FormatCategoryItems items = ALL_ITEM_TYPES);
 
   uint32_t GetCount(FormatCategoryItems items = ALL_ITEM_TYPES);
 
   const char *GetName() { return m_name.GetCString(); }

lldb/include/lldb/lldb-private-enumerations.h

 /// Expression execution policies
 enum ExecutionPolicy {
   eExecutionPolicyOnlyWhenNeeded,
   eExecutionPolicyNever,
   eExecutionPolicyAlways,
   eExecutionPolicyTopLevel // used for top-level code
 };
 
-// Ways that the FormatManager picks a particular format for a type
-enum FormatterChoiceCriterion {
-  eFormatterChoiceCriterionDirectChoice = 0x00000000,
-  eFormatterChoiceCriterionStrippedPointerReference = 0x00000001,
-  eFormatterChoiceCriterionNavigatedTypedefs = 0x00000002,
-  eFormatterChoiceCriterionRegularExpressionSummary = 0x00000004,
-  eFormatterChoiceCriterionRegularExpressionFilter = 0x00000004,
-  eFormatterChoiceCriterionLanguagePlugin = 0x00000008,
-  eFormatterChoiceCriterionStrippedBitField = 0x00000010,
-  eFormatterChoiceCriterionWentToStaticValue = 0x00000020
-};
-
 // Synchronicity behavior of scripted commands
 enum ScriptedCommandSynchronicity {
   eScriptedCommandSynchronicitySynchronous,
   eScriptedCommandSynchronicityAsynchronous,
   eScriptedCommandSynchronicityCurrentValue // use whatever the current
                                             // synchronicity is
 };
 

lldb/source/DataFormatters/FormatManager.cpp

void FormatManager::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,
+    ValueObject &valobj, CompilerType compiler_type,
     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.GetTypeName());
   if (valobj.GetBitfieldBitSize() > 0) {
     StreamString sstring;
     sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
     ConstString bitfieldname(sstring.GetString());
     entries.push_back(
-        {bitfieldname, 0, did_strip_ptr, did_strip_ref, did_strip_typedef});
-    reason |= lldb_private::eFormatterChoiceCriterionStrippedBitField;
+        {bitfieldname, 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});
+        {type_name, did_strip_ptr, did_strip_ref, did_strip_typedef});
 
     ConstString display_type_name(compiler_type.GetTypeName());
     if (display_type_name != type_name)
-      entries.push_back({display_type_name, reason, did_strip_ptr,
+      entries.push_back({display_type_name, 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();
       const bool stripped_typedef = true;
       GetPossibleMatches(
           valobj, deffed_pointed_type,
-          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
           use_dynamic, entries, did_strip_ptr, did_strip_ref,
           stripped_typedef); // this is not exactly the usual meaning of
                              // stripping typedefs
     }
   }
 
   // For arrays with typedef-ed elements, we add a candidate with the typedef
   // stripped.
   uint64_t array_size;
   if (compiler_type.IsArrayType(nullptr, &array_size, nullptr)) {
     CompilerType element_type = compiler_type.GetArrayElementType();
     if (element_type.IsTypedefType()) {
       // Get the stripped element type and compute the stripped array type
       // from it.
       CompilerType deffed_array_type =
           element_type.GetTypedefedType().GetArrayType(array_size);
       const bool stripped_typedef = true;
       GetPossibleMatches(
           valobj, deffed_array_type,
-          reason | lldb_private::eFormatterChoiceCriterionNavigatedTypedefs,
           use_dynamic, entries, did_strip_ptr, did_strip_ref,
           stripped_typedef); // this is not exactly the usual meaning of
                              // stripping typedefs
     }
   }
 
   for (lldb::LanguageType language_type :
        GetCandidateLanguages(valobj.GetObjectRuntimeLanguage())) {
     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});
       }
     }
   }
 
   // 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,
+        GetPossibleMatches(valobj, unqual_compiler_ast_type,
                            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) {

lldb/source/DataFormatters/TypeCategory.cpp

 }
 
 void TypeCategoryImpl::AddLanguage(lldb::LanguageType lang) {
   m_languages.push_back(lang);
 }
 
 bool TypeCategoryImpl::Get(lldb::LanguageType lang,
                            const FormattersMatchVector &candidates,
-                           lldb::TypeFormatImplSP &entry, uint32_t *reason) {
+                           lldb::TypeFormatImplSP &entry) {
   if (!IsEnabled() || !IsApplicable(lang))
     return false;
-  if (GetTypeFormatsContainer()->Get(candidates, entry, reason))
+  if (GetTypeFormatsContainer()->Get(candidates, entry))
     return true;
-  bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry, reason);
-  if (regex && reason)
-    *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+  bool regex = GetRegexTypeFormatsContainer()->Get(candidates, entry);
   return regex;
 }
 
 bool TypeCategoryImpl::Get(lldb::LanguageType lang,
                            const FormattersMatchVector &candidates,
-                           lldb::TypeSummaryImplSP &entry, uint32_t *reason) {
+                           lldb::TypeSummaryImplSP &entry) {
   if (!IsEnabled() || !IsApplicable(lang))
     return false;
-  if (GetTypeSummariesContainer()->Get(candidates, entry, reason))
+  if (GetTypeSummariesContainer()->Get(candidates, entry))
     return true;
-  bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry, reason);
-  if (regex && reason)
-    *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionSummary;
+  bool regex = GetRegexTypeSummariesContainer()->Get(candidates, entry);
   return regex;
 }
 
 bool TypeCategoryImpl::Get(lldb::LanguageType lang,
                            const FormattersMatchVector &candidates,
-                           lldb::SyntheticChildrenSP &entry, uint32_t *reason) {
+                           lldb::SyntheticChildrenSP &entry) {
   if (!IsEnabled() || !IsApplicable(lang))
     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);
+  if (!GetTypeFiltersContainer()->Get(candidates, filter_sp))
+    regex_filter = GetRegexTypeFiltersContainer()->Get(candidates, filter_sp);
 
   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 (!GetTypeSyntheticsContainer()->Get(candidates, synth))
+    regex_synth = GetRegexTypeSyntheticsContainer()->Get(candidates, 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())*/
   {
     pick_synth = filter_sp->GetRevision() <= synth->GetRevision();
   }
   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;
   }
   return false;
 }
 
 void TypeCategoryImpl::Clear(FormatCategoryItems items) {
   if ((items & eFormatCategoryItemValue) == eFormatCategoryItemValue)

lldb/source/DataFormatters/TypeCategoryMap.cpp

bool TypeCategoryMap::AnyMatches(
   }
   return false;
 }
 
 template <typename ImplSP>
 void TypeCategoryMap::Get(FormattersMatchData &match_data, ImplSP &retval) {
   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()) {
       LLDB_LOGF(
           log,
-          "[%s] candidate match = %s %s %s %s reason = %" PRIu32,
+          "[%s] candidate match = %s %s %s %s",
           __FUNCTION__,
           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());
+          match.DidStripTypedef() ? "strip-typedef" : "no-strip-typedef");
     }
   }
 
   for (begin = m_active_categories.begin(); begin != end; begin++) {
     lldb::TypeCategoryImplSP category_sp = *begin;
     ImplSP current_format;
     LLDB_LOGF(log, "[%s] Trying to use category %s", __FUNCTION__,
               category_sp->GetName());
     if (!category_sp->Get(
             match_data.GetValueObject().GetObjectRuntimeLanguage(),
-            match_data.GetMatchesVector(), current_format, &reason_why))
+            match_data.GetMatchesVector(), current_format))
       continue;
 
     retval = std::move(current_format);
     return;
   }
   LLDB_LOGF(log, "[%s] nothing found - returning empty SP", __FUNCTION__);
 }