crates/biome_grit_patterns/src/grit_query.rs (1)

56-58: Guard the “compiled-for-this-language” invariant

from_node compiles patterns against a specific lang, while execute reads self.language. Because the field is now pub, external mutation after construction can desynchronise the compiled pattern from the execution context. Consider keeping the field private and exposing a getter to make it read-only.

Apply within this hunk:

-    /// Target language for the query.
-    pub language: GritTargetLanguage,
+    /// Target language for the query. Set at compile time; do not mutate after construction.
+    language: GritTargetLanguage,

Then add an accessor within the existing impl GritQuery:

impl GritQuery {
    /// Returns the target language used during compilation.
    pub fn language(&self) -> &GritTargetLanguage {
        &self.language
    }
}

crates/biome_analyze/src/matcher.rs (1)

141-146: Prefer Arc for plugin keys to avoid repeated allocations.

Plugin signals will likely reuse the same plugin id many times. Arc reduces cloning churn versus Box.

Apply:

-#[derive(Clone, Debug)]
-pub enum SignalRuleKey {
-    Rule(RuleKey),
-    Plugin(Box<str>),
-}
+#[derive(Clone, Debug)]
+pub enum SignalRuleKey {
+    Rule(RuleKey),
+    // Shared across many signals from the same plugin
+    Plugin(std::sync::Arc<str>),
+}

Optionally, add Display for nicer logging:

impl core::fmt::Display for SignalRuleKey {
    fn fmt(&self, f: &mut core::fmt::Formatter<'_>) -> core::fmt::Result {
        match self {
            SignalRuleKey::Rule(k) => k.fmt(f),
            SignalRuleKey::Plugin(id) => f.write_str(id),
        }
    }
}

crates/biome_js_analyze/src/lib.rs (1)

144-155: Shrink the unsafe scope and keep it surgical.

Move the language check outside the unsafe block so only new_unchecked is unsafe. Same effect, less spooky action at a distance.

Apply:

-    for plugin in plugins {
-        // SAFETY: The plugin target language is correctly checked here.
-        unsafe {
-            if plugin.language() == PluginTargetLanguage::JavaScript {
-                analyzer.add_visitor(
-                    Phases::Syntax,
-                    Box::new(PluginVisitor::new_unchecked(plugin.clone())),
-                )
-            }
-        }
-    }
+    for plugin in plugins {
+        if plugin.language() == PluginTargetLanguage::JavaScript {
+            // SAFETY: The plugin target language was checked above.
+            let visitor = unsafe { PluginVisitor::new_unchecked(plugin.clone()) };
+            analyzer.add_visitor(Phases::Syntax, Box::new(visitor));
+        }
+    }

Minor thought: plugin visitors are appended after built-in visitors. That’s fine given heap-ordered emission, but shout if you want a stable “plugins-first/last” policy and we can wire it explicitly.

crates/biome_css_analyze/src/lib.rs (1)

118-129: Narrow the unsafe scope to the new_unchecked call.

     for plugin in plugins {
-        // SAFETY: The plugin target language is correctly checked here.
-        unsafe {
-            if plugin.language() == PluginTargetLanguage::Css {
-                analyzer.add_visitor(
-                    Phases::Syntax,
-                    Box::new(PluginVisitor::new_unchecked(plugin.clone())),
-                )
-            }
-        }
+        if plugin.language() == PluginTargetLanguage::Css {
+            // SAFETY: The plugin target language is correctly checked here.
+            let visitor = unsafe { PluginVisitor::new_unchecked(plugin.clone()) };
+            analyzer.add_visitor(Phases::Syntax, Box::new(visitor));
+        }
     }

crates/biome_rowan/src/syntax/node.rs (2)

1210-1214: Fix doc reference to the erased node type.
The comment mentions ErasedSyntaxNode, but the type is AnySyntaxNode.

-/// Marker trait to prevent unrelated types to be contained in the [`crate::ErasedSyntaxNode`] struct.
+/// Marker trait restricting which types can be stored inside [`AnySyntaxNode`].

---

1215-1234: Stronger type safety: store dyn AsSyntaxNode instead of dyn Any.
This enforces at the type level that only syntax nodes are boxed (aligns with the doc) while preserving the same downcast ergonomics.

