jobs: allow callbacks to return followup jobs

This introduces `Callback::Followup` that can optionally return
another job to be queued after the callback finishes.
This allows creation of async operation chains where the editor state
needs to be queried in between async operations, without needing
blocking operations.

Needed for features like running multiple LSP code actions in order,
where each action must operate on the latest document state after the
previous action completes.

Author: junglerobba

helix-term/src/application.rs

@@ -339,7 +339,9 @@ impl Application {
                     self.handle_terminal_events(event).await;
                 }
                 Some(callback) = self.jobs.callbacks.recv() => {
-                    self.jobs.handle_callback(&mut self.editor, &mut self.compositor, Ok(Some(callback)));
+                    if let Some(job) = self.jobs.handle_callback(&mut self.editor, &mut self.compositor, Ok(Some(callback))) {
+                        self.jobs.add(job);
+                    }
                     self.render().await;
                 }
                 Some(msg) = self.jobs.status_messages.recv() => {

helix-term/src/job.rs

@@ -11,6 +11,7 @@ use tokio::sync::mpsc::{channel, Receiver, Sender};
 
 pub type EditorCompositorCallback = Box<dyn FnOnce(&mut Editor, &mut Compositor) + Send>;
 pub type EditorCallback = Box<dyn FnOnce(&mut Editor) + Send>;
+pub type EditorCallbackFollowup = Box<dyn FnOnce(&mut Editor) -> Option<Job> + Send>;
 
 runtime_local! {
     static JOB_QUEUE: OnceCell<Sender<Callback>> = OnceCell::new();
@@ -35,6 +36,7 @@ pub fn dispatch_blocking(job: impl FnOnce(&mut Editor, &mut Compositor) + Send +
 pub enum Callback {
     EditorCompositor(EditorCompositorCallback),
     Editor(EditorCallback),
+    Followup(EditorCallbackFollowup),
 }
 
 pub type JobFuture = BoxFuture<'static, anyhow::Result<Option<Callback>>>;
@@ -104,15 +106,23 @@ impl Jobs {
         editor: &mut Editor,
         compositor: &mut Compositor,
         call: anyhow::Result<Option<Callback>>,
-    ) {
+    ) -> Option<Job> {
         match call {
-            Ok(None) => {}
+            Ok(None) => None,
             Ok(Some(call)) => match call {
-                Callback::EditorCompositor(call) => call(editor, compositor),
-                Callback::Editor(call) => call(editor),
+                Callback::EditorCompositor(call) => {
+                    call(editor, compositor);
+                    None
+                }
+                Callback::Editor(call) => {
+                    call(editor);
+                    None
+                }
+                Callback::Followup(call) => call(editor),
             },
             Err(e) => {
                 editor.set_error(format!("Async job failed: {}", e));
+                None
             }
         }
     }
@@ -148,14 +158,23 @@ impl Jobs {
                     if let Some(callback) = callback {
                         // clippy doesn't realize this is an error without the derefs
                         #[allow(clippy::needless_option_as_deref)]
-                        match callback {
+                        if let Some(job) = match callback {
                             Callback::EditorCompositor(call) if compositor.is_some() => {
-                                call(editor, compositor.as_deref_mut().unwrap())
+                                call(editor, compositor.as_deref_mut().unwrap());
+                                None
                             }
-                            Callback::Editor(call) => call(editor),
+                            Callback::Editor(call) => {
+                                call(editor);
+                                None
+                            }
+                            Callback::Followup(call) => call(editor),
 
                             // skip callbacks for which we don't have the necessary references
-                            _ => (),
+                            _ => None,
+                        } {
+                            if job.wait {
+                                self.wait_futures.push(job.future);
+                            }
                         }
                     }
                 }