Migrate convert_bool_then to SyntaxEditor

Update assist docs

Author: ShoyuVanilla

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

@@ -8,12 +8,13 @@ use ide_db::{
 };
 use itertools::Itertools;
 use syntax::{
-    ast::{self, edit::AstNodeEdit, make, HasArgList},
-    ted, AstNode, SyntaxNode,
+    ast::{self, edit::AstNodeEdit, syntax_factory::SyntaxFactory, HasArgList},
+    syntax_editor::SyntaxEditor,
+    AstNode, SyntaxNode,
 };
 
 use crate::{
-    utils::{invert_boolean_expression_legacy, unwrap_trivial_block},
+    utils::{invert_boolean_expression, unwrap_trivial_block},
     AssistContext, AssistId, AssistKind, Assists,
 };
 
@@ -76,9 +77,9 @@ pub(crate) fn convert_if_to_bool_then(acc: &mut Assists, ctx: &AssistContext<'_>
         "Convert `if` expression to `bool::then` call",
         target,
         |builder| {
-            let closure_body = closure_body.clone_for_update();
+            let closure_body = closure_body.clone_subtree();
+            let mut editor = SyntaxEditor::new(closure_body.syntax().clone());
             // Rewrite all `Some(e)` in tail position to `e`
-            let mut replacements = Vec::new();
             for_each_tail_expr(&closure_body, &mut |e| {
                 let e = match e {
                     ast::Expr::BreakExpr(e) => e.expr(),
@@ -88,12 +89,16 @@ pub(crate) fn convert_if_to_bool_then(acc: &mut Assists, ctx: &AssistContext<'_>
                 if let Some(ast::Expr::CallExpr(call)) = e {
                     if let Some(arg_list) = call.arg_list() {
                         if let Some(arg) = arg_list.args().next() {
-                            replacements.push((call.syntax().clone(), arg.syntax().clone()));
+                            editor.replace(call.syntax(), arg.syntax());
                         }
                     }
                 }
             });
-            replacements.into_iter().for_each(|(old, new)| ted::replace(old, new));
+            let edit = editor.finish();
+            let closure_body = ast::Expr::cast(edit.new_root().clone()).unwrap();
+
+            let mut editor = builder.make_editor(expr.syntax());
+            let make = SyntaxFactory::new();
             let closure_body = match closure_body {
                 ast::Expr::BlockExpr(block) => unwrap_trivial_block(block),
                 e => e,
@@ -119,11 +124,18 @@ pub(crate) fn convert_if_to_bool_then(acc: &mut Assists, ctx: &AssistContext<'_>
                     | ast::Expr::WhileExpr(_)
                     | ast::Expr::YieldExpr(_)
             );
-            let cond = if invert_cond { invert_boolean_expression_legacy(cond) } else { cond };
-            let cond = if parenthesize { make::expr_paren(cond) } else { cond };
-            let arg_list = make::arg_list(Some(make::expr_closure(None, closure_body)));
-            let mcall = make::expr_method_call(cond, make::name_ref("then"), arg_list);
-            builder.replace(target, mcall.to_string());
+            let cond = if invert_cond {
+                invert_boolean_expression(&make, cond)
+            } else {
+                cond.clone_for_update()
+            };
+            let cond = if parenthesize { make.expr_paren(cond).into() } else { cond };
+            let arg_list = make.arg_list(Some(make.expr_closure(None, closure_body).into()));
+            let mcall = make.expr_method_call(cond, make.name_ref("then"), arg_list);
+            editor.replace(expr.syntax(), mcall.syntax());
+
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.file_id(), editor);
         },
     )
 }
@@ -173,45 +185,55 @@ pub(crate) fn convert_bool_then_to_if(acc: &mut Assists, ctx: &AssistContext<'_>
         "Convert `bool::then` call to `if`",
         target,
         |builder| {
-            let closure_body = match closure_body {
+            let mapless_make = SyntaxFactory::without_mappings();
+            let closure_body = match closure_body.reset_indent() {
                 ast::Expr::BlockExpr(block) => block,
-                e => make::block_expr(None, Some(e)),
+                e => mapless_make.block_expr(None, Some(e)),
             };
 
-            let closure_body = closure_body.clone_for_update();
+            let closure_body = closure_body.clone_subtree();
+            let mut editor = SyntaxEditor::new(closure_body.syntax().clone());
             // Wrap all tails in `Some(...)`
-            let none_path = make::expr_path(make::ext::ident_path("None"));
-            let some_path = make::expr_path(make::ext::ident_path("Some"));
-            let mut replacements = Vec::new();
+            let none_path = mapless_make.expr_path(mapless_make.ident_path("None"));
+            let some_path = mapless_make.expr_path(mapless_make.ident_path("Some"));
             for_each_tail_expr(&ast::Expr::BlockExpr(closure_body.clone()), &mut |e| {
                 let e = match e {
                     ast::Expr::BreakExpr(e) => e.expr(),
                     ast::Expr::ReturnExpr(e) => e.expr(),
                     _ => Some(e.clone()),
                 };
                 if let Some(expr) = e {
-                    replacements.push((
+                    editor.replace(
                         expr.syntax().clone(),
-                        make::expr_call(some_path.clone(), make::arg_list(Some(expr)))
+                        mapless_make
+                            .expr_call(some_path.clone(), mapless_make.arg_list(Some(expr)))
                             .syntax()
-                            .clone_for_update(),
-                    ));
+                            .clone(),
+                    );
                 }
             });
-            replacements.into_iter().for_each(|(old, new)| ted::replace(old, new));
+            let edit = editor.finish();
+            let closure_body = ast::BlockExpr::cast(edit.new_root().clone()).unwrap();
+
+            let mut editor = builder.make_editor(mcall.syntax());
+            let make = SyntaxFactory::new();
 
             let cond = match &receiver {
                 ast::Expr::ParenExpr(expr) => expr.expr().unwrap_or(receiver),
                 _ => receiver,
             };
-            let if_expr = make::expr_if(
-                cond,
-                closure_body.reset_indent(),
-                Some(ast::ElseBranch::Block(make::block_expr(None, Some(none_path)))),
-            )
-            .indent(mcall.indent_level());
+            let if_expr = make
+                .expr_if(
+                    cond,
+                    closure_body,
+                    Some(ast::ElseBranch::Block(make.block_expr(None, Some(none_path)))),
+                )
+                .indent(mcall.indent_level())
+                .clone_for_update();
+            editor.replace(mcall.syntax().clone(), if_expr.syntax().clone());
 
-            builder.replace(target, if_expr.to_string());
+            editor.add_mappings(make.finish_with_mappings());
+            builder.add_file_edits(ctx.file_id(), editor);
         },
     )
 }

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

@@ -14,7 +14,9 @@ use syntax::{
     ast::{
         self,
         edit::{AstNodeEdit, IndentLevel},
-        make, HasArgList, HasGenericParams, HasName,
+        make,
+        syntax_factory::SyntaxFactory,
+        HasArgList, HasGenericParams, HasName,
     },
     hacks::parse_expr_from_str,
     ted, AstNode, Direction, SyntaxKind, SyntaxNode, TextSize, ToSmolStr, T,
@@ -75,32 +77,32 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
     let mut ret_ty = callable.return_type();
     let mut closure_mentioned_generic_params = ret_ty.generic_params(ctx.db());
 
-    let mut params = callable
-        .params()
-        .into_iter()
-        .map(|param| {
-            let node = ctx.sema.source(param.clone())?.value.right()?;
-            let param_ty = param.ty();
-            closure_mentioned_generic_params.extend(param_ty.generic_params(ctx.db()));
-            match node.ty() {
-                Some(_) => Some(node),
-                None => {
-                    let ty = param_ty
-                        .display_source_code(ctx.db(), module.into(), true)
-                        .unwrap_or_else(|_| "_".to_owned());
-                    Some(make::param(node.pat()?, make::ty(&ty)))
-                }
+    let make = SyntaxFactory::new();
+
+    let mut params = Vec::new();
+    for param in callable.params().into_iter() {
+        let node = ctx.sema.source(param.clone())?.value.right()?;
+        let param_ty = param.ty();
+        closure_mentioned_generic_params.extend(param_ty.generic_params(ctx.db()));
+        let param = match node.ty() {
+            Some(_) => node.clone_subtree().clone_for_update(),
+            None => {
+                let ty = param_ty
+                    .display_source_code(ctx.db(), module.into(), true)
+                    .unwrap_or_else(|_| "_".to_owned());
+                make.param(node.pat()?, make.ty(&ty))
             }
-        })
-        .collect::<Option<Vec<_>>>()?;
+        };
+        params.push(param);
+    }
 
     let mut body = closure.body()?.clone_for_update();
     let mut is_gen = false;
     let mut is_async = closure.async_token().is_some();
     if is_async {
         ret_ty = ret_ty.future_output(ctx.db())?;
     }
-    // We defer the wrapping of the body in the block, because `make::block()` will generate a new node,
+    // We defer the wrapping of the body in the block, because `make.block()` will generate a new node,
     // but we need to locate `AstPtr`s inside the body.
     let mut wrap_body_in_block = true;
     if let ast::Expr::BlockExpr(block) = &body {
@@ -150,10 +152,12 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
         "Convert closure to fn",
         closure.param_list()?.syntax().text_range(),
         |builder| {
-            let closure_name_or_default = closure_name
-                .as_ref()
-                .map(|(_, _, it)| it.clone())
-                .unwrap_or_else(|| make::name("fun_name"));
+            let closure_name_or_default =
+                if let Some(name) = closure_name.as_ref().map(|(_, _, it)| it.clone()) {
+                    name.clone_subtree().clone_for_update()
+                } else {
+                    make.name("fun_name")
+                };
             let captures = closure_ty.captured_items(ctx.db());
             let capture_tys = closure_ty.capture_types(ctx.db());
 
@@ -168,19 +172,19 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
                 // FIXME: Allow configuring the replacement of `self`.
                 let capture_name =
                     if capture.local().is_self(ctx.db()) && !capture.has_field_projections() {
-                        make::name("this")
+                        make.name("this")
                     } else {
-                        make::name(&capture.place_to_name(ctx.db()))
+                        make.name(&capture.place_to_name(ctx.db()))
                     };
 
                 closure_mentioned_generic_params.extend(capture_ty.generic_params(ctx.db()));
 
                 let capture_ty = capture_ty
                     .display_source_code(ctx.db(), module.into(), true)
                     .unwrap_or_else(|_| "_".to_owned());
-                params.push(make::param(
-                    ast::Pat::IdentPat(make::ident_pat(false, false, capture_name.clone_subtree())),
-                    make::ty(&capture_ty),
+                params.push(make.param(
+                    ast::Pat::IdentPat(make.ident_pat(false, false, capture_name.clone_subtree())),
+                    make.ty(&capture_ty),
                 ));
 
                 for capture_usage in capture.usages().sources(ctx.db()) {
@@ -199,16 +203,16 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
                         }
                     };
                     let replacement = wrap_capture_in_deref_if_needed(
+                        &make,
                         &expr,
                         &capture_name,
                         capture.kind(),
                         capture_usage.is_ref(),
-                    )
-                    .clone_for_update();
+                    );
                     capture_usages_replacement_map.push((expr, replacement));
                 }
 
-                captures_as_args.push(capture_as_arg(ctx, capture));
+                captures_as_args.push(capture_as_arg(ctx, &make, capture));
             }
 
             let (closure_type_params, closure_where_clause) =
@@ -223,7 +227,7 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
             }
 
             let body = if wrap_body_in_block {
-                make::block_expr([], Some(body))
+                make.block_expr([], Some(body))
             } else {
                 ast::BlockExpr::cast(body.syntax().clone()).unwrap()
             };
@@ -237,7 +241,7 @@ pub(crate) fn convert_closure_to_fn(acc: &mut Assists, ctx: &AssistContext<'_>)
                     .unwrap_or_else(|_| "_".to_owned());
                 Some(make::ret_type(make::ty(&ret_ty)))
             };
-            let mut fn_ = make::fn_(
+            let mut fn_ = make.fn_(
                 None,
                 closure_name_or_default.clone(),
                 closure_type_params,
@@ -466,6 +470,7 @@ fn compute_closure_type_params(
 }
 
 fn wrap_capture_in_deref_if_needed(
+    make: &SyntaxFactory,
     expr: &ast::Expr,
     capture_name: &ast::Name,
     capture_kind: CaptureKind,
@@ -483,7 +488,7 @@ fn wrap_capture_in_deref_if_needed(
         expr
     }
 
-    let capture_name = make::expr_path(make::path_from_text(&capture_name.text()));
+    let capture_name = make.expr_path(make::path_from_text(&capture_name.text()));
     if capture_kind == CaptureKind::Move || is_ref {
         return capture_name;
     }
@@ -505,13 +510,18 @@ fn wrap_capture_in_deref_if_needed(
     if does_autoderef {
         return capture_name;
     }
-    make::expr_prefix(T![*], capture_name).into()
+    make.expr_prefix(T![*], capture_name).into()
 }
 
-fn capture_as_arg(ctx: &AssistContext<'_>, capture: &ClosureCapture) -> ast::Expr {
+fn capture_as_arg(
+    ctx: &AssistContext<'_>,
+    make: &SyntaxFactory,
+    capture: &ClosureCapture,
+) -> ast::Expr {
     let place =
         parse_expr_from_str(&capture.display_place_source_code(ctx.db()), ctx.file_id().edition())
-            .expect("`display_place_source_code()` produced an invalid expr");
+            .expect("`display_place_source_code()` produced an invalid expr")
+            .clone_subtree();
     let needs_mut = match capture.kind() {
         CaptureKind::SharedRef => false,
         CaptureKind::MutableRef | CaptureKind::UniqueSharedRef => true,
@@ -522,7 +532,7 @@ fn capture_as_arg(ctx: &AssistContext<'_>, capture: &ClosureCapture) -> ast::Exp
             return expr.expr().expect("`display_place_source_code()` produced an invalid expr");
         }
     }
-    make::expr_ref(place, needs_mut)
+    make.expr_ref(place, needs_mut)
 }
 
 fn handle_calls(