-#[derive(Debug)]
-pub struct AnySyntaxNode {
-    raw: Box<dyn Any>,
-}
+#[derive(Debug)]
+pub struct AnySyntaxNode {
+    raw: Box<dyn AsSyntaxNode>,
+}
@@
 impl AnySyntaxNode {
     #[inline]
     pub fn downcast_ref<T: AsSyntaxNode>(&self) -> Option<&T> {
-        self.raw.downcast_ref()
+        // AsSyntaxNode: Any, so we can downcast via Any
+        (self.raw.as_ref() as &dyn Any).downcast_ref()
     }
 }
@@
 impl<L: Language + 'static> From<SyntaxNode<L>> for AnySyntaxNode {
     fn from(value: SyntaxNode<L>) -> Self {
-        Self {
-            raw: Box::new(value),
-        }
+        Self { raw: Box::new(value) }
     }
 }

If #[derive(Debug)] ever complains about the trait object, we can add a tiny manual Debug impl that prints the inner type name. Happy to provide it.

crates/biome_analyze/src/analyzer_plugin.rs (1)

47-55: Provide a safe constructor alongside new_unchecked

The unsafe ctor is easy to misuse. Offer a safe new(plugin) -> Option<Self> (or Result) that checks plugin.language() matches L to prevent accidental cross-language registration.

 pub unsafe fn new_unchecked(plugin: Arc<Box<dyn AnalyzerPlugin>>) -> Self {
     let query = plugin.query().into_iter().map(L::Kind::from_raw).collect();

     Self {
         query,
         plugin,
         skip_subtree: None,
     }
 }
+
+pub fn new(plugin: Arc<Box<dyn AnalyzerPlugin>>, expected: PluginTargetLanguage) -> Option<Self> {
+    if plugin.language() != expected {
+        return None;
+    }
+    // SAFETY: Language checked above.
+    Some(unsafe { Self::new_unchecked(plugin) })
+}

crates/biome_analyze/src/suppressions.rs (3)

191-197: New range-suppression plugin fields look good

The added fields model plugin-specific range suppressions cleanly. Minor nit: prefer initialising booleans explicitly to false rather than Default::default() for readability.

-            suppress_all_plugins: Default::default(),
+            suppress_all_plugins: false,

Also applies to: 208-211

---

620-633: Consider reporting “already suppressed” for plugin suppressions too

already_suppressed(...) only checks rule filters; it won’t attribute a plugin line/range suppression as redundant when a top-level plugin suppression already applies. For parity with rules (nicer UX), extend this to consult plugin suppressions as well.

Here’s a minimal change:

-    fn already_suppressed(
-        &self,
-        filter: Option<&RuleFilter>,
-        range: &TextRange,
-    ) -> Option<TextRange> {
-        filter.and_then(|filter| {
-            self.top_level_suppression
-                .has_filter(filter)
-                .then_some(self.top_level_suppression.comment_range)
-                .or(self
-                    .range_suppressions
-                    .matches_filter_in_range(filter, range))
-        })
-    }
+    fn already_suppressed(
+        &self,
+        filter: Option<&RuleFilter>,
+        range: &TextRange,
+        plugin_name: Option<&str>,
+    ) -> Option<TextRange> {
+        // Rule-based overshadowing
+        if let Some(filter) = filter {
+            if self.top_level_suppression.has_filter(filter) {
+                return Some(self.top_level_suppression.comment_range);
+            }
+            if let Some(r) = self.range_suppressions.matches_filter_in_range(filter, range) {
+                return Some(r);
+            }
+        }
+        // Plugin-based overshadowing
+        if let Some(name) = plugin_name {
+            if self.top_level_suppression.suppressed_plugin(name) {
+                return Some(self.top_level_suppression.comment_range);
+            }
+            if let Some(r) = self.range_suppressions.matches_plugin_in_range(name, range) {
+                return Some(r);
+            }
+        }
+        None
+    }

Add this helper to RangeSuppressions:

+    pub(crate) fn matches_plugin_in_range(
+        &self,
+        plugin: &str,
+        position: &TextRange,
+    ) -> Option<TextRange> {
+        for s in self.suppressions.iter().rev() {
+            if s.suppression_range.contains_range(*position)
+                && (s.suppress_all_plugins || s.suppressed_plugins.contains(plugin))
+            {
+                return Some(s.suppression_range);
+            }
+        }
+        None
+    }

