feat(linter): JS custom rules config

Author: camc314

apps/oxlint/src/lint.rs

@@ -10,11 +10,12 @@ use std::{
 
 use cow_utils::CowUtils;
 use ignore::{gitignore::Gitignore, overrides::OverrideBuilder};
+use napi::tokio;
 use oxc_allocator::AllocatorPool;
 use oxc_diagnostics::{DiagnosticService, GraphicalReportHandler, OxcDiagnostic};
 use oxc_linter::{
-    AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, ExternalLinter, InvalidFilterKind,
-    LintFilter, LintOptions, LintService, LintServiceOptions, Linter, Oxlintrc,
+    AllowWarnDeny, Config, ConfigStore, ConfigStoreBuilder, ExternalLinter, ExternalPluginStore,
+    InvalidFilterKind, LintFilter, LintOptions, LintService, LintServiceOptions, Linter, Oxlintrc,
 };
 use rustc_hash::{FxHashMap, FxHashSet};
 use serde_json::Value;
@@ -178,13 +179,22 @@ impl Runner for LintRunner {
             GraphicalReportHandler::new()
         };
 
+        let mut external_plugin_store = ExternalPluginStore::default();
+
         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.
             basic_options.config.is_none();
 
         let nested_configs = if search_for_nested_configs {
-            match Self::get_nested_configs(stdout, &handler, &filters, &paths, external_linter) {
+            match Self::get_nested_configs(
+                stdout,
+                &handler,
+                &filters,
+                &paths,
+                external_linter,
+                &mut external_plugin_store,
+            ) {
                 Ok(v) => v,
                 Err(v) => return v,
             }
@@ -203,21 +213,25 @@ impl Runner for LintRunner {
         } else {
             None
         };
-        let config_builder =
-            match ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, external_linter) {
-                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,
+            external_linter,
+            &mut external_plugin_store,
+        ) {
+            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);
@@ -270,10 +284,14 @@ impl Runner for LintRunner {
             _ => None,
         };
 
-        let linter =
-            Linter::new(LintOptions::default(), ConfigStore::new(lint_config, nested_configs))
-                .with_fix(fix_options.fix_kind())
-                .with_report_unused_directives(report_unused_directives);
+        let linter = Linter::new(
+            LintOptions::default(),
+            ConfigStore::new(lint_config, nested_configs, external_plugin_store),
+            self.external_linter
+                .map(|external_linter| (external_linter, tokio::runtime::Handle::current())),
+        )
+        .with_fix(fix_options.fix_kind())
+        .with_report_unused_directives(report_unused_directives);
 
         let tsconfig = basic_options.tsconfig;
         if let Some(path) = tsconfig.as_ref() {
@@ -406,6 +424,7 @@ impl LintRunner {
         filters: &Vec<LintFilter>,
         paths: &Vec<Arc<OsStr>>,
         external_linter: Option<&ExternalLinter>,
+        external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<FxHashMap<PathBuf, Config>, CliRunResult> {
         // 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.
@@ -436,8 +455,12 @@ 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, external_linter)
-            {
+            let builder = match ConfigStoreBuilder::from_oxlintrc(
+                false,
+                oxlintrc,
+                external_linter,
+                external_plugin_store,
+            ) {
                 Ok(builder) => builder,
                 Err(e) => {
                     print_and_flush_stdout(

crates/oxc_linter/src/config/config_builder.rs

@@ -10,12 +10,14 @@ use rustc_hash::FxHashMap;
 use oxc_span::{CompactStr, format_compact_str};
 
 use crate::{
-    AllowWarnDeny, LintConfig, LintFilter, LintFilterKind, Oxlintrc, RuleCategory, RuleEnum,
+    AllowWarnDeny, ExternalPluginStore, LintConfig, LintFilter, LintFilterKind, Oxlintrc,
+    RuleCategory, RuleEnum,
     config::{
         ESLintRule, LintPlugins, OxlintOverrides, OxlintRules, overrides::OxlintOverride,
         plugins::BuiltinLintPlugins,
     },
     external_linter::ExternalLinter,
+    external_plugin_store::{ExternalRuleId, ExternalRuleLookupError},
     rules::RULES,
 };
 
@@ -24,6 +26,7 @@ use super::{Config, categories::OxlintCategories};
 #[must_use = "You dropped your builder without building a Linter! Did you mean to call .build()?"]
 pub struct ConfigStoreBuilder {
     pub(super) rules: FxHashMap<RuleEnum, AllowWarnDeny>,
+    pub(super) external_rules: FxHashMap<ExternalRuleId, AllowWarnDeny>,
     config: LintConfig,
     categories: OxlintCategories,
     overrides: OxlintOverrides,
@@ -47,11 +50,12 @@ impl ConfigStoreBuilder {
     pub fn empty() -> Self {
         let config = LintConfig::default();
         let rules = FxHashMap::default();
+        let external_rules = FxHashMap::default();
         let categories: OxlintCategories = OxlintCategories::default();
         let overrides = OxlintOverrides::default();
         let extended_paths = Vec::new();
 
-        Self { rules, config, categories, overrides, extended_paths }
+        Self { rules, external_rules, config, categories, overrides, extended_paths }
     }
 
     /// Warn on all rules in all plugins and categories, including those in `nursery`.
@@ -64,8 +68,9 @@ impl ConfigStoreBuilder {
         let overrides = OxlintOverrides::default();
         let categories: OxlintCategories = OxlintCategories::default();
         let rules = RULES.iter().map(|rule| (rule.clone(), AllowWarnDeny::Warn)).collect();
+        let external_rules = FxHashMap::default();
         let extended_paths = Vec::new();
-        Self { rules, config, categories, overrides, extended_paths }
+        Self { rules, external_rules, config, categories, overrides, extended_paths }
     }
 
     /// Create a [`ConfigStoreBuilder`] from a loaded or manually built [`Oxlintrc`].
@@ -90,6 +95,7 @@ impl ConfigStoreBuilder {
         start_empty: bool,
         oxlintrc: Oxlintrc,
         external_linter: Option<&ExternalLinter>,
+        external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<Self, ConfigBuilderError> {
         // TODO: this can be cached to avoid re-computing the same oxlintrc
         fn resolve_oxlintrc_config(
@@ -146,13 +152,13 @@ impl ConfigStoreBuilder {
                 let resolver = oxc_resolver::Resolver::new(ResolveOptions::default());
                 #[expect(clippy::missing_panics_doc, reason = "infallible")]
                 let oxlintrc_dir_path = oxlintrc.path.parent().unwrap();
-
                 for plugin_specifier in &plugins.external {
                     Self::load_external_plugin(
                         oxlintrc_dir_path,
                         plugin_specifier,
                         external_linter,
                         &resolver,
+                        external_plugin_store,
                     )?;
                 }
             }
@@ -179,8 +185,14 @@ impl ConfigStoreBuilder {
             path: Some(oxlintrc.path),
         };
 
-        let mut builder =
-            Self { rules, config, categories, overrides: oxlintrc.overrides, extended_paths };
+        let mut builder = Self {
+            rules,
+            external_rules: FxHashMap::default(),
+            config,
+            categories,
+            overrides: oxlintrc.overrides,
+            extended_paths,
+        };
 
         for filter in oxlintrc.categories.filters() {
             builder = builder.with_filter(&filter);
@@ -189,7 +201,15 @@ impl ConfigStoreBuilder {
         {
             let all_rules = builder.get_all_rules();
 
-            oxlintrc.rules.override_rules(&mut builder.rules, &all_rules);
+            oxlintrc
+                .rules
+                .override_rules(
+                    &mut builder.rules,
+                    &mut builder.external_rules,
+                    &all_rules,
+                    external_plugin_store,
+                )
+                .map_err(ConfigBuilderError::ExternalRuleLookupError)?;
         }
 
         Ok(builder)
@@ -346,7 +366,12 @@ impl ConfigStoreBuilder {
             .filter(|(r, _)| plugins.contains(r.plugin_name().into()))
             .collect();
         rules.sort_unstable_by_key(|(r, _)| r.id());
-        Config::new(rules, self.categories, self.config, self.overrides)
+
+        let mut external_rules: Vec<_> = self.external_rules.into_iter().collect();
+        external_rules.sort_unstable_by_key(|(r, _)| *r);
+
+        // TODO: fixme
+        Config::new(rules, external_rules, self.categories, self.config, self.overrides)
     }
 
     /// Warn for all correctness rules in the given set of plugins.
@@ -399,6 +424,7 @@ impl ConfigStoreBuilder {
         _plugin_specifier: &str,
         _external_linter: &ExternalLinter,
         _resolver: &Resolver,
+        _external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<(), ConfigBuilderError> {
         unreachable!()
     }
@@ -409,6 +435,7 @@ impl ConfigStoreBuilder {
         plugin_specifier: &str,
         external_linter: &ExternalLinter,
         resolver: &Resolver,
+        external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<(), ConfigBuilderError> {
         use crate::PluginLoadResult;
 
@@ -421,16 +448,27 @@ impl ConfigStoreBuilder {
         // TODO: We should support paths which are not valid UTF-8. How?
         let plugin_path = resolved.full_path().to_str().unwrap().to_string();
 
-        let result = tokio::task::block_in_place(move || {
-            tokio::runtime::Handle::current().block_on((external_linter.load_plugin)(plugin_path))
-        })
-        .map_err(|e| ConfigBuilderError::PluginLoadFailed {
-            plugin_specifier: plugin_specifier.to_string(),
-            error: e.to_string(),
-        })?;
+        if external_plugin_store.is_plugin_registered(&plugin_path) {
+            return Ok(());
+        }
+
+        let result = {
+            let plugin_path = plugin_path.clone();
+            tokio::task::block_in_place(move || {
+                tokio::runtime::Handle::current()
+                    .block_on((external_linter.load_plugin)(plugin_path))
+            })
+            .map_err(|e| ConfigBuilderError::PluginLoadFailed {
+                plugin_specifier: plugin_specifier.to_string(),
+                error: e.to_string(),
+            })
+        }?;
 
         match result {
-            PluginLoadResult::Success => Ok(()),
+            PluginLoadResult::Success { name, offset, rules } => {
+                external_plugin_store.register_plugin(plugin_path, name, offset, rules);
+                Ok(())
+            }
             PluginLoadResult::Failure(e) => Err(ConfigBuilderError::PluginLoadFailed {
                 plugin_specifier: plugin_specifier.to_string(),
                 error: e,
@@ -452,7 +490,8 @@ impl TryFrom<Oxlintrc> for ConfigStoreBuilder {
 
     #[inline]
     fn try_from(oxlintrc: Oxlintrc) -> Result<Self, Self::Error> {
-        Self::from_oxlintrc(false, oxlintrc, None)
+        let mut external_plugin_store = ExternalPluginStore::default();
+        Self::from_oxlintrc(false, oxlintrc, None, &mut external_plugin_store)
     }
 }
 
@@ -481,6 +520,7 @@ pub enum ConfigBuilderError {
         plugin_specifier: String,
         error: String,
     },
+    ExternalRuleLookupError(ExternalRuleLookupError),
     NoExternalLinterConfigured,
 }
 
@@ -509,6 +549,7 @@ impl Display for ConfigBuilderError {
                 f.write_str("Failed to load external plugin because no external linter was configured. This means the Oxlint binary was executed directly rather than via napi bindings.")?;
                 Ok(())
             }
+            ConfigBuilderError::ExternalRuleLookupError(e) => std::fmt::Display::fmt(&e, f),
         }
     }
 }
@@ -743,7 +784,11 @@ mod test {
         "#,
         )
         .unwrap();
-        let builder = ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, None).unwrap();
+        let builder = {
+            let mut external_plugin_store = ExternalPluginStore::default();
+            ConfigStoreBuilder::from_oxlintrc(false, oxlintrc, None, &mut external_plugin_store)
+                .unwrap()
+        };
         for (rule, severity) in &builder.rules {
             let name = rule.name();
             let plugin = rule.plugin_name();
@@ -912,14 +957,18 @@ mod test {
 
     #[test]
     fn test_extends_invalid() {
-        let invalid_config = ConfigStoreBuilder::from_oxlintrc(
-            true,
-            Oxlintrc::from_file(&PathBuf::from(
-                "fixtures/extends_config/extends_invalid_config.json",
-            ))
-            .unwrap(),
-            None,
-        );
+        let invalid_config = {
+            let mut external_plugin_store = ExternalPluginStore::default();
+            ConfigStoreBuilder::from_oxlintrc(
+                true,
+                Oxlintrc::from_file(&PathBuf::from(
+                    "fixtures/extends_config/extends_invalid_config.json",
+                ))
+                .unwrap(),
+                None,
+                &mut external_plugin_store,
+            )
+        };
         let err = invalid_config.unwrap_err();
         assert!(matches!(err, ConfigBuilderError::InvalidConfigFile { .. }));
         if let ConfigBuilderError::InvalidConfigFile { file, reason } = err {
@@ -1072,18 +1121,26 @@ mod test {
     }
 
     fn config_store_from_path(path: &str) -> Config {
+        let mut external_plugin_store = ExternalPluginStore::default();
         ConfigStoreBuilder::from_oxlintrc(
             true,
             Oxlintrc::from_file(&PathBuf::from(path)).unwrap(),
             None,
+            &mut external_plugin_store,
         )
         .unwrap()
         .build()
     }
 
     fn config_store_from_str(s: &str) -> Config {
-        ConfigStoreBuilder::from_oxlintrc(true, serde_json::from_str(s).unwrap(), None)
-            .unwrap()
-            .build()
+        let mut external_plugin_store = ExternalPluginStore::default();
+        ConfigStoreBuilder::from_oxlintrc(
+            true,
+            serde_json::from_str(s).unwrap(),
+            None,
+            &mut external_plugin_store,
+        )
+        .unwrap()
+        .build()
     }
 }