[lldb] Add matching based on Python callbacks for data formatters.

[jgorbe]

Summary

This patch adds a new matching method for data formatters, in addition
to the existing exact typename and regex-based matching. The new method
allows users to specify the name of a Python callback function that
takes a SBType object and decides whether the type is a match or not.

Here is an overview of the changes performed:

• Add a new eFormatterMatchCallback matching type, and logic to handle it in TypeMatcher and SBTypeNameSpecifier.

• Extend FormattersMatchCandidate instances with a pointer to the current ScriptInterpreter and the TypeImpl corresponding to the candidate type, so we can run registered callbacks and pass the type to them. All matcher search functions now receive a FormattersMatchCandidate instead of a type name.

• Add some glue code to ScriptInterpreterPython and the SWIG bindings to allow calling a formatter matching callback. Most of this code is modeled after the equivalent code for watchpoint callback functions.

• Add an API test for the new callback-based matching feature.

For more context, please check the RFC thread where this feature was
originally discussed:
https://discourse.llvm.org/t/rfc-python-callback-for-data-formatters-type-matching/64204/11

[labath]

lldb/source/Commands/CommandObjectType.cpp

2306–2312

Is that even possible? Like, this command can be run before any binaries/debug info is loaded, right? Maybe we should just call that WAI?

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

2159–2167

I think we already had code like this somewhere, but these two versions are completely equivalent.

[jgorbe]

Address review comments.

[jgorbe]

lldb/source/Commands/CommandObjectType.cpp

2306–2312

You're right. I hadn't though of the case where we have no target yet. Changed the comments in this file and a similar one in lldb/include/lldb/DataFormatters/FormattersContainer.h to remove the TODO and indicate this is WAI. Thanks!

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

2159–2167

Done!

[labath]

Seems fine to me. Jim, Med, do you want to add anything?

lldb/bindings/python/python-swigsafecast.swig

return ToSWIGHelper(new lldb::SBBreakpointLocation(std::move(bp_loc_sp)),
                       SWIGTYPE_p_lldb__SBBreakpointLocation);
 }
 
 PythonObject ToSWIGWrapper(lldb::ExecutionContextRefSP ctx_sp) {
   return ToSWIGHelper(new lldb::SBExecutionContext(std::move(ctx_sp)),
                       SWIGTYPE_p_lldb__SBExecutionContext);
 }
 
+PythonObject ToSWIGWrapper(lldb::TypeImplSP type_impl_sp) {
+  return ToSWIGHelper(new lldb::SBType(type_impl_sp), SWIGTYPE_p_lldb__SBType);
+}
+
 PythonObject ToSWIGWrapper(const TypeSummaryOptions &summary_options) {
   return ToSWIGHelper(new lldb::SBTypeSummaryOptions(summary_options),
                       SWIGTYPE_p_lldb__SBTypeSummaryOptions);
 }
 
 PythonObject ToSWIGWrapper(const SymbolContext &sym_ctx) {
   return ToSWIGHelper(new lldb::SBSymbolContext(sym_ctx),
                       SWIGTYPE_p_lldb__SBSymbolContext);

lldb/bindings/python/python-wrapper.swig

PythonObject result =
       pfunc(ToSWIGWrapper(frame_sp), ToSWIGWrapper(wp_sp), dict);
 
   if (result.get() == Py_False)
     stop_at_watchpoint = false;
 
   return stop_at_watchpoint;
 }
 
