RFC: Remove "Validators"

[aprantl]

Summary

Data formatter Validators are completely wired up all the way to the SBAPI, but as far as I can tell they are not used anywhere (including swift-lldb) and also are not tested. I'm puzzled by this, so if anyone can share some info about what this was intended for, please let me know.

This patch deletes them as dead code.

[jingham]

Adrian and I talked about this some more. Apparently the idea was that you have some type Foo and you want to look for some error state in instances of that type (Foo::a + Foo::b < 10). So you add a Type Validator for Foo that does this check, and every time lldb prints a variable of type Foo, it will run the Validator on it, and if it fails validation, then the printer will print an ! at the beginning of the printing, and also there's an SB API to get whether the Value passed the validator.

So then you could just debug along, and either look for the ! in the printing, or add a stop hook that checks the Validator result on all locals, and if you ever saw the error state, you would know to investigate further. That's actually a pretty neat idea.

The current state of the code is that there is actually no way to add a Type Validator. To be really useful, there would need to be a way to create a scripted validator, so the Python bindings and some command/SB API to register the validator.

The implementation is a little cut-and-paste too. It shares all the same options with the Synthetic child provider & Summaries (skips pointers, cascade, etc.) but I don't think you would ever want a type validator that would only validate references to a type, but not the type itself. And then the implementation is very cut & paste. So I'm fine with deleting this for now, but maybe adding it as an interesting project idea to the Projects page - with a reference to the hash of this commit as a starting point?

It's a neat idea but it's also been 5 years now and it was never made useful...

[davide]

In D71310#1778534, @jingham wrote:

Adrian and I talked about this some more. Apparently the idea was that you have some type Foo and you want to look for some error state in instances of that type (Foo::a + Foo::b < 10). So you add a Type Validator for Foo that does this check, and every time lldb prints a variable of type Foo, it will run the Validator on it, and if it fails validation, then the printer will print an ! at the beginning of the printing, and also there's an SB API to get whether the Value passed the validator.

So then you could just debug along, and either look for the ! in the printing, or add a stop hook that checks the Validator result on all locals, and if you ever saw the error state, you would know to investigate further. That's actually a pretty neat idea.

The current state of the code is that there is actually no way to add a Type Validator. To be really useful, there would need to be a way to create a scripted validator, so the Python bindings and some command/SB API to register the validator.

The implementation is a little cut-and-paste too. It shares all the same options with the Synthetic child provider & Summaries (skips pointers, cascade, etc.) but I don't think you would ever want a type validator that would only validate references to a type, but not the type itself. And then the implementation is very cut & paste. So I'm fine with deleting this for now, but maybe adding it as an interesting project idea to the Projects page - with a reference to the hash of this commit as a starting point?

It's a neat idea but it's also been 5 years now and it was never made useful...

+1. This code can be resurrected as-needed.

[teemperor]

+1

[aprantl]

That sounds like there is consensus.

[jingham]

Would you mind adding a mention on the Projects page? This was a neat idea and realistically if it just sits in git, in a few months no one will remember it's there.

[aprantl]

In D71310#1780219, @jingham wrote:

Would you mind adding a mention on the Projects page? This was a neat idea and realistically if it just sits in git, in a few months no one will remember it's there.

Done.

[vsk]

Just a heads up while I investigate, I'm starting to see this on the sanitizer bot:

/Users/buildslave/jenkins/workspace/lldb-cmake-sanitized/llvm-project/lldb/include/lldb/DataFormatters/TypeCategory.h:278:35: runtime error: load of value 190, which is not a valid value for type 'bool'

http://lab.llvm.org:8080/green/view/LLDB/job/lldb-cmake-sanitized/621

This patch is just deleting dead code so it's probably unrelated.

[vsk]

I believe this change is responsible:

-      m_validator_cont("validator", "regex-validator", clist), m_enabled(false),

@aprantl was the m_enabled initialization supposed to be deleted?

Edit: I went ahead and put the initialization back in 46d970cc436, let me know if some other change is needed.

[aprantl]

Whoops. Thanks for fixing it!

lldb/include/lldb/API/SBValue.h

public:
 
   const char *GetSummary();
 
   const char *GetSummary(lldb::SBStream &stream,
                          lldb::SBTypeSummaryOptions &options);
 
   const char *GetObjectDescription();
 
-  const char *GetTypeValidatorResult();
-
   lldb::SBValue GetDynamicValue(lldb::DynamicValueType use_dynamic);
 
   lldb::SBValue GetStaticValue();
 
   lldb::SBValue GetNonSyntheticValue();
 
   lldb::DynamicValueType GetPreferDynamicValue();
 

lldb/include/lldb/Core/ValueObject.h

