perf: batch code fixes

dyc3 · dyc3 · commit 0df6aff45d22 · 2025-12-25T08:34:11.000-05:00
diff --git a/crates/biome_rowan/src/ast/batch.rs b/crates/biome_rowan/src/ast/batch.rs
@@ -590,6 +590,37 @@ where
     pub fn is_empty(&self) -> bool {
         self.changes.is_empty()
     }
+
+    /// Merge another mutation's changes into this one.
+    ///
+    /// Both mutations should operate on trees with the same structure for
+    /// correct results. The changes from the other mutation are added to this
+    /// mutation's change queue.
+    ///
+    /// This is useful for batching multiple non-overlapping fixes into a single
+    /// commit operation, which can significantly improve performance by reducing
+    /// the number of tree rebuilds needed.
+    ///
+    /// # Example
+    ///
+    /// ```ignore
+    /// let mut batch1 = tree.begin();
+    /// batch1.replace_node(node_a, new_a);
+    ///
+    /// let mut batch2 = tree.begin();
+    /// batch2.replace_node(node_b, new_b);
+    ///
+    /// // Merge batch2 into batch1
+    /// batch1.merge(batch2);
+    ///
+    /// // Commit all changes at once
+    /// let new_tree = batch1.commit();
+    /// ```
+    pub fn merge(&mut self, other: BatchMutation<L>) {
+        for change in other.changes {
+            self.changes.push(change);
+        }
+    }
 }
 
 #[cfg(test)]
@@ -701,4 +732,51 @@ pub mod test {
 
         assert_eq!(expected_debug, format!("{after:#?}"));
     }
+
+    #[test]
+    pub fn ok_batch_mutation_merge_two_mutations() {
+        let (before, _) = tree_two("a", "b");
+        let (expected, expected_debug) = tree_two("c", "d");
+
+        let a = find(&before, "a");
+        let b = find(&before, "b");
+        let c = clone_detach(&expected, "c");
+        let d = clone_detach(&expected, "d");
+
+        // Create two separate mutations
+        let mut batch1 = before.clone().begin();
+        batch1.replace_node(a, c);
+
+        let mut batch2 = before.begin();
+        batch2.replace_node(b, d);
+
+        // Merge batch2 into batch1
+        batch1.merge(batch2);
+        let after = batch1.commit();
+
+        // Result should be the same as applying both changes together
+        assert_eq!(expected_debug, format!("{after:#?}"));
+    }
+
+    #[test]
+    pub fn ok_batch_mutation_merge_empty_mutation() {
+        let (before, _) = tree_one("a");
+        let (expected, expected_debug) = tree_one("b");
+
+        let a = find(&before, "a");
+        let b = clone_detach(&expected, "b");
+
+        let mut batch1 = before.clone().begin();
+        batch1.replace_node(a, b);
+
+        // Create an empty mutation
+        let batch2 = before.begin();
+        assert!(batch2.is_empty());
+
+        // Merge empty mutation should not change anything
+        batch1.merge(batch2);
+        let after = batch1.commit();
+
+        assert_eq!(expected_debug, format!("{after:#?}"));
+    }
 }
diff --git a/crates/biome_service/src/file_handlers/css.rs b/crates/biome_service/src/file_handlers/css.rs
@@ -1,6 +1,7 @@
 use super::{
     AnalyzerVisitorBuilder, CodeActionsParams, EnabledForPath, ExtensionHandler, FixAllParams,
-    LintParams, LintResults, ParseResult, ProcessFixAll, ProcessLint, SearchCapabilities, search,
+    LintParams, LintResults, ParseResult, ProcessFixAllBatched, ProcessLint, SearchCapabilities,
+    search,
 };
 use crate::WorkspaceError;
 use crate::configuration::to_analyzer_rules;
@@ -16,7 +17,9 @@ use crate::workspace::{
     CodeAction, DocumentFileSource, FixFileResult, GetSyntaxTreeResult, PullActionsResult,
 };
 use biome_analyze::options::PreferredQuote;
-use biome_analyze::{AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never};
+use biome_analyze::{
+    AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never, RuleError,
+};
 use biome_configuration::css::{
     CssAllowWrongLineCommentsEnabled, CssAssistConfiguration, CssAssistEnabled,
     CssFormatterConfiguration, CssFormatterEnabled, CssLinterConfiguration, CssLinterEnabled,
@@ -675,6 +678,9 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 }
 
 /// Applies all the safe fixes to the given syntax tree.
+///
+/// This uses a batched approach that collects multiple non-overlapping fixes
+/// per analysis pass for improved performance.
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
     let mut tree: CssRoot = params.parse.tree();
     let Some(file_source) = params.document_file_source.to_css_file_source() else {
@@ -704,7 +710,7 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         range: None,
     };
 
