Adapt changes to assist so that we no longer use mutable editor

Author: Shourya742

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

@@ -1294,8 +1294,8 @@ fn coerce_pointee_expand(
         ));
     }
 
-    let (mut editor, strukt) = SyntaxEditor::with_ast_node(strukt);
-    strukt.get_or_create_where_clause(&mut editor, new_predicates.into_iter());
+    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

@@ -56,10 +56,11 @@ pub(crate) fn add_braces(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<(
         },
         expr.syntax().text_range(),
         |builder| {
-            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 = editor.make().block_expr(None, Some(new_expr));
+            let block_expr = make.block_expr(None, Some(new_expr));
 
             editor.replace(expr.syntax(), block_expr.indent(expr.indent_level()).syntax());
             builder.add_file_edits(ctx.vfs_file_id(), editor);

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

@@ -53,14 +53,15 @@ pub(crate) fn add_explicit_method_call_deref(
         "Insert explicit method call derefs",
         dot_token.text_range(),
         |builder| {
-            let mut editor = builder.make_editor(method_call_expr.syntax());
+            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, editor.make());
+                expr = adjust_kind.wrap_expr(expr, make);
             }
 
-            expr = editor.make().expr_paren(expr).into();
+            expr = make.expr_paren(expr).into();
             editor.replace(receiver.syntax(), expr.syntax());
 
             builder.add_file_edits(ctx.vfs_file_id(), editor);

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

@@ -42,13 +42,14 @@ pub(crate) fn add_label_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>) -> O
         "Add Label",
         loop_expr.syntax().text_range(),
         |builder| {
-            let mut editor = builder.make_editor(loop_expr.syntax());
+            let editor = builder.make_editor(loop_expr.syntax());
+            let make = editor.make();
 
-            let label = editor.make().lifetime("'l");
+            let label = make.lifetime("'l");
             let elements = vec![
                 label.syntax().clone().into(),
-                editor.make().token(T![:]).into(),
-                editor.make().whitespace(" ").into(),
+                make.token(T![:]).into(),
+                make.whitespace(" ").into(),
             ];
             editor.insert_all(Position::before(&loop_kw), elements);
 
@@ -64,7 +65,7 @@ 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, &token, ctx, builder);
+                    insert_label_after_token(&editor, &token, ctx, builder);
                 }
             });
 