public:
 
   enum ClearUserVisibleDataItems {
     eClearUserVisibleDataItemsNothing = 1u << 0,
     eClearUserVisibleDataItemsValue = 1u << 1,
     eClearUserVisibleDataItemsSummary = 1u << 2,
     eClearUserVisibleDataItemsLocation = 1u << 3,
     eClearUserVisibleDataItemsDescription = 1u << 4,
     eClearUserVisibleDataItemsSyntheticChildren = 1u << 5,
-    eClearUserVisibleDataItemsValidator = 1u << 6,
     eClearUserVisibleDataItemsAllStrings =
         eClearUserVisibleDataItemsValue | eClearUserVisibleDataItemsSummary |
         eClearUserVisibleDataItemsLocation |
         eClearUserVisibleDataItemsDescription,
     eClearUserVisibleDataItemsAll = 0xFFFF
   };
 
   struct GetValueForExpressionPathOptions {
public:
 
   bool GetSummaryAsCString(std::string &destination,
                            const TypeSummaryOptions &options);
 
   bool GetSummaryAsCString(TypeSummaryImpl *summary_ptr,
                            std::string &destination,
                            const TypeSummaryOptions &options);
 
-  std::pair<TypeValidatorResult, std::string> GetValidationStatus();
-
   const char *GetObjectDescription();
 
   bool HasSpecialPrintableRepresentation(
       ValueObjectRepresentationStyle val_obj_display,
       lldb::Format custom_format);
 
   enum class PrintableRepresentationSpecialCases : bool {
     eDisable = false,
lldb::TypeSummaryImplSP GetSummaryFormat() {
     return m_type_summary_sp;
   }
 
   void SetSummaryFormat(lldb::TypeSummaryImplSP format) {
     m_type_summary_sp = format;
     ClearUserVisibleData(eClearUserVisibleDataItemsSummary);
   }
 
-  lldb::TypeValidatorImplSP GetValidator() {
-    UpdateFormatsIfNeeded();
-    return m_type_validator_sp;
-  }
-
-  void SetValidator(lldb::TypeValidatorImplSP format) {
-    m_type_validator_sp = format;
-    ClearUserVisibleData(eClearUserVisibleDataItemsValidator);
-  }
-
   void SetValueFormat(lldb::TypeFormatImplSP format) {
     m_type_format_sp = format;
     ClearUserVisibleData(eClearUserVisibleDataItemsValue);
   }
 
   lldb::TypeFormatImplSP GetValueFormat() {
     UpdateFormatsIfNeeded();
     return m_type_format_sp;
protected:
   std::string m_location_str;  // Cached location string that will get cleared
                                // if/when the value is updated.
   std::string m_summary_str;   // Cached summary string that will get cleared
                                // if/when the value is updated.
   std::string m_object_desc_str; // Cached result of the "object printer".  This
                                  // differs from the summary
   // in that the summary is consed up by us, the object_desc_string is builtin.
 
-  llvm::Optional<std::pair<TypeValidatorResult, std::string>>
-      m_validation_result;
-
   CompilerType m_override_type; // If the type of the value object should be
                                 // overridden, the type to impose.
 
   ValueObjectManager *m_manager; // This object is managed by the root object
                                  // (any ValueObject that gets created
   // without a parent.)  The manager gets passed through all the generations of
   // dependent objects, and will keep the whole cluster of objects alive as
   // long as a shared pointer to any of them has been handed out.  Shared
protected:
   // as an independent ValueObjectConstResult, which isn't managed by us.
 
   lldb::Format m_format;
   lldb::Format m_last_format;
   uint32_t m_last_format_mgr_revision;
   lldb::TypeSummaryImplSP m_type_summary_sp;
   lldb::TypeFormatImplSP m_type_format_sp;
   lldb::SyntheticChildrenSP m_synthetic_children_sp;
-  lldb::TypeValidatorImplSP m_type_validator_sp;
   ProcessModID m_user_id_of_forced_summary;
   AddressType m_address_type_of_ptr_or_ref_children;
 
   llvm::SmallVector<uint8_t, 16> m_value_checksum;
 
   lldb::LanguageType m_preferred_display_language;
 
   uint64_t m_language_flags;

lldb/include/lldb/DataFormatters/DataVisualization.h

public:
   GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   static lldb::ScriptedSyntheticChildrenSP
   GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   static lldb::SyntheticChildrenSP
   GetSyntheticChildren(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
 
-  static lldb::TypeValidatorImplSP
-  GetValidator(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
-
-  static lldb::TypeValidatorImplSP
-  GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
   static bool
   AnyMatches(ConstString type_name,
              TypeCategoryImpl::FormatCategoryItems items =
                  TypeCategoryImpl::ALL_ITEM_TYPES,
              bool only_enabled = true, const char **matching_category = nullptr,
              TypeCategoryImpl::FormatCategoryItems *matching_type = nullptr);
 
   class NamedSummaryFormats {

lldb/include/lldb/DataFormatters/FormatCache.h

 namespace lldb_private {
 class FormatCache {
 private:
   struct Entry {
   private:
     bool m_format_cached : 1;
     bool m_summary_cached : 1;
     bool m_synthetic_cached : 1;
-    bool m_validator_cached : 1;
 
     lldb::TypeFormatImplSP m_format_sp;
     lldb::TypeSummaryImplSP m_summary_sp;
     lldb::SyntheticChildrenSP m_synthetic_sp;
-    lldb::TypeValidatorImplSP m_validator_sp;
 
   public:
     Entry();
 
     template<typename ImplSP> bool IsCached();
     bool IsFormatCached();
     bool IsSummaryCached();
     bool IsSyntheticCached();
-    bool IsValidatorCached();
 
     void Get(lldb::TypeFormatImplSP &);
     void Get(lldb::TypeSummaryImplSP &);
     void Get(lldb::SyntheticChildrenSP &);
-    void Get(lldb::TypeValidatorImplSP &);
 
     void Set(lldb::TypeFormatImplSP);
     void Set(lldb::TypeSummaryImplSP);
     void Set(lldb::SyntheticChildrenSP);
-    void Set(lldb::TypeValidatorImplSP);
   };
   typedef std::map<ConstString, Entry> CacheMap;
   CacheMap m_map;
   std::recursive_mutex m_mutex;
 
   uint64_t m_cache_hits;
   uint64_t m_cache_misses;
 
   Entry &GetEntry(ConstString type);
 
 public:
   FormatCache();
 
   template <typename ImplSP> bool Get(ConstString type, ImplSP &format_impl_sp);
   void Set(ConstString type, lldb::TypeFormatImplSP &format_sp);
   void Set(ConstString type, lldb::TypeSummaryImplSP &summary_sp);
   void Set(ConstString type, lldb::SyntheticChildrenSP &synthetic_sp);
-  void Set(ConstString type, lldb::TypeValidatorImplSP &synthetic_sp);
 
   void Clear();
 
   uint64_t GetCacheHits() { return m_cache_hits; }
 
   uint64_t GetCacheMisses() { return m_cache_misses; }
 };
 
 } // namespace lldb_private
 
 #endif // lldb_FormatCache_h_

lldb/include/lldb/DataFormatters/FormatClasses.h

 #include <functional>
 #include <memory>
 #include <string>
 #include <vector>
 
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/DataFormatters/TypeValidator.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Type.h"
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
 namespace lldb_private {
 
 class HardcodedFormatters {
 public:
   template <typename FormatterType>
   using HardcodedFormatterFinder =
       std::function<typename FormatterType::SharedPointer(
           lldb_private::ValueObject &, lldb::DynamicValueType,
           FormatManager &)>;
 
   template <typename FormatterType>
   using HardcodedFormatterFinders =
       std::vector<HardcodedFormatterFinder<FormatterType>>;
 
   typedef HardcodedFormatterFinders<TypeFormatImpl> HardcodedFormatFinder;
   typedef HardcodedFormatterFinders<TypeSummaryImpl> HardcodedSummaryFinder;
   typedef HardcodedFormatterFinders<SyntheticChildren> HardcodedSyntheticFinder;
-  typedef HardcodedFormatterFinders<TypeValidatorImpl> HardcodedValidatorFinder;
 };
 
 class FormattersMatchCandidate {
 public:
   FormattersMatchCandidate(ConstString name, uint32_t reason, bool strip_ptr,
                            bool strip_ref, bool strip_tydef)
       : m_type_name(name), m_reason(reason), m_stripped_pointer(strip_ptr),
         m_stripped_reference(strip_ref), m_stripped_typedef(strip_tydef) {}

lldb/include/lldb/DataFormatters/FormatManager.h

public:
   GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   lldb::TypeFilterImplSP
   GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   lldb::ScriptedSyntheticChildrenSP
   GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
 
-  lldb::TypeValidatorImplSP
-  GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
   lldb::TypeFormatImplSP GetFormat(ValueObject &valobj,
                                    lldb::DynamicValueType use_dynamic);
 
   lldb::TypeSummaryImplSP GetSummaryFormat(ValueObject &valobj,
                                            lldb::DynamicValueType use_dynamic);
 
   lldb::SyntheticChildrenSP
   GetSyntheticChildren(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
 
-  lldb::TypeValidatorImplSP GetValidator(ValueObject &valobj,
-                                         lldb::DynamicValueType use_dynamic);
-
   bool
   AnyMatches(ConstString type_name,
              TypeCategoryImpl::FormatCategoryItems items =
                  TypeCategoryImpl::ALL_ITEM_TYPES,
              bool only_enabled = true, const char **matching_category = nullptr,
              TypeCategoryImpl::FormatCategoryItems *matching_type = nullptr) {
     return m_categories_map.AnyMatches(type_name, items, only_enabled,
                                        matching_category, matching_type);

lldb/include/lldb/DataFormatters/FormattersContainer.h

 
 #include "lldb/lldb-public.h"
 
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/FormatClasses.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/DataFormatters/TypeValidator.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Utility/RegularExpression.h"
 #include "lldb/Utility/StringLexer.h"
 
 namespace lldb_private {
 
 class IFormatChangeListener {
 public:

lldb/include/lldb/DataFormatters/LanguageCategory.h

public:
   bool IsEnabled();
 
 private:
   lldb::TypeCategoryImplSP m_category_sp;
 
   HardcodedFormatters::HardcodedFormatFinder m_hardcoded_formats;
   HardcodedFormatters::HardcodedSummaryFinder m_hardcoded_summaries;
   HardcodedFormatters::HardcodedSyntheticFinder m_hardcoded_synthetics;
-  HardcodedFormatters::HardcodedValidatorFinder m_hardcoded_validators;
 
   template <typename ImplSP>
   auto &GetHardcodedFinder();
 
   lldb_private::FormatCache m_format_cache;
 
   bool m_enabled;
 };
 
 } // namespace lldb_private
 
 #endif // lldb_LanguageCategory_h_

lldb/include/lldb/DataFormatters/TypeCategory.h

private:
   RegexMatchContainerSP m_regex_sp;
 };
 
 class TypeCategoryImpl {
 private:
   typedef FormatterContainerPair<TypeFormatImpl> FormatContainer;
   typedef FormatterContainerPair<TypeSummaryImpl> SummaryContainer;
   typedef FormatterContainerPair<TypeFilterImpl> FilterContainer;
-  typedef FormatterContainerPair<TypeValidatorImpl> ValidatorContainer;
   typedef FormatterContainerPair<SyntheticChildren> SynthContainer;
 
 public:
   typedef uint16_t FormatCategoryItems;
   static const uint16_t ALL_ITEM_TYPES = UINT16_MAX;
 
   typedef FormatContainer::ExactMatchContainerSP FormatContainerSP;
   typedef FormatContainer::RegexMatchContainerSP RegexFormatContainerSP;
 
   typedef SummaryContainer::ExactMatchContainerSP SummaryContainerSP;
   typedef SummaryContainer::RegexMatchContainerSP RegexSummaryContainerSP;
 
   typedef FilterContainer::ExactMatchContainerSP FilterContainerSP;
   typedef FilterContainer::RegexMatchContainerSP RegexFilterContainerSP;
 
   typedef SynthContainer::ExactMatchContainerSP SynthContainerSP;
   typedef SynthContainer::RegexMatchContainerSP RegexSynthContainerSP;
 
-  typedef ValidatorContainer::ExactMatchContainerSP ValidatorContainerSP;
-  typedef ValidatorContainer::RegexMatchContainerSP RegexValidatorContainerSP;
-
   template <typename T> class ForEachCallbacks {
   public:
     ForEachCallbacks() = default;
     ~ForEachCallbacks() = default;
 
     template <typename U = TypeFormatImpl>
     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
     SetExact(FormatContainer::ExactMatchForEachCallback callback) {
SetExact(SynthContainer::ExactMatchForEachCallback callback) {
       return *this;
     }
     template <typename U = SyntheticChildren>
     typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
     SetWithRegex(SynthContainer::RegexMatchForEachCallback callback) {
       m_synth_regex = callback;
       return *this;
     }
-    template <typename U = TypeValidatorImpl>
-    typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
-    SetExact(ValidatorContainer::ExactMatchForEachCallback callback) {
-      m_validator_exact = callback;
-      return *this;
-    }
-    template <typename U = TypeValidatorImpl>
-    typename std::enable_if<std::is_same<U, T>::value, ForEachCallbacks &>::type
-    SetWithRegex(ValidatorContainer::RegexMatchForEachCallback callback) {
-      m_validator_regex = callback;
-      return *this;
-    }
 
     FormatContainer::ExactMatchForEachCallback GetFormatExactCallback() const {
       return m_format_exact;
     }
     FormatContainer::RegexMatchForEachCallback GetFormatRegexCallback() const {
       return m_format_regex;
     }
 
public:
 
     SynthContainer::ExactMatchForEachCallback GetSynthExactCallback() const {
       return m_synth_exact;
     }
     SynthContainer::RegexMatchForEachCallback GetSynthRegexCallback() const {
       return m_synth_regex;
     }
 
-    ValidatorContainer::ExactMatchForEachCallback
-    GetValidatorExactCallback() const {
-      return m_validator_exact;
-    }
-    ValidatorContainer::RegexMatchForEachCallback
-    GetValidatorRegexCallback() const {
-      return m_validator_regex;
-    }
-
   private:
     FormatContainer::ExactMatchForEachCallback m_format_exact;
     FormatContainer::RegexMatchForEachCallback m_format_regex;
 
     SummaryContainer::ExactMatchForEachCallback m_summary_exact;
     SummaryContainer::RegexMatchForEachCallback m_summary_regex;
 
     FilterContainer::ExactMatchForEachCallback m_filter_exact;
     FilterContainer::RegexMatchForEachCallback m_filter_regex;
 
     SynthContainer::ExactMatchForEachCallback m_synth_exact;
     SynthContainer::RegexMatchForEachCallback m_synth_regex;
-
-    ValidatorContainer::ExactMatchForEachCallback m_validator_exact;
-    ValidatorContainer::RegexMatchForEachCallback m_validator_regex;
   };
 
   TypeCategoryImpl(IFormatChangeListener *clist, ConstString name);
 
   template <typename T> void ForEach(const ForEachCallbacks<T> &foreach) {
     GetTypeFormatsContainer()->ForEach(foreach.GetFormatExactCallback());
     GetRegexTypeFormatsContainer()->ForEach(foreach.GetFormatRegexCallback());
 
     GetTypeSummariesContainer()->ForEach(foreach.GetSummaryExactCallback());
     GetRegexTypeSummariesContainer()->ForEach(
         foreach.GetSummaryRegexCallback());
 
     GetTypeFiltersContainer()->ForEach(foreach.GetFilterExactCallback());
     GetRegexTypeFiltersContainer()->ForEach(foreach.GetFilterRegexCallback());
 
     GetTypeSyntheticsContainer()->ForEach(foreach.GetSynthExactCallback());
     GetRegexTypeSyntheticsContainer()->ForEach(foreach.GetSynthRegexCallback());
-
-    GetTypeValidatorsContainer()->ForEach(foreach.GetValidatorExactCallback());
-    GetRegexTypeValidatorsContainer()->ForEach(
-        foreach.GetValidatorRegexCallback());
   }
 
   FormatContainerSP GetTypeFormatsContainer() {
     return m_format_cont.GetExactMatch();
   }
 
   RegexFormatContainerSP GetRegexTypeFormatsContainer() {
     return m_format_cont.GetRegexMatch();
public:
   GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   FilterContainer::MapValueType
   GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp);
 
   SynthContainer::MapValueType
   GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp);
 
-  ValidatorContainer::MapValueType
-  GetValidatorForType(lldb::TypeNameSpecifierImplSP type_sp);
-
   lldb::TypeNameSpecifierImplSP
   GetTypeNameSpecifierForFormatAtIndex(size_t index);
 
   lldb::TypeNameSpecifierImplSP
   GetTypeNameSpecifierForSummaryAtIndex(size_t index);
 
   FormatContainer::MapValueType GetFormatAtIndex(size_t index);
 
public:
 
   SynthContainer &GetSyntheticsContainer() { return m_synth_cont; }
 
   SynthContainer::MapValueType GetSyntheticAtIndex(size_t index);
 
   lldb::TypeNameSpecifierImplSP
   GetTypeNameSpecifierForSyntheticAtIndex(size_t index);
 
-  ValidatorContainerSP GetTypeValidatorsContainer() {
-    return m_validator_cont.GetExactMatch();
-  }
-
-  RegexValidatorContainerSP GetRegexTypeValidatorsContainer() {
-    return m_validator_cont.GetRegexMatch();
-  }
-
-  ValidatorContainer::MapValueType GetValidatorAtIndex(size_t index);
-
-  lldb::TypeNameSpecifierImplSP
-  GetTypeNameSpecifierForValidatorAtIndex(size_t index);
-
   bool IsEnabled() const { return m_enabled; }
 
   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);
 
   bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
            lldb::TypeSummaryImplSP &entry, uint32_t *reason = nullptr);
 
   bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
            lldb::SyntheticChildrenSP &entry, uint32_t *reason = nullptr);
 
-  bool Get(lldb::LanguageType lang, const FormattersMatchVector &candidates,
-           lldb::TypeValidatorImplSP &entry, uint32_t *reason = nullptr);
-
   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(); }
 
public:
 
   typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;
 
 private:
   FormatContainer m_format_cont;
   SummaryContainer m_summary_cont;
   FilterContainer m_filter_cont;
   SynthContainer m_synth_cont;
-  ValidatorContainer m_validator_cont;
 
   bool m_enabled;
 
   IFormatChangeListener *m_change_listener;
 
   std::recursive_mutex m_mutex;
 
   ConstString m_name;
private:
 
   friend class FormattersContainer<ConstString, TypeFilterImpl>;
   friend class FormattersContainer<lldb::RegularExpressionSP, TypeFilterImpl>;
 
   friend class FormattersContainer<ConstString, ScriptedSyntheticChildren>;
   friend class FormattersContainer<lldb::RegularExpressionSP,
                                    ScriptedSyntheticChildren>;
 
-  friend class FormattersContainer<ConstString, TypeValidatorImpl>;
-  friend class FormattersContainer<lldb::RegularExpressionSP,
-                                   TypeValidatorImpl>;
 };
 
 } // namespace lldb_private
 
 #endif // lldb_TypeCategory_h_

lldb/include/lldb/DataFormatters/TypeValidator.h

-//===-- TypeValidator.h ------------------------------------------*- C++
-//-*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-#ifndef lldb_TypeValidator_h_
-#define lldb_TypeValidator_h_
-
-
-#include <functional>
-#include <string>
-
-
-#include "lldb/lldb-enumerations.h"
-#include "lldb/lldb-private-enumerations.h"
-#include "lldb/lldb-public.h"
-
-namespace lldb_private {
-
-class TypeValidatorImpl {
-public:
-  class Flags {
-  public:
-    Flags() : m_flags(lldb::eTypeOptionCascade) {}
-
-    Flags(const Flags &other) : m_flags(other.m_flags) {}
-
-    Flags(uint32_t value) : m_flags(value) {}
-
-    Flags &operator=(const Flags &rhs) {
-      if (&rhs != this)
-        m_flags = rhs.m_flags;
-
-      return *this;
-    }
-
-    Flags &operator=(const uint32_t &rhs) {
-      m_flags = rhs;
-      return *this;
-    }
-
-    Flags &Clear() {
-      m_flags = 0;
-      return *this;
-    }
-
-    bool GetCascades() const {
-      return (m_flags & lldb::eTypeOptionCascade) == lldb::eTypeOptionCascade;
-    }
-
-    Flags &SetCascades(bool value = true) {
-      if (value)
-        m_flags |= lldb::eTypeOptionCascade;
-      else
-        m_flags &= ~lldb::eTypeOptionCascade;
-      return *this;
-    }
-
-    bool GetSkipPointers() const {
-      return (m_flags & lldb::eTypeOptionSkipPointers) ==
-             lldb::eTypeOptionSkipPointers;
-    }
-
-    Flags &SetSkipPointers(bool value = true) {
-      if (value)
-        m_flags |= lldb::eTypeOptionSkipPointers;
-      else
-        m_flags &= ~lldb::eTypeOptionSkipPointers;
-      return *this;
-    }
-
-    bool GetSkipReferences() const {
-      return (m_flags & lldb::eTypeOptionSkipReferences) ==
-             lldb::eTypeOptionSkipReferences;
-    }
-
-    Flags &SetSkipReferences(bool value = true) {
-      if (value)
-        m_flags |= lldb::eTypeOptionSkipReferences;
-      else
-        m_flags &= ~lldb::eTypeOptionSkipReferences;
-      return *this;
-    }
-
-    bool GetNonCacheable() const {
-      return (m_flags & lldb::eTypeOptionNonCacheable) ==
-             lldb::eTypeOptionNonCacheable;
-    }
-
-    Flags &SetNonCacheable(bool value = true) {
-      if (value)
-        m_flags |= lldb::eTypeOptionNonCacheable;
-      else
-        m_flags &= ~lldb::eTypeOptionNonCacheable;
-      return *this;
-    }
-
-    uint32_t GetValue() { return m_flags; }
-
-    void SetValue(uint32_t value) { m_flags = value; }
-
-  private:
-    uint32_t m_flags;
-  };
-
-  TypeValidatorImpl(const Flags &flags = Flags());
-
-  typedef std::shared_ptr<TypeValidatorImpl> SharedPointer;
-
-  virtual ~TypeValidatorImpl();
-
-  bool Cascades() const { return m_flags.GetCascades(); }
-  bool SkipsPointers() const { return m_flags.GetSkipPointers(); }
-  bool SkipsReferences() const { return m_flags.GetSkipReferences(); }
-  bool NonCacheable() const { return m_flags.GetNonCacheable(); }
-
-  void SetCascades(bool value) { m_flags.SetCascades(value); }
-
-  void SetSkipsPointers(bool value) { m_flags.SetSkipPointers(value); }
-
-  void SetSkipsReferences(bool value) { m_flags.SetSkipReferences(value); }
-
-  void SetNonCacheable(bool value) { m_flags.SetNonCacheable(value); }
-
-  uint32_t GetOptions() { return m_flags.GetValue(); }
-
-  void SetOptions(uint32_t value) { m_flags.SetValue(value); }
-
-  uint32_t &GetRevision() { return m_my_revision; }
-
-  enum class Type { eTypeUnknown, eTypeCXX };
-
-  struct ValidationResult {
-    TypeValidatorResult m_result;
-    std::string m_message;
-  };
-
-  virtual Type GetType() { return Type::eTypeUnknown; }
-
-  // we are using a ValueObject* instead of a ValueObjectSP because we do not
-  // need to hold on to this for extended periods of time and we trust the
-  // ValueObject to stay around for as long as it is required for us to
-  // generate its value
-  virtual ValidationResult FormatObject(ValueObject *valobj) const = 0;
-
-  virtual std::string GetDescription() = 0;
-
-  static ValidationResult Success();
-
-  static ValidationResult Failure(std::string message);
-
-protected:
-  Flags m_flags;
-  uint32_t m_my_revision;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl);
-};
-
-class TypeValidatorImpl_CXX : public TypeValidatorImpl {
-public:
-  typedef std::function<TypeValidatorImpl::ValidationResult(
-      ValueObject *valobj)>
-      ValidatorFunction;
-
-  TypeValidatorImpl_CXX(ValidatorFunction f, std::string d,
-                        const TypeValidatorImpl::Flags &flags = Flags());
-
-  typedef std::shared_ptr<TypeValidatorImpl_CXX> SharedPointer;
-
-  ~TypeValidatorImpl_CXX() override;
-
-  ValidatorFunction GetValidatorFunction() const {
-    return m_validator_function;
-  }
-
-  void SetValidatorFunction(ValidatorFunction f) { m_validator_function = f; }
-
-  TypeValidatorImpl::Type GetType() override {
-    return TypeValidatorImpl::Type::eTypeCXX;
-  }
-
-  ValidationResult FormatObject(ValueObject *valobj) const override;
-
-  std::string GetDescription() override;
-
-protected:
-  std::string m_description;
-  ValidatorFunction m_validator_function;
-
-private:
-  DISALLOW_COPY_AND_ASSIGN(TypeValidatorImpl_CXX);
-};
-
-} // namespace lldb_private
-
-#endif // lldb_TypeValidator_h_

lldb/include/lldb/DataFormatters/ValueObjectPrinter.h

protected:
   bool GetMostSpecializedValue();
 
   const char *GetDescriptionForDisplay();
 
   const char *GetRootNameForDisplay(const char *if_fail = nullptr);
 
   bool ShouldPrintValueObject();
 
-  bool ShouldPrintValidation();
-
   bool IsNil();
 
   bool IsUninitialized();
 
   bool IsPtr();
 
   bool IsRef();
 
   bool IsInstancePointer();
 
   bool IsAggregate();
 
-  bool PrintValidationMarkerIfNeeded();
-
-  bool PrintValidationErrorIfNeeded();
-
   bool PrintLocationIfNeeded();
 
   void PrintDecl();
 
   bool CheckScopeIfNeeded();
 
   bool ShouldPrintEmptyBrackets(bool value_printed, bool summary_printed);
 
private:
   LazyBool m_is_ref;
   LazyBool m_is_aggregate;
   LazyBool m_is_instance_ptr;
   std::pair<TypeSummaryImpl *, bool> m_summary_formatter;
   std::string m_value;
   std::string m_summary;
   std::string m_error;
   bool m_val_summary_ok;
-  std::pair<TypeValidatorResult, std::string> m_validation;
 
   friend struct StringSummaryFormat;
 
   DISALLOW_COPY_AND_ASSIGN(ValueObjectPrinter);
 };
 
 } // namespace lldb_private
 
 #endif // lldb_ValueObjectPrinter_h_

lldb/include/lldb/Target/Language.h

public:
 
   virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats();
 
   virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries();
 
   virtual HardcodedFormatters::HardcodedSyntheticFinder
   GetHardcodedSynthetics();
 
-  virtual HardcodedFormatters::HardcodedValidatorFinder
-  GetHardcodedValidators();
-
   virtual std::vector<ConstString>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic);
 
   virtual lldb_private::formatters::StringPrinter::EscapingHelper
       GetStringPrinterEscapingHelper(
           lldb_private::formatters::StringPrinter::GetPrintableElementType);
 

