1 files changed, 83 insertions, 85 deletions

diff --git a/crates/ra_assists/src/handlers/early_return.rs b/crates/ra_assists/src/handlers/early_return.rs
index 4bd6040b2..66b296081 100644
--- a/crates/ra_assists/src/handlers/early_return.rs
+++ b/crates/ra_assists/src/handlers/early_return.rs
@@ -2,14 +2,18 @@ use std::{iter::once, ops::RangeInclusive};
 
 use ra_syntax::{
     algo::replace_children,
-    ast::{self, edit::IndentLevel, make},
+    ast::{
+        self,
+        edit::{AstNodeEdit, IndentLevel},
+        make,
+    },
     AstNode,
     SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
     SyntaxNode,
 };
 
 use crate::{
-    assist_ctx::{Assist, AssistCtx},
+    assist_context::{AssistContext, Assists},
     utils::invert_boolean_expression,
     AssistId,
 };
@@ -36,7 +40,7 @@ use crate::{
 //     bar();
 // }
 // ```
-pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
+pub(crate) fn convert_to_guarded_return(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
     let if_expr: ast::IfExpr = ctx.find_node_at_offset()?;
     if if_expr.else_branch().is_some() {
         return None;
@@ -93,96 +97,90 @@ pub(crate) fn convert_to_guarded_return(ctx: AssistCtx) -> Option<Assist> {
     }
 
     then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
-    let cursor_position = ctx.frange.range.start();
+    let cursor_position = ctx.offset();
 
     let target = if_expr.syntax().text_range();
-    ctx.add_assist(
-        AssistId("convert_to_guarded_return"),
-        "Convert to guarded return",
-        target,
-        |edit| {
-            let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
-            let new_block = match if_let_pat {
-                None => {
-                    // If.
-                    let new_expr = {
-                        let then_branch =
-                            make::block_expr(once(make::expr_stmt(early_expression).into()), None);
-                        let cond = invert_boolean_expression(cond_expr);
-                        let e = make::expr_if(make::condition(cond, None), then_branch);
-                        if_indent_level.increase_indent(e)
-                    };
-                    replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
-                }
-                Some((path, bound_ident)) => {
-                    // If-let.
-                    let match_expr = {
-                        let happy_arm = {
-                            let pat = make::tuple_struct_pat(
-                                path,
-                                once(make::bind_pat(make::name("it")).into()),
-                            );
-                            let expr = {
-                                let name_ref = make::name_ref("it");
-                                let segment = make::path_segment(name_ref);
-                                let path = make::path_unqualified(segment);
-                                make::expr_path(path)
-                            };
-                            make::match_arm(once(pat.into()), expr)
-                        };
-
-                        let sad_arm = make::match_arm(
-                            // FIXME: would be cool to use `None` or `Err(_)` if appropriate
-                            once(make::placeholder_pat().into()),
-                            early_expression,
+    acc.add(AssistId("convert_to_guarded_return"), "Convert to guarded return", target, |edit| {
+        let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
+        let new_block = match if_let_pat {
+            None => {
+                // If.
+                let new_expr = {
+                    let then_branch =
+                        make::block_expr(once(make::expr_stmt(early_expression).into()), None);
+                    let cond = invert_boolean_expression(cond_expr);
+                    make::expr_if(make::condition(cond, None), then_branch).indent(if_indent_level)
+                };
+                replace(new_expr.syntax(), &then_block, &parent_block, &if_expr)
+            }
+            Some((path, bound_ident)) => {
+                // If-let.
+                let match_expr = {
+                    let happy_arm = {
+                        let pat = make::tuple_struct_pat(
+                            path,
+                            once(make::bind_pat(make::name("it")).into()),
                         );
-
-                        make::expr_match(cond_expr, make::match_arm_list(vec![happy_arm, sad_arm]))
+                        let expr = {
+                            let name_ref = make::name_ref("it");
+                            let segment = make::path_segment(name_ref);
+                            let path = make::path_unqualified(segment);
+                            make::expr_path(path)
+                        };
+                        make::match_arm(once(pat.into()), expr)
                     };
 
-                    let let_stmt = make::let_stmt(
-                        make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
-                        Some(match_expr),
+                    let sad_arm = make::match_arm(
+                        // FIXME: would be cool to use `None` or `Err(_)` if appropriate
+                        once(make::placeholder_pat().into()),
+                        early_expression,
                     );
-                    let let_stmt = if_indent_level.increase_indent(let_stmt);
-                    replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
-                }
-            };
-            edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
-            edit.set_cursor(cursor_position);
-
-            fn replace(
-                new_expr: &SyntaxNode,
-                then_block: &ast::BlockExpr,
-                parent_block: &ast::BlockExpr,
-                if_expr: &ast::IfExpr,
-            ) -> SyntaxNode {
-                let then_block_items = IndentLevel::from(1).decrease_indent(then_block.clone());
-                let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
-                let end_of_then =
-                    if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
-                        end_of_then.prev_sibling_or_token().unwrap()
-                    } else {
-                        end_of_then
-                    };
-                let mut then_statements = new_expr.children_with_tokens().chain(
-                    then_block_items
-                        .syntax()
-                        .children_with_tokens()
-                        .skip(1)
-                        .take_while(|i| *i != end_of_then),
+
+                    make::expr_match(cond_expr, make::match_arm_list(vec![happy_arm, sad_arm]))
+                };
+
+                let let_stmt = make::let_stmt(
+                    make::bind_pat(make::name(&bound_ident.syntax().to_string())).into(),
+                    Some(match_expr),
                 );
-                replace_children(
-                    &parent_block.syntax(),
-                    RangeInclusive::new(
-                        if_expr.clone().syntax().clone().into(),
-                        if_expr.syntax().clone().into(),
-                    ),
-                    &mut then_statements,
-                )
+                let let_stmt = let_stmt.indent(if_indent_level);
+                replace(let_stmt.syntax(), &then_block, &parent_block, &if_expr)
             }
-        },
-    )
+        };
+        edit.replace_ast(parent_block, ast::BlockExpr::cast(new_block).unwrap());
+        edit.set_cursor(cursor_position);
+
+        fn replace(
+            new_expr: &SyntaxNode,
+            then_block: &ast::BlockExpr,
+            parent_block: &ast::BlockExpr,
+            if_expr: &ast::IfExpr,
+        ) -> SyntaxNode {
+            let then_block_items = then_block.dedent(IndentLevel::from(1));
+            let end_of_then = then_block_items.syntax().last_child_or_token().unwrap();
+            let end_of_then =
+                if end_of_then.prev_sibling_or_token().map(|n| n.kind()) == Some(WHITESPACE) {
+                    end_of_then.prev_sibling_or_token().unwrap()
+                } else {
+                    end_of_then
+                };
+            let mut then_statements = new_expr.children_with_tokens().chain(
+                then_block_items
+                    .syntax()
+                    .children_with_tokens()
+                    .skip(1)
+                    .take_while(|i| *i != end_of_then),
+            );
+            replace_children(
+                &parent_block.syntax(),
+                RangeInclusive::new(
+                    if_expr.clone().syntax().clone().into(),
+                    if_expr.syntax().clone().into(),
+                ),
+                &mut then_statements,
+            )
+        }
+    })
 }
 
 #[cfg(test)]