simpler solution (after asking for simplification)

Author: tdyas

src/rust/nailgun/src/server.rs

@@ -240,28 +240,26 @@ impl Nail for RawFdNail {
 
         // Spawn the underlying function as a blocking task, and capture its exit code to append to the
         // output stream.
-        let executor = self.executor.clone();
         let nail = self.clone();
-        let exit_code_join = executor.native_spawn_blocking(move || {
-            // NB: This closure captures the stdio handles, and will drop/close them when it completes.
-            (nail.runner)(RawFdExecution {
-                cmd,
-                cancelled,
-                stdin_fd: stdin_handle.as_raw_fd(),
-                stdout_fd: stdout_handle.as_raw_fd(),
-                stderr_fd: stderr_handle.as_raw_fd(),
-            })
-        });
-        let exit_code = async move {
-            match exit_code_join.await {
-                Ok(code) => code,
-                Err(e) => {
+        let exit_code = self
+            .executor
+            .spawn_blocking(
+                move || {
+                    // NB: This closure captures the stdio handles, and will drop/close them when it completes.
+                    (nail.runner)(RawFdExecution {
+                        cmd,
+                        cancelled,
+                        stdin_fd: stdin_handle.as_raw_fd(),
+                        stdout_fd: stdout_handle.as_raw_fd(),
+                        stderr_fd: stderr_handle.as_raw_fd(),
+                    })
+                },
+                |e| {
                     log::warn!("Server exited uncleanly: {e}");
                     ExitCode(1)
-                }
-            }
-        }
-        .boxed();
+                },
+            )
+            .boxed();
 
         // Select a single stdout/stderr stream.
         let stdout_stream = stdout_stream.map_ok(ChildOutput::Stdout);

src/rust/task_executor/src/lib.rs

@@ -187,9 +187,9 @@ impl Executor {
     pub fn spawn_blocking<F: FnOnce() -> R + Send + 'static, R: Send + 'static>(
         &self,
         f: F,
-        rescue_join_error: impl FnOnce(JoinError) -> R,
-    ) -> impl Future<Output = R> {
-        self.native_spawn_blocking(f).map(|res| match res {
+        rescue_join_error: impl FnOnce(JoinError) -> R + Send + 'static,
+    ) -> impl Future<Output = R> + Send + 'static {
+        self.native_spawn_blocking(f).map(move |res| match res {
             Ok(o) => o,
             Err(e) => rescue_join_error(e),
         })

src/rust/ui/src/instance/prodash.rs

@@ -99,14 +99,13 @@ impl ProdashInstance {
         // Drop all tasks to clear the Tree. The call to shutdown will render a final "Tick" with the
         // empty Tree, which will clear the screen.
         self.tasks_to_display.clear();
-        let executor = self.executor.clone();
-        let shutdown = executor.native_spawn_blocking(move || self.handle.shutdown_and_wait());
-        async move {
-            if let Err(e) = shutdown.await {
-                fatal_log!("Failed to teardown UI: {e}");
-            }
-        }
-        .boxed()
+        self.executor
+            .clone()
+            .spawn_blocking(
+                move || self.handle.shutdown_and_wait(),
+                |e| fatal_log!("Failed to teardown UI: {e}"),
+            )
+            .boxed()
     }
 
     pub fn render(&mut self, heavy_hitters: &HashMap<SpanId, (String, SystemTime)>) {