lldb/include/lldb/lldb-forward.h

 class TypeMap;
 class TypeListImpl;
 class TypeMemberImpl;
 class TypeMemberFunctionImpl;
 class TypeEnumMemberImpl;
 class TypeEnumMemberListImpl;
 class TypeFormatImpl;
 class TypeNameSpecifierImpl;
-class TypeValidatorImpl;
 class UUID;
 class UnixSignals;
 class Unwind;
 class UnwindAssembly;
 class UnwindPlan;
 class UnwindTable;
 class UserExpression;
 class UtilityFunction;

 typedef std::shared_ptr<lldb_private::TypeEnumMemberImpl> TypeEnumMemberImplSP;
 typedef std::shared_ptr<lldb_private::TypeFilterImpl> TypeFilterImplSP;
 typedef std::shared_ptr<lldb_private::TypeSystem> TypeSystemSP;
 typedef std::shared_ptr<lldb_private::TypeFormatImpl> TypeFormatImplSP;
 typedef std::shared_ptr<lldb_private::TypeNameSpecifierImpl>
     TypeNameSpecifierImplSP;
 typedef std::shared_ptr<lldb_private::TypeSummaryImpl> TypeSummaryImplSP;
 typedef std::shared_ptr<lldb_private::TypeSummaryOptions> TypeSummaryOptionsSP;
