Merge pull request #22049 from Shourya742/2026-04-15-move-syntax-factory-inside-syntax-editor

Move syntax factory inside syntax editor

Author: ChayimFriedman2

crates/hir-expand/src/builtin/derive_macro.rs

@@ -22,7 +22,7 @@ use crate::{
 use syntax::{
     ast::{
         self, AstNode, FieldList, HasAttrs, HasGenericArgs, HasGenericParams, HasModuleItem,
-        HasName, HasTypeBounds, make, syntax_factory::SyntaxFactory,
+        HasName, HasTypeBounds, make,
     },
     syntax_editor::{GetOrCreateWhereClause, SyntaxEditor},
     ted,
@@ -1294,10 +1294,8 @@ fn coerce_pointee_expand(
         ));
     }
 
-    let (mut editor, strukt) = SyntaxEditor::with_ast_node(strukt);
-    let make = SyntaxFactory::with_mappings();
-    strukt.get_or_create_where_clause(&mut editor, &make, new_predicates.into_iter());
-    editor.add_mappings(make.finish_with_mappings());
+    let (editor, strukt) = SyntaxEditor::with_ast_node(strukt);
+    strukt.get_or_create_where_clause(&editor, new_predicates.into_iter());
     let edit = editor.finish();
     let strukt = ast::Struct::cast(edit.new_root().clone()).unwrap();
     let adt = ast::Adt::Struct(strukt.clone());

crates/ide-assists/src/handlers/add_braces.rs

@@ -1,7 +1,7 @@
 use either::Either;
 use syntax::{
     AstNode, T,
-    ast::{self, edit::AstNodeEdit, syntax_factory::SyntaxFactory},
+    ast::{self, edit::AstNodeEdit},
     match_ast,
 };
 
@@ -56,15 +56,13 @@ pub(crate) fn add_braces(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
         },
         expr.syntax().text_range(),
         |builder| {
-            let make = SyntaxFactory::with_mappings();
-            let mut editor = builder.make_editor(expr.syntax());
+            let editor = builder.make_editor(expr.syntax());
+            let make = editor.make();
 
             let new_expr = expr.reset_indent().indent(1.into());
             let block_expr = make.block_expr(None, Some(new_expr));
 
             editor.replace(expr.syntax(), block_expr.indent(expr.indent_level()).syntax());
-
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )

crates/ide-assists/src/handlers/add_explicit_dot_deref.rs

@@ -53,18 +53,18 @@ pub(crate) fn add_explicit_method_call_deref(
         "Insert explicit method call derefs",
         dot_token.text_range(),
         |builder| {
-            let mut edit = builder.make_editor(method_call_expr.syntax());
-            let make = SyntaxFactory::without_mappings();
+            let editor = builder.make_editor(method_call_expr.syntax());
+            let make = editor.make();
             let mut expr = receiver.clone();
 
             for adjust_kind in adjustments {
-                expr = adjust_kind.wrap_expr(expr, &make);
+                expr = adjust_kind.wrap_expr(expr, make);
             }
 
             expr = make.expr_paren(expr).into();
-            edit.replace(receiver.syntax(), expr.syntax());
+            editor.replace(receiver.syntax(), expr.syntax());
 
-            builder.add_file_edits(ctx.vfs_file_id(), edit);
+            builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
 }

crates/ide-assists/src/handlers/add_label_to_loop.rs

@@ -3,7 +3,7 @@ use ide_db::{
 };
 use syntax::{
     SyntaxToken, T,
-    ast::{self, AstNode, HasLoopBody, syntax_factory::SyntaxFactory},
+    ast::{self, AstNode, HasLoopBody},
     syntax_editor::{Position, SyntaxEditor},
 };
 
@@ -42,8 +42,8 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
         "Add Label",
         loop_expr.syntax().text_range(),
         |builder| {
-            let make = SyntaxFactory::with_mappings();
-            let mut editor = builder.make_editor(loop_expr.syntax());
+            let editor = builder.make_editor(loop_expr.syntax());
+            let make = editor.make();
 
             let label = make.lifetime("'l");
             let elements = vec![
@@ -65,11 +65,10 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
                     _ => return,
                 };
                 if let Some(token) = token {
-                    insert_label_after_token(&mut editor, &make, &token, ctx, builder);
+                    insert_label_after_token(&editor, &token, ctx, builder);
                 }
             });
 
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
             builder.rename();
         },
