feat(linter): load custom JS plugins

Author: camc314

Cargo.lock

@@ -140,7 +140,7 @@ oxc_tasks_transform_checker = { path = "tasks/transform_checker" }
 oxlint = { path = "apps/oxlint" }
 
 # Relaxed version so the user can decide which version to use.
-napi = "3.0.0-beta"
+napi = { version = "3.0.0-beta", features = ["tokio_rt"] }
 napi-build = "2.2.1"
 napi-derive = "3.0.0-beta"
 
@@ -235,7 +235,13 @@ ureq = { version = "3.0.11", default-features = false }
 walkdir = "2.5.0"
 
 [workspace.metadata.cargo-shear]
-ignored = ["napi", "oxc_transform_napi", "oxc_parser_napi", "prettyplease", "lazy_static"]
+ignored = [
+  "napi",
+  "oxc_transform_napi",
+  "oxc_parser_napi",
+  "prettyplease",
+  "lazy_static",
+]
 
 [profile.dev]
 # Disabling debug info speeds up local and CI builds,

Cargo.toml

@@ -1,7 +1,7 @@
 use std::path::PathBuf;
 
 use bpaf::Bpaf;
-use oxc_linter::{AllowWarnDeny, FixKind, LintPlugins};
+use oxc_linter::{AllowWarnDeny, BuiltinLintPlugins, FixKind, LintPlugins};
 
 use crate::output_formatter::OutputFormat;
 
@@ -328,23 +328,25 @@ impl OverrideToggle {
 
 impl EnablePlugins {
     pub fn apply_overrides(&self, plugins: &mut LintPlugins) {
-        self.react_plugin.inspect(|yes| plugins.set(LintPlugins::REACT, yes));
-        self.unicorn_plugin.inspect(|yes| plugins.set(LintPlugins::UNICORN, yes));
-        self.oxc_plugin.inspect(|yes| plugins.set(LintPlugins::OXC, yes));
-        self.typescript_plugin.inspect(|yes| plugins.set(LintPlugins::TYPESCRIPT, yes));
-        self.import_plugin.inspect(|yes| plugins.set(LintPlugins::IMPORT, yes));
-        self.jsdoc_plugin.inspect(|yes| plugins.set(LintPlugins::JSDOC, yes));
-        self.jest_plugin.inspect(|yes| plugins.set(LintPlugins::JEST, yes));
-        self.vitest_plugin.inspect(|yes| plugins.set(LintPlugins::VITEST, yes));
-        self.jsx_a11y_plugin.inspect(|yes| plugins.set(LintPlugins::JSX_A11Y, yes));
-        self.nextjs_plugin.inspect(|yes| plugins.set(LintPlugins::NEXTJS, yes));
-        self.react_perf_plugin.inspect(|yes| plugins.set(LintPlugins::REACT_PERF, yes));
-        self.promise_plugin.inspect(|yes| plugins.set(LintPlugins::PROMISE, yes));
-        self.node_plugin.inspect(|yes| plugins.set(LintPlugins::NODE, yes));
+        self.react_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::REACT, yes));
+        self.unicorn_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::UNICORN, yes));
+        self.oxc_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::OXC, yes));
+        self.typescript_plugin
+            .inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::TYPESCRIPT, yes));
+        self.import_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::IMPORT, yes));
+        self.jsdoc_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::JSDOC, yes));
+        self.jest_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::JEST, yes));
+        self.vitest_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::VITEST, yes));
+        self.jsx_a11y_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::JSX_A11Y, yes));
+        self.nextjs_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::NEXTJS, yes));
+        self.react_perf_plugin
+            .inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::REACT_PERF, yes));
+        self.promise_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::PROMISE, yes));
+        self.node_plugin.inspect(|yes| plugins.builtin.set(BuiltinLintPlugins::NODE, yes));
 
         // Without this, jest plugins adapted to vitest will not be enabled.
         if self.vitest_plugin.is_enabled() && self.jest_plugin.is_not_set() {
-            plugins.set(LintPlugins::JEST, true);
+            plugins.builtin.set(BuiltinLintPlugins::JEST, true);
         }
     }
 }

apps/oxlint/src/command/lint.rs

@@ -10,14 +10,16 @@ pub mod cli {
     pub use crate::{command::*, lint::LintRunner, result::CliRunResult, runner::Runner};
 }
 
+pub use oxc_linter::{ExternalLinter, ExternalLinterCb, ExternalLinterLoadPluginCb};
+
 #[cfg(all(feature = "allocator", not(miri), not(target_family = "wasm")))]
 #[global_allocator]
 static GLOBAL: mimalloc_safe::MiMalloc = mimalloc_safe::MiMalloc;
 
 use cli::{CliRunResult, LintRunner, Runner};
 use std::{ffi::OsStr, io::BufWriter};
 