-typedef std::shared_ptr<lldb_private::TypeValidatorImpl> TypeValidatorImplSP;
 typedef std::shared_ptr<lldb_private::ScriptedSyntheticChildren>
     ScriptedSyntheticChildrenSP;
 typedef std::shared_ptr<lldb_private::UnixSignals> UnixSignalsSP;
 typedef std::weak_ptr<lldb_private::UnixSignals> UnixSignalsWP;
 typedef std::shared_ptr<lldb_private::UnwindAssembly> UnwindAssemblySP;
 typedef std::shared_ptr<lldb_private::UnwindPlan> UnwindPlanSP;
 typedef std::shared_ptr<lldb_private::UtilityFunction> UtilityFunctionSP;
 typedef lldb_private::SharingPtr<lldb_private::ValueObject> ValueObjectSP;

lldb/scripts/interface/SBValue.i

public:
 
     const char *
     GetSummary (lldb::SBStream& stream,
                 lldb::SBTypeSummaryOptions& options);
 
     const char *
     GetObjectDescription ();
 
-    const char *
-    GetTypeValidatorResult ();
-
     lldb::SBValue
     GetDynamicValue (lldb::DynamicValueType use_dynamic);
 
     lldb::SBValue
     GetStaticValue ();
 
     lldb::SBValue
     GetNonSyntheticValue ();

