editor: support setExceptionBreakpoints

helix-dap/src/client.rs

@@ -399,4 +399,17 @@ impl Client {
 
         self.request::<requests::Evaluate>(args).await
     }
+
+    pub async fn set_exception_breakpoints(
+        &mut self,
+        filters: Vec<String>,
+    ) -> Result<Option<Vec<Breakpoint>>> {
+        let args = requests::SetExceptionBreakpointsArguments { filters };
+
+        let response = self
+            .request::<requests::SetExceptionBreakpoints>(args)
+            .await;
+
+        Ok(response.ok().map(|r| r.breakpoints).unwrap_or_default())
+    }
 }

helix-dap/src/types.rs

@@ -515,6 +515,29 @@ pub mod requests {
         type Result = EvaluateResponse;
         const COMMAND: &'static str = "evaluate";
     }
+
+    #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+    #[serde(rename_all = "camelCase")]
+    pub struct SetExceptionBreakpointsArguments {
+        pub filters: Vec<String>,
+        // pub filterOptions: Option<Vec<ExceptionFilterOptions>>, // needs capability
+        // pub exceptionOptions: Option<Vec<ExceptionOptions>>, // needs capability
+    }
+
+    #[derive(Debug, PartialEq, Clone, Deserialize, Serialize)]
+    #[serde(rename_all = "camelCase")]
+    pub struct SetExceptionBreakpointsResponse {
+        pub breakpoints: Option<Vec<Breakpoint>>,
+    }
+
+    #[derive(Debug)]
+    pub enum SetExceptionBreakpoints {}
+
+    impl Request for SetExceptionBreakpoints {
+        type Arguments = SetExceptionBreakpointsArguments;
+        type Result = SetExceptionBreakpointsResponse;
+        const COMMAND: &'static str = "setExceptionBreakpoints";
+    }
 }
 
 // Events