[lldb] Hoist code to create StructuredData into DiagnosticEventData (NFC)

[JDevlieghere]

Summary

Hoist the code that creates a StructuredData dictionary from a
diagnostic event into the DiagnosticEventData. This addresses Ismail's
code review feedback from D143687.

[mib]

LGTM with some nitpicks.

lldb/source/API/SBDebugger.cpp

175–176

nit: should be dictionary_sp

lldb/source/Core/DebuggerEvents.cpp

96

ditto

lldb/include/lldb/Core/DebuggerEvents.h

 //===-- DebuggerEvents.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
 //
 //===----------------------------------------------------------------------===//
 
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Event.h"
+#include "lldb/Utility/StructuredData.h"
 
 #include <string>
 
 #ifndef LLDB_CORE_DEBUGGER_EVENTS_H
 #define LLDB_CORE_DEBUGGER_EVENTS_H
 
 namespace lldb_private {
 class Stream;
public:
   void Dump(Stream *s) const override;
 
   static ConstString GetFlavorString();
   ConstString GetFlavor() const override;
 
   static const DiagnosticEventData *
   GetEventDataFromEvent(const Event *event_ptr);
 
+  static StructuredData::DictionarySP
+  GetAsStructuredData(const Event *event_ptr);
+
 protected:
   std::string m_message;
   Type m_type;
   const bool m_debugger_specific;
 
   DiagnosticEventData(const DiagnosticEventData &) = delete;
   const DiagnosticEventData &operator=(const DiagnosticEventData &) = delete;
 };

lldb/source/API/SBDebugger.cpp

const char *SBDebugger::GetProgressFromEvent(const lldb::SBEvent &event,
   is_debugger_specific = progress_data->IsDebuggerSpecific();
   return progress_data->GetMessage().c_str();
 }
 
 lldb::SBStructuredData
 SBDebugger::GetDiagnosticFromEvent(const lldb::SBEvent &event) {
   LLDB_INSTRUMENT_VA(event);
 
-  const DiagnosticEventData *diagnostic_data =
-      DiagnosticEventData::GetEventDataFromEvent(event.get());
-  if (!diagnostic_data)
-    return {};
+  StructuredData::DictionarySP dictionary_sp =
+      DiagnosticEventData::GetAsStructuredData(event.get());
 
-  auto dictionary = std::make_unique<StructuredData::Dictionary>();
-  dictionary->AddStringItem("message", diagnostic_data->GetMessage());
-  dictionary->AddStringItem("type", diagnostic_data->GetPrefix());
-  dictionary->AddBooleanItem("debugger_specific",
-                             diagnostic_data->IsDebuggerSpecific());
+  if (!dictionary_sp)
+    return {};
 
   SBStructuredData data;
-  data.m_impl_up->SetObjectSP(std::move(dictionary));
+  data.m_impl_up->SetObjectSP(std::move(dictionary_sp));
   return data;
 }
 
 SBBroadcaster SBDebugger::GetBroadcaster() {
   LLDB_INSTRUMENT_VA(this);
   SBBroadcaster broadcaster(&m_opaque_sp->GetBroadcaster(), false);
   return broadcaster;
 }

lldb/source/Core/DebuggerEvents.cpp

ConstString DiagnosticEventData::GetFlavor() const {
   return DiagnosticEventData::GetFlavorString();
 }
 
 const DiagnosticEventData *
 DiagnosticEventData::GetEventDataFromEvent(const Event *event_ptr) {
   return GetEventDataFromEventImpl<DiagnosticEventData>(event_ptr);
 }
 
+StructuredData::DictionarySP
+DiagnosticEventData::GetAsStructuredData(const Event *event_ptr) {
+  const DiagnosticEventData *diagnostic_data =
+      DiagnosticEventData::GetEventDataFromEvent(event_ptr);
+
+  if (!diagnostic_data)
+    return {};
+
+  auto dictionary_sp = std::make_shared<StructuredData::Dictionary>();
+  dictionary_sp->AddStringItem("message", diagnostic_data->GetMessage());
+  dictionary_sp->AddStringItem("type", diagnostic_data->GetPrefix());
+  dictionary_sp->AddBooleanItem("debugger_specific",
+                                diagnostic_data->IsDebuggerSpecific());
+  return dictionary_sp;
+}
+
 ConstString SymbolChangeEventData::GetFlavorString() {
   static ConstString g_flavor("SymbolChangeEventData");
   return g_flavor;
 }
 
 ConstString SymbolChangeEventData::GetFlavor() const {
   return SymbolChangeEventData::GetFlavorString();
 }