lldb/source/API/SBValue.cpp

const char *SBValue::GetObjectDescription() {
   lldb::ValueObjectSP value_sp(GetSP(locker));
   if (value_sp) {
     cstr = value_sp->GetObjectDescription();
   }
 
   return cstr;
 }
 
-const char *SBValue::GetTypeValidatorResult() {
-  LLDB_RECORD_METHOD_NO_ARGS(const char *, SBValue, GetTypeValidatorResult);
-
-  const char *cstr = nullptr;
-  ValueLocker locker;
-  lldb::ValueObjectSP value_sp(GetSP(locker));
-  if (value_sp) {
-    const auto &validation(value_sp->GetValidationStatus());
-    if (TypeValidatorResult::Failure == validation.first) {
-      if (validation.second.empty())
-        cstr = "unknown error";
-      else
-        cstr = validation.second.c_str();
-    }
-  }
-
-  return cstr;
-}
-
 SBType SBValue::GetType() {
   LLDB_RECORD_METHOD_NO_ARGS(lldb::SBType, SBValue, GetType);
 
   SBType sb_type;
   ValueLocker locker;
   lldb::ValueObjectSP value_sp(GetSP(locker));
   TypeImplSP type_sp;
   if (value_sp) {
void RegisterMethods<SBValue>(Registry &R) {
   LLDB_REGISTER_METHOD(const char *, SBValue, GetName, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeName, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetDisplayTypeName, ());
   LLDB_REGISTER_METHOD(size_t, SBValue, GetByteSize, ());
   LLDB_REGISTER_METHOD(bool, SBValue, IsInScope, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetValue, ());
   LLDB_REGISTER_METHOD(lldb::ValueType, SBValue, GetValueType, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetObjectDescription, ());
-  LLDB_REGISTER_METHOD(const char *, SBValue, GetTypeValidatorResult, ());
   LLDB_REGISTER_METHOD(lldb::SBType, SBValue, GetType, ());
   LLDB_REGISTER_METHOD(bool, SBValue, GetValueDidChange, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary, ());
   LLDB_REGISTER_METHOD(const char *, SBValue, GetSummary,
                        (lldb::SBStream &, lldb::SBTypeSummaryOptions &));
   LLDB_REGISTER_METHOD(const char *, SBValue, GetLocation, ());
   LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString, (const char *));
   LLDB_REGISTER_METHOD(bool, SBValue, SetValueFromCString,

lldb/source/Core/ValueObject.cpp

 #include "lldb/Core/ValueObjectMemory.h"
 #include "lldb/Core/ValueObjectSyntheticFilter.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/DumpValueObjectOptions.h"
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/StringPrinter.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
-#include "lldb/DataFormatters/TypeValidator.h"
 #include "lldb/DataFormatters/ValueObjectPrinter.h"
 #include "lldb/Expression/ExpressionVariable.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Symbol/ClangASTContext.h"
 #include "lldb/Symbol/CompileUnit.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Symbol/Declaration.h"
 #include "lldb/Symbol/SymbolContext.h"

 static user_id_t g_value_obj_uid = 0;
 
 // ValueObject constructor
 ValueObject::ValueObject(ValueObject &parent)
     : UserID(++g_value_obj_uid), // Unique identifier for every value object
       m_parent(&parent), m_root(nullptr),
       m_update_point(parent.GetUpdatePoint()), m_name(), m_data(), m_value(),
       m_error(), m_value_str(), m_old_value_str(), m_location_str(),
-      m_summary_str(), m_object_desc_str(), m_validation_result(),
-      m_manager(parent.GetManager()), m_children(), m_synthetic_children(),
-      m_dynamic_value(nullptr), m_synthetic_value(nullptr),
-      m_deref_valobj(nullptr), m_format(eFormatDefault),
-      m_last_format(eFormatDefault), m_last_format_mgr_revision(0),
-      m_type_summary_sp(), m_type_format_sp(), m_synthetic_children_sp(),
-      m_type_validator_sp(), m_user_id_of_forced_summary(),
+      m_summary_str(), m_object_desc_str(), m_manager(parent.GetManager()),
+      m_children(), m_synthetic_children(), m_dynamic_value(nullptr),
+      m_synthetic_value(nullptr), m_deref_valobj(nullptr),
+      m_format(eFormatDefault), m_last_format(eFormatDefault),
+      m_last_format_mgr_revision(0), m_type_summary_sp(), m_type_format_sp(),
+      m_synthetic_children_sp(), m_user_id_of_forced_summary(),
       m_address_type_of_ptr_or_ref_children(eAddressTypeInvalid),
       m_value_checksum(),
       m_preferred_display_language(lldb::eLanguageTypeUnknown),
       m_language_flags(0), m_value_is_valid(false), m_value_did_change(false),
       m_children_count_valid(false), m_old_value_valid(false),
       m_is_deref_of_parent(false), m_is_array_item_for_pointer(false),
       m_is_bitfield_for_scalar(false), m_is_child_at_offset(false),
       m_is_getting_summary(false),
       m_did_calculate_complete_objc_class_type(false),
       m_is_synthetic_children_generated(
           parent.m_is_synthetic_children_generated) {
   m_data.SetByteOrder(parent.GetDataExtractor().GetByteOrder());
   m_data.SetAddressByteSize(parent.GetDataExtractor().GetAddressByteSize());
   m_manager->ManageObject(this);
 }
 
 // ValueObject constructor
 ValueObject::ValueObject(ExecutionContextScope *exe_scope,
                          AddressType child_ptr_or_ref_addr_type)
     : UserID(++g_value_obj_uid), // Unique identifier for every value object
       m_parent(nullptr), m_root(nullptr), m_update_point(exe_scope), m_name(),
       m_data(), m_value(), m_error(), m_value_str(), m_old_value_str(),
       m_location_str(), m_summary_str(), m_object_desc_str(),
-      m_validation_result(), m_manager(), m_children(), m_synthetic_children(),
+      m_manager(), m_children(), m_synthetic_children(),
       m_dynamic_value(nullptr), m_synthetic_value(nullptr),
       m_deref_valobj(nullptr), m_format(eFormatDefault),
       m_last_format(eFormatDefault), m_last_format_mgr_revision(0),
       m_type_summary_sp(), m_type_format_sp(), m_synthetic_children_sp(),
-      m_type_validator_sp(), m_user_id_of_forced_summary(),
+      m_user_id_of_forced_summary(),
       m_address_type_of_ptr_or_ref_children(child_ptr_or_ref_addr_type),
       m_value_checksum(),
       m_preferred_display_language(lldb::eLanguageTypeUnknown),
       m_language_flags(0), m_value_is_valid(false), m_value_did_change(false),
       m_children_count_valid(false), m_old_value_valid(false),
       m_is_deref_of_parent(false), m_is_array_item_for_pointer(false),
       m_is_bitfield_for_scalar(false), m_is_child_at_offset(false),
       m_is_getting_summary(false),
if ((m_last_format_mgr_revision != DataVisualization::GetCurrentRevision())) {
 
     SetValueFormat(DataVisualization::GetFormat(*this, eNoDynamicValues));
     SetSummaryFormat(
         DataVisualization::GetSummaryFormat(*this, GetDynamicValueType()));
 #ifndef LLDB_DISABLE_PYTHON
     SetSyntheticChildren(
         DataVisualization::GetSyntheticChildren(*this, GetDynamicValueType()));
 #endif
-    SetValidator(DataVisualization::GetValidator(*this, GetDynamicValueType()));
   }
 
   return any_change;
 }
 
 void ValueObject::SetNeedsUpdate() {
   m_update_point.SetNeedsUpdate();
   // We have to clear the value string here so ConstResult children will notice
ValueObject::ReadPointedString(lldb::DataBufferSP &buffer_sp, Status &error,
   } else {
     error.SetErrorString("not a string object");
     s << "<not a string object>";
   }
   CopyStringDataToBufferSP(s, buffer_sp);
   return {total_bytes_read, was_capped};
 }
 
-std::pair<TypeValidatorResult, std::string> ValueObject::GetValidationStatus() {
-  if (!UpdateValueIfNeeded(true))
-    return {TypeValidatorResult::Success,
-            ""}; // not the validator's job to discuss update problems
-
-  if (m_validation_result.hasValue())
-    return m_validation_result.getValue();
-
-  if (!m_type_validator_sp)
-    return {TypeValidatorResult::Success, ""}; // no validator no failure
-
-  auto outcome = m_type_validator_sp->FormatObject(this);
-
-  return (m_validation_result = {outcome.m_result, outcome.m_message})
-      .getValue();
-}
-
 const char *ValueObject::GetObjectDescription() {
   if (!UpdateValueIfNeeded(true))
     return nullptr;
 
   // Return cached value.
   if (!m_object_desc_str.empty())
     return m_object_desc_str.c_str();
 
if ((clear_mask & eClearUserVisibleDataItemsDescription) ==
       eClearUserVisibleDataItemsDescription)
     m_object_desc_str.clear();
 
   if ((clear_mask & eClearUserVisibleDataItemsSyntheticChildren) ==
       eClearUserVisibleDataItemsSyntheticChildren) {
     if (m_synthetic_value)
       m_synthetic_value = nullptr;
   }
-
-  if ((clear_mask & eClearUserVisibleDataItemsValidator) ==
-      eClearUserVisibleDataItemsValidator)
-    m_validation_result.reset();
 }
 
 SymbolContextScope *ValueObject::GetSymbolContextScope() {
   if (m_parent) {
     if (!m_parent->IsPointerOrReferenceType())
       return m_parent->GetSymbolContextScope();
   }
   return nullptr;

lldb/source/DataFormatters/CMakeLists.txt

 add_lldb_library(lldbDataFormatters
   CXXFunctionPointer.cpp
   DataVisualization.cpp
   DumpValueObjectOptions.cpp
   FormatCache.cpp
   FormatClasses.cpp
   FormatManager.cpp
   FormattersHelpers.cpp
   LanguageCategory.cpp
   StringPrinter.cpp
   TypeCategory.cpp
   TypeCategoryMap.cpp
   TypeFormat.cpp
   TypeSummary.cpp
   TypeSynthetic.cpp
-  TypeValidator.cpp
   ValueObjectPrinter.cpp
   VectorType.cpp
 
   LINK_LIBS
     lldbCore
     lldbInterpreter
     lldbSymbol
     lldbTarget
     lldbUtility
   
   LINK_COMPONENTS
     Support
   )

lldb/source/DataFormatters/DataVisualization.cpp

DataVisualization::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
   return GetFormatManager().GetFilterForType(type_sp);
 }
 
 lldb::ScriptedSyntheticChildrenSP
 DataVisualization::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
   return GetFormatManager().GetSyntheticForType(type_sp);
 }
 
-lldb::TypeValidatorImplSP
-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);
 }
 