+// This function is called by
+// ScriptInterpreterPython::FormatterMatchingCallbackFunction and it's used when
+// a data formatter provides the name of a callback to inspect a candidate type
+// before considering a match.
+bool lldb_private::LLDBSwigPythonFormatterCallbackFunction(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::TypeImplSP type_impl_sp) {
+
+  PyErr_Cleaner py_err_cleaner(true);
+
+  auto dict = PythonModule::MainModule().ResolveName<PythonDictionary>(
+      session_dictionary_name);
+  auto pfunc = PythonObject::ResolveNameWithDictionary<PythonCallable>(
+      python_function_name, dict);
+
+  if (!pfunc.IsAllocated())
+    return false;
+
+  PythonObject result =
+      pfunc(ToSWIGWrapper(type_impl_sp), dict);
+
+  // Only if everything goes okay and the function returns True we'll consider
+  // it a match.
+  return result.get() == Py_True;
+}
+
 bool lldb_private::LLDBSwigPythonCallTypeScript(
     const char *python_function_name, const void *session_dictionary,
     const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
     const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {
 
   retval.clear();
 
   if (!python_function_name || !session_dictionary)

lldb/include/lldb/API/SBType.h

protected:
   lldb::TypeMemberFunctionImplSP m_opaque_sp;
 };
 
 class SBType {
 public:
   SBType();
 
   SBType(const lldb::SBType &rhs);
+  SBType(const lldb::TypeImplSP &);
 
   ~SBType();
 
   explicit operator bool() const;
 
   bool IsValid() const;
 
   uint64_t GetByteSize();
protected:
   friend class SBTypeNameSpecifier;
   friend class SBTypeMember;
   friend class SBTypeMemberFunction;
   friend class SBTypeList;
   friend class SBValue;
 
   SBType(const lldb_private::CompilerType &);
   SBType(const lldb::TypeSP &);
-  SBType(const lldb::TypeImplSP &);
 };
 
 class SBTypeList {
 public:
   SBTypeList();
 
   SBTypeList(const lldb::SBTypeList &rhs);
 

lldb/include/lldb/DataFormatters/DataVisualization.h

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

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/Interpreter/ScriptInterpreter.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 {
struct Flags {
     // Returns a copy of this with the "stripped typedef" flag set.
     Flags WithStrippedTypedef() {
       Flags result(*this);
       result.stripped_typedef = true;
       return result;
     }
   };
 
-  FormattersMatchCandidate(ConstString name, Flags flags)
-      : m_type_name(name), m_flags(flags) {}
+  FormattersMatchCandidate(ConstString name,
+                           ScriptInterpreter *script_interpreter, TypeImpl type,
+                           Flags flags)
+      : m_type_name(name), m_script_interpreter(script_interpreter),
+        m_type(type), m_flags(flags) {}
 
   ~FormattersMatchCandidate() = default;
 
   ConstString GetTypeName() const { return m_type_name; }
 
+  TypeImpl GetType() const { return m_type; }
+
+  ScriptInterpreter *GetScriptInterpreter() const {
+    return m_script_interpreter;
+  }
+
   bool DidStripPointer() const { return m_flags.stripped_pointer; }
 
   bool DidStripReference() const { return m_flags.stripped_reference; }
 
   bool DidStripTypedef() const { return m_flags.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;
+  // If a formatter provides a matching callback function, we need the script
+  // interpreter and the type object (as an argument to the callback).
+  ScriptInterpreter *m_script_interpreter;
+  TypeImpl m_type;
   Flags m_flags;
 };
 
 typedef std::vector<FormattersMatchCandidate> FormattersMatchVector;
 typedef std::vector<lldb::LanguageType> CandidateLanguagesVector;
 
 class FormattersMatchData {
 public:

lldb/include/lldb/DataFormatters/FormatManager.h

public:
 
   lldb::TypeSummaryImplSP GetSummaryFormat(ValueObject &valobj,
                                            lldb::DynamicValueType use_dynamic);
 
   lldb::SyntheticChildrenSP
   GetSyntheticChildren(ValueObject &valobj, lldb::DynamicValueType use_dynamic);
 
   bool
-  AnyMatches(ConstString type_name,
+  AnyMatches(const FormattersMatchCandidate &candidate_type,
              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,
+    return m_categories_map.AnyMatches(candidate_type, items, only_enabled,
                                        matching_category, matching_type);
   }
 
   static bool GetFormatFromCString(const char *format_cstr,
                                    bool partial_match_ok, lldb::Format &format);
 
   static char GetFormatAsFormatChar(lldb::Format format);
 

lldb/include/lldb/DataFormatters/FormattersContainer.h

public:
 
   virtual void Changed() = 0;
 
   virtual uint32_t GetCurrentRevision() = 0;
 };
 
 /// Class for matching type names.
 class TypeMatcher {
+  /// Type name for exact match, or name of the python callback if m_match_type
+  /// is `eFormatterMatchCallback`.
+  ConstString m_name;
   RegularExpression m_type_name_regex;
-  ConstString m_type_name;
   /// Indicates what kind of matching strategy should be used:
-  /// - eFormatterMatchExact: match the exact type name in m_type_name.
+  /// - eFormatterMatchExact: match the exact type name in m_name.
   /// - eFormatterMatchRegex: match using the RegularExpression object
   ///   `m_type_name_regex` instead.
+  /// - eFormatterMatchCallback: run the function in m_name to decide if a type
+  ///   matches or not.
   lldb::FormatterMatchType m_match_type;
 
   // if the user tries to add formatters for, say, "struct Foo" those will not
   // match any type because of the way we strip qualifiers from typenames this
   // method looks for the case where the user is adding a
   // "class","struct","enum" or "union" Foo and strips the unnecessary qualifier
   static ConstString StripTypeName(ConstString type) {
     if (type.IsEmpty())
static ConstString StripTypeName(ConstString type) {
 
     return ConstString(type_lexer.GetUnlexed());
   }
 
 public:
   TypeMatcher() = delete;
   /// Creates a matcher that accepts any type with exactly the given type name.
   TypeMatcher(ConstString type_name)
-      : m_type_name(type_name), m_match_type(lldb::eFormatterMatchExact) {}
+      : m_name(type_name), m_match_type(lldb::eFormatterMatchExact) {}
   /// Creates a matcher that accepts any type matching the given regex.
   TypeMatcher(RegularExpression regex)
       : m_type_name_regex(std::move(regex)),
         m_match_type(lldb::eFormatterMatchRegex) {}
   /// Creates a matcher using the matching type and string from the given type
   /// name specifier.
   TypeMatcher(lldb::TypeNameSpecifierImplSP type_specifier)
-      : m_type_name(type_specifier->GetName()),
+      : m_name(type_specifier->GetName()),
         m_match_type(type_specifier->GetMatchType()) {
     if (m_match_type == lldb::eFormatterMatchRegex)
       m_type_name_regex = RegularExpression(type_specifier->GetName());
   }
 
-  /// True iff this matches the given type name.
-  bool Matches(ConstString type_name) const {
-    if (m_match_type == lldb::eFormatterMatchRegex)
+  /// True iff this matches the given type.
+  bool Matches(FormattersMatchCandidate candidate_type) const {
+    ConstString type_name = candidate_type.GetTypeName();
+    switch (m_match_type) {
+    case lldb::eFormatterMatchExact:
+      return m_name == type_name ||
+             StripTypeName(m_name) == StripTypeName(type_name);
+    case lldb::eFormatterMatchRegex:
       return m_type_name_regex.Execute(type_name.GetStringRef());
-    return m_type_name == type_name ||
-           StripTypeName(m_type_name) == StripTypeName(type_name);
+    case lldb::eFormatterMatchCallback:
+      // CommandObjectType{Synth,Filter}Add tries to prevent the user from
+      // creating both a synthetic child provider and a filter for the same type
+      // in the same category, but we don't have a type object at that point, so
+      // it creates a dummy candidate without type or script interpreter.
+      // Skip callback matching in these cases.
+      if (candidate_type.GetScriptInterpreter())
+        return candidate_type.GetScriptInterpreter()->FormatterCallbackFunction(
+            m_name.AsCString(),
+            std::make_shared<TypeImpl>(candidate_type.GetType()));
+    }
+    return false;
   }
 
   lldb::FormatterMatchType GetMatchType() const { return m_match_type; }
 
   /// Returns the underlying match string for this TypeMatcher.
   ConstString GetMatchString() const {
+    if (m_match_type == lldb::eFormatterMatchExact)
+        return StripTypeName(m_name);
     if (m_match_type == lldb::eFormatterMatchRegex)
         return ConstString(m_type_name_regex.GetText());
-    return StripTypeName(m_type_name);
+    return m_name;
   }
 
   /// Returns true if this TypeMatcher and the given one were most created by
   /// the same match string.
   /// The main purpose of this function is to find existing TypeMatcher
   /// instances by the user input that created them. This is necessary as LLDB
   /// allows referencing existing TypeMatchers in commands by the user input
   /// that originally created them:
for (auto iter = m_map.begin(); iter != m_map.end(); ++iter)
         m_map.erase(iter);
         if (listener)
           listener->Changed();
         return true;
       }
     return false;
   }
 
-  bool Get(ConstString type, ValueSP &entry) {
+  // Finds the first formatter in the container that matches `candidate`.
+  bool Get(FormattersMatchCandidate candidate, ValueSP &entry) {
     std::lock_guard<std::recursive_mutex> guard(m_map_mutex);
     for (auto &formatter : llvm::reverse(m_map)) {
-      if (formatter.first.Matches(type)) {
+      if (formatter.first.Matches(candidate)) {
         entry = formatter.second;
         return true;
       }
     }
     return false;
   }
 
+  // Finds the first match between candidate types in `candidates` and
+  // formatters in this container.
   bool Get(const FormattersMatchVector &candidates, ValueSP &entry) {
     for (const FormattersMatchCandidate &candidate : candidates) {
-      if (Get(candidate.GetTypeName(), entry)) {
+      if (Get(candidate, entry)) {
         if (candidate.IsMatch(entry) == false) {
           entry.reset();
           continue;
         } else {
           return true;
         }
       }
     }

lldb/include/lldb/DataFormatters/TypeCategory.h

bool Get(const FormattersMatchVector &candidates,
            std::shared_ptr<FormatterImpl> &entry) {
     for (auto sc : m_subcontainers) {
       if (sc->Get(candidates, entry))
         return true;
     }
     return false;
   }
 
-  bool AnyMatches(ConstString type_name) {
+  bool AnyMatches(const FormattersMatchCandidate &candidate) {
     std::shared_ptr<FormatterImpl> entry;
     for (auto sc : m_subcontainers) {
-      if (sc->Get(type_name, entry))
+      if (sc->Get(FormattersMatchVector{candidate}, entry))
         return true;
     }
     return false;
   }
 
   /// Returns a formatter that is an exact match for `type_specifier_sp`. It
   /// looks for a formatter with the same matching type that was created from
   /// the same string. This is useful so we can refer to a formatter using the
public:
   size_t GetNumLanguages();
 
   lldb::LanguageType GetLanguageAtIndex(size_t idx);
 
   void AddLanguage(lldb::LanguageType lang);
 
   std::string GetDescription();
 
-  bool AnyMatches(ConstString type_name,
+  bool AnyMatches(const FormattersMatchCandidate &candidate_type,
                   FormatCategoryItems items = ALL_ITEM_TYPES,
                   bool only_enabled = true,
                   const char **matching_category = nullptr,
                   FormatCategoryItems *matching_type = nullptr);
 
   void AutoComplete(CompletionRequest &request, FormatCategoryItems items);
 
   typedef std::shared_ptr<TypeCategoryImpl> SharedPointer;

lldb/include/lldb/DataFormatters/TypeCategoryMap.h

 #include <functional>
 #include <list>
 #include <map>
 #include <mutex>
 
 #include "lldb/lldb-enumerations.h"
 #include "lldb/lldb-public.h"
 
+#include "lldb/DataFormatters/FormatClasses.h"
 #include "lldb/DataFormatters/FormattersContainer.h"
 #include "lldb/DataFormatters/TypeCategory.h"
 
 namespace lldb_private {
 class TypeCategoryMap {
 private:
   typedef std::list<lldb::TypeCategoryImplSP> ActiveCategoriesList;
   typedef ActiveCategoriesList::iterator ActiveCategoriesIterator;
public:
 
   bool Get(uint32_t pos, ValueSP &entry);
 
   void ForEach(ForEachCallback callback);
 
   lldb::TypeCategoryImplSP GetAtIndex(uint32_t);
 
   bool
-  AnyMatches(ConstString type_name,
+  AnyMatches(const FormattersMatchCandidate &candidate_type,
              TypeCategoryImpl::FormatCategoryItems items =
                  TypeCategoryImpl::ALL_ITEM_TYPES,
              bool only_enabled = true, const char **matching_category = nullptr,
              TypeCategoryImpl::FormatCategoryItems *matching_type = nullptr);
 
   uint32_t GetCount() { return m_map.size(); }
 
   template <typename ImplSP> void Get(FormattersMatchData &, ImplSP &);

lldb/include/lldb/Interpreter/ScriptInterpreter.h

public:
   virtual bool GetScriptedSummary(const char *function_name,
                                   lldb::ValueObjectSP valobj,
                                   StructuredData::ObjectSP &callee_wrapper_sp,
                                   const TypeSummaryOptions &options,
                                   std::string &retval) {
     return false;
   }
 
+  // Calls the specified formatter matching Python function and returns its
+  // result (true if it's a match, false if we should keep looking for a
+  // matching formatter).
+  virtual bool FormatterCallbackFunction(const char *function_name,
+                                         lldb::TypeImplSP type_impl_sp) {
+    return true;
+  }
+
   virtual void Clear() {
     // Clean up any ref counts to SBObjects that might be in global variables
   }
 
   virtual size_t
   CalculateNumChildren(const StructuredData::ObjectSP &implementor,
                        uint32_t max) {
     return 0;

lldb/include/lldb/Target/Language.h

public:
 
   virtual HardcodedFormatters::HardcodedFormatFinder GetHardcodedFormats();
 
   virtual HardcodedFormatters::HardcodedSummaryFinder GetHardcodedSummaries();
 
   virtual HardcodedFormatters::HardcodedSyntheticFinder
   GetHardcodedSynthetics();
 
-  virtual std::vector<ConstString>
+  virtual std::vector<FormattersMatchCandidate>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic);
 
   virtual std::unique_ptr<TypeScavenger> GetTypeScavenger();
 
   virtual const char *GetLanguageSpecificTypeLookupHelp();
 
   class MethodNameVariant {

lldb/include/lldb/lldb-enumerations.h

enum TemplateArgumentKind {
   eTemplateArgumentKindNullPtr,
 };
 
 /// Type of match to be performed when looking for a formatter for a data type.
 /// Used by classes like SBTypeNameSpecifier or lldb_private::TypeMatcher.
 enum FormatterMatchType {
   eFormatterMatchExact,
   eFormatterMatchRegex,
+  eFormatterMatchCallback,
 
-  eLastFormatterMatchType = eFormatterMatchRegex,
+  eLastFormatterMatchType = eFormatterMatchCallback,
 };
 
 /// Options that can be set for a formatter to alter its behavior. Not
 /// all of these are applicable to all formatter types.
 FLAGS_ENUM(TypeOptions){eTypeOptionNone = (0u),
                         eTypeOptionCascade = (1u << 0),
                         eTypeOptionSkipPointers = (1u << 1),
                         eTypeOptionSkipReferences = (1u << 2),

lldb/source/API/SBTypeNameSpecifier.cpp

bool SBTypeNameSpecifier::IsRegex() {
 
   return m_opaque_sp->GetMatchType() == eFormatterMatchRegex;
 }
 
 bool SBTypeNameSpecifier::GetDescription(
     lldb::SBStream &description, lldb::DescriptionLevel description_level) {
   LLDB_INSTRUMENT_VA(this, description, description_level);
 
+  lldb::FormatterMatchType match_type = GetMatchType();
+  const char *match_type_str =
+      (match_type == eFormatterMatchExact   ? "plain"
+       : match_type == eFormatterMatchRegex ? "regex"
+                                            : "callback");
   if (!IsValid())
     return false;
-  description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(),
-                     IsRegex() ? "regex" : "plain");
+  description.Printf("SBTypeNameSpecifier(%s,%s)", GetName(), match_type_str);
   return true;
 }
 
 lldb::SBTypeNameSpecifier &SBTypeNameSpecifier::
 operator=(const lldb::SBTypeNameSpecifier &rhs) {
   LLDB_INSTRUMENT_VA(this, rhs);
 
   if (this != &rhs) {

lldb/source/Commands/CommandObjectType.cpp

 //===-- CommandObjectType.cpp ---------------------------------------------===//
 //
 // 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 "CommandObjectType.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/Core/IOHandler.h"
 #include "lldb/DataFormatters/DataVisualization.h"
+#include "lldb/DataFormatters/FormatClasses.h"
 #include "lldb/Host/Config.h"
 #include "lldb/Host/OptionParser.h"
 #include "lldb/Interpreter/CommandInterpreter.h"
 #include "lldb/Interpreter/CommandObject.h"
 #include "lldb/Interpreter/CommandOptionArgumentTable.h"
 #include "lldb/Interpreter/CommandReturnObject.h"
 #include "lldb/Interpreter/OptionArgParser.h"
 #include "lldb/Interpreter/OptionGroupFormat.h"
if (type == eRegularSynth) {
     if (FixArrayTypeNameWithRegex(type_name))
       type = eRegexSynth;
   }
 
   // Only check for conflicting filters in the same category if `type_name` is
   // an actual type name. Matching a regex string against registered regexes
   // doesn't work.
   if (type == eRegularSynth) {
-    if (category->AnyMatches(type_name, eFormatCategoryItemFilter, false)) {
+    // It's not generally possible to get a type object here. For example, this
+    // command can be run before loading any binaries. Do just a best-effort
+    // name-based lookup here to try to prevent conflicts.
+    FormattersMatchCandidate candidate_type(type_name, nullptr, TypeImpl(),
+                                            FormattersMatchCandidate::Flags());
+    if (category->AnyMatches(candidate_type, eFormatCategoryItemFilter,
+                             false)) {
       if (error)
         error->SetErrorStringWithFormat("cannot add synthetic for type %s when "
                                         "filter is defined in same category!",
                                         type_name.AsCString());
       return false;
     }
   }
 
if (type == eRegularFilter) {
       if (FixArrayTypeNameWithRegex(type_name))
         type = eRegexFilter;
     }
 
     // Only check for conflicting synthetic child providers in the same category
     // if `type_name` is an actual type name. Matching a regex string against
     // registered regexes doesn't work.
     if (type == eRegularFilter) {
-      if (category->AnyMatches(type_name, eFormatCategoryItemSynth, false)) {
+      // It's not generally possible to get a type object here. For example,
+      // this command can be run before loading any binaries. Do just a
+      // best-effort name-based lookup here to try to prevent conflicts.
+      FormattersMatchCandidate candidate_type(
+          type_name, nullptr, TypeImpl(), FormattersMatchCandidate::Flags());
+      lldb::SyntheticChildrenSP entry;
+      if (category->AnyMatches(candidate_type, eFormatCategoryItemSynth,
+                               false)) {
         if (error)
           error->SetErrorStringWithFormat("cannot add filter for type %s when "
                                           "synthetic is defined in same "
                                           "category!",
                                           type_name.AsCString());
         return false;
       }
     }

lldb/source/DataFormatters/DataVisualization.cpp

 }
 
 lldb::ScriptedSyntheticChildrenSP
 DataVisualization::GetSyntheticForType(lldb::TypeNameSpecifierImplSP type_sp) {
   return GetFormatManager().GetSyntheticForType(type_sp);
 }
 
 bool DataVisualization::AnyMatches(
-    ConstString type_name, TypeCategoryImpl::FormatCategoryItems items,
-    bool only_enabled, const char **matching_category,
+    const FormattersMatchCandidate &candidate_type,
+    TypeCategoryImpl::FormatCategoryItems items, bool only_enabled,
+    const char **matching_category,
     TypeCategoryImpl::FormatCategoryItems *matching_type) {
-  return GetFormatManager().AnyMatches(type_name, items, only_enabled,
+  return GetFormatManager().AnyMatches(candidate_type, items, only_enabled,
                                        matching_category, matching_type);
 }
 
 bool DataVisualization::Categories::GetCategory(ConstString category,
                                                 lldb::TypeCategoryImplSP &entry,
                                                 bool allow_create) {
   entry = GetFormatManager().GetCategory(category, allow_create);
   return (entry.get() != nullptr);

lldb/source/DataFormatters/FormatManager.cpp

 //===-- FormatManager.cpp -------------------------------------------------===//
 //
 // 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/FormatManager.h"
 
 #include "lldb/Core/Debugger.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/DataFormatters/LanguageCategory.h"
+#include "lldb/Interpreter/ScriptInterpreter.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Language.h"
 #include "lldb/Utility/LLDBLog.h"
 #include "lldb/Utility/Log.h"
 #include "llvm/ADT/STLExtras.h"
 
 using namespace lldb;
 using namespace lldb_private;

 }
 
 void FormatManager::GetPossibleMatches(
     ValueObject &valobj, CompilerType compiler_type,
     lldb::DynamicValueType use_dynamic, FormattersMatchVector &entries,
     FormattersMatchCandidate::Flags current_flags, bool root_level) {
   compiler_type = compiler_type.GetTypeForFormatters();
   ConstString type_name(compiler_type.GetTypeName());
+  ScriptInterpreter *script_interpreter =
+      valobj.GetTargetSP()->GetDebugger().GetScriptInterpreter();
   if (valobj.GetBitfieldBitSize() > 0) {
     StreamString sstring;
     sstring.Printf("%s:%d", type_name.AsCString(), valobj.GetBitfieldBitSize());
     ConstString bitfieldname(sstring.GetString());
-    entries.push_back({bitfieldname, current_flags});
+    entries.push_back({bitfieldname, script_interpreter,
+                       TypeImpl(compiler_type), current_flags});
   }
 
   if (!compiler_type.IsMeaninglessWithoutDynamicResolution()) {
-    entries.push_back({type_name, current_flags});
+    entries.push_back({type_name, script_interpreter, TypeImpl(compiler_type),
+                       current_flags});
 
     ConstString display_type_name(compiler_type.GetTypeName());
     if (display_type_name != type_name)
-      entries.push_back({display_type_name, current_flags});
+      entries.push_back({display_type_name, script_interpreter,
+                         TypeImpl(compiler_type), current_flags});
   }
 
   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, use_dynamic, entries,
                        current_flags.WithStrippedReference());
     if (non_ref_type.IsTypedefType()) {
if (element_type.IsTypedefType()) {
           valobj, deffed_array_type,
           use_dynamic, entries, current_flags.WithStrippedTypedef());
     }
   }
 
   for (lldb::LanguageType language_type :
        GetCandidateLanguages(valobj.GetObjectRuntimeLanguage())) {
     if (Language *language = Language::FindPlugin(language_type)) {
-      for (ConstString candidate :
+      for (const FormattersMatchCandidate& candidate :
            language->GetPossibleFormattersMatches(valobj, use_dynamic)) {
-        entries.push_back({candidate, current_flags});
+        entries.push_back(candidate);
       }
     }
   }
 
   // try to strip typedef chains
   if (compiler_type.IsTypedefType()) {
     CompilerType deffed_type = compiler_type.GetTypedefedType();
     GetPossibleMatches(valobj, deffed_type, use_dynamic, entries,

lldb/source/DataFormatters/TypeCategory.cpp

if (items & eFormatCategoryItemFilter)
     count += m_filter_cont.GetCount();
 
   if (items & eFormatCategoryItemSynth)
     count += m_synth_cont.GetCount();
 
   return count;
 }
 
-bool TypeCategoryImpl::AnyMatches(ConstString type_name,
-                                  FormatCategoryItems items, bool only_enabled,
-                                  const char **matching_category,
-                                  FormatCategoryItems *matching_type) {
+bool TypeCategoryImpl::AnyMatches(
+    const FormattersMatchCandidate &candidate_type, FormatCategoryItems items,
+    bool only_enabled, const char **matching_category,
   if (!IsEnabled() && only_enabled)
     return false;
 
-  lldb::TypeFormatImplSP format_sp;
-  lldb::TypeSummaryImplSP summary_sp;
-  TypeFilterImpl::SharedPointer filter_sp;
-  ScriptedSyntheticChildren::SharedPointer synth_sp;
-
   if (items & eFormatCategoryItemFormat) {
-    if (m_format_cont.AnyMatches(type_name)) {
+    if (m_format_cont.AnyMatches(candidate_type)) {
       if (matching_category)
         *matching_category = m_name.GetCString();
       if (matching_type)
         *matching_type = eFormatCategoryItemFormat;
       return true;
     }
   }
 
   if (items & eFormatCategoryItemSummary) {
-    if (m_summary_cont.AnyMatches(type_name)) {
+    if (m_summary_cont.AnyMatches(candidate_type)) {
       if (matching_category)
         *matching_category = m_name.GetCString();
       if (matching_type)
         *matching_type = eFormatCategoryItemSummary;
       return true;
     }
   }
 
   if (items & eFormatCategoryItemFilter) {
-    if (m_filter_cont.AnyMatches(type_name)) {
+    if (m_filter_cont.AnyMatches(candidate_type)) {
       if (matching_category)
         *matching_category = m_name.GetCString();
       if (matching_type)
         *matching_type = eFormatCategoryItemFilter;
       return true;
     }
   }
 
   if (items & eFormatCategoryItemSynth) {
-    if (m_synth_cont.AnyMatches(type_name)) {
+    if (m_synth_cont.AnyMatches(candidate_type)) {
       if (matching_category)
         *matching_category = m_name.GetCString();
       if (matching_type)
         *matching_type = eFormatCategoryItemSynth;
       return true;
     }
   }
 

lldb/source/DataFormatters/TypeCategoryMap.cpp

while (pos > 0) {
     if (iter == end)
       return false;
   }
   entry = iter->second;
   return false;
 }
 
 bool TypeCategoryMap::AnyMatches(
-    ConstString type_name, TypeCategoryImpl::FormatCategoryItems items,
-    bool only_enabled, const char **matching_category,
+    const FormattersMatchCandidate &candidate_type,
+    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,
+    if (pos->second->AnyMatches(candidate_type, items, only_enabled,
                                 matching_category, matching_type))
       return true;
   }
   return false;
 }
 
 template <typename ImplSP>
 void TypeCategoryMap::Get(FormattersMatchData &match_data, ImplSP &retval) {

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

public:
   // Also returns the FunctionNameType of each possible name.
   std::vector<Language::MethodNameVariant>
   GetMethodNameVariants(ConstString method_name) const override;
 
   bool SymbolNameFitsToLanguage(Mangled mangled) const override;
 
   lldb::TypeCategoryImplSP GetFormatters() override;
 
-  std::vector<ConstString>
+  std::vector<FormattersMatchCandidate>
   GetPossibleFormattersMatches(ValueObject &valobj,
                                lldb::DynamicValueType use_dynamic) override;
 
   std::unique_ptr<TypeScavenger> GetTypeScavenger() override;
 
   bool GetFormatterPrefixSuffix(ValueObject &valobj, ConstString type_hint,
                                 std::string &prefix,
                                 std::string &suffix) override;

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

 //===-- ObjCLanguage.cpp --------------------------------------------------===//
 //
 // 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 <mutex>
 
 #include "ObjCLanguage.h"
 
 #include "Plugins/ExpressionParser/Clang/ClangUtil.h"
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
+#include "lldb/Core/Debugger.h"
 #include "lldb/Core/PluginManager.h"
 #include "lldb/Core/ValueObject.h"
 #include "lldb/DataFormatters/DataVisualization.h"
 #include "lldb/DataFormatters/FormattersHelpers.h"
 #include "lldb/Symbol/CompilerType.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/StreamString.h"
llvm::call_once(g_initialize, [this]() -> void {
     if (g_category) {
       LoadCoreMediaFormatters(g_category);
       LoadObjCFormatters(g_category);
     }
   });
   return g_category;
 }
 
-std::vector<ConstString>
+std::vector<FormattersMatchCandidate>
 ObjCLanguage::GetPossibleFormattersMatches(ValueObject &valobj,
                                            lldb::DynamicValueType use_dynamic) {
-  std::vector<ConstString> result;
+  std::vector<FormattersMatchCandidate> result;
 
   if (use_dynamic == lldb::eNoDynamicValues)
     return result;
 
   CompilerType compiler_type(valobj.GetCompilerType());
 
   const bool check_cpp = false;
   const bool check_objc = true;
   bool canBeObjCDynamic =
       compiler_type.IsPossibleDynamicType(nullptr, check_cpp, check_objc);
 
   if (canBeObjCDynamic && ClangUtil::IsClangType(compiler_type)) {
     do {
       lldb::ProcessSP process_sp = valobj.GetProcessSP();
       if (!process_sp)
         break;
       ObjCLanguageRuntime *runtime = ObjCLanguageRuntime::Get(*process_sp);
       if (runtime == nullptr)
         break;
       ObjCLanguageRuntime::ClassDescriptorSP objc_class_sp(
           runtime->GetClassDescriptor(valobj));
       if (!objc_class_sp)
         break;
       if (ConstString name = objc_class_sp->GetClassName())
-        result.push_back(name);
+        result.push_back(
+            {name, valobj.GetTargetSP()->GetDebugger().GetScriptInterpreter(),
+             TypeImpl(objc_class_sp->GetType()),
+             FormattersMatchCandidate::Flags{}});
     } while (false);
   }
 
   return result;
 }
 
 std::unique_ptr<Language::TypeScavenger> ObjCLanguage::GetTypeScavenger() {
   class ObjCScavengerResult : public Language::TypeScavenger::Result {

lldb/source/Plugins/ScriptInterpreter/Python/SWIGPythonBridge.h

llvm::Expected<bool> LLDBSwigPythonBreakpointCallbackFunction(
     const lldb::StackFrameSP &sb_frame,
     const lldb::BreakpointLocationSP &sb_bp_loc,
     const lldb_private::StructuredDataImpl &args_impl);
 
 bool LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp);
 
+bool LLDBSwigPythonFormatterCallbackFunction(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::TypeImplSP type_impl_sp);
+
 bool LLDBSwigPythonCallTypeScript(const char *python_function_name,
                                   const void *session_dictionary,
                                   const lldb::ValueObjectSP &valobj_sp,
                                   void **pyfunct_wrapper,
                                   const lldb::TypeSummaryOptionsSP &options_sp,
                                   std::string &retval);
 
 python::PythonObject

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPython.cpp

Locker py_lock(this,
                    Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
     callee_wrapper_sp = std::make_shared<StructuredPythonObject>(
         PythonObject(PyRefType::Borrowed, static_cast<PyObject *>(new_callee)));
   }
 
   return ret_val;
 }
 
+bool ScriptInterpreterPythonImpl::FormatterCallbackFunction(
+    const char *python_function_name, TypeImplSP type_impl_sp) {
+  Locker py_lock(this,
+                 Locker::AcquireLock | Locker::InitSession | Locker::NoSTDIN);
+  return LLDBSwigPythonFormatterCallbackFunction(
+      python_function_name, m_dictionary_name.c_str(), type_impl_sp);
+}
+
 bool ScriptInterpreterPythonImpl::BreakpointCallbackFunction(
     void *baton, StoppointCallbackContext *context, user_id_t break_id,
     user_id_t break_loc_id) {
   CommandDataPython *bp_option_data = (CommandDataPython *)baton;
   const char *python_function_name = bp_option_data->script_source.c_str();
 
   if (!context)
     return true;
 
   ExecutionContext exe_ctx(context->exe_ctx_ref);
   Target *target = exe_ctx.GetTargetPtr();

lldb/source/Plugins/ScriptInterpreter/Python/ScriptInterpreterPythonImpl.h

public:
   bool GenerateWatchpointCommandCallbackData(StringList &input,
                                              std::string &output) override;
 
   bool GetScriptedSummary(const char *function_name, lldb::ValueObjectSP valobj,
                           StructuredData::ObjectSP &callee_wrapper_sp,
                           const TypeSummaryOptions &options,
                           std::string &retval) override;
 
+  bool FormatterCallbackFunction(const char *function_name,
+                                 lldb::TypeImplSP type_impl_sp) override;
+
   bool GetDocumentationForItem(const char *item, std::string &dest) override;
 
   bool GetShortHelpForCommandObject(StructuredData::GenericSP cmd_obj_sp,
                                     std::string &dest) override;
 
   uint32_t
   GetFlagsForCommandObject(StructuredData::GenericSP cmd_obj_sp) override;
 

lldb/source/Target/Language.cpp

HardcodedFormatters::HardcodedSummaryFinder Language::GetHardcodedSummaries() {
   return {};
 }
 
 HardcodedFormatters::HardcodedSyntheticFinder
 Language::GetHardcodedSynthetics() {
   return {};
 }
 
-std::vector<ConstString>
+std::vector<FormattersMatchCandidate>
 Language::GetPossibleFormattersMatches(ValueObject &valobj,
                                        lldb::DynamicValueType use_dynamic) {
   return {};
 }
 
 struct language_name_pair {
   const char *name;
   LanguageType type;

lldb/test/API/functionalities/data-formatter/callback-matching/Makefile

+CXX_SOURCES := main.cpp
+
+include Makefile.rules

lldb/test/API/functionalities/data-formatter/callback-matching/TestDataFormatterCallbackMatching.py

+"""
+Test lldb data formatter callback-based matching.
+"""
+
+import lldb
+from lldbsuite.test.decorators import *
+from lldbsuite.test.lldbtest import *
+from lldbsuite.test import lldbutil
+
+
+class PythonSynthDataFormatterTestCase(TestBase):
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break at.
+        self.line = line_number('main.cpp', '// Set break point at this line.')
+
+    def test_callback_matchers(self):
+        """Test data formatter commands."""
+        self.build()
+
+        _, process, thread, _ = lldbutil.run_to_line_breakpoint(
+            self, lldb.SBFileSpec("main.cpp"), self.line)
+
+        # Print derived without a formatter.
+        self.expect("frame variable derived",
+                    substrs=['x = 2222',
+                             'y = 3333'])
+
+        # now set up a summary function that uses a python callback to match
+        # classes that derive from `Base`.
+        self.runCmd("command script import --allow-reload ./formatters_with_callback.py")
+
+        # Now `derived` should use our callback summary + synthetic children.
+        self.expect("frame variable derived",
+                    substrs=['hello from callback summary',
+                             'synthetic_child = 9999'])
+
+        # But not other classes.
+        self.expect("frame variable base", matching=False,
+                    substrs=['hello from callback summary'])
+        self.expect("frame variable base",
+                    substrs=['x = 1111'])
+
+        self.expect("frame variable nd", matching=False,
+                    substrs=['hello from callback summary'])
+        self.expect("frame variable nd",
+                    substrs=['z = 4444'])

lldb/test/API/functionalities/data-formatter/callback-matching/formatters_with_callback.py

+import lldb
+
+def derives_from_base(sbtype, internal_dict):
+    for base in sbtype.get_bases_array():
+        if base.GetName() == "Base":
+            return True
+    return False
+
+
+class SynthProvider:
+    def __init__(self, valobj, dict):
+        self.valobj = valobj
+
+    def num_children(self):
+        return 1
+
+    def get_child_index(self, name):
+        return 0
+
+    def get_child_at_index(self, index):
+        if index == 0:
+            return self.valobj.CreateValueFromExpression("synthetic_child",
+                                                         "9999")
+        return None
+
+
+def __lldb_init_module(debugger, dict):
+    cat = debugger.CreateCategory("callback_formatters")
+    cat.AddTypeSummary(
+        lldb.SBTypeNameSpecifier("formatters_with_callback.derives_from_base",
+                                 lldb.eFormatterMatchCallback),
+        lldb.SBTypeSummary.CreateWithScriptCode(
+            "return 'hello from callback summary'"))
+    cat.AddTypeSynthetic(
+        lldb.SBTypeNameSpecifier('formatters_with_callback.derives_from_base',
+                                 lldb.eFormatterMatchCallback),
+        lldb.SBTypeSynthetic.CreateWithClassName(
+            'formatters_with_callback.SynthProvider'))
+    cat.SetEnabled(True)

lldb/test/API/functionalities/data-formatter/callback-matching/main.cpp

+struct Base { int x; };
+struct Derived : public Base { int y; };
+
+struct NonDerived { int z; };
+
+int main()
+{
+    Base base = {1111};
+
+    Derived derived;
+    derived.x = 2222;
+    derived.y = 3333;
+
+    NonDerived nd = {4444};
+    return 0;     // Set break point at this line.
+}

lldb/unittests/DataFormatter/FormattersContainerTest.cpp

 //===-- FormattersContainerTests.cpp --------------------------------------===//
 //
 // 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/FormattersContainer.h"
+#include "lldb/DataFormatters/FormatClasses.h"
 
 #include "gtest/gtest.h"
 
 using namespace lldb;
 using namespace lldb_private;
 
+// Creates a dummy candidate with just a type name in order to test the string
+// matching (exact name match and regex match) paths.
+FormattersMatchCandidate CandidateFromTypeName(const char *type_name) {
+  return FormattersMatchCandidate(ConstString(type_name), nullptr, TypeImpl(),
+                                  FormattersMatchCandidate::Flags());
+}
+
 // All the prefixes that the exact name matching will strip from the type.
 static const std::vector<std::string> exact_name_prefixes = {
     "", // no prefix.
     "class ", "struct ", "union ", "enum ",
 };
 
 // TypeMatcher that uses a exact type name string that needs to be matched.
 TEST(TypeMatcherTests, ExactName) {
   for (const std::string &prefix : exact_name_prefixes) {
     SCOPED_TRACE("Prefix: " + prefix);
 
     TypeMatcher matcher(ConstString(prefix + "Name"));
-    EXPECT_TRUE(matcher.Matches(ConstString("class Name")));
-    EXPECT_TRUE(matcher.Matches(ConstString("struct Name")));
-    EXPECT_TRUE(matcher.Matches(ConstString("union Name")));
-    EXPECT_TRUE(matcher.Matches(ConstString("enum Name")));
-    EXPECT_TRUE(matcher.Matches(ConstString("Name")));
-
-    EXPECT_FALSE(matcher.Matches(ConstString("Name ")));
-    EXPECT_FALSE(matcher.Matches(ConstString("ame")));
-    EXPECT_FALSE(matcher.Matches(ConstString("Nam")));
-    EXPECT_FALSE(matcher.Matches(ConstString("am")));
-    EXPECT_FALSE(matcher.Matches(ConstString("a")));
-    EXPECT_FALSE(matcher.Matches(ConstString(" ")));
-    EXPECT_FALSE(matcher.Matches(ConstString("class N")));
-    EXPECT_FALSE(matcher.Matches(ConstString("class ")));
-    EXPECT_FALSE(matcher.Matches(ConstString("class")));
+    EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("class Name")));
+    EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("struct Name")));
+    EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("union Name")));
+    EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("enum Name")));
+    EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("Name")));
+
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("Name ")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("ame")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("Nam")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("am")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("a")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName(" ")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("class N")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("class ")));
+    EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("class")));
   }
 }
 
 // TypeMatcher that uses a regex to match a type name.
 TEST(TypeMatcherTests, RegexName) {
   TypeMatcher matcher(RegularExpression("^a[a-z]c$"));
-  EXPECT_TRUE(matcher.Matches(ConstString("abc")));
-  EXPECT_TRUE(matcher.Matches(ConstString("azc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("abc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("azc")));
 
   // FIXME: This isn't consistent with the 'exact' type name matches above.
-  EXPECT_FALSE(matcher.Matches(ConstString("class abc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("class abc")));
 
-  EXPECT_FALSE(matcher.Matches(ConstString("abbc")));
-  EXPECT_FALSE(matcher.Matches(ConstString(" abc")));
-  EXPECT_FALSE(matcher.Matches(ConstString("abc ")));
-  EXPECT_FALSE(matcher.Matches(ConstString(" abc ")));
-  EXPECT_FALSE(matcher.Matches(ConstString("XabcX")));
-  EXPECT_FALSE(matcher.Matches(ConstString("ac")));
-  EXPECT_FALSE(matcher.Matches(ConstString("a[a-z]c")));
-  EXPECT_FALSE(matcher.Matches(ConstString("aAc")));
-  EXPECT_FALSE(matcher.Matches(ConstString("ABC")));
-  EXPECT_FALSE(matcher.Matches(ConstString("")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("abbc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName(" abc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("abc ")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName(" abc ")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("XabcX")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("ac")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("a[a-z]c")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("aAc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("ABC")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("")));
 }
 
 // TypeMatcher that only searches the type name.
 TEST(TypeMatcherTests, RegexMatchPart) {
   TypeMatcher matcher(RegularExpression("a[a-z]c"));
-  EXPECT_TRUE(matcher.Matches(ConstString("class abc")));
-  EXPECT_TRUE(matcher.Matches(ConstString("abc")));
-  EXPECT_TRUE(matcher.Matches(ConstString(" abc ")));
-  EXPECT_TRUE(matcher.Matches(ConstString("azc")));
-  EXPECT_TRUE(matcher.Matches(ConstString("abc ")));
-  EXPECT_TRUE(matcher.Matches(ConstString(" abc ")));
-  EXPECT_TRUE(matcher.Matches(ConstString(" abc")));
-  EXPECT_TRUE(matcher.Matches(ConstString("XabcX")));
-
-  EXPECT_FALSE(matcher.Matches(ConstString("abbc")));
-  EXPECT_FALSE(matcher.Matches(ConstString("ac")));
-  EXPECT_FALSE(matcher.Matches(ConstString("a[a-z]c")));
-  EXPECT_FALSE(matcher.Matches(ConstString("aAc")));
-  EXPECT_FALSE(matcher.Matches(ConstString("ABC")));
-  EXPECT_FALSE(matcher.Matches(ConstString("")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("class abc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("abc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName(" abc ")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("azc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("abc ")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName(" abc ")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName(" abc")));
+  EXPECT_TRUE(matcher.Matches(CandidateFromTypeName("XabcX")));
+
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("abbc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("ac")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("a[a-z]c")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("aAc")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("ABC")));
+  EXPECT_FALSE(matcher.Matches(CandidateFromTypeName("")));
 }
 
 // GetMatchString for exact type name matchers.
 TEST(TypeMatcherTests, GetMatchStringExactName) {
   EXPECT_EQ(TypeMatcher(ConstString("aa")).GetMatchString(), "aa");
   EXPECT_EQ(TypeMatcher(ConstString("")).GetMatchString(), "");
   EXPECT_EQ(TypeMatcher(ConstString("[a]")).GetMatchString(), "[a]");
 }

lldb/unittests/ScriptInterpreter/Python/PythonTestSuite.cpp

 }
 
 bool lldb_private::LLDBSwigPythonWatchpointCallbackFunction(
     const char *python_function_name, const char *session_dictionary_name,
     const lldb::StackFrameSP &sb_frame, const lldb::WatchpointSP &sb_wp) {
   return false;
 }
 
+bool lldb_private::LLDBSwigPythonFormatterCallbackFunction(
+    const char *python_function_name, const char *session_dictionary_name,
+    lldb::TypeImplSP type_impl_sp) {
+  return false;
+}
+
 bool lldb_private::LLDBSwigPythonCallTypeScript(
     const char *python_function_name, const void *session_dictionary,
     const lldb::ValueObjectSP &valobj_sp, void **pyfunct_wrapper,
     const lldb::TypeSummaryOptionsSP &options_sp, std::string &retval) {
   return false;
 }
 
 python::PythonObject lldb_private::LLDBSwigPythonCreateSyntheticProvider(