@@ -83,13 +84,14 @@ fn loop_token(loop_expr: &ast::AnyHasLoopBody) -> Option<syntax::SyntaxToken> {
 }
 
 fn insert_label_after_token(
-    editor: &mut SyntaxEditor,
+    editor: &SyntaxEditor,
     token: &SyntaxToken,
     ctx: &AssistContext<'_>,
     builder: &mut SourceChangeBuilder,
 ) {
-    let label = editor.make().lifetime("'l");
-    let elements = vec![editor.make().whitespace(" ").into(), label.syntax().clone().into()];
+    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);
 
     if let Some(cap) = ctx.config.snippet_cap {

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 mut editor = edit.make_editor(impl_def.syntax());
+        let editor = edit.make_editor(impl_def.syntax());
+        let make = editor.make();
         let new_item = add_trait_assoc_items_to_impl(
-            editor.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(
-                editor.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 {
@@ -189,12 +190,12 @@ fn add_missing_impl_members_inner(
             .collect::<Vec<_>>();
 
         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 = editor.make().assoc_item_list(new_assoc_items);
+            let assoc_item_list = make.assoc_item_list(new_assoc_items);
             editor.insert_all(
                 Position::after(impl_def.syntax()),
-                vec![editor.make().whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
+                vec![make.whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
             );
             first_new_item = assoc_item_list.assoc_items().next();
         }

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

@@ -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
@@ -357,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);
@@ -386,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;
@@ -419,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,21 +93,23 @@ 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 editor = builder.make_editor(let_stmt.syntax());
+                    let make = editor.make();
 
                     if let_stmt.semicolon_token().is_none() {
                         editor.insert(
                             Position::last_child_of(let_stmt.syntax()),
-                            editor.make().token(syntax::SyntaxKind::SEMICOLON),
+                            make.token(syntax::SyntaxKind::SEMICOLON),
                         );
                     }
 
-                    let placeholder_ty = editor.make().ty_placeholder();
+                    let make = editor.make();
+                    let placeholder_ty = make.ty_placeholder();
 
                     if let Some(pat) = let_stmt.pat() {
                         let elements = vec![
-                            editor.make().token(syntax::SyntaxKind::COLON).into(),
-                            editor.make().whitespace(" ").into(),
+                            make.token(syntax::SyntaxKind::COLON).into(),
+                            make.whitespace(" ").into(),
                             placeholder_ty.syntax().clone().into(),
                         ];
                         editor.insert_all(Position::after(pat.syntax()), elements);
@@ -140,7 +142,7 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         ident.text_range(),
         |builder| {
             builder.trigger_parameter_hints();
-            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()),
             };

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

@@ -80,8 +80,9 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         _ => return None,
     };
 
-    let (mut editor, demorganed) = SyntaxEditor::with_ast_node(&bin_expr);
-    editor.replace(demorganed.op_token()?, editor.make().token(inv_token));
+    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([
         (bin_expr.lhs()?, demorganed.lhs()?, prec),
@@ -92,23 +93,23 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         if let BinExpr(bin_expr) = &expr {
             if let BinExpr(cbin_expr) = &demorganed {
                 if op == bin_expr.op_kind()? {
-                    editor.replace(cbin_expr.op_token()?, editor.make().token(inv_token));
+                    editor.replace(cbin_expr.op_token()?, make.token(inv_token));
                     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(editor.make(), expr);
+                    let mut inv = invert_boolean_expression(make, expr);
                     if precedence(&inv).needs_parentheses_in(prec) {
-                        inv = editor.make().expr_paren(inv).into();
+                        inv = make.expr_paren(inv).into();
                     }
                     editor.replace(demorganed.syntax(), inv.syntax());
                 }
             } else {
                 return None;
             }
         } else {
-            let mut inv = invert_boolean_expression(editor.make(), demorganed.clone());
+            let mut inv = invert_boolean_expression(make, demorganed.clone());
             if precedence(&inv).needs_parentheses_in(prec) {
-                inv = editor.make().expr_paren(inv).into();
+                inv = make.expr_paren(inv).into();
             }
             editor.replace(demorganed.syntax(), inv.syntax());
         }
@@ -123,7 +124,8 @@ pub(crate) fn apply_demorgan(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
         "Apply De Morgan's law",
         op_range,
         |builder| {
-            let mut editor = builder.make_editor(bin_expr.syntax());
+            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()
@@ -139,17 +141,17 @@ 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(editor.make(), demorganed))
+                (paren_expr.syntax().clone(), add_bang_paren(make, demorganed))
             } else {
-                (bin_expr.syntax().clone(), add_bang_paren(editor.make(), demorganed))
+                (bin_expr.syntax().clone(), add_bang_paren(make, demorganed))
             };
 
             let final_expr = if target_node
                 .parent()
                 .is_some_and(|p| result_expr.needs_parens_in_place_of(&p, &target_node))
             {
                 cov_mark::hit!(demorgan_keep_parens_for_op_precedence2);
-                editor.make().expr_paren(result_expr).into()
+                make.expr_paren(result_expr).into()
             } else {
                 result_expr
             };
@@ -202,17 +204,18 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
         label,
         op_range,
         |builder| {
-            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" => editor.make().name_ref("any"),
-                "any" => editor.make().name_ref("all"),
+                "all" => make.name_ref("any"),
+                "any" => make.name_ref("all"),
                 _ => unreachable!(),
             };
             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, 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()
@@ -233,10 +236,7 @@ pub(crate) fn apply_demorgan_iterator(acc: &mut Assists, ctx: &AssistContext<'_>
                     prefix_expr.op_token().expect("prefix expression always has an operator"),
                 );
             } else {
-                editor.insert(
-                    Position::before(method_call.syntax()),
-                    editor.make().token(SyntaxKind::BANG),
-                );
+                editor.insert(Position::before(method_call.syntax()), make.token(SyntaxKind::BANG));
             }
             builder.add_file_edits(ctx.vfs_file_id(), editor);
         },
@@ -265,7 +265,7 @@ 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, 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() {