fix(linter/plugins): handle error from destroyWorkspace

Author: overlookmotel

apps/oxlint/src/js_plugins/external_linter.rs

@@ -326,8 +326,41 @@ fn wrap_create_workspace(cb: JsCreateWorkspaceCb) -> ExternalLinterCreateWorkspa
 }
 
 /// Wrap `destroyWorkspace` JS callback as a normal Rust function.
+///
+/// The JS-side `destroyWorkspace` function is synchronous, but it's wrapped in a `ThreadsafeFunction`,
+/// so cannot be called synchronously. Use an `mpsc::channel` to wait for the result from JS side,
+/// and block current thread until `destroyWorkspace` completes execution.
 fn wrap_destroy_workspace(cb: JsDestroyWorkspaceCb) -> ExternalLinterDestroyWorkspaceCb {
     Arc::new(Box::new(move |workspace_uri| {
-        let _ = cb.call(workspace_uri, ThreadsafeFunctionCallMode::NonBlocking);
+        let (tx, rx) = channel();
+
+        // Send data to JS
+        let status = cb.call_with_return_value(
+            workspace_uri,
+            ThreadsafeFunctionCallMode::NonBlocking,
+            move |result, _env| {
+                // This call cannot fail, because `rx.recv()` below blocks until it receives a message.
+                // This closure is a `FnOnce`, so it can't be called more than once, so only 1 message can be sent.
+                // Therefore, `rx` cannot be dropped before this call.
+                let res = tx.send(result);
+                debug_assert!(res.is_ok(), "Failed to send result of `destroyWorkspace`");
+                Ok(())
+            },
+        );
+
+        if status == Status::Ok {
+            match rx.recv() {
+                // Destroying workspace succeeded
+                Ok(Ok(())) => Ok(()),
+                // `destroyWorkspace` threw an error
+                Ok(Err(err)) => Err(format!("`destroyWorkspace` threw an error: {err}")),
+                // Sender "hung up" - should be impossible because closure passed to `call_with_return_value`
+                // takes ownership of the sender `tx`. Unless NAPI-RS drops the closure without calling it,
+                // `tx.send()` always happens before `tx` is dropped.
+                Err(err) => Err(format!("`destroyWorkspace` did not respond: {err}")),
+            }
+        } else {
+            Err(format!("Failed to schedule `destroyWorkspace` callback: {status:?}"))
+        }
     }))
 }

apps/oxlint/src/lsp/server_linter.rs

@@ -301,7 +301,11 @@ impl ToolBuilder for ServerLinterBuilder {
     fn shutdown(&self, root_uri: &Uri) {
         // Destroy JS workspace
         if let Some(external_linter) = &self.external_linter {
-            (external_linter.destroy_workspace)(root_uri.as_str().to_string());
+            let res = (external_linter.destroy_workspace)(root_uri.as_str().to_string());
+
+            if let Err(err) = res {
+                error!("Failed to destroy JS workspace:\n{err}\n");
+            }
         }
     }
 }

crates/oxc_linter/src/external_linter.rs

@@ -12,7 +12,8 @@ use crate::{
 pub type ExternalLinterCreateWorkspaceCb =
     Arc<Box<dyn Fn(String) -> Result<(), String> + Send + Sync>>;
 
-pub type ExternalLinterDestroyWorkspaceCb = Arc<Box<dyn Fn(String) + Send + Sync>>;
+pub type ExternalLinterDestroyWorkspaceCb =
+    Arc<Box<dyn Fn(String) -> Result<(), String> + Send + Sync>>;
 
 pub type ExternalLinterLoadPluginCb = Arc<
     Box<