lldb/source/DataFormatters/FormatCache.cpp

 
 #include "lldb/DataFormatters/FormatCache.h"
 
 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_synthetic_cached(false) {}
 
 bool FormatCache::Entry::IsFormatCached() { return m_format_cached; }
 
 bool FormatCache::Entry::IsSummaryCached() { return m_summary_cached; }
 
 bool FormatCache::Entry::IsSyntheticCached() { return m_synthetic_cached; }
 
-bool FormatCache::Entry::IsValidatorCached() { return m_validator_cached; }
-
 void FormatCache::Entry::Get(lldb::TypeFormatImplSP &retval) {
   retval = m_format_sp;
 }
 
 void FormatCache::Entry::Get(lldb::TypeSummaryImplSP &retval) {
   retval = m_summary_sp;
 }
 
 void FormatCache::Entry::Get(lldb::SyntheticChildrenSP &retval) {
   retval = m_synthetic_sp;
 }
 
-void FormatCache::Entry::Get(lldb::TypeValidatorImplSP &retval) {
-  retval = m_validator_sp;
-}
-
 void FormatCache::Entry::Set(lldb::TypeFormatImplSP format_sp) {
   m_format_cached = true;
   m_format_sp = format_sp;
 }
 
 void FormatCache::Entry::Set(lldb::TypeSummaryImplSP summary_sp) {
   m_summary_cached = true;
   m_summary_sp = summary_sp;
 }
 
 void FormatCache::Entry::Set(lldb::SyntheticChildrenSP synthetic_sp) {
   m_synthetic_cached = true;
   m_synthetic_sp = synthetic_sp;
 }
 
