Remove all occurance of explicit SyntaxFactory::with_mapping, and update all the occurances to use make via SyntaxEditor

Author: Shourya742

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,
@@ -1295,9 +1295,7 @@ 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());
+    strukt.get_or_create_where_clause(&mut 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,12 @@ 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 new_expr = expr.reset_indent().indent(1.into());
-            let block_expr = make.block_expr(None, Some(new_expr));
+            let block_expr = editor.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,17 @@ 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 mut editor = builder.make_editor(method_call_expr.syntax());
             let mut expr = receiver.clone();
 
             for adjust_kind in adjustments {
-                expr = adjust_kind.wrap_expr(expr, &make);
+                expr = adjust_kind.wrap_expr(expr, editor.make());
             }
 
-            expr = make.expr_paren(expr).into();
-            edit.replace(receiver.syntax(), expr.syntax());
+            expr = editor.make().expr_paren(expr).into();
+            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,14 +42,13 @@ 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 label = make.lifetime("'l");
+            let label = editor.make().lifetime("'l");
             let elements = vec![
                 label.syntax().clone().into(),
-                make.token(T![:]).into(),
-                make.whitespace(" ").into(),
+                editor.make().token(T![:]).into(),
+                editor.make().whitespace(" ").into(),
             ];
             editor.insert_all(Position::before(&loop_kw), elements);
 
@@ -65,11 +64,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(&mut editor, &token, ctx, builder);
                 }
             });
 
-            editor.add_mappings(make.finish_with_mappings());
             builder.add_file_edits(ctx.vfs_file_id(), editor);
             builder.rename();
         },
@@ -86,13 +84,12 @@ fn loop_token(loop_expr: &ast::AnyHasLoopBody) -> Option<syntax::SyntaxToken> {
 
 fn insert_label_after_token(
     editor: &mut SyntaxEditor,
-    make: &SyntaxFactory,
     token: &SyntaxToken,
     ctx: &AssistContext<'_>,
     builder: &mut SourceChangeBuilder,
 ) {
-    let label = make.lifetime("'l");
-    let elements = vec![make.whitespace(" ").into(), label.syntax().clone().into()];
+    let label = editor.make().lifetime("'l");
+    let elements = vec![editor.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,9 @@ 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 mut editor = edit.make_editor(impl_def.syntax());
         let new_item = add_trait_assoc_items_to_impl(
-            &make,
+            editor.make(),
             &ctx.sema,
             ctx.config,
             &missing_items,
@@ -166,7 +166,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,
+                editor.make(),
                 ctx,
                 func,
                 trait_ref,
@@ -188,14 +188,13 @@ 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);
         } else {
-            let assoc_item_list = make.assoc_item_list(new_assoc_items);
+            let assoc_item_list = editor.make().assoc_item_list(new_assoc_items);
             editor.insert_all(
                 Position::after(impl_def.syntax()),
-                vec![make.whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
+                vec![editor.make().whitespace(" ").into(), assoc_item_list.syntax().clone().into()],
             );
             first_new_item = assoc_item_list.assoc_items().next();
         }
@@ -218,7 +217,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();
@@ -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);
         },
     )

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

@@ -94,21 +94,20 @@ pub(crate) fn add_turbo_fish(acc: &mut Assists, ctx: &AssistContext<'_>) -> Opti
                 ident.text_range(),
                 |builder| {
                     let mut editor = builder.make_editor(let_stmt.syntax());
-                    let make = SyntaxFactory::without_mappings();
 
                     if let_stmt.semicolon_token().is_none() {
                         editor.insert(
                             Position::last_child_of(let_stmt.syntax()),
-                            make.token(syntax::SyntaxKind::SEMICOLON),
+                            editor.make().token(syntax::SyntaxKind::SEMICOLON),
                         );
                     }
 
-                    let placeholder_ty = make.ty_placeholder();
+                    let placeholder_ty = editor.make().ty_placeholder();
 
                     if let Some(pat) = let_stmt.pat() {
                         let elements = vec![
-                            make.token(syntax::SyntaxKind::COLON).into(),
-                            make.whitespace(" ").into(),
+                            editor.make().token(syntax::SyntaxKind::COLON).into(),
+                            editor.make().whitespace(" ").into(),
                             placeholder_ty.syntax().clone().into(),
                         ];
                         editor.insert_all(Position::after(pat.syntax()), elements);
@@ -141,14 +140,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 {
                 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 +177,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,10 +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);
-    editor.replace(demorganed.op_token()?, make.token(inv_token));
+    editor.replace(demorganed.op_token()?, editor.make().token(inv_token));
 
     let mut exprs = VecDeque::from([
         (bin_expr.lhs()?, demorganed.lhs()?, prec),
@@ -94,29 +92,28 @@ 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()?, make.token(inv_token));
+                    editor.replace(cbin_expr.op_token()?, editor.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(&make, expr);
+                    let mut inv = invert_boolean_expression(editor.make(), expr);
                     if precedence(&inv).needs_parentheses_in(prec) {
-                        inv = make.expr_paren(inv).into();
+                        inv = editor.make().expr_paren(inv).into();
                     }
                     editor.replace(demorganed.syntax(), inv.syntax());
                 }
             } else {
                 return None;
             }
         } else {
-            let mut inv = invert_boolean_expression(&make, demorganed.clone());
+            let mut inv = invert_boolean_expression(editor.make(), demorganed.clone());
             if precedence(&inv).needs_parentheses_in(prec) {
-                inv = make.expr_paren(inv).into();
+                inv = editor.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 +123,8 @@ 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 mut editor = builder.make_editor(bin_expr.syntax());
+
             let (target_node, result_expr) = if let Some(neg_expr) = bin_expr
                 .syntax()
                 .parent()
@@ -141,24 +139,22 @@ 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(editor.make(), demorganed))
             } else {
-                (bin_expr.syntax().clone(), add_bang_paren(&make, demorganed))
+                (bin_expr.syntax().clone(), add_bang_paren(editor.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);
-                make.expr_paren(result_expr).into()
+                editor.make().expr_paren(result_expr).into()
             } else {
                 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,18 +202,17 @@ 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());
             // replace the method name
             let new_name = match name.text().as_str() {
-                "all" => make.name_ref("any"),
-                "any" => make.name_ref("all"),
+                "all" => editor.make().name_ref("any"),
+                "any" => editor.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, &make, e);
+            let tail_cb = &mut |e: &_| tail_cb_impl(&mut editor, e);
             walk_expr(&closure_body, &mut |expr| {
                 if let ast::Expr::ReturnExpr(ret_expr) = expr
                     && let Some(ret_expr_arg) = &ret_expr.expr()
@@ -238,10 +233,11 @@ 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()), make.token(SyntaxKind::BANG));
+                editor.insert(
+                    Position::before(method_call.syntax()),
+                    editor.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: &mut 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());
         }
     }