[lldb] Enable synthetic providers in C++

[electriclilies]

Hangon reviewers, I forgot to squash my commits.

[electriclilies]

Abandoning this since I messed up when updating, changes are now at https://reviews.llvm.org/D158010

lldb/include/lldb/Core/ValueObject.h

public:
   }
 
   lldb::TypeFormatImplSP GetValueFormat() {
     UpdateFormatsIfNeeded();
     return m_type_format_sp;
   }
 
   void SetSyntheticChildren(const lldb::SyntheticChildrenSP &synth_sp) {
-    llvm::errs() << "set synthetic children called\n";
-    llvm::errs() << "synth_sp: " << synth_sp.get() << "\n";
     if (synth_sp.get() == m_synthetic_children_sp.get())
       return;
     ClearUserVisibleData(eClearUserVisibleDataItemsSyntheticChildren);
-    llvm::errs() << "actually set m_synthetic_children_sp\n";
     m_synthetic_children_sp = synth_sp;
   }
 
   lldb::SyntheticChildrenSP GetSyntheticChildren() {
-    llvm::errs() << "inside get synthetic children\n";
     UpdateFormatsIfNeeded();
     return m_synthetic_children_sp;
   }
 
   // Use GetParent for display purposes, but if you want to tell the parent to
   // update itself then use m_parent.  The ValueObjectDynamicValue's parent is
   // not the correct parent for displaying, they are really siblings, so for
   // display it needs to route through to its grandparent.

lldb/include/lldb/Core/ValueObjectSyntheticFilter.h

public:
 
   lldb::ValueObjectSP
   GetDynamicValue(lldb::DynamicValueType valueType) override;
 
   bool IsInScope() override;
 
   bool HasSyntheticValue() override { return false; }
 
