restore exception breakpoints

Author: eronnen

lldb/tools/lldb-dap/Handler/RequestHandler.h

@@ -353,18 +353,14 @@ class SetBreakpointsRequestHandler
   Run(const protocol::SetBreakpointsArguments &args) const override;
 };
 
-class SetExceptionBreakpointsRequestHandler
-    : public RequestHandler<
-          protocol::SetExceptionBreakpointsArguments,
-          llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>> {
+class SetExceptionBreakpointsRequestHandler : public LegacyRequestHandler {
 public:
-  using RequestHandler::RequestHandler;
+  using LegacyRequestHandler::LegacyRequestHandler;
   static llvm::StringLiteral GetCommand() { return "setExceptionBreakpoints"; }
   FeatureSet GetSupportedFeatures() const override {
     return {protocol::eAdapterFeatureExceptionOptions};
   }
-  llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>
-  Run(const protocol::SetExceptionBreakpointsArguments &args) const override;
+  void operator()(const llvm::json::Object &request) const override;
 };
 
 class SetFunctionBreakpointsRequestHandler

lldb/tools/lldb-dap/Handler/SetExceptionBreakpointsRequestHandler.cpp

@@ -14,41 +14,80 @@
 
 namespace lldb_dap {
 
-/// The request configures the debugger’s response to thrown exceptions. Each of
-/// the `filters`, `filterOptions`, and `exceptionOptions` in the request are
-/// independent configurations to a debug adapter indicating a kind of exception
-/// to catch. An exception thrown in a program should result in a stopped event
-/// from the debug adapter (with reason exception) if any of the configured
-/// filters match. Clients should only call this request if the corresponding
-/// capability exceptionBreakpointFilters returns one or more filters.
-llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>
-SetExceptionBreakpointsRequestHandler::Run(
-    const protocol::SetExceptionBreakpointsArguments &args) const {
-  std::vector<protocol::Breakpoint> response_breakpoints;
+// "SetExceptionBreakpointsRequest": {
+//   "allOf": [ { "$ref": "#/definitions/Request" }, {
+//     "type": "object",
+//     "description": "SetExceptionBreakpoints request; value of command field
+//     is 'setExceptionBreakpoints'. The request configures the debuggers
+//     response to thrown exceptions. If an exception is configured to break, a
+//     StoppedEvent is fired (event type 'exception').", "properties": {
+//       "command": {
+//         "type": "string",
+//         "enum": [ "setExceptionBreakpoints" ]
+//       },
+//       "arguments": {
+//         "$ref": "#/definitions/SetExceptionBreakpointsArguments"
+//       }
+//     },
+//     "required": [ "command", "arguments"  ]
+//   }]
+// },
+// "SetExceptionBreakpointsArguments": {
+//   "type": "object",
+//   "description": "Arguments for 'setExceptionBreakpoints' request.",
+//   "properties": {
+//     "filters": {
+//       "type": "array",
+//       "items": {
+//         "type": "string"
+//       },
+//       "description": "IDs of checked exception options. The set of IDs is
+//       returned via the 'exceptionBreakpointFilters' capability."
+//     },
+//     "exceptionOptions": {
+//       "type": "array",
+//       "items": {
+//         "$ref": "#/definitions/ExceptionOptions"
+//       },
+//       "description": "Configuration options for selected exceptions."
+//     }
+//   },
+//   "required": [ "filters" ]
+// },
+// "SetExceptionBreakpointsResponse": {
+//   "allOf": [ { "$ref": "#/definitions/Response" }, {
+//     "type": "object",
+//     "description": "Response to 'setExceptionBreakpoints' request. This is
+//     just an acknowledgement, so no body field is required."
+//   }]
+// }
+void SetExceptionBreakpointsRequestHandler::operator()(
+    const llvm::json::Object &request) const {
+  llvm::json::Object response;
+  lldb::SBError error;
+  FillResponse(request, response);
+  const auto *arguments = request.getObject("arguments");
+  const auto *filters = arguments->getArray("filters");
   // Keep a list of any exception breakpoint filter names that weren't set
   // so we can clear any exception breakpoints if needed.
   std::set<llvm::StringRef> unset_filters;
   for (const auto &bp : *dap.exception_breakpoints)
     unset_filters.insert(bp.GetFilter());
 
-  for (const auto &value : args.filters) {
+  for (const auto &value : *filters) {
     const auto filter = GetAsString(value);
     auto *exc_bp = dap.GetExceptionBreakpoint(std::string(filter));
-    protocol::Breakpoint response_bp;
     if (exc_bp) {
       exc_bp->SetBreakpoint();
       unset_filters.erase(std::string(filter));
-      response_bp.verified = true;
     }
-    response_breakpoints.push_back(response_bp);
   }
   for (const auto &filter : unset_filters) {
     auto *exc_bp = dap.GetExceptionBreakpoint(filter);
     if (exc_bp)
       exc_bp->ClearBreakpoint();
   }
-
-  return protocol::SetExceptionBreakpointsResponseBody{response_breakpoints};
+  dap.SendJSON(llvm::json::Value(std::move(response)));
 }
 
 } // namespace lldb_dap

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

@@ -327,20 +327,6 @@ llvm::json::Value toJSON(const SetFunctionBreakpointsResponseBody &SFBR) {
   return result;
 }
 
-bool fromJSON(const llvm::json::Value &Params,
-              SetExceptionBreakpointsArguments &SEBA, llvm::json::Path P) {
-  json::ObjectMapper O(Params, P);
-  return O && O.map("filters", SEBA.filters) &&
-         O.map("filterOptions", SEBA.filterOptions) &&
-         O.map("exceptionOptions", SEBA.exceptionOptions);
-}
-
-llvm::json::Value toJSON(const SetExceptionBreakpointsResponseBody &SEBR) {
-  json::Object result;
-  result["breakpoints"] = SEBR.breakpoints;
-  return result;
-}
-
 bool fromJSON(const llvm::json::Value &Params,
               SetInstructionBreakpointsArguments &SIBA, llvm::json::Path P) {
   json::ObjectMapper O(Params, P);

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

@@ -426,54 +426,6 @@ struct SetFunctionBreakpointsResponseBody {
 };
 llvm::json::Value toJSON(const SetFunctionBreakpointsResponseBody &);
 
-/// Arguments for `setExceptionBreakpoints` request.
-struct SetExceptionBreakpointsArguments {
-  /// Set of exception filters specified by their ID. The set of all possible
-  /// exception filters is defined by the `exceptionBreakpointFilters`
-  /// capability. The `filter` and `filterOptions` sets are additive.
-  std::vector<std::string> filters;
-
-  /// Set of exception filters and their options. The set of all possible
-  /// exception filters is defined by the `exceptionBreakpointFilters`
-  /// capability. This attribute is only honored by a debug adapter if the
-  /// corresponding capability `supportsExceptionFilterOptions` is true. The
-  /// `filter` and `filterOptions` sets are additive.
-  std::optional<std::vector<ExceptionFilterOptions>> filterOptions;
-
-  /// Configuration options for selected exceptions.
-  /// The attribute is only honored by a debug adapter if the corresponding
-  /// capability `supportsExceptionOptions` is true.
-  std::optional<std::vector<ExceptionOptions>> exceptionOptions;
-};
-bool fromJSON(const llvm::json::Value &, SetExceptionBreakpointsArguments &,
-              llvm::json::Path);
-
-/// Response to `setExceptionBreakpoints` request.
-/// The response contains an array of Breakpoint objects with information about
-/// each exception breakpoint or filter. The Breakpoint objects are in the same
-/// order as the elements of the filters, filterOptions, exceptionOptions arrays
-/// given as arguments. If both filters and filterOptions are given, the
-/// returned array must start with filters information first, followed by
-/// filterOptions information.
-/// The verified property of a Breakpoint object signals whether the exception
-/// breakpoint or filter could be successfully created and whether the condition
-/// is valid. In case of an error the message property explains the problem. The
-/// id property can be used to introduce a unique ID for the exception
-/// breakpoint or filter so that it can be updated subsequently by sending
-/// breakpoint events. For backward compatibility both the breakpoints array and
-/// the enclosing body are optional. If these elements are missing a client is
-/// not able to show problems for individual exception breakpoints or filters.
-struct SetExceptionBreakpointsResponseBody {
-  /// Information about the exception breakpoints or filters.
-  /// The breakpoints returned are in the same order as the elements of the
-  /// `filters`, `filterOptions`, `exceptionOptions` arrays in the arguments.
-  /// If both `filters` and `filterOptions` are given, the returned array must
-  /// start with `filters` information first, followed by `filterOptions`
-  /// information.
-  std::vector<Breakpoint> breakpoints;
-};
-llvm::json::Value toJSON(const SetExceptionBreakpointsResponseBody &);
-
 /// Arguments for `setInstructionBreakpoints` request.
 struct SetInstructionBreakpointsArguments {
   /// The instruction references of the breakpoints.

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

@@ -315,47 +315,6 @@ json::Value toJSON(const Breakpoint &BP) {
   return result;
 }
 
-bool fromJSON(const llvm::json::Value &Params, ExceptionBreakMode &EBM,
-              llvm::json::Path P) {
-  auto rawMode = Params.getAsString();
-  if (!rawMode) {
-    P.report("expected a string");
-    return false;
-  }
-  std::optional<ExceptionBreakMode> mode =
-      StringSwitch<std::optional<ExceptionBreakMode>>(*rawMode)
-          .Case("never", eExceptionBreakModeNever)
-          .Case("always", eExceptionBreakModeAlways)
-          .Case("unhandled", eExceptionBreakModeUnhandled)
-          .Case("userUnhandled", eExceptionBreakModeUserUnhandled)
-          .Default(std::nullopt);
-  if (!mode) {
-    P.report("unexpected ExceptionBreakMode value");
-    return false;
-  }
-  EBM = *mode;
-  return true;
-}
-
-bool fromJSON(const llvm::json::Value &Params, ExceptionPathSegment &EPS,
-              llvm::json::Path P) {
-  json::ObjectMapper O(Params, P);
-  return O && O.map("negate", EPS.negate) && O.map("names", EPS.names);
-}
-
-bool fromJSON(const llvm::json::Value &Params, ExceptionOptions &EO,
-              llvm::json::Path P) {
-  json::ObjectMapper O(Params, P);
-  return O && O.map("path", EO.path) && O.map("breakMode", EO.breakMode);
-}
-
-bool fromJSON(const llvm::json::Value &Params, ExceptionFilterOptions &EFO,
-              llvm::json::Path P) {
-  json::ObjectMapper O(Params, P);
-  return O && O.map("filterId", EFO.filterId) &&
-         O.map("condition", EFO.condition) && O.map("mode", EFO.mode);
-}
-
 bool fromJSON(const llvm::json::Value &Params, SourceBreakpoint &SB,
               llvm::json::Path P) {
   json::ObjectMapper O(Params, P);

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

@@ -503,67 +503,6 @@ 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.
-struct ExceptionFilterOptions {
-  /// ID of an exception filter returned by the `exceptionBreakpointFilters`
-  /// capability.
-  std::string filterId;
-
-  /// An expression for conditional exceptions.
-  /// The exception breaks into the debugger if the result of the condition is
-  /// true.
-  std::optional<std::string> condition;
-
-  /// The mode of this exception breakpoint. If defined, this must be one of the
-  /// `breakpointModes` the debug adapter advertised in its `Capabilities`.
-  std::optional<std::string> mode;
-};
-bool fromJSON(const llvm::json::Value &, ExceptionFilterOptions &,
-              llvm::json::Path);
-
-/// This enumeration defines all possible conditions when a thrown exception
-/// should result in a break.
-enum ExceptionBreakMode : unsigned {
-  /// Never breaks.
-  eExceptionBreakModeNever,
-  /// Always breaks.
-  eExceptionBreakModeAlways,
-  /// Breaks when the exception is unhandled.
-  eExceptionBreakModeUnhandled,
-  /// Breaks if the exception is not handled by user code.
-  eExceptionBreakModeUserUnhandled
-};
-bool fromJSON(const llvm::json::Value &, ExceptionBreakMode &,
-              llvm::json::Path);
-
-/// An ExceptionPathSegment represents a segment in a path that is used to
-/// match leafs or nodes in a tree of exceptions.
-struct ExceptionPathSegment {
-  /// If false or missing, this segment matches the names provided. Otherwise,
-  /// it matches anything except the names provided.
-  std::optional<bool> negate;
-
-  /// Depending on the value of `negate`, the names that should match or not
-  /// match.
-  std::vector<std::string> names;
-};
-bool fromJSON(const llvm::json::Value &, ExceptionPathSegment &,
-              llvm::json::Path);
-
-/// ExceptionOptions assigns configuration options to a set of exceptions.
-struct ExceptionOptions {
-  /// A path that selects a single or multiple exceptions in a tree. If `path`
-  /// is missing, the whole tree is selected.
-  /// By convention, the first segment of the path is a category that is used
-  /// to group exceptions in the UI.
-  std::optional<std::vector<ExceptionPathSegment>> path;
-
-  /// Condition when a thrown exception should result in a break.
-  ExceptionBreakMode breakMode;
-};
-bool fromJSON(const llvm::json::Value &, ExceptionOptions &, llvm::json::Path);
-
 } // namespace lldb_dap::protocol
 
 #endif