And pass plugin_name.as_deref() from callers where you compute already_suppressed.

Happy to wire this across the three call sites if you’d like a patch.

---

703-712: Docs: suppression example typo

The example reads “// lint/biome-ignore plugin/my-plugin”. Should be “// biome-ignore lint/plugin/my-plugin”.

-    /// A suppression disabling a plugin eg. `// lint/biome-ignore plugin/my-plugin`
+    /// A suppression disabling a plugin, e.g. `// biome-ignore lint/plugin/my-plugin`

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/lib/src/lint/nursery/*.rs : For new JavaScript lint rules generated by `just new-js-lintrule`, implement the rule in the generated file under `biome_js_analyze/lib/src/lint/nursery/`

Learnt from: CR
PR: biomejs/biome#0
File: CLAUDE.md:0-0
Timestamp: 2025-08-17T08:55:30.118Z
Learning: Applies to crates/biome_*_{syntax,parser,formatter,analyze,factory,semantic}/** : Maintain the per-language crate structure: biome_{lang}_{syntax,parser,formatter,analyze,factory,semantic}

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_type_info/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:50:12.090Z
Learning: Applies to crates/biome_js_type_info/src/**/*.rs : Represent links between types using TypeReference (not Arc) to avoid cross-module retention and recursive structures; store type data in linear vectors

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/xtask/codegen/*.ungram : Union node names must start with Any* (e.g., AnyHtmlAttribute)

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Use the generic Format trait and FormatNode for AST nodes when implementing the formatter

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : When a token is mandatory and present in the AST, use the AST-provided token (e.g., node.l_paren_token().format()) instead of hardcoded tokens

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/*.rs : Import the FormatNode trait and implement it for your Node

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_js_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:52.001Z
Learning: Applies to crates/biome_js_formatter/**/Cargo.toml : Add biome_js_formatter as a path dependency in Cargo.toml: biome_js_formatter = { version = "0.0.1", path = "../biome_js_formatter" }

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/Cargo.toml : Add the specified dev-dependencies (biome_formatter_test, biome_html_factory, biome_html_parser, biome_parser, biome_service, countme with feature enable, iai 0.1.1, quickcheck, quickcheck_macros, tests_macros) to Cargo.toml under [dev-dependencies]