-  bool IsSynthetic() override { llvm::errs() << "is synthetic\n"; return true; }
+  bool IsSynthetic() override { return true; }
 
   void CalculateSyntheticValue() override {}
 
   bool IsDynamic() override {
     return ((m_parent != nullptr) ? m_parent->IsDynamic() : false);
   }
 
   lldb::ValueObjectSP GetStaticValue() override {

lldb/source/Core/ValueObject.cpp

bool ValueObject::UpdateFormatsIfNeeded() {
 
   if ((m_last_format_mgr_revision != DataVisualization::GetCurrentRevision())) {
     m_last_format_mgr_revision = DataVisualization::GetCurrentRevision();
     any_change = true;
 
     SetValueFormat(DataVisualization::GetFormat(*this, eNoDynamicValues));
     SetSummaryFormat(
         DataVisualization::GetSummaryFormat(*this, GetDynamicValueType()));
-    llvm::errs() << "about to call SetSyntheticChildren\n";
     SetSyntheticChildren(
         DataVisualization::GetSyntheticChildren(*this, GetDynamicValueType()));
-    llvm::errs() << "SetSyntheticChildren call finished\n";
   }
 
   return any_change;
 }
 
 void ValueObject::SetNeedsUpdate() {
   m_update_point.SetNeedsUpdate();
   // We have to clear the value string here so ConstResult children will notice
ValueObject *ValueObject::CreateChildAtIndex(size_t idx,
   bool child_is_base_class = false;
   bool child_is_deref_of_parent = false;
   uint64_t language_flags = 0;
 
   const bool transparent_pointers = !synthetic_array_member;
   CompilerType child_compiler_type;
 
   ExecutionContext exe_ctx(GetExecutionContextRef());
+
   child_compiler_type = GetCompilerType().GetChildCompilerTypeAtIndex(
       &exe_ctx, idx, transparent_pointers, omit_empty_base_classes,
       ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
       child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
       child_is_deref_of_parent, this, language_flags);
   if (child_compiler_type) {
     if (synthetic_index)
       child_byte_offset += child_byte_size * synthetic_index;
bool ValueObject::HasSpecialPrintableRepresentation(
   }
   return false;
 }
 
 bool ValueObject::DumpPrintableRepresentation(
     Stream &s, ValueObjectRepresentationStyle val_obj_display,
     Format custom_format, PrintableRepresentationSpecialCases special,
     bool do_dump_error) {
+
   // If the ValueObject has an error, we might end up dumping the type, which
   // is useful, but if we don't even have a type, then don't examine the object
   // further as that's not meaningful, only the error is.
   if (m_error.Fail() && !GetCompilerType().IsValid()) {
     if (do_dump_error)
       s.Printf("<%s>", m_error.AsCString());
     return false;
   }
if (synthetic_child_sp.get()) {
       synthetic_child_sp->SetName(
           ConstString(SkipLeadingExpressionPathSeparators(expression)));
     }
   }
   return synthetic_child_sp;
 }
 
 void ValueObject::CalculateSyntheticValue() {
-  llvm::errs() << "calculatesyntheticvalue\n";
   TargetSP target_sp(GetTargetSP());
   if (target_sp && !target_sp->GetEnableSyntheticValue()) {
     m_synthetic_value = nullptr;
     return;
   }
 
   lldb::SyntheticChildrenSP current_synth_sp(m_synthetic_children_sp);
 
   if (!UpdateFormatsIfNeeded() && m_synthetic_value)
     return;
-  llvm::errs() << "1\n";
 
   if (m_synthetic_children_sp.get() == nullptr)
     return;
 
-  llvm::errs() << "2\n";
-
   if (current_synth_sp == m_synthetic_children_sp && m_synthetic_value)
     return;
 
-  llvm::errs() << "3\n";
-
   m_synthetic_value = new ValueObjectSynthetic(*this, m_synthetic_children_sp);
-  llvm::errs() << "set synthetic children\n";
 }
 
 void ValueObject::CalculateDynamicValue(DynamicValueType use_dynamic) {
   if (use_dynamic == eNoDynamicValues)
     return;
 
   if (!m_dynamic_value && !IsDynamic()) {
     ExecutionContext exe_ctx(GetExecutionContextRef());
if (is_pointer_or_reference_type) {
     bool child_is_base_class = false;
     bool child_is_deref_of_parent = false;
     const bool transparent_pointers = false;
     CompilerType compiler_type = GetCompilerType();
     CompilerType child_compiler_type;
     uint64_t language_flags = 0;
 
     ExecutionContext exe_ctx(GetExecutionContextRef());
+
     child_compiler_type = compiler_type.GetChildCompilerTypeAtIndex(
         &exe_ctx, 0, transparent_pointers, omit_empty_base_classes,
         ignore_array_bounds, child_name_str, child_byte_size, child_byte_offset,
         child_bitfield_bit_size, child_bitfield_bit_offset, child_is_base_class,
         child_is_deref_of_parent, this, language_flags);
     if (child_compiler_type && child_byte_size) {
       ConstString child_name;
       if (!child_name_str.empty())

lldb/source/DataFormatters/DataVisualization.cpp

 lldb::TypeSummaryImplSP
 DataVisualization::GetSummaryForType(lldb::TypeNameSpecifierImplSP type_sp) {
   return GetFormatManager().GetSummaryForType(type_sp);
 }
 
 lldb::SyntheticChildrenSP
 DataVisualization::GetSyntheticChildren(ValueObject &valobj,
                                         lldb::DynamicValueType use_dynamic) {
-  llvm::errs() << "inside get synthetic children2\n";
   return GetFormatManager().GetSyntheticChildren(valobj, use_dynamic);
 }
 
 lldb::TypeFilterImplSP
 DataVisualization::GetFilterForType(lldb::TypeNameSpecifierImplSP type_sp) {
   return GetFormatManager().GetFilterForType(type_sp);
 }
 

lldb/source/DataFormatters/FormatManager.cpp

m_language_categories_map[lang_type] =
       LanguageCategory::UniquePointer(lang_category);
   return lang_category;
 }
 
 template <typename ImplSP>
 ImplSP FormatManager::GetHardcoded(FormattersMatchData &match_data) {
   ImplSP retval_sp;
   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
-    llvm::errs() << "lang type: " << lang_type << "\n";
     if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
-      llvm::errs() << "lang_category: " << lang_category << "\n";
-      if (lang_category->GetHardcoded(*this, match_data, retval_sp)) {
-        llvm::errs() << "lang_category->GetHardcoded succeeded\n";
+      if (lang_category->GetHardcoded(*this, match_data, retval_sp))
         return retval_sp;
-      }
-    }
-  }
   return retval_sp;
 }
 
 namespace {
 template <typename ImplSP> const char *FormatterKind;
 template <> const char *FormatterKind<lldb::TypeFormatImplSP> = "format";
 template <> const char *FormatterKind<lldb::TypeSummaryImplSP> = "summary";
 template <> const char *FormatterKind<lldb::SyntheticChildrenSP> = "synthetic";
 } // namespace
 
 #define FORMAT_LOG(Message) "[%s] " Message, FormatterKind<ImplSP>
 
 template <typename ImplSP>
 ImplSP FormatManager::Get(ValueObject &valobj,
                           lldb::DynamicValueType use_dynamic) {
-  llvm::errs() << "format manager get\n";
-  llvm::errs() << "valobj dynamic value type: " << valobj.DoesProvideSyntheticValue() << "\n";
   FormattersMatchData match_data(valobj, use_dynamic);
   if (ImplSP retval_sp = GetCached<ImplSP>(match_data))
     return retval_sp;
-  llvm::errs() << "ckpt 1\n";
 
   Log *log = GetLog(LLDBLog::DataFormatters);
 
   LLDB_LOGF(log, FORMAT_LOG("Search failed. Giving language a chance."));
   for (lldb::LanguageType lang_type : match_data.GetCandidateLanguages()) {
     if (LanguageCategory *lang_category = GetCategoryForLanguage(lang_type)) {
       ImplSP retval_sp;
       if (lang_category->Get(match_data, retval_sp))
         if (retval_sp) {
           LLDB_LOGF(log, FORMAT_LOG("Language search success. Returning."));
           return retval_sp;
         }
     }
   }
-  llvm::errs() << "ckpt 2\n";
-
 
   LLDB_LOGF(log, FORMAT_LOG("Search failed. Giving hardcoded a chance."));
   return GetHardcoded<ImplSP>(match_data);
 }
 
 template <typename ImplSP>
 ImplSP FormatManager::GetCached(FormattersMatchData &match_data) {
   ImplSP retval_sp;

 FormatManager::GetSummaryFormat(ValueObject &valobj,
                                 lldb::DynamicValueType use_dynamic) {
   return Get<lldb::TypeSummaryImplSP>(valobj, use_dynamic);
 }
 
 lldb::SyntheticChildrenSP
 FormatManager::GetSyntheticChildren(ValueObject &valobj,
                                     lldb::DynamicValueType use_dynamic) {
-  llvm::errs() << "format manager get synthetic children\n";
   return Get<lldb::SyntheticChildrenSP>(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")),

lldb/source/DataFormatters/LanguageCategory.cpp

LanguageCategory::Get<lldb::TypeSummaryImplSP>(FormattersMatchData &,
                                                lldb::TypeSummaryImplSP &);
 template bool
 LanguageCategory::Get<lldb::SyntheticChildrenSP>(FormattersMatchData &,
                                                  lldb::SyntheticChildrenSP &);
 /// \}
 
 template <>
 auto &LanguageCategory::GetHardcodedFinder<lldb::TypeFormatImplSP>() {
-    llvm::errs() << "get hardedcoded finder type formatn\n";
   return m_hardcoded_formats;
 }
 
 template <>
 auto &LanguageCategory::GetHardcodedFinder<lldb::TypeSummaryImplSP>() {
-  llvm::errs() << "get hardedcoded finder type summary\n";
   return m_hardcoded_summaries;
 }
 
 template <>
 auto &LanguageCategory::GetHardcodedFinder<lldb::SyntheticChildrenSP>() {
-  llvm::errs() << "get hardedcoded finder synthetic children\n";
-
   return m_hardcoded_synthetics;
 }
 
 } // namespace lldb_private
 
 template <typename ImplSP>
 bool LanguageCategory::GetHardcoded(FormatManager &fmt_mgr,
                                     FormattersMatchData &match_data,
                                     ImplSP &retval_sp) {
-  llvm::errs() << "languagecategory::GetHardcoded\n";
-  if (!IsEnabled()) {
-    llvm::errs() << "not enabled\n";
+  if (!IsEnabled())
     return false;
-  }
 
   ValueObject &valobj(match_data.GetValueObject());
   lldb::DynamicValueType use_dynamic(match_data.GetDynamicValueType());
-  llvm::errs() << "language category checkpoint\n";
+
   for (auto &candidate : GetHardcodedFinder<ImplSP>()) {
-    llvm::errs() << "looking at candidates\n;";
     if (auto result = candidate(valobj, use_dynamic, fmt_mgr)) {
-      llvm::errs() << "result\n";
       retval_sp = result;
       break;
     }
   }
   return (bool)retval_sp;
 }
 
 /// Explicit instantiations for the three types.