-void FormatCache::Entry::Set(lldb::TypeValidatorImplSP validator_sp) {
-  m_validator_cached = true;
-  m_validator_sp = validator_sp;
-}
-
 FormatCache::FormatCache()
     : m_map(), m_mutex()
 #ifdef LLDB_CONFIGURATION_DEBUG
       ,
       m_cache_hits(0), m_cache_misses(0)
 #endif
 {
 }
template<> bool FormatCache::Entry::IsCached<lldb::TypeFormatImplSP>() {
   return IsFormatCached();
 }
 template<> bool FormatCache::Entry::IsCached<lldb::TypeSummaryImplSP> () {
   return IsSummaryCached();
 }
 template<> bool FormatCache::Entry::IsCached<lldb::SyntheticChildrenSP>() {
   return IsSyntheticCached();
 }
-template<> bool FormatCache::Entry::IsCached<lldb::TypeValidatorImplSP>() {
-  return IsValidatorCached();
-}
 
 template <typename ImplSP>
 bool FormatCache::Get(ConstString type, ImplSP &format_impl_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   auto entry = GetEntry(type);
   if (entry.IsCached<ImplSP>()) {
 #ifdef LLDB_CONFIGURATION_DEBUG
     m_cache_hits++;
 #endif
     entry.Get(format_impl_sp);
     return true;
   }
 #ifdef LLDB_CONFIGURATION_DEBUG
   m_cache_misses++;
 #endif
   format_impl_sp.reset();
   return false;
 }
 
-/// Explicit instantiations for the four types.
+/// Explicit instantiations for the three types.
 /// \{
 template bool
-FormatCache::Get<lldb::TypeValidatorImplSP>(ConstString,
-                                            lldb::TypeValidatorImplSP &);
-template bool
 FormatCache::Get<lldb::TypeFormatImplSP>(ConstString, lldb::TypeFormatImplSP &);
 template bool
 FormatCache::Get<lldb::TypeSummaryImplSP>(ConstString,
                                           lldb::TypeSummaryImplSP &);
 template bool
 FormatCache::Get<lldb::SyntheticChildrenSP>(ConstString,
                                             lldb::SyntheticChildrenSP &);
 /// \}

 }
 
 void FormatCache::Set(ConstString type,
                       lldb::SyntheticChildrenSP &synthetic_sp) {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   GetEntry(type).Set(synthetic_sp);
 }
 
-void FormatCache::Set(ConstString type,
-                      lldb::TypeValidatorImplSP &validator_sp) {
-  std::lock_guard<std::recursive_mutex> guard(m_mutex);
-  GetEntry(type).Set(validator_sp);
-}
-
 void FormatCache::Clear() {
   std::lock_guard<std::recursive_mutex> guard(m_mutex);
   m_map.clear();
 }

lldb/source/DataFormatters/FormatManager.cpp

if (synth_current_sp &&
          (prio_category > category_sp->GetEnabledPosition()))) {
       prio_category = category_sp->GetEnabledPosition();
       synth_chosen_sp = synth_current_sp;
     }
   }
   return synth_chosen_sp;
 }
 
-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())
-      continue;
-    lldb::TypeValidatorImplSP validator_current_sp(
-        category_sp->GetValidatorForType(type_sp).get());
-    if (validator_current_sp &&
-        (validator_chosen_sp.get() == nullptr ||
-         (prio_category > category_sp->GetEnabledPosition()))) {
-      prio_category = category_sp->GetEnabledPosition();
-      validator_chosen_sp = validator_current_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;
     }

 }
 
 lldb::SyntheticChildrenSP
 FormatManager::GetSyntheticChildren(ValueObject &valobj,
                                     lldb::DynamicValueType use_dynamic) {
   return Get<lldb::SyntheticChildrenSP>(valobj, use_dynamic);
 }
 
-lldb::TypeValidatorImplSP
-FormatManager::GetValidator(ValueObject &valobj,
-                            lldb::DynamicValueType use_dynamic) {
-  return Get<lldb::TypeValidatorImplSP>(valobj, use_dynamic);
-}
-
 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_system_category_name(ConstString("system")),
       m_vectortypes_category_name(ConstString("VectorTypes")) {
   LoadSystemFormatters();
   LoadVectorFormatters();

lldb/source/DataFormatters/LanguageCategory.cpp

 //===-- LanguageCategory.cpp ---------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/DataFormatters/LanguageCategory.h"
 
 #include "lldb/DataFormatters/FormatManager.h"
 #include "lldb/DataFormatters/TypeCategory.h"
 #include "lldb/DataFormatters/TypeFormat.h"
 #include "lldb/DataFormatters/TypeSummary.h"
 #include "lldb/DataFormatters/TypeSynthetic.h"
-#include "lldb/DataFormatters/TypeValidator.h"
 #include "lldb/Target/Language.h"
 
 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) {
+      m_hardcoded_synthetics(), 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();
 }
 
 template<typename ImplSP>
 bool LanguageCategory::Get(FormattersMatchData &match_data,
                            ImplSP &retval_sp) {
   if (!m_category_sp)
bool result = m_category_sp->Get(valobj.GetObjectRuntimeLanguage(),
                                    match_data.GetMatchesVector(), retval_sp);
   if (match_data.GetTypeForCache() &&
       (!retval_sp || !retval_sp->NonCacheable())) {
     m_format_cache.Set(match_data.GetTypeForCache(), retval_sp);
   }
   return result;
 }
 
-/// Explicit instantiations for the four types.
+/// Explicit instantiations for the three types.
 /// \{
 template bool
-LanguageCategory::Get<lldb::TypeValidatorImplSP>(FormattersMatchData &,
-                                                 lldb::TypeValidatorImplSP &);
-template bool
 LanguageCategory::Get<lldb::TypeFormatImplSP>(FormattersMatchData &,
                                               lldb::TypeFormatImplSP &);
 template bool
 LanguageCategory::Get<lldb::TypeSummaryImplSP>(FormattersMatchData &,
                                                lldb::TypeSummaryImplSP &);
 template bool
 LanguageCategory::Get<lldb::SyntheticChildrenSP>(FormattersMatchData &,
                                                  lldb::SyntheticChildrenSP &);
auto &LanguageCategory::GetHardcodedFinder<lldb::TypeSummaryImplSP>() {
   return m_hardcoded_summaries;
 }
 
 template <>
 auto &LanguageCategory::GetHardcodedFinder<lldb::SyntheticChildrenSP>() {
   return m_hardcoded_synthetics;
 }
 
-template <>
-auto &LanguageCategory::GetHardcodedFinder<lldb::TypeValidatorImplSP>() {
-  return m_hardcoded_validators;
-}
-
 template <typename ImplSP>
 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
                                     FormattersMatchData &match_data,
                                     ImplSP &retval_sp) {
   if (!IsEnabled())
     return false;
 
   ValueObject &valobj(match_data.GetValueObject());
   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
 
   for (auto &candidate : GetHardcodedFinder<ImplSP>()) {
     if (auto result = candidate(valobj, use_dynamic, fmt_mgr)) {
       retval_sp = result;
       break;
     }
   }
   return (bool)retval_sp;
 }
 
-/// Explicit instantiations for the four types.
+/// Explicit instantiations for the three types.
 /// \{
