feat(biome_service): support applying GritQL plugin rewrites via --write

.changeset/fixable-gritql-plugins.md

@@ -0,0 +1,17 @@
+---
+"@biomejs/biome": minor
+---
+
+Added support for applying GritQL plugin rewrites as code actions. GritQL plugins that use the rewrite operator (`=>`) now produce fixable diagnostics for JavaScript, CSS, and JSON files. By default, plugin rewrites are treated as unsafe fixes and require `--write --unsafe` to apply. Plugin authors can pass `fix_kind = "safe"` to `register_diagnostic()` to mark a fix as safe, allowing it to be applied with just `--write`.
+
+**Example plugin** (`useConsoleInfo.grit`):
+```grit
+language js
+
+`console.log($msg)` as $call where {
+    register_diagnostic(span = $call, message = "Use console.info instead of console.log.", severity = "warn", fix_kind = "safe"),
+    $call => `console.info($msg)`
+}
+```
+
+Running `biome check --write` applies safe rewrites. Unsafe rewrites (the default, or `fix_kind = "unsafe"`) still require `--write --unsafe`.

crates/biome_analyze/Cargo.toml

@@ -21,6 +21,7 @@ biome_diagnostics        = { workspace = true }
 biome_parser             = { workspace = true }
 biome_rowan              = { workspace = true }
 biome_suppression        = { workspace = true }
+biome_text_edit          = { workspace = true }
 camino                   = { workspace = true }
 enumflags2               = { workspace = true }
 indexmap                 = { workspace = true }

crates/biome_analyze/src/analyzer_plugin.rs

@@ -1,10 +1,12 @@
+use biome_diagnostics::Applicability;
+use biome_rowan::{
+    AnySyntaxNode, Language, RawSyntaxKind, SyntaxKind, SyntaxNode, TextRange, WalkEvent,
+};
 use camino::Utf8PathBuf;
 use rustc_hash::FxHashSet;
 use std::hash::Hash;
 use std::{fmt::Debug, sync::Arc};
 
-use biome_rowan::{AnySyntaxNode, Language, RawSyntaxKind, SyntaxKind, SyntaxNode, WalkEvent};
-
 use crate::matcher::SignalRuleKey;
 use crate::{
     PluginSignal, RuleCategory, RuleDiagnostic, SignalEntry, Visitor, VisitorContext, profiling,
@@ -16,13 +18,41 @@ pub type AnalyzerPluginSlice<'a> = &'a [Arc<Box<dyn AnalyzerPlugin>>];
 /// Vector of analyzer plugins that can be cheaply cloned.
 pub type AnalyzerPluginVec = Vec<Arc<Box<dyn AnalyzerPlugin>>>;
 
+/// Data for a code action produced by a plugin.
+#[derive(Debug, Clone)]
+pub struct PluginActionData {
+    /// The source range this action applies to.
+    pub source_range: TextRange,
+    /// The original source text that was matched.
+    pub original_text: String,
+    /// The rewritten text to replace the original.
+    pub rewritten_text: String,
+    /// A message describing the action.
+    pub message: String,
+    /// Whether this fix is safe or unsafe.
+    pub applicability: Applicability,
+}
+
+/// A diagnostic paired with its optional code action.
+#[derive(Debug)]
+pub struct PluginDiagnosticEntry {
+    pub diagnostic: RuleDiagnostic,
+    pub action: Option<PluginActionData>,
+}
+
+/// Result of evaluating a plugin, containing diagnostics paired with their actions.
+#[derive(Debug, Default)]
+pub struct PluginEvalResult {
+    pub entries: Vec<PluginDiagnosticEntry>,
+}
+
 /// Definition of an analyzer plugin.
 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>;
+    fn evaluate(&self, node: AnySyntaxNode, path: Arc<Utf8PathBuf>) -> PluginEvalResult;
 }
 
 #[derive(Copy, Clone, Debug, Eq, PartialEq, Hash)]
@@ -103,20 +133,26 @@ where
         }
 
         let rule_timer = profiling::start_plugin_rule("plugin");
-        let diagnostics = self
+        let eval_result = self
             .plugin
             .evaluate(node.clone().into(), ctx.options.file_path.clone());
         rule_timer.stop();
 
