feat: add plugins to override config (#6117)

Author: wanghaoPolar

Cargo.lock

@@ -3,6 +3,7 @@ use crate::analyzer::{LinterEnabled, RuleDomains};
 use crate::formatter::{FormatWithErrorsEnabled, FormatterEnabled};
 use crate::html::HtmlConfiguration;
 use crate::max_size::MaxSize;
+use crate::plugins::Plugins;
 use crate::{
     CssConfiguration, GraphqlConfiguration, GritConfiguration, JsConfiguration, JsonConfiguration,
     Rules,
@@ -68,6 +69,10 @@ pub struct OverridePattern {
     /// Specific configuration for the filesystem
     #[serde(skip_serializing_if = "Option::is_none")]
     pub files: Option<OverrideFilesConfiguration>,
+
+    /// Specific configuration for additional plugins
+    #[serde(skip_serializing_if = "Option::is_none")]
+    pub plugins: Option<Plugins>,
 }
 
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]

crates/biome_configuration/src/overrides.rs

@@ -3,7 +3,10 @@ use biome_deserialize::{
 };
 use biome_deserialize_macros::{Deserializable, Merge};
 use serde::{Deserialize, Serialize};
-use std::str::FromStr;
+use std::{
+    ops::{Deref, DerefMut},
+    str::FromStr,
+};
 
 #[derive(Clone, Debug, Default, Deserialize, Deserializable, Eq, Merge, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
@@ -12,7 +15,7 @@ pub struct Plugins(pub Vec<PluginConfiguration>);
 
 impl Plugins {
     pub fn iter(&self) -> impl Iterator<Item = &PluginConfiguration> {
-        self.0.iter()
+        self.deref().iter()
     }
 }
 
@@ -24,6 +27,20 @@ impl FromStr for Plugins {
     }
 }
 
+impl Deref for Plugins {
+    type Target = Vec<PluginConfiguration>;
+
+    fn deref(&self) -> &Self::Target {
+        &self.0
+    }
+}
+
+impl DerefMut for Plugins {
+    fn deref_mut(&mut self) -> &mut Self::Target {
+        &mut self.0
+    }
+}
+
 #[derive(Clone, Debug, Deserialize, Eq, PartialEq, Serialize)]
 #[cfg_attr(feature = "schema", derive(schemars::JsonSchema))]
 #[serde(rename_all = "camelCase", deny_unknown_fields, untagged)]

crates/biome_configuration/src/plugins.rs

@@ -1,5 +1,6 @@
 ---
 source: crates/biome_configuration/tests/spec_tests.rs
+assertion_line: 58
 expression: incorrect_key.json
 ---
 incorrect_key.json:4:4 deserialize ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
@@ -26,3 +27,4 @@ incorrect_key.json:4:4 deserialize ━━━━━━━━━━━━━━━
   - linter
   - assist
   - files
+  - plugins

crates/biome_configuration/tests/invalid/overrides/incorrect_key.json.snap

@@ -12,6 +12,7 @@ version              = "0.0.1"
 
 [dependencies]
 biome_analyze            = { workspace = true }
+biome_configuration      = { workspace = true }
 biome_console            = { workspace = true }
 biome_deserialize        = { workspace = true }
 biome_deserialize_macros = { workspace = true }

crates/biome_plugin_loader/Cargo.toml

@@ -33,6 +33,9 @@ pub enum PluginDiagnostic {
 
     /// When an analyzer rule plugin uses an unsupported file format.
     UnsupportedRuleFormat(UnsupportedRuleFormat),
+
+    /// When plugin is requested but not loaded
+    NotLoaded(NotLoaded),
 }
 
 impl From<CompileError> for PluginDiagnostic {
@@ -88,6 +91,18 @@ impl PluginDiagnostic {
             message: MessageAndDescription::from(markup! {{message}}.to_owned()),
         })
     }