-template bool LanguageCategory::GetHardcoded<lldb::TypeValidatorImplSP>(
-    FormatManager &, FormattersMatchData &, lldb::TypeValidatorImplSP &);
 template bool LanguageCategory::GetHardcoded<lldb::TypeFormatImplSP>(
     FormatManager &, FormattersMatchData &, lldb::TypeFormatImplSP &);
 template bool LanguageCategory::GetHardcoded<lldb::TypeSummaryImplSP>(
     FormatManager &, FormattersMatchData &, lldb::TypeSummaryImplSP &);
 template bool LanguageCategory::GetHardcoded<lldb::SyntheticChildrenSP>(
     FormatManager &, FormattersMatchData &, lldb::SyntheticChildrenSP &);
 /// \}
 

lldb/source/DataFormatters/TypeCategory.cpp

 using namespace lldb_private;
 
 TypeCategoryImpl::TypeCategoryImpl(IFormatChangeListener *clist,
                                    ConstString name)
     : m_format_cont("format", "regex-format", clist),
       m_summary_cont("summary", "regex-summary", clist),
       m_filter_cont("filter", "regex-filter", clist),
       m_synth_cont("synth", "regex-synth", clist),
-      m_validator_cont("validator", "regex-validator", clist), m_enabled(false),
       m_change_listener(clist), m_mutex(), m_name(name), m_languages() {}
 
 static bool IsApplicable(lldb::LanguageType category_lang,
                          lldb::LanguageType valobj_lang) {
   switch (category_lang) {
   // Unless we know better, allow only exact equality.
   default:
     return category_lang == valobj_lang;
if (pick_synth) {
     if (regex_filter && reason)
       *reason |= lldb_private::eFormatterChoiceCriterionRegularExpressionFilter;
     entry = filter_sp;
     return true;
   }
   return false;
 }
 
-bool TypeCategoryImpl::Get(lldb::LanguageType lang,
-                           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();
 
   if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
     GetTypeSyntheticsContainer()->Clear();
   if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
     GetRegexTypeSyntheticsContainer()->Clear();
-
-  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)
if ((items & eFormatCategoryItemRegexFilter) ==
       eFormatCategoryItemRegexFilter)
     success = GetRegexTypeFiltersContainer()->Delete(name) || success;
 
   if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
     success = GetTypeSyntheticsContainer()->Delete(name) || success;
   if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
     success = GetRegexTypeSyntheticsContainer()->Delete(name) || success;
 
-  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 & eFormatCategoryItemRegexFilter) ==
       eFormatCategoryItemRegexFilter)
     count += GetRegexTypeFiltersContainer()->GetCount();
 
   if ((items & eFormatCategoryItemSynth) == eFormatCategoryItemSynth)
     count += GetTypeSyntheticsContainer()->GetCount();
   if ((items & eFormatCategoryItemRegexSynth) == eFormatCategoryItemRegexSynth)
     count += GetRegexTypeSyntheticsContainer()->GetCount();
 
-  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;
   ScriptedSyntheticChildren::SharedPointer synth_sp;
-  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 (GetRegexTypeSyntheticsContainer()->Get(type_name, synth_sp)) {
       if (matching_category)
         *matching_category = m_name.GetCString();
       if (matching_type)
         *matching_type = eFormatCategoryItemRegexSynth;
       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;
-    }
-  }
-
   return false;
 }
 
 TypeCategoryImpl::FormatContainer::MapValueType
 TypeCategoryImpl::GetFormatForType(lldb::TypeNameSpecifierImplSP type_sp) {
   FormatContainer::MapValueType retval;
 
   if (type_sp) {
if (type_sp) {
     else
       GetTypeSyntheticsContainer()->GetExact(ConstString(type_sp->GetName()),
                                              retval);
   }
 
   return retval;
 }
 
-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;
-}
-
 lldb::TypeNameSpecifierImplSP
 TypeCategoryImpl::GetTypeNameSpecifierForSummaryAtIndex(size_t index) {
   if (index < GetTypeSummariesContainer()->GetCount())
     return GetTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(index);
   else
     return GetRegexTypeSummariesContainer()->GetTypeNameSpecifierAtIndex(
         index - GetTypeSummariesContainer()->GetCount());
 }

 TypeCategoryImpl::GetTypeNameSpecifierForSyntheticAtIndex(size_t index) {
   if (index < GetTypeSyntheticsContainer()->GetCount())
     return GetTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(index);
   else
     return GetRegexTypeSyntheticsContainer()->GetTypeNameSpecifierAtIndex(
         index - GetTypeSyntheticsContainer()->GetCount());
 }
 
-TypeCategoryImpl::ValidatorContainer::MapValueType
-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();
 }
 

lldb/source/DataFormatters/TypeCategoryMap.cpp

if (!category_sp->Get(
       continue;
 
     retval = std::move(current_format);
     return;
   }
   LLDB_LOGF(log, "[%s] nothing found - returning empty SP", __FUNCTION__);
 }
 
-/// Explicit instantiations for the four types.
+/// Explicit instantiations for the three types.
 /// \{
-template void TypeCategoryMap::Get<lldb::TypeValidatorImplSP>(
-    FormattersMatchData &match_data, lldb::TypeValidatorImplSP &retval);
-
 template void
 TypeCategoryMap::Get<lldb::TypeFormatImplSP>(FormattersMatchData &match_data,
                                              lldb::TypeFormatImplSP &retval);
 template void
 TypeCategoryMap::Get<lldb::TypeSummaryImplSP>(FormattersMatchData &match_data,
                                               lldb::TypeSummaryImplSP &retval);
 template void TypeCategoryMap::Get<lldb::SyntheticChildrenSP>(
     FormattersMatchData &match_data, lldb::SyntheticChildrenSP &retval);

lldb/source/DataFormatters/TypeValidator.cpp

-//===-- TypeValidator.cpp ---------------------------------------*- C++ -*-===//
-//
-// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
-// See https://llvm.org/LICENSE.txt for license information.
-// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
-//
-//===----------------------------------------------------------------------===//
-
-
-
-
-#include "lldb/DataFormatters/TypeValidator.h"
-#include "lldb/Utility/StreamString.h"
-
-using namespace lldb;
-using namespace lldb_private;
-
-TypeValidatorImpl::TypeValidatorImpl(const Flags &flags)
-    : m_flags(flags), m_my_revision(0) {}
-
-TypeValidatorImpl::~TypeValidatorImpl() {}
-
-TypeValidatorImpl::ValidationResult TypeValidatorImpl::Success() {
-  return ValidationResult{TypeValidatorResult::Success, ""};
-}
-
-TypeValidatorImpl::ValidationResult
-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() {}
-
-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);
-}
-
-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();
-}

lldb/source/DataFormatters/ValueObjectPrinter.cpp

m_printed_instance_pointers =
           : InstancePointersSetSP(new InstancePointersSet());
 }
 
 bool ValueObjectPrinter::PrintValueObject() {
   if (!GetMostSpecializedValue() || m_valobj == nullptr)
     return false;
 
   if (ShouldPrintValueObject()) {
-    PrintValidationMarkerIfNeeded();
-
     PrintLocationIfNeeded();
     m_stream->Indent();
 
     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) {
if (print_children) {
     } 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::PrintValidationMarkerIfNeeded() {
-  if (!ShouldPrintValidation())
-    return false;
-
-  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;
-}

lldb/source/Target/Language.cpp

HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
   return {};
 }
 
 HardcodedFormatters::HardcodedSyntheticFinder
 Language::GetHardcodedSynthetics() {
   return {};
 }
 
-HardcodedFormatters::HardcodedValidatorFinder
-Language::GetHardcodedValidators() {
-  return {};
-}
-
 std::vector<ConstString>
 Language::GetPossibleFormattersMatches(ValueObject &valobj,
                                        lldb::DynamicValueType use_dynamic) {
   return {};
 }
 
 lldb_private::formatters::StringPrinter::EscapingHelper
 Language::GetStringPrinterEscapingHelper(