decouple JSON from DAP Breakpoint classes

Author: eronnen

lldb/tools/lldb-dap/Breakpoint.h

@@ -17,7 +17,9 @@ namespace lldb_dap {
 
 class Breakpoint : public BreakpointBase {
 public:
-  Breakpoint(DAP &d, const llvm::json::Object &obj) : BreakpointBase(d, obj) {}
+  Breakpoint(DAP &d, const std::optional<std::string> &condition,
+             const std::optional<std::string> &hit_condition)
+      : BreakpointBase(d, condition, hit_condition) {}
   Breakpoint(DAP &d, lldb::SBBreakpoint bp) : BreakpointBase(d), m_bp(bp) {}
 
   lldb::break_id_t GetID() const { return m_bp.GetID(); }

lldb/tools/lldb-dap/BreakpointBase.cpp

@@ -12,11 +12,11 @@
 
 using namespace lldb_dap;
 
-BreakpointBase::BreakpointBase(DAP &d, const llvm::json::Object &obj)
-    : m_dap(d),
-      m_condition(std::string(GetString(obj, "condition").value_or(""))),
-      m_hit_condition(
-          std::string(GetString(obj, "hitCondition").value_or(""))) {}
+BreakpointBase::BreakpointBase(DAP &d,
+                               const std::optional<std::string> &condition,
+                               const std::optional<std::string> &hit_condition)
+    : m_dap(d), m_condition(condition.value_or("")),
+      m_hit_condition(hit_condition.value_or("")) {}
 
 void BreakpointBase::UpdateBreakpoint(const BreakpointBase &request_bp) {
   if (m_condition != request_bp.m_condition) {

lldb/tools/lldb-dap/BreakpointBase.h

@@ -18,7 +18,8 @@ namespace lldb_dap {
 class BreakpointBase {
 public:
   explicit BreakpointBase(DAP &d) : m_dap(d) {}
-  BreakpointBase(DAP &d, const llvm::json::Object &obj);
+  BreakpointBase(DAP &d, const std::optional<std::string> &condition,
+                 const std::optional<std::string> &hit_condition);
   virtual ~BreakpointBase() = default;
 
   virtual void SetCondition() = 0;

lldb/tools/lldb-dap/FunctionBreakpoint.cpp

@@ -8,15 +8,15 @@
 
 #include "FunctionBreakpoint.h"
 #include "DAP.h"
-#include "JSONUtils.h"
 #include "lldb/API/SBMutex.h"
 #include <mutex>
 
 namespace lldb_dap {
 
-FunctionBreakpoint::FunctionBreakpoint(DAP &d, const llvm::json::Object &obj)
-    : Breakpoint(d, obj),
-      m_function_name(std::string(GetString(obj, "name").value_or(""))) {}
+FunctionBreakpoint::FunctionBreakpoint(
+    DAP &d, const protocol::FunctionBreakpoint &breakpoint)
+    : Breakpoint(d, breakpoint.condition, breakpoint.hitCondition),
+      m_function_name(breakpoint.name) {}
 
 void FunctionBreakpoint::SetBreakpoint() {
   lldb::SBMutex lock = m_dap.GetAPIMutex();

lldb/tools/lldb-dap/FunctionBreakpoint.h

@@ -11,12 +11,13 @@
 
 #include "Breakpoint.h"
 #include "DAPForward.h"
+#include "Protocol/ProtocolTypes.h"
 
 namespace lldb_dap {
 
 class FunctionBreakpoint : public Breakpoint {
 public:
-  FunctionBreakpoint(DAP &dap, const llvm::json::Object &obj);
+  FunctionBreakpoint(DAP &dap, const protocol::FunctionBreakpoint &breakpoint);
 
   /// Set this breakpoint in LLDB as a new breakpoint.
   void SetBreakpoint();

lldb/tools/lldb-dap/InstructionBreakpoint.cpp

@@ -9,20 +9,19 @@
 
 #include "InstructionBreakpoint.h"
 #include "DAP.h"
-#include "JSONUtils.h"
 #include "lldb/API/SBBreakpoint.h"
 #include "lldb/API/SBTarget.h"
 #include "llvm/ADT/StringRef.h"
 
 namespace lldb_dap {
 
-InstructionBreakpoint::InstructionBreakpoint(DAP &d,
-                                             const llvm::json::Object &obj)
-    : Breakpoint(d, obj), m_instruction_address_reference(LLDB_INVALID_ADDRESS),
-      m_offset(GetInteger<int64_t>(obj, "offset").value_or(0)) {
-  GetString(obj, "instructionReference")
-      .value_or("")
-      .getAsInteger(0, m_instruction_address_reference);
+InstructionBreakpoint::InstructionBreakpoint(
+    DAP &d, const protocol::InstructionBreakpoint &breakpoint)
+    : Breakpoint(d, breakpoint.condition, breakpoint.hitCondition),
+      m_instruction_address_reference(LLDB_INVALID_ADDRESS),
+      m_offset(breakpoint.offset.value_or(0)) {
+  llvm::StringRef instruction_reference(breakpoint.instructionReference);
+  instruction_reference.getAsInteger(0, m_instruction_address_reference);
   m_instruction_address_reference += m_offset;
 }
 

lldb/tools/lldb-dap/InstructionBreakpoint.h

@@ -12,6 +12,7 @@
 
 #include "Breakpoint.h"
 #include "DAPForward.h"
+#include "Protocol/ProtocolTypes.h"
 #include "lldb/lldb-types.h"
 #include <cstdint>
 
@@ -20,7 +21,8 @@ namespace lldb_dap {
 /// Instruction Breakpoint
 class InstructionBreakpoint : public Breakpoint {
 public:
-  InstructionBreakpoint(DAP &d, const llvm::json::Object &obj);
+  InstructionBreakpoint(DAP &d,
+                        const protocol::InstructionBreakpoint &breakpoint);
 
   /// Set instruction breakpoint in LLDB as a new breakpoint.
   void SetBreakpoint();

lldb/tools/lldb-dap/Protocol/ProtocolRequests.h

@@ -398,9 +398,9 @@ bool fromJSON(const llvm::json::Value &, SetBreakpointsArguments &,
 
 /// Response to `setBreakpoints` request.
 /// Returned is information about each breakpoint created by this request.
-/// This includes the actual code location and whether the breakpoint could be verified.
-/// The breakpoints returned are in the same order as the elements of the breakpoints
-/// (or the deprecated lines) array in the arguments.
+/// This includes the actual code location and whether the breakpoint could be
+/// verified. The breakpoints returned are in the same order as the elements of
+/// the breakpoints (or the deprecated lines) array in the arguments.
 struct SetBreakpointsResponseBody {
   /// Information about the breakpoints.
   /// The array elements are in the same order as the elements of the

lldb/tools/lldb-dap/Protocol/ProtocolTypes.h

@@ -322,7 +322,9 @@ enum SteppingGranularity : unsigned {
 bool fromJSON(const llvm::json::Value &, SteppingGranularity &,
               llvm::json::Path);
 
-/// Information about a breakpoint created in `setBreakpoints`, `setFunctionBreakpoints`, `setInstructionBreakpoints`, or `setDataBreakpoints` requests.
+/// Information about a breakpoint created in `setBreakpoints`,
+/// `setFunctionBreakpoints`, `setInstructionBreakpoints`, or
+/// `setDataBreakpoints` requests.
 struct Breakpoint {
   /// A machine-readable explanation of why a breakpoint may not be verified.
   enum class Reason : unsigned {
@@ -343,8 +345,8 @@ struct Breakpoint {
   bool verified;
 
   /// A message about the state of the breakpoint.
-  /// This is shown to the user and can be used to explain why a breakpoint could
-  /// not be verified.
+  /// This is shown to the user and can be used to explain why a breakpoint
+  /// could not be verified.
   std::optional<std::string> message;
 
   /// The source where the breakpoint is located.
@@ -362,18 +364,17 @@ struct Breakpoint {
   std::optional<uint32_t> endLine;
 
   /// End position of the source range covered by the breakpoint. It is measured
-  /// in UTF-16 code units and the client capability `columnsStartAt1` determines
-  /// whether it is 0- or 1-based.
-  /// If no end line is given, then the end column is assumed to be in the start
-  /// line.
+  /// in UTF-16 code units and the client capability `columnsStartAt1`
+  /// determines whether it is 0- or 1-based. If no end line is given, then the
+  /// end column is assumed to be in the start line.
   std::optional<uint32_t> endColumn;
 
   /// A memory reference to where the breakpoint is set.
   std::optional<std::string> instructionReference;
 
   /// The offset from the instruction reference.
   /// This can be negative.
-  std::optional<int64_t> offset;
+  std::optional<int32_t> offset;
 
   /// A machine-readable explanation of why a breakpoint may not be verified. If
   /// a breakpoint is verified or a specific reason is not known, the adapter
@@ -382,7 +383,8 @@ struct Breakpoint {
 };
 llvm::json::Value toJSON(const Breakpoint &);
 
-/// Properties of a breakpoint or logpoint passed to the `setBreakpoints` request
+/// Properties of a breakpoint or logpoint passed to the `setBreakpoints`
+/// request
 struct SourceBreakpoint {
   /// The source line of the breakpoint or logpoint.
   uint32_t line;
@@ -419,8 +421,7 @@ struct SourceBreakpoint {
   /// `breakpointModes` the debug adapter advertised in its `Capabilities`.
   std::optional<std::string> mode;
 };
-bool fromJSON(const llvm::json::Value &, SourceBreakpoint &,
-              llvm::json::Path);
+bool fromJSON(const llvm::json::Value &, SourceBreakpoint &, llvm::json::Path);
 
 /// Properties of a breakpoint passed to the `setFunctionBreakpoints` request.
 struct FunctionBreakpoint {
@@ -441,7 +442,8 @@ struct FunctionBreakpoint {
 bool fromJSON(const llvm::json::Value &, FunctionBreakpoint &,
               llvm::json::Path);
 
-/// This enumeration defines all possible access types for data breakpoints. Values: ‘read’, ‘write’, ‘readWrite’
+/// This enumeration defines all possible access types for data breakpoints.
+/// Values: ‘read’, ‘write’, ‘readWrite’
 enum DataBreakpointAccessType : unsigned {
   eDataBreakpointAccessTypeRead,
   eDataBreakpointAccessTypeWrite,
@@ -479,7 +481,7 @@ struct InstructionBreakpoint {
 
   /// The offset from the instruction reference in bytes.
   /// This can be negative.
-  std::optional<int64_t> offset;
+  std::optional<int32_t> offset;
 
   /// An expression for conditional breakpoints.
   /// It is only honored by a debug adapter if the corresponding capability
@@ -499,7 +501,8 @@ struct InstructionBreakpoint {
 bool fromJSON(const llvm::json::Value &, InstructionBreakpoint &,
               llvm::json::Path);
 
-/// An ExceptionFilterOptions is used to specify an exception filter together with a condition for the `setExceptionBreakpoints` request.
+/// An ExceptionFilterOptions is used to specify an exception filter together
+/// with a condition for the `setExceptionBreakpoints` request.
 struct ExceptionFilterOptions {
   /// ID of an exception filter returned by the `exceptionBreakpointFilters`
   /// capability.
@@ -557,8 +560,7 @@ struct ExceptionOptions {
   /// Condition when a thrown exception should result in a break.
   ExceptionBreakMode breakMode;
 };
-bool fromJSON(const llvm::json::Value &, ExceptionOptions &,
-              llvm::json::Path);
+bool fromJSON(const llvm::json::Value &, ExceptionOptions &, llvm::json::Path);
 
 } // namespace lldb_dap::protocol
 

lldb/tools/lldb-dap/SourceBreakpoint.cpp

@@ -26,13 +26,12 @@
 
 namespace lldb_dap {
 
-SourceBreakpoint::SourceBreakpoint(DAP &dap, const llvm::json::Object &obj)
-    : Breakpoint(dap, obj),
-      m_log_message(GetString(obj, "logMessage").value_or("").str()),
-      m_line(
-          GetInteger<uint64_t>(obj, "line").value_or(LLDB_INVALID_LINE_NUMBER)),
-      m_column(GetInteger<uint64_t>(obj, "column")
-                   .value_or(LLDB_INVALID_COLUMN_NUMBER)) {}
+SourceBreakpoint::SourceBreakpoint(DAP &dap,
+                                   const protocol::SourceBreakpoint &breakpoint)
+    : Breakpoint(dap, breakpoint.condition, breakpoint.hitCondition),
+      m_log_message(breakpoint.logMessage.value_or("")),
+      m_line(breakpoint.line),
+      m_column(breakpoint.column.value_or(LLDB_INVALID_COLUMN_NUMBER)) {}
 
 void SourceBreakpoint::SetBreakpoint(const llvm::StringRef source_path) {
   lldb::SBMutex lock = m_dap.GetAPIMutex();