-        let signals = diagnostics.into_iter().map(|diagnostic| {
-            let name = diagnostic
+        let signals = eval_result.entries.into_iter().map(|entry| {
+            let name = entry
+                .diagnostic
                 .subcategory
                 .clone()
                 .unwrap_or_else(|| "anonymous".into());
+            let text_range = entry.diagnostic.span().unwrap_or_default();
+
+            let signal = PluginSignal::<L>::new(entry.diagnostic)
+                .with_plugin_action(entry.action)
+                .with_root(node.clone());
 
             SignalEntry {
-                text_range: diagnostic.span().unwrap_or_default(),
-                signal: Box::new(PluginSignal::<L>::new(diagnostic)),
+                text_range,
+                signal: Box::new(signal),
                 rule: SignalRuleKey::Plugin(name.into()),
                 category: RuleCategory::Lint,
                 instances: Default::default(),

crates/biome_analyze/src/lib.rs

@@ -30,7 +30,8 @@ mod visitor;
 pub use biome_diagnostics::category_concat;
 
 pub use crate::analyzer_plugin::{
-    AnalyzerPlugin, AnalyzerPluginSlice, AnalyzerPluginVec, PluginTargetLanguage, PluginVisitor,
+    AnalyzerPlugin, AnalyzerPluginSlice, AnalyzerPluginVec, PluginActionData,
+    PluginDiagnosticEntry, PluginEvalResult, PluginTargetLanguage, PluginVisitor,
 };
 pub use crate::categories::{
     ActionCategory, OtherActionCategory, RefactorKind, RuleCategories, RuleCategoriesBuilder,

crates/biome_analyze/src/signals.rs

@@ -2,16 +2,18 @@ use crate::categories::{
     SUPPRESSION_INLINE_ACTION_CATEGORY, SUPPRESSION_TOP_LEVEL_ACTION_CATEGORY,
 };
 use crate::{
-    AnalyzerDiagnostic, AnalyzerOptions, OtherActionCategory, Queryable, RuleDiagnostic, RuleGroup,
-    ServiceBag, SuppressionAction,
+    AnalyzerDiagnostic, AnalyzerOptions, OtherActionCategory, PluginActionData, Queryable,
+    RuleDiagnostic, RuleGroup, ServiceBag, SuppressionAction,
     categories::ActionCategory,
     context::RuleContext,
     registry::{RuleLanguage, RuleRoot},
     rule::Rule,
 };
 use biome_console::{MarkupBuf, markup};
 use biome_diagnostics::{Applicability, CodeSuggestion, Error, advice::CodeSuggestionAdvice};
-use biome_rowan::{BatchMutation, Language};
+use biome_rowan::{BatchMutation, Language, SyntaxNode, TextRange};
+use biome_text_edit::TextEdit;
+use std::borrow::Cow;
 use std::iter::FusedIterator;
 use std::marker::PhantomData;
 use std::vec::IntoIter;
@@ -109,18 +111,30 @@ where
 /// Unlike [DiagnosticSignal] which converts through [Error] into
 /// [DiagnosticKind::Raw](crate::diagnostics::DiagnosticKind::Raw), this type
 /// directly converts via `AnalyzerDiagnostic::from(RuleDiagnostic)`.
-pub struct PluginSignal<L> {
+pub struct PluginSignal<L: Language> {
     diagnostic: RuleDiagnostic,
-    _phantom: PhantomData<L>,
+    plugin_action: Option<PluginActionData>,
+    root: Option<SyntaxNode<L>>,
 }
 
 impl<L: Language> PluginSignal<L> {
     pub fn new(diagnostic: RuleDiagnostic) -> Self {
         Self {
             diagnostic,
-            _phantom: PhantomData,
+            plugin_action: None,
+            root: None,
         }
     }
+
+    pub fn with_plugin_action(mut self, action: Option<PluginActionData>) -> Self {
+        self.plugin_action = action;
+        self
+    }
+
+    pub fn with_root(mut self, root: SyntaxNode<L>) -> Self {
+        self.root = Some(root);
+        self
+    }
 }
 
 impl<L: Language> AnalyzerSignal<L> for PluginSignal<L> {
@@ -129,7 +143,25 @@ impl<L: Language> AnalyzerSignal<L> for PluginSignal<L> {
     }
 
     fn actions(&self) -> AnalyzerActionIter<L> {
-        AnalyzerActionIter::new(vec![])
+        let Some(action_data) = &self.plugin_action else {
+            return AnalyzerActionIter::new(vec![]);
+        };
+
+        let Some(root) = &self.root else {
+            return AnalyzerActionIter::new(vec![]);
+        };
+
+        let text_edit =
+            TextEdit::from_unicode_words(&action_data.original_text, &action_data.rewritten_text);
+
+        AnalyzerActionIter::new(vec![AnalyzerAction {
+            rule_name: None,
+            category: ActionCategory::QuickFix(Cow::Borrowed("plugin")),
+            applicability: action_data.applicability,
+            message: markup!({ action_data.message }).to_owned(),
+            mutation: BatchMutation::new(root.clone()),
+            text_edit: Some((action_data.source_range, text_edit)),
+        }])
     }
 
     fn transformations(&self) -> AnalyzerTransformationIter<L> {
@@ -149,6 +181,8 @@ pub struct AnalyzerAction<L: Language> {
     pub applicability: Applicability,
     pub message: MarkupBuf,
     pub mutation: BatchMutation<L>,
+    /// Pre-computed text edit for plugin rewrites. Takes precedence over mutation.
+    pub text_edit: Option<(TextRange, TextEdit)>,
 }
 
 impl<L: Language> AnalyzerAction<L> {
@@ -179,7 +213,10 @@ impl<L: Language> Default for AnalyzerActionIter<L> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (_, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
+        let (_, suggestion) = action
+            .text_edit
+            .or_else(|| action.mutation.to_text_range_and_edit())
+            .unwrap_or_default();
         Self {
             applicability: action.applicability,
             msg: action.message,
@@ -190,7 +227,10 @@ impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionAdvice<MarkupBuf> {
 
 impl<L: Language> From<AnalyzerAction<L>> for CodeSuggestionItem {
     fn from(action: AnalyzerAction<L>) -> Self {
-        let (range, suggestion) = action.mutation.to_text_range_and_edit().unwrap_or_default();
+        let (range, suggestion) = action
+            .text_edit
+            .or_else(|| action.mutation.to_text_range_and_edit())
+            .unwrap_or_default();
 
         Self {
             rule_name: action.rule_name,
@@ -469,6 +509,7 @@ where
                     category: action.category,
                     mutation: action.mutation,
                     message: action.message,
+                    text_edit: None,
                 });
             };
             if let Some(text_range) = R::text_range(&ctx, &self.state)
@@ -485,6 +526,7 @@ where
                     applicability: Applicability::Always,
                     mutation: suppression_action.mutation,
                     message: suppression_action.message,
+                    text_edit: None,
                 };
                 actions.push(action);
             }
@@ -498,6 +540,7 @@ where
                     applicability: Applicability::Always,
                     mutation: suppression_action.mutation,
                     message: suppression_action.message,
+                    text_edit: None,
                 };
                 actions.push(action);
             }