-    let mut process_fix_all = ProcessFixAll::new(
+    let mut process = ProcessFixAllBatched::<CssLanguage>::new(
         &params,
         rules,
         tree.syntax().text_range_with_trivia().len().into(),
@@ -719,25 +725,22 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
             file_source,
         };
 
-        let (action, _) = analyze(
+        // Analyze and collect ALL applicable actions (never breaks early)
+        let (_, _) = analyze(
             &tree,
             filter,
             &analyzer_options,
             css_services,
             &params.plugins,
-            |signal| process_fix_all.process_signal(signal),
+            |signal| process.collect_signal(signal),
         );
 
-        let result = process_fix_all.process_action(action, |root| {
-            tree = match CssRoot::cast(root) {
-                Some(tree) => tree,
-                None => return None,
-            };
-            Some(tree.syntax().text_range_with_trivia().len().into())
-        })?;
+        // Get non-overlapping batch of actions
+        let batch = process.take_batch();
 
-        if result.is_none() {
-            return process_fix_all.finish(|| {
+        if batch.is_empty() {
+            // No more fixes to apply - we're done
+            return process.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
                         params.settings.format_options::<CssLanguage>(
@@ -751,6 +754,23 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 })
             });
         }
+
+        // Merge all actions into one mutation and apply
+        if let Some(combined_mutation) = process.merge_actions(batch) {
+            let (new_root, _) = combined_mutation.commit_with_text_range_and_edit(true);
+            tree = match CssRoot::cast(new_root) {
+                Some(tree) => tree,
+                None => {
+                    return Err(WorkspaceError::RuleError(
+                        RuleError::ReplacedRootWithNonRootError { rule_name: None },
+                    ));
+                }
+            };
+
+            // Check for runaway growth
+            let new_len: u32 = tree.syntax().text_range_with_trivia().len().into();
+            process.check_growth(new_len)?;
+        }
     }
 }
 
diff --git a/crates/biome_service/src/file_handlers/graphql.rs b/crates/biome_service/src/file_handlers/graphql.rs
@@ -1,6 +1,6 @@
 use super::{
     AnalyzerVisitorBuilder, CodeActionsParams, DocumentFileSource, EnabledForPath,
-    ExtensionHandler, FixAllParams, LintParams, LintResults, ParseResult, ProcessFixAll,
+    ExtensionHandler, FixAllParams, LintParams, LintResults, ParseResult, ProcessFixAllBatched,
     ProcessLint, SearchCapabilities,
 };
 use crate::WorkspaceError;
@@ -14,7 +14,9 @@ use crate::settings::{
     Settings, check_feature_activity, check_override_feature_activity,
 };
 use crate::workspace::{CodeAction, FixFileResult, GetSyntaxTreeResult, PullActionsResult};
-use biome_analyze::{AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never};
+use biome_analyze::{
+    AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never, RuleError,
+};
 use biome_configuration::graphql::{
     GraphqlAssistConfiguration, GraphqlAssistEnabled, GraphqlFormatterConfiguration,
     GraphqlFormatterEnabled, GraphqlLinterConfiguration, GraphqlLinterEnabled,
@@ -541,6 +543,9 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
 }
 
 /// If applies all the safe fixes to the given syntax tree.
+///
+/// This uses a batched approach that collects multiple non-overlapping fixes
+/// per analysis pass for improved performance.
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
     let mut tree: GraphqlRoot = params.parse.tree();
 
@@ -567,26 +572,24 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         range: None,
     };
 
