Make thread_picker non-blocking

helix-dap/src/client.rs

@@ -209,7 +209,7 @@ impl Client {
     }
 
     /// Execute a RPC request on the debugger.
-    fn call<R: crate::types::Request>(
+    pub fn call<R: crate::types::Request>(
         &self,
         arguments: R::Arguments,
     ) -> impl Future<Output = Result<Value>>
@@ -248,7 +248,7 @@ impl Client {
         }
     }
 
-    async fn request<R: crate::types::Request>(&self, params: R::Arguments) -> Result<R::Result>
+    pub async fn request<R: crate::types::Request>(&self, params: R::Arguments) -> Result<R::Result>
     where
         R::Arguments: serde::Serialize,
         R::Result: core::fmt::Debug, // TODO: temporary
@@ -384,9 +384,8 @@ impl Client {
         Ok((response.stack_frames, response.total_frames))
     }
 
-    pub async fn threads(&self) -> Result<Vec<Thread>> {
+    pub fn threads(&self) -> impl Future<Output = Result<Value>> {
-        let response = self.request::<requests::Threads>(()).await?;
+        self.call::<requests::Threads>(())
-        Ok(response.threads)
     }
 
     pub async fn scopes(&self, frame_id: usize) -> Result<Vec<Scope>> {

helix-term/src/application.rs

@@ -340,8 +340,8 @@ impl Application {
                     let all_threads_stopped = all_threads_stopped.unwrap_or_default();
 
                     if all_threads_stopped {
-                        if let Ok(threads) = debugger.threads().await {
+                        if let Ok(response) = debugger.request::<dap::requests::Threads>(()).await {
-                            for thread in threads {
+                            for thread in response.threads {
                                 fetch_stack_trace(debugger, thread.id).await;
                             }
                             select_thread_id(

helix-term/src/commands/dap.rs

@@ -19,7 +19,7 @@ use std::collections::HashMap;
 use std::future::Future;
 use std::path::PathBuf;
 
-use anyhow::bail;
+use anyhow::{anyhow, bail};
 
 // general utils:
 pub fn dap_pos_to_pos(doc: &helix_core::Rope, line: usize, column: usize) -> Option<usize> {
@@ -99,25 +99,31 @@ pub fn jump_to_stack_frame(editor: &mut Editor, frame: &helix_dap::StackFrame) {
     align_view(doc, view, Align::Center);
 }
 
-fn thread_picker(cx: &mut Context, callback_fn: impl Fn(&mut Editor, &dap::Thread) + 'static) {
+fn thread_picker(
+    cx: &mut Context,
+    callback_fn: impl Fn(&mut Editor, &dap::Thread) + Send + 'static,
+) {
     let debugger = match &mut cx.editor.debugger {
         Some(debugger) => debugger,
         None => return,
     };
 
-    let threads = match block_on(debugger.threads()) {
+    let future = debugger.threads();
-        Ok(threads) => threads,
+    dap_callback(
-        Err(e) => {
+        cx.jobs,
-            cx.editor
+        future,
-                .set_error(format!("Failed to retrieve threads: {}", e));
+        move |editor: &mut Editor,
-            return;
+              compositor: &mut Compositor,
-        }
+              response: dap::requests::ThreadsResponse| {
-    };
+            let threads = response.threads;
-
             if threads.len() == 1 {
-        callback_fn(cx.editor, &threads[0]);
+                callback_fn(editor, &threads[0]);
                 return;
             }
+            let debugger = match &mut editor.debugger {
+                Some(debugger) => debugger,
+                None => return,
+            };
 
             let thread_states = debugger.thread_states.clone();
             let picker = FilePicker::new(
@@ -145,7 +151,9 @@ fn thread_picker(cx: &mut Context, callback_fn: impl Fn(&mut Editor, &dap::Threa
                     Some((path, pos))
                 },
             );
-    cx.push_layer(Box::new(picker))
+            compositor.push(Box::new(picker));
+        },
+    );
 }
 
 fn get_breakpoint_at_current_line(editor: &mut Editor) -> Option<(usize, Breakpoint)> {