@@ -85,12 +84,12 @@ fn loop_token(loop_expr: &ast::AnyHasLoopBody) -> Option<syntax::SyntaxToken> {
 }
 
 fn insert_label_after_token(
-    editor: &mut SyntaxEditor,
-    make: &SyntaxFactory,
+    editor: &SyntaxEditor,
     token: &SyntaxToken,
     ctx: &AssistContext<'_>,
     builder: &mut SourceChangeBuilder,
 ) {
+    let make = editor.make();
     let label = make.lifetime("'l");
     let elements = vec![make.whitespace(" ").into(), label.syntax().clone().into()];
     editor.insert_all(Position::after(token), elements);

crates/ide-assists/src/handlers/add_missing_impl_members.rs

@@ -148,9 +148,10 @@ fn add_missing_impl_members_inner(
 
     let target = impl_def.syntax().text_range();
     acc.add(AssistId::quick_fix(assist_id), label, target, |edit| {
-        let make = SyntaxFactory::with_mappings();
+        let editor = edit.make_editor(impl_def.syntax());
+        let make = editor.make();
         let new_item = add_trait_assoc_items_to_impl(
-            &make,
+            make,
             &ctx.sema,
             ctx.config,
             &missing_items,
@@ -166,7 +167,7 @@ fn add_missing_impl_members_inner(
         let mut first_new_item = if let DefaultMethods::No = mode
             && let ast::AssocItem::Fn(func) = &first_new_item
             && let Some(body) = try_gen_trait_body(
-                &make,
+                make,
                 ctx,
                 func,
                 trait_ref,
@@ -175,7 +176,7 @@ fn add_missing_impl_members_inner(
             )
             && let Some(func_body) = func.body()
         {
-            let (mut func_editor, _) = SyntaxEditor::new(first_new_item.syntax().clone());
+            let (func_editor, _) = SyntaxEditor::new(first_new_item.syntax().clone());
             func_editor.replace(func_body.syntax(), body.syntax());
             ast::AssocItem::cast(func_editor.finish().new_root().clone())
         } else {
@@ -188,9 +189,8 @@ fn add_missing_impl_members_inner(
             .chain(other_items.iter().cloned())
             .collect::<Vec<_>>();
 
-        let mut editor = edit.make_editor(impl_def.syntax());
         if let Some(assoc_item_list) = impl_def.assoc_item_list() {
-            assoc_item_list.add_items(&mut editor, new_assoc_items);
+            assoc_item_list.add_items(&editor, new_assoc_items);
         } else {
             let assoc_item_list = make.assoc_item_list(new_assoc_items);
             editor.insert_all(
@@ -218,7 +218,6 @@ fn add_missing_impl_members_inner(
                 editor.add_annotation(first_new_item.syntax(), tabstop);
             };
         };
-        editor.add_mappings(make.finish_with_mappings());
         edit.add_file_edits(ctx.vfs_file_id(), editor);
     })
 }

crates/ide-assists/src/handlers/add_missing_match_arms.rs

@@ -74,7 +74,7 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
         .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
         .collect();
 
-    let make = SyntaxFactory::with_mappings();
+    let make = SyntaxFactory::without_mappings();
 
     let scope = ctx.sema.scope(expr.syntax())?;
     let module = scope.module();
@@ -271,12 +271,12 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                 }
             };
 
-            let mut editor = builder.make_editor(&old_place);
+            let editor = builder.make_editor(&old_place);
             let mut arms_edit = ArmsEdit { match_arm_list, place: old_place, last_arm: None };
 
-            arms_edit.remove_wildcard_arms(ctx, &mut editor);
-            arms_edit.add_comma_after_last_arm(ctx, &make, &mut editor);
-            arms_edit.append_arms(&missing_arms, &make, &mut editor);
+            arms_edit.remove_wildcard_arms(ctx, &editor);
+            arms_edit.add_comma_after_last_arm(ctx, &make, &editor);
+            arms_edit.append_arms(&missing_arms, &make, &editor);
 
             if let Some(cap) = ctx.config.snippet_cap {
                 if let Some(it) = missing_arms
@@ -297,7 +297,6 @@ pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>)
                 }
             }
 
-            editor.add_mappings(make.take());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -358,7 +357,7 @@ struct ArmsEdit {
 }
 
 impl ArmsEdit {
-    fn remove_wildcard_arms(&mut self, ctx: &AssistContext<'_>, editor: &mut SyntaxEditor) {
+    fn remove_wildcard_arms(&mut self, ctx: &AssistContext<'_>, editor: &SyntaxEditor) {
         for arm in self.match_arm_list.arms() {
             if !matches!(arm.pat(), Some(Pat::WildcardPat(_))) {
                 self.last_arm = Some(arm);
@@ -387,7 +386,7 @@ impl ArmsEdit {
         }
     }
 
-    fn append_arms(&self, arms: &[ast::MatchArm], make: &SyntaxFactory, editor: &mut SyntaxEditor) {
+    fn append_arms(&self, arms: &[ast::MatchArm], make: &SyntaxFactory, editor: &SyntaxEditor) {
         let Some(mut before) = self.place.last_token() else {
             stdx::never!("match arm list not contain any token");
             return;
@@ -420,7 +419,7 @@ impl ArmsEdit {
         &self,
         ctx: &AssistContext<'_>,
         make: &SyntaxFactory,
-        editor: &mut SyntaxEditor,
+        editor: &SyntaxEditor,
     ) {
         if let Some(last_arm) = &self.last_arm
             && last_arm.comma_token().is_none()

crates/ide-assists/src/handlers/add_turbo_fish.rs

@@ -93,8 +93,8 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 "Add `: _` before assignment operator",
                 ident.text_range(),
                 |builder| {
-                    let mut editor = builder.make_editor(let_stmt.syntax());
-                    let make = SyntaxFactory::without_mappings();
+                    let editor = builder.make_editor(let_stmt.syntax());
+                    let make = editor.make();
 
                     if let_stmt.semicolon_token().is_none() {
                         editor.insert(
@@ -103,6 +103,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                         );
                     }
 
+                    let make = editor.make();
                     let placeholder_ty = make.ty_placeholder();
 
                     if let Some(pat) = let_stmt.pat() {
@@ -141,14 +142,12 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         ident.text_range(),
         |builder| {
             builder.trigger_parameter_hints();
-
-            let make = SyntaxFactory::with_mappings();
-            let mut editor = match &turbofish_target {
+            let editor = match &turbofish_target {
                 Either::Left(it) => builder.make_editor(it.syntax()),
                 Either::Right(it) => builder.make_editor(it.syntax()),
             };
 
-            let fish_head = get_fish_head(&make, number_of_arguments);
+            let fish_head = get_fish_head(editor.make(), number_of_arguments);
 
             match turbofish_target {
                 Either::Left(path_segment) => {
@@ -180,8 +179,6 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                     editor.add_annotation(arg.syntax(), builder.make_placeholder_snippet(cap));
                 }
             }
-
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )

crates/ide-assists/src/handlers/apply_demorgan.rs

@@ -80,9 +80,8 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         _ => return None,
     };
 
-    let make = SyntaxFactory::with_mappings();
-
-    let (mut editor, demorganed) = SyntaxEditor::with_ast_node(&bin_expr);
+    let (editor, demorganed) = SyntaxEditor::with_ast_node(&bin_expr);
+    let make = editor.make();
     editor.replace(demorganed.op_token()?, make.token(inv_token));
 
     let mut exprs = VecDeque::from([
@@ -98,7 +97,7 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                     exprs.push_back((bin_expr.lhs()?, cbin_expr.lhs()?, prec));
                     exprs.push_back((bin_expr.rhs()?, cbin_expr.rhs()?, prec));
                 } else {
-                    let mut inv = invert_boolean_expression(&make, expr);
+                    let mut inv = invert_boolean_expression(make, expr);
                     if precedence(&inv).needs_parentheses_in(prec) {
                         inv = make.expr_paren(inv).into();
                     }
@@ -108,15 +107,14 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 return None;
             }
         } else {
-            let mut inv = invert_boolean_expression(&make, demorganed.clone());
+            let mut inv = invert_boolean_expression(make, demorganed.clone());
             if precedence(&inv).needs_parentheses_in(prec) {
                 inv = make.expr_paren(inv).into();
             }
             editor.replace(demorganed.syntax(), inv.syntax());
         }
     }
 
-    editor.add_mappings(make.finish_with_mappings());
     let edit = editor.finish();
     let demorganed = ast::Expr::cast(edit.new_root().clone())?;
 
@@ -126,7 +124,9 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         "Apply De Morgan's law",
         op_range,
         |builder| {
-            let make = SyntaxFactory::with_mappings();
+            let editor = builder.make_editor(bin_expr.syntax());
+            let make = editor.make();
+
             let (target_node, result_expr) = if let Some(neg_expr) = bin_expr
                 .syntax()
                 .parent()
@@ -141,9 +141,9 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 bin_expr.syntax().parent().and_then(ast::ParenExpr::cast)
             {
                 cov_mark::hit!(demorgan_double_parens);
-                (paren_expr.syntax().clone(), add_bang_paren(&make, demorganed))
+                (paren_expr.syntax().clone(), add_bang_paren(make, demorganed))
             } else {
-                (bin_expr.syntax().clone(), add_bang_paren(&make, demorganed))
+                (bin_expr.syntax().clone(), add_bang_paren(make, demorganed))
             };
 
             let final_expr = if target_node
@@ -156,9 +156,7 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 result_expr
             };
 
-            let mut editor = builder.make_editor(&target_node);
             editor.replace(&target_node, final_expr.syntax());
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -206,8 +204,8 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
         label,
         op_range,
         |builder| {
-            let make = SyntaxFactory::with_mappings();
-            let mut editor = builder.make_editor(method_call.syntax());
+            let editor = builder.make_editor(method_call.syntax());
+            let make = editor.make();
             // replace the method name
             let new_name = match name.text().as_str() {
                 "all" => make.name_ref("any"),
@@ -217,7 +215,7 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
             editor.replace(name.syntax(), new_name.syntax());
 
             // negate all tail expressions in the closure body
-            let tail_cb = &mut |e: &_| tail_cb_impl(&mut editor, &make, e);
+            let tail_cb = &mut |e: &_| tail_cb_impl(&editor, e);
             walk_expr(&closure_body, &mut |expr| {
                 if let ast::Expr::ReturnExpr(ret_expr) = expr
                     && let Some(ret_expr_arg) = &ret_expr.expr()
@@ -240,8 +238,6 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
             } else {
                 editor.insert(Position::before(method_call.syntax()), make.token(SyntaxKind::BANG));
             }
-
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
     )
@@ -269,18 +265,18 @@ fn validate_method_call_expr(
     it_type.impls_trait(sema.db, iter_trait, &[]).then_some((name_ref, arg_expr))
 }
 
-fn tail_cb_impl(editor: &mut SyntaxEditor, make: &SyntaxFactory, e: &ast::Expr) {
+fn tail_cb_impl(editor: &SyntaxEditor, e: &ast::Expr) {
     match e {
         ast::Expr::BreakExpr(break_expr) => {
             if let Some(break_expr_arg) = break_expr.expr() {
-                for_each_tail_expr(&break_expr_arg, &mut |e| tail_cb_impl(editor, make, e))
+                for_each_tail_expr(&break_expr_arg, &mut |e| tail_cb_impl(editor, e))
             }
         }
         ast::Expr::ReturnExpr(_) => {
             // all return expressions have already been handled by the walk loop
         }
         e => {
-            let inverted_body = invert_boolean_expression(make, e.clone());
+            let inverted_body = invert_boolean_expression(editor.make(), e.clone());
             editor.replace(e.syntax(), inverted_body.syntax());
         }
     }