-    let mut process_fix_all = ProcessFixAll::new(
+    let mut process = ProcessFixAllBatched::<GraphqlLanguage>::new(
         &params,
         rules,
         tree.syntax().text_range_with_trivia().len().into(),
     );
+
     loop {
-        let (action, _) = analyze(&tree, filter, &analyzer_options, |signal| {
-            process_fix_all.process_signal(signal)
+        // Analyze and collect ALL applicable actions (never breaks early)
+        let (_, _) = analyze(&tree, filter, &analyzer_options, |signal| {
+            process.collect_signal(signal)
         });
 
-        let result = process_fix_all.process_action(action, |root| {
-            tree = match GraphqlRoot::cast(root) {
-                Some(tree) => tree,
-                None => return None,
-            };
-            Some(tree.syntax().text_range_with_trivia().len().into())
-        })?;
+        // Get non-overlapping batch of actions
+        let batch = process.take_batch();
 
-        if result.is_none() {
-            return process_fix_all.finish(|| {
+        if batch.is_empty() {
+            // No more fixes to apply - we're done
+            return process.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
                         params.settings.format_options::<GraphqlLanguage>(
@@ -600,5 +603,22 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 })
             });
         }
+
+        // Merge all actions into one mutation and apply
+        if let Some(combined_mutation) = process.merge_actions(batch) {
+            let (new_root, _) = combined_mutation.commit_with_text_range_and_edit(true);
+            tree = match GraphqlRoot::cast(new_root) {
+                Some(tree) => tree,
+                None => {
+                    return Err(WorkspaceError::RuleError(
+                        RuleError::ReplacedRootWithNonRootError { rule_name: None },
+                    ));
+                }
+            };
+
+            // Check for runaway growth
+            let new_len: u32 = tree.syntax().text_range_with_trivia().len().into();
+            process.check_growth(new_len)?;
+        }
     }
 }
diff --git a/crates/biome_service/src/file_handlers/html.rs b/crates/biome_service/src/file_handlers/html.rs
@@ -2,7 +2,7 @@ use super::{
     AnalyzerCapabilities, AnalyzerVisitorBuilder, Capabilities, CodeActionsParams,
     DebugCapabilities, DocumentFileSource, EnabledForPath, ExtensionHandler, FixAllParams,
     FormatEmbedNode, FormatterCapabilities, LintParams, LintResults, ParseEmbedResult, ParseResult,
-    ParserCapabilities, ProcessFixAll, ProcessLint, SearchCapabilities, UpdateSnippetsNodes,
+    ParserCapabilities, ProcessFixAllBatched, ProcessLint, SearchCapabilities, UpdateSnippetsNodes,
 };
 use crate::configuration::to_analyzer_rules;
 use crate::settings::{OverrideSettings, check_feature_activity, check_override_feature_activity};
@@ -13,7 +13,9 @@ use crate::{
     settings::{ServiceLanguage, Settings},
     workspace::GetSyntaxTreeResult,
 };
-use biome_analyze::{AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never};
+use biome_analyze::{
+    AnalysisFilter, AnalyzerConfiguration, AnalyzerOptions, ControlFlow, Never, RuleError,
+};
 use biome_configuration::html::{
     HtmlAssistConfiguration, HtmlAssistEnabled, HtmlFormatterConfiguration, HtmlFormatterEnabled,
     HtmlLinterConfiguration, HtmlLinterEnabled, HtmlParseInterpolation, HtmlParserConfiguration,
@@ -853,6 +855,10 @@ pub(crate) fn code_actions(params: CodeActionsParams) -> PullActionsResult {
     PullActionsResult { actions }
 }
 
+/// If applies all the safe fixes to the given syntax tree.
+///
+/// This uses a batched approach that collects multiple non-overlapping fixes
+/// per analysis pass for improved performance.
 #[tracing::instrument(level = "debug", skip(params))]
 pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceError> {
     let mut tree: HtmlRoot = params.parse.tree();
@@ -880,27 +886,24 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
         range: None,
     };
 
-    let mut process_fix_all = ProcessFixAll::new(
+    let mut process = ProcessFixAllBatched::<HtmlLanguage>::new(
         &params,
         rules,
         tree.syntax().text_range_with_trivia().len().into(),
     );
 
     loop {
-        let (action, _) = analyze(&tree, filter, &analyzer_options, |signal| {
-            process_fix_all.process_signal(signal)
+        // Analyze and collect ALL applicable actions (never breaks early)
+        let (_, _) = analyze(&tree, filter, &analyzer_options, |signal| {
+            process.collect_signal(signal)
         });
 
-        let result = process_fix_all.process_action(action, |root| {
-            tree = match HtmlRoot::cast(root) {
-                Some(tree) => tree,
-                None => return None,
-            };
-            Some(tree.syntax().text_range_with_trivia().len().into())
-        })?;
+        // Get non-overlapping batch of actions
+        let batch = process.take_batch();
 
-        if result.is_none() {
-            return process_fix_all.finish(|| {
+        if batch.is_empty() {
+            // No more fixes to apply - we're done
+            return process.finish(|| {
                 Ok(if params.should_format {
                     Either::Left(format_node(
                         params.settings.format_options::<HtmlLanguage>(
@@ -915,6 +918,23 @@ pub(crate) fn fix_all(params: FixAllParams) -> Result<FixFileResult, WorkspaceEr
                 })
             });
         }
+
+        // Merge all actions into one mutation and apply
+        if let Some(combined_mutation) = process.merge_actions(batch) {
+            let (new_root, _) = combined_mutation.commit_with_text_range_and_edit(true);
+            tree = match HtmlRoot::cast(new_root) {
+                Some(tree) => tree,
+                None => {
+                    return Err(WorkspaceError::RuleError(
+                        RuleError::ReplacedRootWithNonRootError { rule_name: None },
+                    ));
+                }
+            };
+
+            // Check for runaway growth
+            let new_len: u32 = tree.syntax().text_range_with_trivia().len().into();
+            process.check_growth(new_len)?;
+        }
     }
 }
 
diff --git a/crates/biome_service/src/file_handlers/javascript.rs b/crates/biome_service/src/file_handlers/javascript.rs
diff --git a/crates/biome_service/src/file_handlers/mod.rs b/crates/biome_service/src/file_handlers/mod.rs