Learnt from: CR
PR: biomejs/biome#0
File: CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:40:38.097Z
Learning: Applies to crates/**/Cargo.toml : In internal crates, use `workspace = true` for internal dependencies.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_parser/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:57:34.751Z
Learning: Applies to crates/biome_parser/crates/biome_*_syntax/** : Create a new crate named biome_<language>_syntax under crates/

Learnt from: CR
PR: biomejs/biome#0
File: CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:40:38.097Z
Learning: Applies to Cargo.toml : Centralize shared dependencies in the root Cargo.toml using workspace dependencies.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_service/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:53:15.299Z
Learning: Applies to crates/biome_service/src/workspace.rs : Implement the Workspace trait in src/workspace.rs

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use the local `rule_category!()` macro in diagnostics for the rule’s category, not string-parsed categories

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_formatter/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:48:27.774Z
Learning: Applies to crates/biome_formatter/biome_html_formatter/src/lib.rs : Place the plumbing traits and impls (AsFormat, IntoFormat, FormattedIterExt, and their Iterator adapters) in the biome_html_formatter crate’s lib.rs

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Specify category and severity using #[diagnostic(...)] on the type or derive them from fields

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Types implementing Diagnostic must also implement Debug (e.g., use #[derive(Debug, Diagnostic)])

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : #[derive(Diagnostic)] can be used on enums only if every variant contains a diagnostic type

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : Define per-rule options in the `biome_rule_options` crate under `lib/`, with serde- and schemars-compatible derives and `#[serde(rename_all = "camelCase", deny_unknown_fields, default)]`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/crates/biome_diagnostics_categories/src/categories.rs : When declaring a new diagnostic category, register it in crates/biome_diagnostics_categories/src/categories.rs

crates/biome_analyze/src/analyzer_plugin.rs (1)

110-116: Good fix: use span() accessor instead of field access

Using diagnostic.span() avoids visibility/compat pitfalls flagged earlier. Nice one.

crates/biome_analyze/src/analyzer_plugin.rs (4)

18-24: Prefer Arc over Arc<Box> to avoid double indirection

The extra Box adds an unnecessary allocation and pointer chase. If ABI/public API allows, consider simplifying to Arc for AnalyzerPluginSlice/Vec and fields that store plugins.

---

32-36: Struct field also inherits the double indirection

PluginVisitor.plugin mirrors the Arc<Box<...>> pattern. If you adopt Arc, update this field accordingly to keep things consistent and lean.

---

43-55: Make construction safe (or guarded) by checking the plugin’s target language

new_unchecked relies on callers to pair the correct language with the plugin. A mismatch silently no-ops (query kinds won’t match) and is painful to debug. Offer a safe constructor that validates plugin.language().

Patch sketch (adds a safe new and keeps new_unchecked for internal use):

 impl<L> PluginVisitor<L>
 where
     L: Language + 'static,
     L::Kind: Eq + Hash,
 {
+    /// Creates a syntax visitor from the plugin, validating the target language.
+    pub fn new(plugin: Arc<Box<dyn AnalyzerPlugin>>, expected: PluginTargetLanguage) -> Result<Self, PluginTargetLanguage> {
+        let actual = plugin.language();
+        if actual != expected {
+            return Err(actual);
+        }
+        // SAFETY: `actual == expected` guarantees the language pairing.
+        Ok(unsafe { Self::new_unchecked(plugin) })
+    }
+
     /// Creates a syntax visitor from the plugin.
     ///
     /// # Safety
     /// Do not forget to check the plugin is targeted for the language `L`.
     pub unsafe fn new_unchecked(plugin: Arc<Box<dyn AnalyzerPlugin>>) -> Self {
         let query = plugin.query().into_iter().map(L::Kind::from_raw).collect();

---

87-93: No change needed: ordering(range).is_ne() correctly skips only disjoint nodes.

• Optional: for clearer intent, you may use node.text_range_with_trivia().intersect(range).is_none() (be aware it treats boundary-touching as overlap).

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use the local `rule_category!()` macro in diagnostics for the rule’s category, not string-parsed categories

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Specify category and severity using #[diagnostic(...)] on the type or derive them from fields

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Types implementing Diagnostic must also implement Debug (e.g., use #[derive(Debug, Diagnostic)])

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : #[derive(Diagnostic)] can be used on enums only if every variant contains a diagnostic type

crates/biome_analyze/src/suppressions.rs (4)

191-197: Docs/style nit: wording consistency

• “Set to true if this comment suppress all plugins” → “suppresses”.
• Consider aligning field naming with TopLevelSuppression (“plugins” vs “suppressed_plugins”) for symmetry.

---

208-211: Minor: prefer explicit false over Default::default() for bool

Clearer at a glance and avoids type inference surprises.

-            suppress_all_plugins: Default::default(),
+            suppress_all_plugins: false,

---

229-233: Avoid plugin name allocations: pass &str through the pipeline

No need to allocate a String here; accept Option<&str> and only allocate when inserting into the set.

-    pub(crate) fn push_suppression(
+    pub(crate) fn push_suppression(
         &mut self,
         suppression: &AnalyzerSuppression,
         filter: Option<RuleFilter<'static>>,
-        plugin_name: Option<String>,
+        plugin_name: Option<&str>,
         text_range: TextRange,
         already_suppressed: Option<TextRange>,
     ) -> Result<(), AnalyzerSuppressionDiagnostic> {
@@
-                Some(PLUGIN_LINT_RULE_FILTER) => {
-                    if let Some(plugin_name) = plugin_name {
-                        range_suppression.suppressed_plugins.insert(plugin_name);
-                    } else {
+                Some(PLUGIN_LINT_RULE_FILTER) => {
+                    if let Some(plugin_name) = plugin_name {
+                        range_suppression
+                            .suppressed_plugins
+                            .insert(plugin_name.to_string());
+                    } else {
                         range_suppression.suppress_all_plugins = true;
-                    }
+                    }
                 }

Also applies to: 239-245

---

551-559: Plumb plugin name by reference to avoid copies

Follow-up to the earlier suggestion: pass &str into RangeSuppressions::push_suppression.

-                self.range_suppressions.push_suppression(
+                self.range_suppressions.push_suppression(
                     suppression,
                     filter,
-                    plugin_name,
+                    plugin_name.as_deref(),
                     comment_range,
                     already_suppressed,
                 )

Optionally, consider marking plugin-level “already suppressed” to match rule-level behaviour:

• Add a helper (outside the changed hunk):

impl RangeSuppressions {
    pub(crate) fn matches_plugin_in_range(
        &self,
        plugin_name: &str,
        position: &TextRange,
    ) -> Option<TextRange> {
        for s in self.suppressions.iter().rev() {
            if s.suppression_range.contains_range(*position)
                && (s.suppress_all_plugins || s.suppressed_plugins.contains(plugin_name))
            {
                return Some(s.suppression_range);
            }
        }
        None
    }
}

• Then, in push_suppression (before matching on suppression.variant), enrich already_suppressed for plugin suppressions:

let mut already_suppressed = self.already_suppressed(filter.as_ref(), &comment_range);
if matches!(filter, Some(PLUGIN_LINT_RULE_FILTER)) {
    if self.top_level_suppression.suppress_all_plugins
        || plugin_name
            .as_ref()
            .is_some_and(|n| self.top_level_suppression.suppressed_plugin(n))
    {
        already_suppressed = Some(self.top_level_suppression.comment_range);
    } else if let Some(name) = plugin_name.as_deref() {
        if let Some(r) = self
            .range_suppressions
            .matches_plugin_in_range(name, &comment_range)
        {
            already_suppressed = Some(r);
        }
    }
}

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

crates/biome_analyze/src/suppressions.rs (2)

259-267: Unify diagnostic wording: use “biome-ignore-*” consistently

Elsewhere you use “biome-ignore-*”. Let’s align this message too.

-                    markup!{"Found a "<Emphasis>"biome-range-end"</Emphasis>" suppression without a "<Emphasis>"biome-range-start"</Emphasis>" suppression. This is invalid"}
+                    markup!{"Found a "<Emphasis>"biome-ignore-end"</Emphasis>" suppression without a "<Emphasis>"biome-ignore-start"</Emphasis>" suppression. This is invalid"}

---

270-295: Bug: generic biome-ignore-end drops state instead of closing the last open suppression

Popping and returning early skips marking is_ended and doesn’t extend the range to include the end comment. Close the most recent open suppression instead, mirroring the other branches.

-            let range_suppression = match filter {
-                None => {
-                    self.suppressions.pop();
-                    return Ok(());
-                }
+            let range_suppression = match filter {
+                None => self
+                    .suppressions
+                    .iter_mut()
+                    .rev()
+                    .find(|s| !s.is_ended),
                 Some(PLUGIN_LINT_RULE_FILTER) => self
                     .suppressions
                     .iter_mut()
                     .rev()
                     .filter(|s| !s.is_ended)
                     .find(|s| match &plugin_name {
                         Some(plugin_name) => s.suppressed_plugins.contains(plugin_name),
                         None => s.suppress_all_plugins,
                     }),
                 Some(filter) => self
                     .suppressions
                     .iter_mut()
                     .rev()
                     .filter(|s| !s.is_ended)
                     .find(|s| {
                         s.filters_by_category
                             .get(&suppression.category)
                             .is_some_and(|filters| filters.contains(&filter))
                     }),
             };

crates/biome_analyze/src/suppressions.rs (3)

191-197: Naming consistency + doc nit

Range uses suppressed_plugins while top-level uses plugins. Consider aligning names for symmetry. Also fix the grammar in the doc string.

-    /// Set to true if this comment suppress all plugins
+    /// Set to true if this comment suppresses all plugins

---

208-211: Prefer explicit false over Default::default() for bools

Tiny readability win; keeps intent obvious.

-            suppressed_plugins: Default::default(),
-            suppress_all_plugins: Default::default(),
+            suppressed_plugins: Default::default(),
+            suppress_all_plugins: false,

---

107-109: Bug: cover() result is ignored for top-level expand

This never updates range. Assign the result.

-        self.range.cover(range);
+        self.range = self.range.cover(range);

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

crates/biome_analyze/src/matcher.rs (1)

147-151: Nice DX win implementing From

This matches previous feedback and smooths call-sites converting to SignalRuleKey.

crates/biome_analyze/src/analyzer_plugin.rs (1)

107-116: Avoid “anonymous” plugin keys; ensure stable identity for per-plugin suppressions

Falling back to "anonymous" breaks per-plugin suppression for JS plugins (subcategory isn’t set there). Either make plugin identity explicit on the trait, or ensure JS plugins set a stable subcategory. This was raised before; still unresolved here.

Option A (preferred, explicit key on the trait):

@@
 pub trait AnalyzerPlugin: Debug + Send + Sync {
     fn language(&self) -> PluginTargetLanguage;
 
     fn query(&self) -> Vec<RawSyntaxKind>;
 
     fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> Vec<RuleDiagnostic>;
+
+    /// Stable identity used for suppressions and reporting.
+    fn key(&self) -> std::borrow::Cow<'static, str>;
 }
@@
-                let name = diagnostic
-                    .subcategory
-                    .clone()
-                    .unwrap_or_else(|| "anonymous".into());
+                let name = diagnostic
+                    .subcategory
+                    .clone()
+                    .unwrap_or_else(|| (&*self.plugin).key().into_owned());

Option B (minimal churn): in crates/biome_plugin_loader/src/analyzer_js_plugin.rs, map pulled diagnostics to set a stable subcategory (e.g. plugin file stem) before returning:

let name = self
    .path
    .file_stem()
    .map(|s| s.to_string())
    .unwrap_or_else(|| "anonymous".to_string());

plugin
    .ctx
    .pull_diagnostics()
    .into_iter()
    .map(|d| d.subcategory(name.clone()))
    .collect()

Run to confirm no “anonymous” subcategories remain for JS plugins:

#!/bin/bash
rg -n --type=rust -C2 'pull_diagnostics\(\).*collect' crates/biome_plugin_loader | sed -n '1,200p'
rg -n --type=rust -C2 'subcategory\(' crates/biome_plugin_loader/src/analyzer_js_plugin.rs || echo "No subcategory set in JS plugin loader"

crates/biome_analyze/src/suppressions.rs (1)

278-283: Generic biome-ignore-end shouldn’t pop and drop state

Popping removes the suppression entirely, which prevents “unused range suppression” diagnostics and loses context. Instead, close the latest open suppression (any kind), mark it ended, and extend the range to include the end comment.

-                None => {
-                    self.suppressions.pop();
-                    return Ok(());
-                }
+                None => self
+                    .suppressions
+                    .iter_mut()
+                    .rev()
+                    .find(|s| !s.is_ended),
@@
-            if let Some(existing_suppression) = range_suppression {
+            if let Some(existing_suppression) = range_suppression {
                 // Mark this as ended and expand it by the text range of this comment
                 existing_suppression.is_ended = true;
                 existing_suppression.suppression_range =
                     existing_suppression.suppression_range.cover(text_range);
             } else {

crates/biome_analyze/src/matcher.rs (2)

141-151: Good abstraction; consider deriving Eq/Hash and a Display impl

SignalRuleKey cleanly captures both core rules and plugins. To ease use in maps/sets and logging, derive Eq/Hash and add Display.

-#[derive(Clone, Debug)]
+#[derive(Clone, Debug, PartialEq, Eq, Hash)]
 pub enum SignalRuleKey {
     Rule(RuleKey),
     Plugin(Box<str>),
 }
+
+impl std::fmt::Display for SignalRuleKey {
+    fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
+        match self {
+            SignalRuleKey::Rule(k) => k.fmt(f),
+            SignalRuleKey::Plugin(name) => write!(f, "plugin/{name}"),
+        }
+    }
+}

---

153-165: Documentation nit: include plugins in the field doc

The field comment still says “rule”; it now also represents plugin diagnostics.

-    /// Unique identifier for the rule that emitted this signal
+    /// Unique identifier for the rule or plugin that emitted this signal
     pub rule: SignalRuleKey,

crates/biome_css_analyze/tests/plugin/useLowercaseColorsSuppression.grit (1)

1-9: Confirm plugin name used for suppressions

Suppressions in the CSS fixture target lint/plugin/useLowercaseColorsSuppression. Ensure this rule’s emitted diagnostics use that exact plugin name (e.g. file-stem) as the subcategory; otherwise the suppressions won’t match. If the Grit DSL supports an explicit name, consider declaring it to make this deterministic.

crates/biome_css_analyze/tests/plugin/useLowercaseColorsSuppression.css (1)

13-16: Minor consistency: drop trailing semicolon in directive

One directive has a trailing semicolon inside the comment; others don’t. For consistency:

-    /* biome-ignore lint/plugin/anotherPlugin: reason; */
+    /* biome-ignore lint/plugin/anotherPlugin: reason */