+
+    pub fn not_loaded(path: Utf8PathBuf) -> Self {
+        Self::NotLoaded(NotLoaded {
+            message: MessageAndDescription::from(
+                markup! {
+                    "Plugin is requested but not loaded: "
+                    <Emphasis>{path.to_string()}</Emphasis>
+                }
+                .to_owned(),
+            ),
+        })
+    }
 }
 
 impl Debug for PluginDiagnostic {
@@ -161,6 +176,17 @@ pub struct UnsupportedRuleFormat {
     pub message: MessageAndDescription,
 }
 
+#[derive(Debug, Serialize, Deserialize, Diagnostic)]
+#[diagnostic(
+    category = "plugin",
+    severity = Error,
+)]
+pub struct NotLoaded {
+    #[message]
+    #[description]
+    pub message: MessageAndDescription,
+}
+
 #[cfg(test)]
 mod test {
     use crate::plugin_manifest::PluginManifest;

crates/biome_plugin_loader/src/diagnostics.rs

@@ -1,9 +1,10 @@
 use biome_analyze::AnalyzerPluginVec;
+use biome_configuration::plugins::{PluginConfiguration, Plugins};
 use camino::Utf8PathBuf;
 use papaya::HashMap;
-use rustc_hash::FxBuildHasher;
+use rustc_hash::{FxBuildHasher, FxHashSet};
 
-use crate::BiomePlugin;
+use crate::{BiomePlugin, PluginDiagnostic};
 
 /// Cache for storing loaded plugins in memory.
 ///
@@ -18,12 +19,38 @@ impl PluginCache {
         self.0.pin().insert(path, plugin);
     }
 
-    /// Returns the loaded analyzer plugins.
-    pub fn get_analyzer_plugins(&self) -> AnalyzerPluginVec {
-        let mut plugins = AnalyzerPluginVec::new();
-        for plugin in self.0.pin().values() {
-            plugins.extend_from_slice(&plugin.analyzer_plugins);
+    /// Returns the loaded and matched analyzer plugins, deduped
+    pub fn get_analyzer_plugins(
+        &self,
+        plugin_configs: &Plugins,
+    ) -> Result<AnalyzerPluginVec, Vec<PluginDiagnostic>> {
+        let mut result = AnalyzerPluginVec::new();
+        let mut seen = FxHashSet::default();
+        let mut diagnostics: Vec<PluginDiagnostic> = Vec::new();
+
+        let map = self.0.pin();
+        for plugin_config in plugin_configs.iter() {
+            match plugin_config {
+                PluginConfiguration::Path(plugin_path) => {
+                    if seen.insert(plugin_path) {
+                        let path_buf = Utf8PathBuf::from(plugin_path);
+                        match map.get(path_buf.as_path()) {
+                            Some(plugin) => {
+                                result.extend_from_slice(&plugin.analyzer_plugins);
+                            }
+                            None => {
+                                diagnostics.push(PluginDiagnostic::not_loaded(path_buf));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+
+        if !diagnostics.is_empty() {
+            return Err(diagnostics);
         }
-        plugins
+
+        Ok(result)
     }
 }

crates/biome_plugin_loader/src/plugin_cache.rs

@@ -220,6 +220,37 @@ impl Settings {
         result
     }
 
+    /// Returns the plugins that should be enabled for the given `path`, taking overrides into account.
+    pub fn get_plugins_for_path(&self, path: &Utf8Path) -> Cow<Plugins> {
+        let mut result = Cow::Borrowed(&self.plugins);
+
+        for pattern in &self.override_settings.patterns {
+            if pattern.is_file_included(path) {
+                result.to_mut().extend_from_slice(&pattern.plugins);
+            }
+        }
+
+        result
+    }
+
+    /// Return all plugins configured in setting
+    pub fn as_all_plugins(&self) -> Cow<Plugins> {
+        let mut result = Cow::Borrowed(&self.plugins);
+
+        let all_override_plugins = self
+            .override_settings
+            .patterns
+            .iter()
+            .flat_map(|pattern| pattern.plugins.iter().cloned())
+            .collect::<Vec<_>>();
+
+        if !all_override_plugins.is_empty() {
+            result.to_mut().0.extend(all_override_plugins);
+        }
+
+        result
+    }
+
     pub fn is_formatter_enabled(&self) -> bool {
         self.formatter.is_enabled()
     }
@@ -1240,6 +1271,8 @@ pub struct OverrideSettingPattern {
     pub languages: LanguageListSettings,
     /// Files specific settings
     pub files: OverrideFilesSettings,
+    /// Additional plugins to be applied
+    pub plugins: Plugins,
 }
 
 impl OverrideSettingPattern {
@@ -1516,6 +1549,7 @@ pub fn to_override_settings(
                 actions: assist.actions,
             })
             .unwrap_or_default();
+        let plugins = pattern.plugins.unwrap_or_default();
 
         let files = pattern
             .files
@@ -1549,6 +1583,7 @@ pub fn to_override_settings(
             assist,
             languages,
             files,
+            plugins,
         };
 
         override_settings.patterns.push(pattern_setting);

crates/biome_service/src/settings.rs

@@ -0,0 +1,40 @@
+---
+source: crates/biome_service/src/workspace.tests.rs
+expression: plugin_diagnostics
+---
+[
+    Diagnostic {
+        category: Some(
+            Category {
+                name: "plugin",
+                link: None,
+            },
+        ),
+        severity: Error,
+        description: "Prefer object spread instead of `Object.assign()`",
+        message: "Prefer object spread instead of `Object.assign()`",
+        advices: Advices {
+            advices: [],
+        },
+        verbose_advices: Advices {
+            advices: [],
+        },
+        location: Location {
+            path: Some(
+                File(
+                    "/project/a.ts",
+                ),
+            ),
+            span: Some(
+                25..39,
+            ),
+            source_code: None,
+        },
+        tags: DiagnosticTags(
+            BitFlags<DiagnosticTag> {
+                bits: 0b0,
+            },
+        ),
+        source: None,
+    },
+]

crates/biome_service/src/snapshots/biome_service__workspace__tests__diagnostics___project__a.ts.snap

@@ -0,0 +1,74 @@
+---
+source: crates/biome_service/src/workspace.tests.rs
+expression: plugin_diagnostics
+---
+[
+    Diagnostic {
+        category: Some(
+            Category {
+                name: "plugin",
+                link: None,
+            },
+        ),
+        severity: Error,
+        description: "Prefer object spread instead of `Object.assign()`",
+        message: "Prefer object spread instead of `Object.assign()`",
+        advices: Advices {
+            advices: [],
+        },
+        verbose_advices: Advices {
+            advices: [],
+        },
+        location: Location {
+            path: Some(
+                File(
+                    "/project/lib/b.ts",
+                ),
+            ),
+            span: Some(
+                25..39,
+            ),
+            source_code: None,
+        },
+        tags: DiagnosticTags(
+            BitFlags<DiagnosticTag> {
+                bits: 0b0,
+            },
+        ),
+        source: None,
+    },
+    Diagnostic {
+        category: Some(
+            Category {
+                name: "plugin",
+                link: None,
+            },
+        ),
+        severity: Error,
+        description: "Consider using `for...in` loop instead of `Object.keys()` for simple object iteration.",
+        message: "Consider using `for...in` loop instead of `Object.keys()` for simple object iteration.",
+        advices: Advices {
+            advices: [],
+        },
+        verbose_advices: Advices {
+            advices: [],
+        },
+        location: Location {
+            path: Some(
+                File(
+                    "/project/lib/b.ts",
+                ),
+            ),
+            span: Some(
+                67..81,
+            ),
+            source_code: None,
+        },
+        tags: DiagnosticTags(
+            BitFlags<DiagnosticTag> {
+                bits: 0b0,
+            },
+        ),
+        source: None,
+    },
+]