return exception breakpoints list

Author: eronnen

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

@@ -354,15 +354,16 @@ class SetBreakpointsRequestHandler
 };
 
 class SetExceptionBreakpointsRequestHandler
-    : public RequestHandler<protocol::SetExceptionBreakpointsArguments,
-                            protocol::SetExceptionBreakpointsResponseBody> {
+    : public RequestHandler<
+          protocol::SetExceptionBreakpointsArguments,
+          llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>> {
 public:
   using RequestHandler::RequestHandler;
   static llvm::StringLiteral GetCommand() { return "setExceptionBreakpoints"; }
   FeatureSet GetSupportedFeatures() const override {
     return {protocol::eAdapterFeatureExceptionOptions};
   }
-  protocol::SetExceptionBreakpointsResponseBody
+  llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>
   Run(const protocol::SetExceptionBreakpointsArguments &args) const override;
 };
 

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

@@ -21,8 +21,10 @@ namespace lldb_dap {
 /// 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::Error SetExceptionBreakpointsRequestHandler::Run(
+llvm::Expected<protocol::SetExceptionBreakpointsResponseBody>
+SetExceptionBreakpointsRequestHandler::Run(
     const protocol::SetExceptionBreakpointsArguments &args) const {
+  std::vector<protocol::Breakpoint> response_breakpoints;
   // 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;
@@ -32,18 +34,21 @@ llvm::Error SetExceptionBreakpointsRequestHandler::Run(
   for (const auto &value : args.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 llvm::Error::success();
+  return protocol::SetExceptionBreakpointsResponseBody{response_breakpoints};
 }
 
 } // namespace lldb_dap

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

@@ -335,6 +335,12 @@ bool fromJSON(const llvm::json::Value &Params,
          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

@@ -448,9 +448,31 @@ struct SetExceptionBreakpointsArguments {
 bool fromJSON(const llvm::json::Value &, SetExceptionBreakpointsArguments &,
               llvm::json::Path);
 
-/// Response to `setExceptionBreakpoints` request can be empty, for backwards
-/// compatability with older client.
-using SetExceptionBreakpointsResponseBody = VoidResponse;
+/// 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 {