crates/biome_plugin_loader/src/analyzer_js_plugin.rs (2)

76-86: Scoped query to JS roots is fine; keep an eye on granularity

Limiting to AnyJsRoot ensures evaluate runs once per file. The TODO about granular queries from JS plugins is spot on; wiring that later will avoid running whole-file plugins unnecessarily.

---

105-112: Follow-up: plumb AST to JS plugins

Leaving a TODO is fine for this PR. Next step: serialise a minimal AST facade (or pass a node handle) so plugins can truly act as syntax visitors and avoid re-parsing or relying on global state.

crates/biome_analyze/src/analyzer_plugin.rs (3)

89-95: Range pruning: use intersection for clarity

The ordering check is harder to parse. Using an explicit intersection reads clearer and avoids subtle ordering semantics.

-        if let Some(range) = ctx.range
-            && node.text_range_with_trivia().ordering(range).is_ne()
-        {
+        if let Some(range) = ctx.range
+            && node.text_range_with_trivia().intersect(range).is_none()
+        {
             self.skip_subtree = Some(node.clone());
             return;
         }

---

49-57: Make the unsafe constructor safer in debug builds

Add a debug assertion that the plugin language matches L to catch misuse early. If you can’t derive PluginTargetLanguage from L here, place this assert at the call sites that know the language.

---

32-38: Avoid double indirection for plugins

Using Arc<Box<dyn AnalyzerPlugin>> is an unnecessary extra hop. Prefer Arc<dyn AnalyzerPlugin> across the API when feasible.

crates/biome_analyze/src/lib.rs (1)

73-76: Docstring is outdated; plugins now run as visitors

This still claims plugins “do not support the same visitor pattern” which is no longer true after this PR. Please update to avoid confusing readers.

Suggested rewording:

• “The analyzer also supports plugins as syntax visitors. They respect the same suppression comments and report signals in the same format.”

Configuration used: Path: .coderabbit.yaml

Review profile: CHILL

Plan: Pro

💡 Knowledge Base configuration:

• MCP integration is disabled by default for public repositories
• Jira integration is disabled by default for public repositories
• Linear integration is disabled by default for public repositories

You can enable these sources in your CodeRabbit configuration.

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/tests/quick_test.rs : Use `biome_js_analyze/tests/quick_test.rs` for quick, ad-hoc testing; un-ignore the test and adjust the rule filter as needed

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_js_analyze/lib/src/lint/nursery/*.rs : For new JavaScript lint rules generated by `just new-js-lintrule`, implement the rule in the generated file under `biome_js_analyze/lib/src/lint/nursery/`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/biome_rule_options/lib/**/*.rs : Define per-rule options in the `biome_rule_options` crate under `lib/`, with serde- and schemars-compatible derives and `#[serde(rename_all = "camelCase", deny_unknown_fields, default)]`

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_analyze/CONTRIBUTING.md:0-0
Timestamp: 2025-08-17T08:56:30.831Z
Learning: Applies to crates/biome_analyze/crates/**/lib/src/**/nursery/**/*.rs : Use the local `rule_category!()` macro in diagnostics for the rule’s category, not string-parsed categories

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Specify category and severity using #[diagnostic(...)] on the type or derive them from fields

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : Types implementing Diagnostic must also implement Debug (e.g., use #[derive(Debug, Diagnostic)])

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/**/*.rs : #[derive(Diagnostic)] can be used on enums only if every variant contains a diagnostic type

Learnt from: CR
PR: biomejs/biome#0
File: crates/biome_diagnostics/CONTRIBUTING.md:0-0
Timestamp: 2025-08-11T11:46:05.836Z
Learning: Applies to crates/biome_diagnostics/crates/biome_diagnostics_categories/src/categories.rs : When declaring a new diagnostic category, register it in crates/biome_diagnostics_categories/src/categories.rs