draft(oxlnt/lsp): support jsPlugins

Sysix · Sysix · commit 4813d868b705 · 2025-11-18T15:23:18.000+01:00
diff --git a/.vscode/settings.json b/.vscode/settings.json
@@ -0,0 +1,3 @@
+{
+  "oxc.path.server": "./apps/oxlint/dist/cli.js"
+}
diff --git a/apps/oxlint/src/js_plugins/external_linter.rs b/apps/oxlint/src/js_plugins/external_linter.rs
@@ -1,4 +1,4 @@
-use std::sync::{atomic::Ordering, mpsc::channel};
+use std::sync::{Arc, atomic::Ordering, mpsc::channel};
 
 use napi::{
     Status,
@@ -36,7 +36,7 @@ pub fn create_external_linter(
 ///
 /// The returned function will panic if called outside of a Tokio runtime.
 fn wrap_load_plugin(cb: JsLoadPluginCb) -> ExternalLinterLoadPluginCb {
-    Box::new(move |plugin_path, package_name| {
+    Arc::new(Box::new(move |plugin_path, package_name| {
         let cb = &cb;
         tokio::task::block_in_place(|| {
             tokio::runtime::Handle::current().block_on(async move {
@@ -49,7 +49,7 @@ fn wrap_load_plugin(cb: JsLoadPluginCb) -> ExternalLinterLoadPluginCb {
                 Ok(plugin_load_result)
             })
         })
-    })
+    }))
 }
 
 /// Result returned by `lintFile` JS callback.
@@ -69,7 +69,7 @@ pub enum LintFileReturnValue {
 /// Use an `mpsc::channel` to wait for the result from JS side, and block current thread until `lintFile`
 /// completes execution.
 fn wrap_lint_file(cb: JsLintFileCb) -> ExternalLinterLintFileCb {
-    Box::new(
+    Arc::new(Box::new(
         move |file_path: String,
               rule_ids: Vec<u32>,
               settings_json: String,
@@ -115,7 +115,7 @@ fn wrap_lint_file(cb: JsLintFileCb) -> ExternalLinterLintFileCb {
                 Err(err) => panic!("Callback did not respond: {err}"),
             }
         },
-    )
+    ))
 }
 
 /// Get buffer ID of the `Allocator` and, if it hasn't already been sent to JS,
diff --git a/apps/oxlint/src/lsp.rs b/apps/oxlint/src/lsp.rs
@@ -1,4 +1,7 @@
 /// Run the language server
-pub async fn run_lsp() {
-    oxc_language_server::run_server(vec![Box::new(oxc_language_server::ServerLinterBuilder)]).await;
+pub async fn run_lsp(external_linter: Option<oxc_linter::ExternalLinter>) {
+    oxc_language_server::run_server(vec![Box::new(oxc_language_server::ServerLinterBuilder::new(
+        external_linter,
+    ))])
+    .await;
 }
diff --git a/apps/oxlint/src/main.rs b/apps/oxlint/src/main.rs
@@ -9,7 +9,7 @@ async fn main() -> CliRunResult {
 
     // If --lsp flag is set, run the language server
     if command.lsp {
-        run_lsp().await;
+        run_lsp(None).await;
         return CliRunResult::LintSucceeded;
     }
 
diff --git a/apps/oxlint/src/run.rs b/apps/oxlint/src/run.rs
@@ -91,9 +91,18 @@ async fn lint_impl(
         }
     };
 
+    // JS plugins are only supported on 64-bit little-endian platforms at present
+    #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
+    let external_linter = Some(super::js_plugins::create_external_linter(load_plugin, lint_file));
+    #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
+    let external_linter = {
+        let (_, _) = (load_plugin, lint_file);
+        None
+    };
+
     // If --lsp flag is set, run the language server
     if command.lsp {
-        crate::lsp::run_lsp().await;
+        crate::lsp::run_lsp(external_linter).await;
         return CliRunResult::LintSucceeded;
     }
 
@@ -102,15 +111,6 @@ async fn lint_impl(
 
     command.handle_threads();
 
-    // JS plugins are only supported on 64-bit little-endian platforms at present
-    #[cfg(all(target_pointer_width = "64", target_endian = "little"))]
-    let external_linter = Some(super::js_plugins::create_external_linter(load_plugin, lint_file));
-    #[cfg(not(all(target_pointer_width = "64", target_endian = "little")))]
-    let external_linter = {
-        let (_, _) = (load_plugin, lint_file);
-        None
-    };
-
     // stdio is blocked by LineWriter, use a BufWriter to reduce syscalls.
     // See `https://github.com/rust-lang/rust/issues/60673`.
     let mut stdout = BufWriter::new(std::io::stdout());
diff --git a/crates/oxc_language_server/src/linter/isolated_lint_handler.rs b/crates/oxc_language_server/src/linter/isolated_lint_handler.rs
@@ -10,9 +10,9 @@ use tower_lsp_server::{UriExt, lsp_types::Uri};
 
 use oxc_allocator::Allocator;
 use oxc_linter::{
-    AllowWarnDeny, ConfigStore, DisableDirectives, Fix, FixKind, LINTABLE_EXTENSIONS, LintOptions,
-    LintRunner, LintRunnerBuilder, LintServiceOptions, Linter, Message, PossibleFixes,
-    RuleCommentType, RuntimeFileSystem, read_to_arena_str, read_to_string,
+    AllowWarnDeny, ConfigStore, DisableDirectives, ExternalLinter, Fix, FixKind,
+    LINTABLE_EXTENSIONS, LintOptions, LintRunner, LintRunnerBuilder, LintServiceOptions, Linter,
+    Message, PossibleFixes, RuleCommentType, RuntimeFileSystem, read_to_arena_str, read_to_string,
 };
 
 use super::error_with_position::{
@@ -67,11 +67,12 @@ impl IsolatedLintHandler {
     pub fn new(
         lint_options: LintOptions,
         config_store: ConfigStore,
+        external_linter: Option<ExternalLinter>,
         options: &IsolatedLintHandlerOptions,
     ) -> Self {
         let config_store_clone = config_store.clone();
 
-        let linter = Linter::new(lint_options, config_store, None);
+        let linter = Linter::new(lint_options, config_store, external_linter);
         let mut lint_service_options = LintServiceOptions::new(options.root_path.clone())
             .with_cross_module(options.use_cross_module);
 
@@ -121,6 +122,7 @@ impl IsolatedLintHandler {
         debug!("lint {}", path.display());
         let rope = &Rope::from_str(source_text);
 
+        // ToDO: with external linter, we need a new FS (raw) system
         let fs = IsolatedLintHandlerFileSystem::new(path.to_path_buf(), Arc::from(source_text));
 
         let mut messages: Vec<DiagnosticReport> = self
diff --git a/crates/oxc_language_server/src/linter/server_linter.rs b/crates/oxc_language_server/src/linter/server_linter.rs
@@ -14,8 +14,8 @@ use tower_lsp_server::{
 };
 
 use oxc_linter::{
-    AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, ExternalPluginStore, FixKind,
-    LintIgnoreMatcher, LintOptions, Oxlintrc,
+    AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, ExternalLinter, ExternalPluginStore,
+    FixKind, LintIgnoreMatcher, LintOptions, Oxlintrc,
 };
 
 use crate::{
@@ -36,12 +36,17 @@ use crate::{
     utils::normalize_path,
 };
 
-pub struct ServerLinterBuilder;
+pub struct ServerLinterBuilder {
+    external_linter: Option<ExternalLinter>,
+}
 
 impl ServerLinterBuilder {
+    pub const fn new(external_linter: Option<ExternalLinter>) -> Self {
+        Self { external_linter }
+    }
     /// # Panics
     /// Panics if the root URI cannot be converted to a file path.
-    pub fn build(root_uri: &Uri, options: serde_json::Value) -> ServerLinter {
+    pub fn build(&self, root_uri: &Uri, options: serde_json::Value) -> ServerLinter {
         let options = match serde_json::from_value::<LSPLintOptions>(options) {
             Ok(opts) => opts,
             Err(e) => {
@@ -52,9 +57,18 @@ impl ServerLinterBuilder {
             }
         };
         let root_path = root_uri.to_file_path().unwrap();
+        let mut external_plugin_store = ExternalPluginStore::default();
+
+        let mut external_linter = self.external_linter.as_ref();
         let mut nested_ignore_patterns = Vec::new();
-        let (nested_configs, mut extended_paths) =
-            Self::create_nested_configs(&root_path, &options, &mut nested_ignore_patterns);
+        let (nested_configs, mut extended_paths) = Self::create_nested_configs(
+            &root_path,
+            &options,
+            external_linter,
+            &mut external_plugin_store,
+            &mut nested_ignore_patterns,
+        );
+
         let config_path = options.config_path.as_ref().map_or(LINT_CONFIG_FILE, |v| v);
         let config = normalize_path(root_path.join(config_path));
         let oxlintrc = if config.try_exists().is_ok_and(|exists| exists) {
@@ -73,11 +87,13 @@ impl ServerLinterBuilder {
         };
 
         let base_patterns = oxlintrc.ignore_patterns.clone();
-
-        let mut external_plugin_store = ExternalPluginStore::new(false);
-        let config_builder =
-            ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, None, &mut external_plugin_store)
-                .unwrap_or_default();
+        let config_builder = ConfigStoreBuilder::from_oxlintrc(
+            false,
+            oxlintrc,
+            external_linter,
+            &mut external_plugin_store,
+        )
+        .unwrap_or_default();
 
         // TODO(refactor): pull this into a shared function, because in oxlint we have the same functionality.
         let use_nested_config = options.use_nested_configs();
@@ -90,9 +106,14 @@ impl ServerLinterBuilder {
         extended_paths.extend(config_builder.extended_paths.clone());
         let base_config = config_builder.build(&external_plugin_store).unwrap_or_else(|err| {
             warn!("Failed to build config: {err}");
-            ConfigStoreBuilder::empty().build(&external_plugin_store).unwrap()
+            ConfigStoreBuilder::empty().build(&ExternalPluginStore::new(false)).unwrap()
         });
 
+        // If no external rules, discard `ExternalLinter`
+        if external_plugin_store.is_empty() {
+            external_linter = None;
+        }
+
         let lint_options = LintOptions {
             fix: fix_kind,
             report_unused_directive: match options.unused_disable_directives {
@@ -119,6 +140,7 @@ impl ServerLinterBuilder {
         let isolated_linter = IsolatedLintHandler::new(
             lint_options,
             config_store,
+            external_linter.cloned(),
             &IsolatedLintHandlerOptions {
                 use_cross_module,
                 type_aware: options.type_aware,
@@ -150,7 +172,7 @@ impl ToolBuilder for ServerLinterBuilder {
         vec![FIX_ALL_COMMAND_ID.to_string()]
     }
     fn build_boxed(&self, root_uri: &Uri, options: serde_json::Value) -> Box<dyn Tool> {
-        Box::new(ServerLinterBuilder::build(root_uri, options))
+        Box::new(self.build(root_uri, options))
     }
 }
 
@@ -160,6 +182,8 @@ impl ServerLinterBuilder {
     fn create_nested_configs(
         root_path: &Path,
         options: &LSPLintOptions,
+        external_linter: Option<&ExternalLinter>,
+        external_plugin_store: &mut ExternalPluginStore,
         nested_ignore_patterns: &mut Vec<(Vec<String>, PathBuf)>,
     ) -> (ConcurrentHashMap<PathBuf, Config>, FxHashSet<PathBuf>) {
         let mut extended_paths = FxHashSet::default();
@@ -184,20 +208,29 @@ impl ServerLinterBuilder {
             };
             // Collect ignore patterns and their root
             nested_ignore_patterns.push((oxlintrc.ignore_patterns.clone(), dir_path.to_path_buf()));
-            let mut external_plugin_store = ExternalPluginStore::new(false);
-            let Ok(config_store_builder) = ConfigStoreBuilder::from_oxlintrc(
+
+            let Ok(config_store_builder) = (match ConfigStoreBuilder::from_oxlintrc(
                 false,
                 oxlintrc,
-                None,
-                &mut external_plugin_store,
-            ) else {
-                warn!("Skipping config (builder failed): {}", file_path.display());
+                external_linter,
+                external_plugin_store,
+            ) {
+                Ok(builder) => Ok(builder),
+                Err(err) => {
+                    warn!(
+                        "Failed to create ConfigStoreBuilder for {}: {:?}",
+                        dir_path.display(),
+                        err
+                    );
+                    Err(err)
+                }
+            }) else {
                 continue;
             };
             extended_paths.extend(config_store_builder.extended_paths.clone());
-            let config = config_store_builder.build(&external_plugin_store).unwrap_or_else(|err| {
+            let config = config_store_builder.build(external_plugin_store).unwrap_or_else(|err| {
                 warn!("Failed to build nested config for {}: {:?}", dir_path.display(), err);
-                ConfigStoreBuilder::empty().build(&external_plugin_store).unwrap()
+                ConfigStoreBuilder::empty().build(&ExternalPluginStore::new(false)).unwrap()
             });
             nested_configs.pin().insert(dir_path.to_path_buf(), config);
         }
@@ -299,7 +332,8 @@ impl Tool for ServerLinter {
 
         // get the cached files before refreshing the linter, and revalidate them after
         let cached_files = self.get_cached_files_of_diagnostics();
-        let new_linter = ServerLinterBuilder::build(root_uri, new_options_json.clone());
+        // TODO: external linter should also be passed here
+        let new_linter = ServerLinterBuilder::new(None).build(root_uri, new_options_json.clone());
         let diagnostics = Some(new_linter.revalidate_diagnostics(cached_files));
 
         let patterns = {
@@ -353,7 +387,8 @@ impl Tool for ServerLinter {
         options: serde_json::Value,
     ) -> ToolRestartChanges {
         // TODO: Check if the changed file is actually a config file (including extended paths)
-        let new_linter = ServerLinterBuilder::build(root_uri, options);
+        // TODO: external linter should also be passed here
+        let new_linter = ServerLinterBuilder::new(None).build(root_uri, options);
 
         // get the cached files before refreshing the linter, and revalidate them after
         let cached_files = self.get_cached_files_of_diagnostics();
@@ -611,6 +646,7 @@ fn range_overlaps(a: Range, b: Range) -> bool {
 mod test {
     use std::path::{Path, PathBuf};
 
+    use oxc_linter::ExternalPluginStore;
     use serde_json::json;
 
     use crate::linter::{
@@ -622,9 +658,12 @@ mod test {
     #[test]
     fn test_create_nested_configs_with_disabled_nested_configs() {
         let mut nested_ignore_patterns = Vec::new();
+        let mut external_plugin_store = ExternalPluginStore::default();
         let (configs, _) = ServerLinterBuilder::create_nested_configs(
             Path::new("/root/"),
             &LintOptions { disable_nested_config: true, ..LintOptions::default() },
+            None,
+            &mut external_plugin_store,
             &mut nested_ignore_patterns,
         );
 
@@ -634,9 +673,13 @@ mod test {
     #[test]
     fn test_create_nested_configs() {
         let mut nested_ignore_patterns = Vec::new();
+        let mut external_plugin_store = ExternalPluginStore::default();
+
         let (configs, _) = ServerLinterBuilder::create_nested_configs(
             &get_file_path("fixtures/linter/init_nested_configs"),
             &LintOptions::default(),
+            None,
+            &mut external_plugin_store,
             &mut nested_ignore_patterns,
         );
         let configs = configs.pin();
diff --git a/crates/oxc_language_server/src/linter/tester.rs b/crates/oxc_language_server/src/linter/tester.rs
@@ -171,7 +171,7 @@ impl Tester<'_> {
             .join(self.relative_root_dir);
         let uri = Uri::from_file_path(absolute_path).expect("could not convert current dir to uri");
 
-        ServerLinterBuilder::build(&uri, self.options.clone())
+        ServerLinterBuilder::new(None).build(&uri, self.options.clone())
     }
 
     /// Given a relative file path (relative to `oxc_language_server` crate root), run the linter
diff --git a/crates/oxc_language_server/src/main.rs b/crates/oxc_language_server/src/main.rs
@@ -6,7 +6,7 @@ async fn main() {
         #[cfg(feature = "formatter")]
         v.push(Box::new(oxc_language_server::ServerFormatterBuilder));
         #[cfg(feature = "linter")]
-        v.push(Box::new(oxc_language_server::ServerLinterBuilder));
+        v.push(Box::new(oxc_language_server::ServerLinterBuilder::new(None)));
         v
     };
 
diff --git a/crates/oxc_language_server/src/worker.rs b/crates/oxc_language_server/src/worker.rs
@@ -441,7 +441,7 @@ mod test_watchers {
         ) -> WorkspaceWorker {
             let worker = WorkspaceWorker::new(absolute_path);
             let tools: Vec<Box<dyn ToolBuilder>> =
-                vec![Box::new(ServerLinterBuilder), Box::new(ServerFormatterBuilder)];
+                vec![Box::new(ServerLinterBuilder::new(None)), Box::new(ServerFormatterBuilder)];
 
             worker.start_worker(options, &tools).await;
 
diff --git a/crates/oxc_linter/src/external_linter.rs b/crates/oxc_linter/src/external_linter.rs
diff --git a/editors/vscode/client/PathValidator.ts b/editors/vscode/client/PathValidator.ts
diff --git a/editors/vscode/client/extension.ts b/editors/vscode/client/extension.ts

Original file line number	Diff line number	Diff line change
`@@ -0,0 +1,3 @@`
	`1`	`+{`
	`2`	`+ "oxc.path.server": "./apps/oxlint/dist/cli.js"`
	`3`	`+}`
Original file line number	Diff line number	Diff line change
`@@ -9,7 +9,7 @@ async fn main() -> CliRunResult {`
`9`	`9`
`10`	`10`	`// If --lsp flag is set, run the language server`
`11`	`11`	`if command.lsp {`
`12`		`- run_lsp().await;`
	`12`	`+ run_lsp(None).await;`
`13`	`13`	`return CliRunResult::LintSucceeded;`
`14`	`14`	`}`
`15`	`15`
Original file line number	Diff line number	Diff line change
`@@ -171,7 +171,7 @@ impl Tester<'_> {`
`171`	`171`	`.join(self.relative_root_dir);`
`172`	`172`	`let uri = Uri::from_file_path(absolute_path).expect("could not convert current dir to uri");`
`173`	`173`
`174`		`- ServerLinterBuilder::build(&uri, self.options.clone())`
	`174`	`+ ServerLinterBuilder::new(None).build(&uri, self.options.clone())`
`175`	`175`	`}`
`176`	`176`
`177`	`177`	/// Given a relative file path (relative to `oxc_language_server` crate root), run the linter
Original file line number	Diff line number	Diff line change
`@@ -6,7 +6,7 @@ async fn main() {`
`6`	`6`	`#[cfg(feature = "formatter")]`
`7`	`7`	`v.push(Box::new(oxc_language_server::ServerFormatterBuilder));`
`8`	`8`	`#[cfg(feature = "linter")]`
`9`		`- v.push(Box::new(oxc_language_server::ServerLinterBuilder));`
	`9`	`+ v.push(Box::new(oxc_language_server::ServerLinterBuilder::new(None)));`
`10`	`10`	`v`
`11`	`11`	`};`
`12`	`12`