rust-analyzer

diff --git a/crates/ide-assists/src/handlers/convert_to_guarded_return.rs b/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
index dc51bf4b5b..374c7cd869 100644
--- a/crates/ide-assists/src/handlers/convert_to_guarded_return.rs
+++ b/crates/ide-assists/src/handlers/convert_to_guarded_return.rs

@@ -10,14 +10,14 @@ use syntax::{

ast::{

self,

edit::{AstNodeEdit, IndentLevel},

- make,

+ syntax_factory::SyntaxFactory,

};

use crate::{

AssistId,

assist_context::{AssistContext, Assists},

- utils::{invert_boolean_expression_legacy, is_never_block},

+ utils::{invert_boolean_expression, is_never_block},

};

// Assist: convert_to_guarded_return

@@ -69,6 +69,7 @@ fn if_expr_to_guarded_return(

acc: &mut Assists,

ctx: &AssistContext<'_>,

) -> Option<()> {

+ let make = SyntaxFactory::without_mappings();

let else_block = match if_expr.else_branch() {

Some(ast::ElseBranch::Block(block_expr)) if is_never_block(&ctx.sema, &block_expr) => {

Some(block_expr)

@@ -88,7 +89,7 @@ fn if_expr_to_guarded_return(

return None;

}

- let let_chains = flat_let_chain(cond);

+ let let_chains = flat_let_chain(cond, &make);

let then_branch = if_expr.then_branch()?;

let then_block = then_branch.stmt_list()?;

@@ -110,7 +111,8 @@ fn if_expr_to_guarded_return(

let early_expression = else_block

.or_else(|| {

- early_expression(parent_container, &ctx.sema).map(ast::make::tail_only_block_expr)

+ early_expression(parent_container, &ctx.sema, &make)

+ .map(ast::make::tail_only_block_expr)

})?

.reset_indent();

@@ -133,6 +135,7 @@ fn if_expr_to_guarded_return(

"Convert to guarded return",

target,

|edit| {

+ let make = SyntaxFactory::without_mappings();

let if_indent_level = IndentLevel::from_node(if_expr.syntax());

let replacement = let_chains.into_iter().map(|expr| {

if let ast::Expr::LetExpr(let_expr) = &expr

@@ -140,15 +143,15 @@ fn if_expr_to_guarded_return(

{

// If-let.

let let_else_stmt =

- make::let_else_stmt(pat, None, expr, early_expression.clone());

+ make.let_else_stmt(pat, None, expr, early_expression.clone());

let let_else_stmt = let_else_stmt.indent(if_indent_level);

let_else_stmt.syntax().clone()

} else {

// If.

let new_expr = {

- let then_branch = clean_stmt_block(&early_expression);

- let cond = invert_boolean_expression_legacy(expr);

- make::expr_if(cond, then_branch, None).indent(if_indent_level)

+ let then_branch = clean_stmt_block(&early_expression, &make);

+ let cond = invert_boolean_expression(&make, expr);

+ make.expr_if(cond, then_branch, None).indent(if_indent_level)

};

new_expr.syntax().clone()

}

@@ -159,7 +162,7 @@ fn if_expr_to_guarded_return(

.enumerate()

.flat_map(|(i, node)| {

(i != 0)

- .then(|| make::tokens::whitespace(newline).into())

+ .then(|| make.whitespace(newline).into())

.into_iter()

.chain(node.children_with_tokens())

})

@@ -201,12 +204,13 @@ fn let_stmt_to_guarded_return(

let happy_pattern = try_enum.happy_pattern(pat);

let target = let_stmt.syntax().text_range();

+ let make = SyntaxFactory::without_mappings();

let early_expression: ast::Expr = {

let parent_block =

let_stmt.syntax().parent()?.ancestors().find_map(ast::BlockExpr::cast)?;

let parent_container = parent_block.syntax().parent()?;

- early_expression(parent_container, &ctx.sema)?

+ early_expression(parent_container, &ctx.sema, &make)?

};

acc.add(

@@ -215,9 +219,10 @@ fn let_stmt_to_guarded_return(

target,

|edit| {

let let_indent_level = IndentLevel::from_node(let_stmt.syntax());

+ let make = SyntaxFactory::without_mappings();

let replacement = {

- let let_else_stmt = make::let_else_stmt(

+ let let_else_stmt = make.let_else_stmt(

happy_pattern,

let_stmt.ty(),

expr.reset_indent(),

@@ -228,6 +233,7 @@ fn let_stmt_to_guarded_return(

};

let mut editor = edit.make_editor(let_stmt.syntax());

editor.replace(let_stmt.syntax(), replacement);

+ editor.add_mappings(make.finish_with_mappings());

edit.add_file_edits(ctx.vfs_file_id(), editor);

)

@@ -236,38 +242,39 @@ fn let_stmt_to_guarded_return(

fn early_expression(

parent_container: SyntaxNode,

sema: &Semantics<'_, RootDatabase>,

+ make: &SyntaxFactory,

) -> Option<ast::Expr> {

let return_none_expr = || {

- let none_expr = make::expr_path(make::ext::ident_path("None"));

- make::expr_return(Some(none_expr))

+ let none_expr = make.expr_path(make.ident_path("None"));

+ make.expr_return(Some(none_expr))

};

if let Some(fn_) = ast::Fn::cast(parent_container.clone())

&& let Some(fn_def) = sema.to_def(&fn_)

&& let Some(TryEnum::Option) = TryEnum::from_ty(sema, &fn_def.ret_type(sema.db))

{

- return Some(return_none_expr());

+ return Some(return_none_expr().into());

}

if let Some(body) = ast::ClosureExpr::cast(parent_container.clone()).and_then(|it| it.body())

&& let Some(ret_ty) = sema.type_of_expr(&body).map(TypeInfo::original)

&& let Some(TryEnum::Option) = TryEnum::from_ty(sema, &ret_ty)

{

- return Some(return_none_expr());

+ return Some(return_none_expr().into());

}

Some(match parent_container.kind() {

- WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make::expr_continue(None),

- FN | CLOSURE_EXPR => make::expr_return(None),

+ WHILE_EXPR | LOOP_EXPR | FOR_EXPR => make.expr_continue(None),

+ FN | CLOSURE_EXPR => make.expr_return(None).into(),

_ => return None,

})

}

-fn flat_let_chain(mut expr: ast::Expr) -> Vec<ast::Expr> {

+fn flat_let_chain(mut expr: ast::Expr, make: &SyntaxFactory) -> Vec<ast::Expr> {

let mut chains = vec![];

let mut reduce_cond = |rhs| {

if !matches!(rhs, ast::Expr::LetExpr(_))

&& let Some(last) = chains.pop_if(|last| !matches!(last, ast::Expr::LetExpr(_)))

{

- chains.push(make::expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));

+ chains.push(make.expr_bin_op(rhs, ast::BinaryOp::LogicOp(ast::LogicOp::And), last));

} else {

chains.push(rhs);

}

@@ -286,12 +293,12 @@ fn flat_let_chain(mut expr: ast::Expr) -> Vec<ast::Expr> {

chains

}

-fn clean_stmt_block(block: &ast::BlockExpr) -> ast::BlockExpr {

+fn clean_stmt_block(block: &ast::BlockExpr, make: &SyntaxFactory) -> ast::BlockExpr {

if block.statements().next().is_none()

&& let Some(tail_expr) = block.tail_expr()

&& block.modifier().is_none()

{

- make::block_expr(once(make::expr_stmt(tail_expr).into()), None)

+ make.block_expr(once(make.expr_stmt(tail_expr).into()), None)

} else {

block.clone()

}

diff --git a/crates/ide-assists/src/handlers/convert_while_to_loop.rs b/crates/ide-assists/src/handlers/convert_while_to_loop.rs
index 9fd8b4b315..c06e539a4f 100644
--- a/crates/ide-assists/src/handlers/convert_while_to_loop.rs
+++ b/crates/ide-assists/src/handlers/convert_while_to_loop.rs

@@ -6,7 +6,7 @@ use syntax::{

ast::{

self, HasLoopBody,

edit::{AstNodeEdit, IndentLevel},

- make,

+ syntax_factory::SyntaxFactory,

syntax_editor::{Element, Position},

};

@@ -14,7 +14,7 @@ use syntax::{

use crate::{

AssistId,

assist_context::{AssistContext, Assists},

- utils::invert_boolean_expression_legacy,

+ utils::invert_boolean_expression,

};

// Assist: convert_while_to_loop

@@ -52,44 +52,44 @@ pub(crate) fn convert_while_to_loop(acc: &mut Assists, ctx: &AssistContext<'_>)

"Convert while to loop",

target,

|builder| {

+ let make = SyntaxFactory::without_mappings();

let mut edit = builder.make_editor(while_expr.syntax());

let while_indent_level = IndentLevel::from_node(while_expr.syntax());

- let break_block = make::block_expr(

- iter::once(make::expr_stmt(make::expr_break(None, None)).into()),

- None,

- )

- .indent(IndentLevel(1));

+ let break_block = make

+ .block_expr(iter::once(make.expr_stmt(make.expr_break(None, None)).into()), None)

+ .indent(IndentLevel(1));

edit.replace_all(

while_kw.syntax_element()..=while_cond.syntax().syntax_element(),

- vec![make::token(T![loop]).syntax_element()],

+ vec![make.token(T![loop]).syntax_element()],

);

if is_pattern_cond(while_cond.clone()) {

let then_branch = while_body.reset_indent().indent(IndentLevel(1));

- let if_expr = make::expr_if(while_cond, then_branch, Some(break_block.into()));

- let stmts = iter::once(make::expr_stmt(if_expr.into()).into());

- let block_expr = make::block_expr(stmts, None);

+ let if_expr = make.expr_if(while_cond, then_branch, Some(break_block.into()));

+ let stmts = iter::once(make.expr_stmt(if_expr.into()).into());

+ let block_expr = make.block_expr(stmts, None);

edit.replace(while_body.syntax(), block_expr.indent(while_indent_level).syntax());

} else {

- let if_cond = invert_boolean_expression_legacy(while_cond);

- let if_expr = make::expr_if(if_cond, break_block, None).indent(while_indent_level);

+ let if_cond = invert_boolean_expression(&make, while_cond);

+ let if_expr = make.expr_if(if_cond, break_block, None).indent(while_indent_level);

if !while_body.syntax().text().contains_char('\n') {

edit.insert(

Position::after(&l_curly),

- make::tokens::whitespace(&format!("\n{while_indent_level}")),

+ make.whitespace(&format!("\n{while_indent_level}")),

);

}

edit.insert_all(

Position::after(&l_curly),

vec![

- make::tokens::whitespace(&format!("\n{}", while_indent_level + 1)).into(),

+ make.whitespace(&format!("\n{}", while_indent_level + 1)).into(),

if_expr.syntax().syntax_element(),

);

};

+ edit.add_mappings(make.finish_with_mappings());

builder.add_file_edits(ctx.vfs_file_id(), edit);

)

diff --git a/crates/ide-assists/src/handlers/invert_if.rs b/crates/ide-assists/src/handlers/invert_if.rs
index bf82d8df9b..c8cb7bb60f 100644
--- a/crates/ide-assists/src/handlers/invert_if.rs
+++ b/crates/ide-assists/src/handlers/invert_if.rs

@@ -1,13 +1,13 @@

use ide_db::syntax_helpers::node_ext::is_pattern_cond;

use syntax::{

- ast::{self, AstNode},

+ ast::{self, AstNode, syntax_factory::SyntaxFactory},

};

use crate::{

AssistId,

assist_context::{AssistContext, Assists},

- utils::invert_boolean_expression_legacy,

+ utils::invert_boolean_expression,

};

// Assist: invert_if

@@ -50,7 +50,8 @@ pub(crate) fn invert_if(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()

};

acc.add(AssistId::refactor_rewrite("invert_if"), "Invert if", if_range, |edit| {

- let flip_cond = invert_boolean_expression_legacy(cond.clone());

+ let make = SyntaxFactory::without_mappings();

+ let flip_cond = invert_boolean_expression(&make, cond.clone());

edit.replace_ast(cond, flip_cond);

let else_node = else_block.syntax();

diff --git a/crates/ide-assists/src/utils.rs b/crates/ide-assists/src/utils.rs
index 85b3e6d317..db59fc29c3 100644
--- a/crates/ide-assists/src/utils.rs
+++ b/crates/ide-assists/src/utils.rs

@@ -275,11 +275,6 @@ pub(crate) fn invert_boolean_expression(make: &SyntaxFactory, expr: ast::Expr) -

invert_special_case(make, &expr).unwrap_or_else(|| make.expr_prefix(T![!], expr).into())

}

-// FIXME: Migrate usages of this function to the above function and remove this.

-pub(crate) fn invert_boolean_expression_legacy(expr: ast::Expr) -> ast::Expr {

- invert_special_case_legacy(&expr).unwrap_or_else(|| make::expr_prefix(T![!], expr).into())

fn invert_special_case(make: &SyntaxFactory, expr: &ast::Expr) -> Option<ast::Expr> {

match expr {

ast::Expr::BinExpr(bin) => {

@@ -343,58 +338,6 @@ fn invert_special_case(make: &SyntaxFactory, expr: &ast::Expr) -> Option<ast::Ex

}

-fn invert_special_case_legacy(expr: &ast::Expr) -> Option<ast::Expr> {

- match expr {

- ast::Expr::BinExpr(bin) => {

- let bin = bin.clone_subtree();

- let op_token = bin.op_token()?;

- let rev_token = match op_token.kind() {

- T![==] => T![!=],

- T![!=] => T![==],

- T![<] => T![>=],

- T![<=] => T![>],

- T![>] => T![<=],

- T![>=] => T![<],

- // Parenthesize other expressions before prefixing `!`

- _ => {

- return Some(

- make::expr_prefix(T![!], make::expr_paren(expr.clone()).into()).into(),

- );

- }

- };

- let mut bin_editor = SyntaxEditor::new(bin.syntax().clone());

- bin_editor.replace(op_token, make::token(rev_token));

- ast::Expr::cast(bin_editor.finish().new_root().clone())

- }

- ast::Expr::MethodCallExpr(mce) => {

- let receiver = mce.receiver()?;

- let method = mce.name_ref()?;

- let arg_list = mce.arg_list()?;

- let method = match method.text().as_str() {

- "is_some" => "is_none",

- "is_none" => "is_some",

- "is_ok" => "is_err",

- "is_err" => "is_ok",

- _ => return None,

- };

- Some(make::expr_method_call(receiver, make::name_ref(method), arg_list).into())

- }

- ast::Expr::PrefixExpr(pe) if pe.op_kind()? == ast::UnaryOp::Not => match pe.expr()? {

- ast::Expr::ParenExpr(parexpr) => parexpr.expr(),

- _ => pe.expr(),

- },

- ast::Expr::Literal(lit) => match lit.kind() {

- ast::LiteralKind::Bool(b) => match b {

- true => Some(ast::Expr::Literal(make::expr_literal("false"))),

- false => Some(ast::Expr::Literal(make::expr_literal("true"))),

- },

- _ => None,

- },

- _ => None,

- }

pub(crate) fn insert_attributes(

before: impl Element,

edit: &mut SyntaxEditor,

diff --git a/crates/syntax/src/ast/syntax_factory/constructors.rs b/crates/syntax/src/ast/syntax_factory/constructors.rs
index 3ca163d07f..dd8cc8d6f2 100644
--- a/crates/syntax/src/ast/syntax_factory/constructors.rs
+++ b/crates/syntax/src/ast/syntax_factory/constructors.rs

@@ -5,7 +5,7 @@ use crate::{

AstNode, NodeOrToken, SyntaxKind, SyntaxNode, SyntaxToken,

ast::{

self, HasArgList, HasAttrs, HasGenericArgs, HasGenericParams, HasLoopBody, HasName,

- HasTypeBounds, HasVisibility, Param, RangeItem, make,

+ HasTypeBounds, HasVisibility, Lifetime, Param, RangeItem, make,

syntax_editor::SyntaxMappingBuilder,

};

@@ -1806,6 +1806,14 @@ impl SyntaxFactory {

self.ty_path(path)

}

+ pub fn expr_break(&self, label: Option<Lifetime>, expr: Option<ast::Expr>) -> ast::Expr {

+ make::expr_break(label, expr)

+ }

+ pub fn expr_continue(&self, label: Option<Lifetime>) -> ast::Expr {

+ make::expr_continue(label)

+ }

}

// We need to collect `input` here instead of taking `impl IntoIterator + Clone`,