draft(oxlnt/lsp): support jsPlugins

Author: Sysix

.vscode/settings.json

@@ -0,0 +1,3 @@
+{
+  "oxc.path.server": "./apps/oxlint/dist/cli.js"
+}

apps/oxlint/src-js/plugins/load.ts

@@ -127,15 +127,16 @@ export async function loadPlugin(path: string, packageName: string | null): Prom
  * @param path - Absolute path of plugin file
  * @param packageName - Optional package name from `package.json` (fallback if `plugin.meta.name` is not defined)
  * @returns - Plugin details
- * @throws {Error} If plugin has already been registered
  * @throws {Error} If plugin has no name
  * @throws {TypeError} If one of plugin's rules is malformed, or its `createOnce` method returns invalid visitor
  * @throws {TypeError} if `plugin.meta.name` is not a string
  * @throws {*} If plugin throws an error during import
  */
 async function loadPluginImpl(path: string, packageName: string | null): Promise<PluginDetails> {
+  // If plugin was already registered, unregister it first.
+  // This allows re-loading the plugin when the linter is restarted in `--lsp` mode.
   if (registeredPluginPaths.has(path)) {
-    throw new Error('This plugin has already been registered. This is a bug in Oxlint. Please report it.');
+    registeredPluginPaths.delete(path);
   }
 
   const { default: plugin } = (await import(pathToFileURL(path).href)) as { default: Plugin };

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,

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;
 }

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;
     }
 

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());

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

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::new(self.external_linter.is_some());
+
+        let mut external_linter = self.external_linter.clone();
         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.as_ref(),
+            &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.as_ref(),
+            &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.clone(),
             &IsolatedLintHandlerOptions {
                 use_cross_module,
                 type_aware: options.type_aware,
@@ -135,6 +157,7 @@ impl ServerLinterBuilder {
             options.run,
             root_path.to_path_buf(),
             isolated_linter,
+            external_linter,
             LintIgnoreMatcher::new(&base_patterns, &root_path, nested_ignore_patterns),
             Self::create_ignore_glob(&root_path),
             extended_paths,
@@ -150,7 +173,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 +183,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 +209,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);
         }
@@ -244,6 +278,7 @@ pub struct ServerLinter {
     run: Run,
     cwd: PathBuf,
     isolated_linter: IsolatedLintHandler,
+    external_linter: Option<ExternalLinter>,
     ignore_matcher: LintIgnoreMatcher,
     gitignore_glob: Vec<Gitignore>,
     extended_paths: FxHashSet<PathBuf>,
@@ -299,7 +334,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());
+        let new_linter = ServerLinterBuilder::new(self.external_linter.clone())
+            .build(root_uri, new_options_json.clone());
         let diagnostics = Some(new_linter.revalidate_diagnostics(cached_files));
 
         let patterns = {
@@ -353,7 +389,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);
+        let new_linter =
+            ServerLinterBuilder::new(self.external_linter.clone()).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();
@@ -508,6 +545,7 @@ impl ServerLinter {
         run: Run,
         cwd: PathBuf,
         isolated_linter: IsolatedLintHandler,
+        external_linter: Option<ExternalLinter>,
         ignore_matcher: LintIgnoreMatcher,
         gitignore_glob: Vec<Gitignore>,
         extended_paths: FxHashSet<PathBuf>,
@@ -516,6 +554,7 @@ impl ServerLinter {
             run,
             cwd,
             isolated_linter,
+            external_linter,
             ignore_matcher,
             gitignore_glob,
             extended_paths,
@@ -611,6 +650,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 +662,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 +677,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();