[lldb] Add an SB API to get progress events as SBStructuredData

[JDevlieghere]

Summary

This is a preparatory patch to add an SB API to get the progress data as SBStructuredData. The approach is identical to the one taken for SBDebugger::GetDiagnosticFromEvent. By returning SBStructuredData we can grow the dictionary over time with more fields, which is what my follow up patch does.

[mib]

lldb/source/API/SBDebugger.cpp

175–186

It feels wrong me that we're doing this at the SB API levels, I feel like we should have an overload of ProgressEventData::GetEventDataFromEvent that returns an actual structured data dictionary. This way, when we extend the progress events, we won't need to update all the places where GetEventDataFromEvent is called from.

[JDevlieghere]

lldb/source/API/SBDebugger.cpp

175–186

Good point, I totally agree. I'll move the code into the ProgressEventData and DiagnosticEventData respectively and have that return a StructuredData dictionary.

[JDevlieghere]

Address @mib's feedback

[mib]

Thanks! LGTM!

lldb/bindings/interface/SBDebugger.i

public:
 
 
     static const char *GetProgressFromEvent(const lldb::SBEvent &event,
                                         uint64_t &OUTPUT,
                                         uint64_t &OUTPUT,
                                         uint64_t &OUTPUT,
                                         bool &OUTPUT);
 
+    static lldb::SBStructuredData GetProgressDataFromEvent(const lldb::SBEvent &event);
+
     static lldb::SBStructuredData GetDiagnosticFromEvent(const lldb::SBEvent &event);
 
     SBBroadcaster GetBroadcaster();
 
     static void
     Initialize();
 
     static SBError

lldb/include/lldb/API/SBDebugger.h

public:
   /// \return The message for the progress. If the returned value is NULL, then
   ///   \a event was not a eBroadcastBitProgress event.
   static const char *GetProgressFromEvent(const lldb::SBEvent &event,
                                           uint64_t &progress_id,
                                           uint64_t &completed, uint64_t &total,
                                           bool &is_debugger_specific);
 
   static lldb::SBStructuredData
+  GetProgressDataFromEvent(const lldb::SBEvent &event);
+
+  static lldb::SBStructuredData
   GetDiagnosticFromEvent(const lldb::SBEvent &event);
 
   lldb::SBDebugger &operator=(const lldb::SBDebugger &rhs);
 
   static void Initialize();
 
   static lldb::SBError InitializeWithErrorHandling();
 

lldb/include/lldb/Core/DebuggerEvents.h

public:
 
   static ConstString GetFlavorString();
 
   ConstString GetFlavor() const override;
 
   void Dump(Stream *s) const override;
 
   static const ProgressEventData *GetEventDataFromEvent(const Event *event_ptr);
+
+  static StructuredData::DictionarySP
+  GetAsStructuredData(const Event *event_ptr);
+
   uint64_t GetID() const { return m_id; }
   bool IsFinite() const { return m_total != UINT64_MAX; }
   uint64_t GetCompleted() const { return m_completed; }
   uint64_t GetTotal() const { return m_total; }
   const std::string &GetMessage() const { return m_message; }
   bool IsDebuggerSpecific() const { return m_debugger_specific; }
 
 private:

lldb/source/API/SBDebugger.cpp

const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
   progress_id = progress_data->GetID();
   completed = progress_data->GetCompleted();
   total = progress_data->GetTotal();
   is_debugger_specific = progress_data->IsDebuggerSpecific();
   return progress_data->GetMessage().c_str();
 }
 
 lldb::SBStructuredData
+SBDebugger::GetProgressDataFromEvent(const lldb::SBEvent &event) {
+  LLDB_INSTRUMENT_VA(event);
+
+  StructuredData::DictionarySP dictionary_sp =
+      ProgressEventData::GetAsStructuredData(event.get());
+
+  if (!dictionary_sp)
+    return {};
+
+  SBStructuredData data;
+  data.m_impl_up->SetObjectSP(std::move(dictionary_sp));
+  return data;
+}
+
+lldb::SBStructuredData
 SBDebugger::GetDiagnosticFromEvent(const lldb::SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
   StructuredData::DictionarySP dictionary_sp =
       DiagnosticEventData::GetAsStructuredData(event.get());
 
   if (!dictionary_sp)
     return {};

lldb/source/Core/DebuggerEvents.cpp

if (m_total != UINT64_MAX)
     s->Printf(", progress = %" PRIu64 " of %" PRIu64, m_completed, m_total);
 }
 
 const ProgressEventData *
 ProgressEventData::GetEventDataFromEvent(const Event *event_ptr) {
   return GetEventDataFromEventImpl<ProgressEventData>(event_ptr);
 }
 
+StructuredData::DictionarySP
+ProgressEventData::GetAsStructuredData(const Event *event_ptr) {
+  const ProgressEventData *progress_data =
+      ProgressEventData::GetEventDataFromEvent(event_ptr);
+
+  if (!progress_data)
+    return {};
+
+  auto dictionary_sp = std::make_shared<StructuredData::Dictionary>();
+  dictionary_sp->AddStringItem("message", progress_data->GetMessage());
+  dictionary_sp->AddIntegerItem("progress_id", progress_data->GetID());
+  dictionary_sp->AddIntegerItem("completed", progress_data->GetCompleted());
+  dictionary_sp->AddIntegerItem("total", progress_data->GetTotal());
+  dictionary_sp->AddBooleanItem("debugger_specific",
+                                progress_data->IsDebuggerSpecific());
+
+  return dictionary_sp;
+}
+
 llvm::StringRef DiagnosticEventData::GetPrefix() const {
   switch (m_type) {
   case Type::Info:
     return "info";
   case Type::Warning:
     return "warning";
   case Type::Error:
     return "error";

lldb/test/API/functionalities/progress_reporting/TestProgressReporting.py

def test_dwarf_symbol_loading_progress_report(self):
         lldbutil.run_to_source_breakpoint(self, 'break here', lldb.SBFileSpec('main.c'))
 
         event = lldbutil.fetch_next_event(self, self.listener, self.broadcaster)
         ret_args = lldb.SBDebugger.GetProgressFromEvent(event)
         self.assertGreater(len(ret_args), 0)
         message = ret_args[0]
         self.assertGreater(len(message), 0)
 
+    def test_dwarf_symbol_loading_progress_report_structured_data(self):
+        """Test that we are able to fetch dwarf symbol loading progress events
+           using the structured data API"""
+        self.build()
+
+        lldbutil.run_to_source_breakpoint(self, 'break here', lldb.SBFileSpec('main.c'))
+
+        event = lldbutil.fetch_next_event(self, self.listener, self.broadcaster)
+        progress_data = lldb.SBDebugger.GetProgressDataFromEvent(event)
+        message = progress_data.GetValueForKey("message").GetStringValue(100)
+        self.assertGreater(len(message), 0)