feat(linter): JS custom rules config

Author: camc314

apps/oxlint/src/lint.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, 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 +178,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 +212,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);
@@ -273,10 +286,13 @@ 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,
+        )
+        .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() {
@@ -409,6 +425,7 @@ impl LintRunner {
         filters: &Vec<LintFilter>,
         paths: &Vec<Arc<OsStr>>,
         external_linter: Option<&ExternalLinter>,
+        mut 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.
@@ -439,8 +456,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,7 +10,8 @@ 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,
@@ -90,6 +91,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 +148,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,
                     )?;
                 }
             }
@@ -399,6 +401,7 @@ impl ConfigStoreBuilder {
         _plugin_specifier: &str,
         _external_linter: &ExternalLinter,
         _resolver: &Resolver,
+        _external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<(), ConfigBuilderError> {
         unreachable!()
     }
@@ -409,6 +412,7 @@ impl ConfigStoreBuilder {
         plugin_specifier: &str,
         external_linter: &ExternalLinter,
         resolver: &Resolver,
+        external_plugin_store: &mut ExternalPluginStore,
     ) -> Result<(), ConfigBuilderError> {
         use crate::PluginLoadResult;
 
@@ -421,16 +425,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 +467,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)
     }
 }
 
@@ -743,7 +759,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();

crates/oxc_linter/src/config/config_store.rs

@@ -10,6 +10,7 @@ use super::{
 };
 use crate::{
     AllowWarnDeny, LintPlugins,
+    external_plugin_store::{ExternalPluginStore, ExternalRuleId},
     rules::{RULES, RuleEnum},
 };
 
@@ -19,11 +20,17 @@ pub struct ResolvedLinterState {
     // TODO: Arc + Vec -> SyncVec? It would save a pointer dereference.
     pub rules: Arc<[(RuleEnum, AllowWarnDeny)]>,
     pub config: Arc<LintConfig>,
+
+    pub external_rules: Vec<(ExternalRuleId, AllowWarnDeny)>,
 }
 
 impl Clone for ResolvedLinterState {
     fn clone(&self) -> Self {
-        Self { rules: Arc::clone(&self.rules), config: Arc::clone(&self.config) }
+        Self {
+            rules: Arc::clone(&self.rules),
+            config: Arc::clone(&self.config),
+            external_rules: self.external_rules.clone(),
+        }
     }
 }
 
@@ -64,6 +71,7 @@ impl Config {
                         .into_boxed_slice(),
                 ),
                 config: Arc::new(config),
+                external_rules: vec![], // FIXME(camc314)
             },
             base_rules: rules,
             categories,
@@ -179,7 +187,11 @@ impl Config {
 
         let rules =
             rules.into_iter().filter(|(_, severity)| severity.is_warn_deny()).collect::<Vec<_>>();
-        ResolvedLinterState { rules: Arc::from(rules.into_boxed_slice()), config }
+        ResolvedLinterState {
+            rules: Arc::from(rules.into_boxed_slice()),
+            config,
+            external_rules: vec![], // FIXME(camc314)
+        }
     }
 }
 
@@ -192,11 +204,20 @@ impl Config {
 pub struct ConfigStore {
     base: Config,
     nested_configs: FxHashMap<PathBuf, Config>,
+    external_plugin_store: Arc<ExternalPluginStore>,
 }
 
 impl ConfigStore {
-    pub fn new(base_config: Config, nested_configs: FxHashMap<PathBuf, Config>) -> Self {
-        Self { base: base_config, nested_configs }
+    pub fn new(
+        base_config: Config,
+        nested_configs: FxHashMap<PathBuf, Config>,
+        external_plugin_store: ExternalPluginStore,
+    ) -> Self {
+        Self {
+            base: base_config,
+            nested_configs,
+            external_plugin_store: Arc::new(external_plugin_store),
+        }
     }
 
     pub fn number_of_rules(&self) -> Option<usize> {
@@ -212,6 +233,7 @@ impl ConfigStore {
     }
 
     pub(crate) fn resolve(&self, path: &Path) -> ResolvedLinterState {
+        dbg!(&self.external_plugin_store);
         let resolved_config = if self.nested_configs.is_empty() {
             &self.base
         } else if let Some(config) = self.get_nearest_config(path) {
@@ -243,7 +265,7 @@ mod test {
 
     use super::{ConfigStore, OxlintOverrides};
     use crate::{
-        AllowWarnDeny, BuiltinLintPlugins, LintPlugins, RuleEnum,
+        AllowWarnDeny, BuiltinLintPlugins, ExternalPluginStore, LintPlugins, RuleEnum,
         config::{
             LintConfig, OxlintEnv, OxlintGlobals, OxlintSettings, categories::OxlintCategories,
             config_store::Config,
@@ -272,6 +294,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(base_rules, OxlintCategories::default(), LintConfig::default(), overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
 
         let rules_for_source_file = store.resolve("App.tsx".as_ref());
@@ -294,6 +317,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(base_rules, OxlintCategories::default(), LintConfig::default(), overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
 
         let rules_for_source_file = store.resolve("App.tsx".as_ref());
@@ -317,6 +341,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(base_rules, OxlintCategories::default(), LintConfig::default(), overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert_eq!(store.number_of_rules(), Some(1));
 
@@ -340,6 +365,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(base_rules, OxlintCategories::default(), LintConfig::default(), overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert_eq!(store.number_of_rules(), Some(1));
 
@@ -363,6 +389,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(base_rules, OxlintCategories::default(), LintConfig::default(), overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert_eq!(store.number_of_rules(), Some(1));
 
@@ -395,6 +422,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(vec![], OxlintCategories::default(), base_config, overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
 
         assert_eq!(store.base.base.config.plugins.builtin, BuiltinLintPlugins::IMPORT);
@@ -438,6 +466,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(vec![], OxlintCategories::default(), base_config, overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert!(!store.base.base.config.env.contains("React"));
 
@@ -465,6 +494,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(vec![], OxlintCategories::default(), base_config, overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert!(store.base.base.config.env.contains("es2024"));
 
@@ -493,6 +523,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(vec![], OxlintCategories::default(), base_config, overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert!(!store.base.base.config.globals.is_enabled("React"));
         assert!(!store.base.base.config.globals.is_enabled("Secret"));
@@ -526,6 +557,7 @@ mod test {
         let store = ConfigStore::new(
             Config::new(vec![], OxlintCategories::default(), base_config, overrides),
             FxHashMap::default(),
+            ExternalPluginStore::default(),
         );
         assert!(store.base.base.config.globals.is_enabled("React"));
         assert!(store.base.base.config.globals.is_enabled("Secret"));