-pub fn lint() -> CliRunResult {
+pub fn lint(external_linter: Option<ExternalLinter>) -> CliRunResult {
     init_tracing();
     init_miette();
 
@@ -49,7 +51,7 @@ pub fn lint() -> CliRunResult {
     // See `https://github.com/rust-lang/rust/issues/60673`.
     let mut stdout = BufWriter::new(std::io::stdout());
 
-    LintRunner::new(command).run(&mut stdout)
+    LintRunner::new(command, external_linter).run(&mut stdout)
 }
 
 // Initialize the data which relies on `is_atty` system calls so they don't block subsequent threads.

apps/oxlint/src/lib.rs

@@ -13,8 +13,8 @@ use ignore::{gitignore::Gitignore, overrides::OverrideBuilder};
 use oxc_allocator::AllocatorPool;
 use oxc_diagnostics::{DiagnosticService, GraphicalReportHandler, OxcDiagnostic};
 use oxc_linter::{
-    AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, InvalidFilterKind, LintFilter,
-    LintOptions, LintService, LintServiceOptions, Linter, Oxlintrc,
+    AllowWarnDeny, Config, ConfigBuilderError, ConfigStore, ConfigStoreBuilder, ExternalLinter,
+    InvalidFilterKind, LintFilter, LintOptions, LintService, LintServiceOptions, Linter, Oxlintrc,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde_json::Value;
@@ -29,16 +29,22 @@ use crate::{
 pub struct LintRunner {
     options: LintCommand,
     cwd: PathBuf,
+    external_linter: Option<ExternalLinter>,
 }
 
 impl Runner for LintRunner {
     type Options = LintCommand;
 
-    fn new(options: Self::Options) -> Self {
-        Self { options, cwd: env::current_dir().expect("Failed to get current working directory") }
+    fn new(options: Self::Options, external_linter: Option<ExternalLinter>) -> Self {
+        Self {
+            options,
+            cwd: env::current_dir().expect("Failed to get current working directory"),
+            external_linter,
+        }
     }
 
     fn run(self, stdout: &mut dyn Write) -> CliRunResult {
+        println!("LintRunner::run");
         let format_str = self.options.output_options.format;
         let output_formatter = OutputFormatter::new(format_str);
 
@@ -59,10 +65,12 @@ impl Runner for LintRunner {
             enable_plugins,
             misc_options,
             disable_nested_config,
-            inline_config_options,
+            ref inline_config_options,
             ..
         } = self.options;
 
+        let external_linter = self.external_linter.as_ref();
+
         let search_for_nested_configs = !disable_nested_config &&
             // If the `--config` option is explicitly passed, we should not search for nested config files
             // as the passed config file takes absolute precedence.
@@ -173,7 +181,7 @@ impl Runner for LintRunner {
         let handler = GraphicalReportHandler::new();
 
         let nested_configs = if search_for_nested_configs {
-            match Self::get_nested_configs(stdout, &handler, &filters, &paths) {
+            match Self::get_nested_configs(stdout, &handler, &filters, &paths, external_linter) {
                 Ok(v) => v,
                 Err(v) => return v,
             }
@@ -192,20 +200,22 @@ impl Runner for LintRunner {
         } else {
             None
         };
-        let config_builder = match ConfigStoreBuilder::from_oxlintrc(false, oxlintrc) {
-            Ok(builder) => builder,
-            Err(e) => {
-                print_and_flush_stdout(
-                    stdout,
-                    &format!(
-                        "Failed to parse configuration file.\n{}\n",
-                        render_report(&handler, &OxcDiagnostic::error(e.to_string()))
-                    ),
-                );
-                return CliRunResult::InvalidOptionConfig;
+        let config_builder =
+            match ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, self.external_linter.as_ref())
+            {
+                Ok(builder) => builder,
+                Err(e) => {
+                    print_and_flush_stdout(
+                        stdout,
+                        &format!(
+                            "Failed to parse configuration file.\n{}\n",
+                            render_report(&handler, &OxcDiagnostic::error(e.to_string()))
+                        ),
+                    );
+                    return CliRunResult::InvalidOptionConfig;
+                }
             }
-        }
-        .with_filters(&filters);
+            .with_filters(&filters);
 
         if let Some(basic_config_file) = oxlintrc_for_print {
             let config_file = config_builder.resolve_final_config_file(basic_config_file);
@@ -387,7 +397,9 @@ impl LintRunner {
         handler: &GraphicalReportHandler,
         filters: &Vec<LintFilter>,
         paths: &Vec<Arc<OsStr>>,
+        external_linter: Option<&ExternalLinter>,
     ) -> Result<FxHashMap<PathBuf, Config>, CliRunResult> {
+        println!("LintRunner::get_nested_configs");
         // TODO(perf): benchmark whether or not it is worth it to store the configurations on a
         // per-file or per-directory basis, to avoid calling `.parent()` on every path.
         let mut nested_oxlintrc = FxHashMap::<&Path, Oxlintrc>::default();
@@ -417,14 +429,20 @@ impl LintRunner {
         // iterate over each config and build the ConfigStore
         for (dir, oxlintrc) in nested_oxlintrc {
             // TODO(refactor): clean up all of the error handling in this function
-            let builder = match ConfigStoreBuilder::from_oxlintrc(false, oxlintrc) {
+            let builder = match ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, external_linter)
+            {
                 Ok(builder) => builder,
                 Err(e) => {
+                    let err = if let ConfigBuilderError::OxcDiagnostic(e) = e {
+                        e
+                    } else {
+                        OxcDiagnostic::error(e.to_string())
+                    };
                     print_and_flush_stdout(
                         stdout,
                         &format!(
                             "Failed to parse configuration file.\n{}\n",
-                            render_report(handler, &OxcDiagnostic::error(e.to_string()))
+                            render_report(handler, &err)
                         ),
                     );
 
@@ -538,6 +556,7 @@ fn check_for_writer_error(error: std::io::Error) -> Result<(), std::io::Error> {
 }
 
 fn render_report(handler: &GraphicalReportHandler, diagnostic: &OxcDiagnostic) -> String {
+    dbg!(diagnostic);
     let mut err = String::new();
     handler.render_report(&mut err, diagnostic).unwrap();
     err

apps/oxlint/src/lint.rs

@@ -1,5 +1,5 @@
 use oxlint::{cli::CliRunResult, lint};
 
 fn main() -> CliRunResult {
-    lint()
+    lint(None)
 }

apps/oxlint/src/main.rs

@@ -1,12 +1,14 @@
 use std::io::Write;
 
+use oxc_linter::ExternalLinter;
+
 use crate::cli::CliRunResult;
 
 /// A trait for exposing functionality to the CLI.
 pub trait Runner {
     type Options;
 
-    fn new(matches: Self::Options) -> Self;
+    fn new(matches: Self::Options, external_linter: Option<ExternalLinter>) -> Self;
 
     /// Executes the runner, providing some result to the CLI.
     fn run(self, stdout: &mut dyn Write) -> CliRunResult;

apps/oxlint/src/runner.rs

@@ -37,7 +37,7 @@ impl Tester {
 
         let options = lint_command().run_inner(new_args.as_slice()).unwrap();
         let mut output = Vec::new();
-        let _ = LintRunner::new(options).with_cwd(self.cwd.clone()).run(&mut output);
+        let _ = LintRunner::new(options, None).with_cwd(self.cwd.clone()).run(&mut output);
     }
 
     pub fn test_and_snapshot(&self, args: &[&str]) {
@@ -59,7 +59,7 @@ impl Tester {
                 format!("working directory: {}\n", relative_dir.to_str().unwrap()).as_bytes(),
             );
             output.extend_from_slice(b"----------\n");
-            let result = LintRunner::new(options).with_cwd(self.cwd.clone()).run(&mut output);
+            let result = LintRunner::new(options, None).with_cwd(self.cwd.clone()).run(&mut output);
 
             output.extend_from_slice(b"----------\n");
             output.extend_from_slice(format!("CLI result: {result:?}\n").as_bytes());

apps/oxlint/src/tester.rs

@@ -54,7 +54,7 @@ impl ServerLinter {
 
         // clone because we are returning it for ignore builder
         let config_builder =
-            ConfigStoreBuilder::from_oxlintrc(false, oxlintrc.clone()).unwrap_or_default();
+            ConfigStoreBuilder::from_oxlintrc(false, oxlintrc.clone(), None).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();
@@ -131,7 +131,7 @@ impl ServerLinter {
                 warn!("Skipping invalid config file: {}", file_path.display());
                 continue;
             };
-            let Ok(config_store_builder) = ConfigStoreBuilder::from_oxlintrc(false, oxlintrc)
+            let Ok(config_store_builder) = ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, None)
             else {
                 warn!("Skipping config (builder failed): {}", file_path.display());
                 continue;

crates/oxc_language_server/src/linter/server_linter.rs

@@ -15,8 +15,12 @@ description.workspace = true
 
 [features]
 default = []
-ruledocs = ["oxc_macros/ruledocs"] # Enables the `ruledocs` feature for conditional compilation
-language_server = ["oxc_data_structures/rope"] # For the Runtime to support needed information for the language server
+ruledocs = [
+    "oxc_macros/ruledocs",
+] # Enables the `ruledocs` feature for conditional compilation
+language_server = [
+    "oxc_data_structures/rope",
+] # For the Runtime to support needed information for the language server
 
 [lints]
 workspace = true
@@ -48,6 +52,7 @@ constcat = { workspace = true }
 convert_case = { workspace = true }
 cow-utils = { workspace = true }
 fast-glob = { workspace = true }
+futures = { workspace = true }
 globset = { workspace = true }
 indexmap = { workspace = true, features = ["rayon"] }
 itertools = { workspace = true }
@@ -57,8 +62,11 @@ language-tags = { workspace = true }
 lazy-regex = { workspace = true }
 lazy_static = { workspace = true }
 memchr = { workspace = true }
+napi = { workspace = true }
+napi-derive = { workspace = true }
 nonmax = { workspace = true }
 phf = { workspace = true, features = ["macros"] }
+tokio = { workspace = true }
 rayon = { workspace = true }
 rust-lapper = { workspace = true }
 rustc-hash = { workspace = true }