From 76733f0cd456005295e60da8c45d74c8c48f177c Mon Sep 17 00:00:00 2001
From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
Date: Wed, 29 Apr 2020 13:52:55 +0200
Subject: Add unwrap block assist #4156

Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
---
 crates/ra_assists/src/doc_tests/generated.rs   |  19 ++
 crates/ra_assists/src/handlers/unwrap_block.rs | 435 +++++++++++++++++++++++++
 crates/ra_assists/src/lib.rs                   |   2 +
 3 files changed, 456 insertions(+)
 create mode 100644 crates/ra_assists/src/handlers/unwrap_block.rs

(limited to 'crates/ra_assists')

diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index e4fa9ee36..6fe95da6a 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -726,3 +726,22 @@ use std::{collections::HashMap};
 "#####,
     )
 }
+
+#[test]
+fn doctest_unwrap_block() {
+    check(
+        "unwrap_block",
+        r#####"
+fn foo() {
+    if true {<|>
+        println!("foo");
+    }
+}
+"#####,
+        r#####"
+fn foo() {
+    <|>println!("foo");
+}
+"#####,
+    )
+}
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
new file mode 100644
index 000000000..b98601f1c
--- /dev/null
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -0,0 +1,435 @@
+use crate::{Assist, AssistCtx, AssistId};
+
+use ast::LoopBodyOwner;
+use ra_fmt::unwrap_trivial_block;
+use ra_syntax::{ast, AstNode};
+
+// Assist: unwrap_block
+//
+// Removes the `mut` keyword.
+//
+// ```
+// fn foo() {
+//     if true {<|>
+//         println!("foo");
+//     }
+// }
+// ```
+// ->
+// ```
+// fn foo() {
+//     <|>println!("foo");
+// }
+// ```
+pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
+    let res = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
+        // if expression
+        let mut expr_to_unwrap: Option<ast::Expr> = None;
+        for block_expr in if_expr.blocks() {
+            if let Some(block) = block_expr.block() {
+                let cursor_in_range =
+                    block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
+
+                if cursor_in_range {
+                    let exprto = unwrap_trivial_block(block_expr);
+                    expr_to_unwrap = Some(exprto);
+                    break;
+                }
+            }
+        }
+        let expr_to_unwrap = expr_to_unwrap?;
+        // Find if we are in a else if block
+        let ancestor = ctx
+            .sema
+            .ancestors_with_macros(if_expr.syntax().clone())
+            .skip(1)
+            .find_map(ast::IfExpr::cast);
+
+        if let Some(ancestor) = ancestor {
+            Some((ast::Expr::IfExpr(ancestor), expr_to_unwrap))
+        } else {
+            Some((ast::Expr::IfExpr(if_expr), expr_to_unwrap))
+        }
+    } else if let Some(for_expr) = ctx.find_node_at_offset::<ast::ForExpr>() {
+        // for expression
+        let block_expr = for_expr.loop_body()?;
+        let block = block_expr.block()?;
+        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
+
+        if cursor_in_range {
+            let expr_to_unwrap = unwrap_trivial_block(block_expr);
+
+            Some((ast::Expr::ForExpr(for_expr), expr_to_unwrap))
+        } else {
+            None
+        }
+    } else if let Some(while_expr) = ctx.find_node_at_offset::<ast::WhileExpr>() {
+        // while expression
+        let block_expr = while_expr.loop_body()?;
+        let block = block_expr.block()?;
+        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
+
+        if cursor_in_range {
+            let expr_to_unwrap = unwrap_trivial_block(block_expr);
+
+            Some((ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
+        } else {
+            None
+        }
+    } else if let Some(loop_expr) = ctx.find_node_at_offset::<ast::LoopExpr>() {
+        // loop expression
+        let block_expr = loop_expr.loop_body()?;
+        let block = block_expr.block()?;
+        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
+
+        if cursor_in_range {
+            let expr_to_unwrap = unwrap_trivial_block(block_expr);
+
+            Some((ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
+        } else {
+            None
+        }
+    } else {
+        None
+    };
+
+    let (expr, expr_to_unwrap) = res?;
+    ctx.add_assist(AssistId("unwrap_block"), "Unwrap block", |edit| {
+        edit.set_cursor(expr.syntax().text_range().start());
+        edit.target(expr_to_unwrap.syntax().text_range());
+
+        let pat_start: &[_] = &[' ', '{', '\n'];
+        let expr_to_unwrap = expr_to_unwrap.to_string();
+        let expr_string = expr_to_unwrap.trim_start_matches(pat_start);
+        let mut expr_string_lines: Vec<&str> = expr_string.lines().collect();
+        expr_string_lines.pop(); // Delete last line
+
+        let expr_string = expr_string_lines
+            .into_iter()
+            .map(|line| line.replacen("    ", "", 1)) // Delete indentation
+            .collect::<Vec<String>>()
+            .join("\n");
+
+        edit.replace(expr.syntax().text_range(), expr_string);
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+
+    use super::*;
+
+    #[test]
+    fn simple_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {<|>
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                <|>foo();
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_else() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();
+                if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {<|>
+                    println!("bar");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                <|>println!("bar");
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_else_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                //bar();
+                if true {
+                    println!("true");
+
+                    //comment
+                    //bar();
+                } else if false {<|>
+                    println!("bar");
+                } else {
+                    println!("foo");
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                //bar();
+                <|>println!("bar");
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                bar();<|>
+                if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn issue_example_with_if() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
+                if let Some(ty) = &ctx.expected_type {<|>
+                    if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
+                        let variants = enum_data.variants(ctx.db);
+
+                        let module = if let Some(module) = ctx.scope().module() {
+                            // Compute path from the completion site if available.
+                            module
+                        } else {
+                            // Otherwise fall back to the enum's definition site.
+                            enum_data.module(ctx.db)
+                        };
+
+                        for variant in variants {
+                            if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
+                                // Variants with trivial paths are already added by the existing completion logic,
+                                // so we should avoid adding these twice
+                                if path.segments.len() > 1 {
+                                    acc.add_enum_variant(ctx, variant, Some(path.to_string()));
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
+                <|>if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
+                    let variants = enum_data.variants(ctx.db);
+
+                    let module = if let Some(module) = ctx.scope().module() {
+                        // Compute path from the completion site if available.
+                        module
+                    } else {
+                        // Otherwise fall back to the enum's definition site.
+                        enum_data.module(ctx.db)
+                    };
+
+                    for variant in variants {
+                        if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
+                            // Variants with trivial paths are already added by the existing completion logic,
+                            // so we should avoid adding these twice
+                            if path.segments.len() > 1 {
+                                acc.add_enum_variant(ctx, variant, Some(path.to_string()));
+                            }
+                        }
+                    }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_in_for() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    if true {<|>
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                for i in 0..5 {
+                    <|>foo();
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_loop() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                loop {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_while() {
+        check_assist(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {<|>
+                    if true {
+                        foo();
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                <|>if true {
+                    foo();
+
+                    //comment
+                    bar();
+                } else {
+                    println!("bar");
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn simple_if_in_while_bad_cursor_position() {
+        check_assist_not_applicable(
+            unwrap_block,
+            r#"
+            fn main() {
+                while true {
+                    if true {
+                        foo();<|>
+
+                        //comment
+                        bar();
+                    } else {
+                        println!("bar");
+                    }
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index 64bd87afb..c5df86600 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -143,6 +143,7 @@ mod handlers {
     mod split_import;
     mod add_from_impl_for_enum;
     mod reorder_fields;
+    mod unwrap_block;
 
     pub(crate) fn all() -> &'static [AssistHandler] {
         &[
@@ -181,6 +182,7 @@ mod handlers {
             replace_unwrap_with_match::replace_unwrap_with_match,
             split_import::split_import,
             add_from_impl_for_enum::add_from_impl_for_enum,
+            unwrap_block::unwrap_block,
             // These are manually sorted for better priorities
             add_missing_impl_members::add_missing_impl_members,
             add_missing_impl_members::add_missing_default_members,
-- 
cgit v1.2.3


From bbe22640b8d52354c3de3e126c9fcda5b1b174fd Mon Sep 17 00:00:00 2001
From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
Date: Wed, 29 Apr 2020 14:53:47 +0200
Subject: Add unwrap block assist #4156

Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
---
 crates/ra_assists/src/doc_tests/generated.rs   | 2 +-
 crates/ra_assists/src/handlers/unwrap_block.rs | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

(limited to 'crates/ra_assists')

diff --git a/crates/ra_assists/src/doc_tests/generated.rs b/crates/ra_assists/src/doc_tests/generated.rs
index 6fe95da6a..b53b97e89 100644
--- a/crates/ra_assists/src/doc_tests/generated.rs
+++ b/crates/ra_assists/src/doc_tests/generated.rs
@@ -740,7 +740,7 @@ fn foo() {
 "#####,
         r#####"
 fn foo() {
-    <|>println!("foo");
+    println!("foo");
 }
 "#####,
     )
diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index b98601f1c..35d87bc9e 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -6,7 +6,7 @@ use ra_syntax::{ast, AstNode};
 
 // Assist: unwrap_block
 //
-// Removes the `mut` keyword.
+// This assist removes if...else, for, while and loop control statements to just keep the body.
 //
 // ```
 // fn foo() {
@@ -18,7 +18,7 @@ use ra_syntax::{ast, AstNode};
 // ->
 // ```
 // fn foo() {
-//     <|>println!("foo");
+//     println!("foo");
 // }
 // ```
 pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
-- 
cgit v1.2.3


From df7899e47a83fb5544d09d2db9405762d3ce29b7 Mon Sep 17 00:00:00 2001
From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
Date: Fri, 1 May 2020 16:41:29 +0200
Subject: Add unwrap block assist #4156

Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
---
 crates/ra_assists/src/handlers/unwrap_block.rs | 69 +++++++++-----------------
 1 file changed, 23 insertions(+), 46 deletions(-)

(limited to 'crates/ra_assists')

diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index 35d87bc9e..71d6d462b 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,8 +1,8 @@
 use crate::{Assist, AssistCtx, AssistId};
 
-use ast::LoopBodyOwner;
+use ast::{BlockExpr, Expr, LoopBodyOwner};
 use ra_fmt::unwrap_trivial_block;
-use ra_syntax::{ast, AstNode};
+use ra_syntax::{ast, AstNode, TextRange};
 
 // Assist: unwrap_block
 //
@@ -26,24 +26,14 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
         // if expression
         let mut expr_to_unwrap: Option<ast::Expr> = None;
         for block_expr in if_expr.blocks() {
-            if let Some(block) = block_expr.block() {
-                let cursor_in_range =
-                    block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
-
-                if cursor_in_range {
-                    let exprto = unwrap_trivial_block(block_expr);
-                    expr_to_unwrap = Some(exprto);
-                    break;
-                }
+            if let Some(expr) = excract_expr(ctx.frange.range, block_expr) {
+                expr_to_unwrap = Some(expr);
+                break;
             }
         }
         let expr_to_unwrap = expr_to_unwrap?;
         // Find if we are in a else if block
-        let ancestor = ctx
-            .sema
-            .ancestors_with_macros(if_expr.syntax().clone())
-            .skip(1)
-            .find_map(ast::IfExpr::cast);
+        let ancestor = if_expr.syntax().ancestors().skip(1).find_map(ast::IfExpr::cast);
 
         if let Some(ancestor) = ancestor {
             Some((ast::Expr::IfExpr(ancestor), expr_to_unwrap))
@@ -53,42 +43,18 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     } else if let Some(for_expr) = ctx.find_node_at_offset::<ast::ForExpr>() {
         // for expression
         let block_expr = for_expr.loop_body()?;
-        let block = block_expr.block()?;
-        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
-
-        if cursor_in_range {
-            let expr_to_unwrap = unwrap_trivial_block(block_expr);
-
-            Some((ast::Expr::ForExpr(for_expr), expr_to_unwrap))
-        } else {
-            None
-        }
+        excract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::ForExpr(for_expr), expr_to_unwrap))
     } else if let Some(while_expr) = ctx.find_node_at_offset::<ast::WhileExpr>() {
         // while expression
         let block_expr = while_expr.loop_body()?;
-        let block = block_expr.block()?;
-        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
-
-        if cursor_in_range {
-            let expr_to_unwrap = unwrap_trivial_block(block_expr);
-
-            Some((ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
-        } else {
-            None
-        }
+        excract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
     } else if let Some(loop_expr) = ctx.find_node_at_offset::<ast::LoopExpr>() {
         // loop expression
         let block_expr = loop_expr.loop_body()?;
-        let block = block_expr.block()?;
-        let cursor_in_range = block.l_curly_token()?.text_range().contains_range(ctx.frange.range);
-
-        if cursor_in_range {
-            let expr_to_unwrap = unwrap_trivial_block(block_expr);
-
-            Some((ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
-        } else {
-            None
-        }
+        excract_expr(ctx.frange.range, block_expr)
+            .map(|expr_to_unwrap| (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
     } else {
         None
     };
@@ -114,6 +80,17 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
+fn excract_expr(cursor_range: TextRange, block_expr: BlockExpr) -> Option<Expr> {
+    let block = block_expr.block()?;
+    let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
+
+    if cursor_in_range {
+        Some(unwrap_trivial_block(block_expr))
+    } else {
+        None
+    }
+}
+
 #[cfg(test)]
 mod tests {
     use crate::helpers::{check_assist, check_assist_not_applicable};
-- 
cgit v1.2.3


From eea21738ab9e0b7438d03f7b2efc18c15cc30cf2 Mon Sep 17 00:00:00 2001
From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
Date: Sat, 2 May 2020 12:20:39 +0200
Subject: Add unwrap block assist #4156

Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
---
 crates/ra_assists/src/handlers/unwrap_block.rs | 89 ++++----------------------
 1 file changed, 13 insertions(+), 76 deletions(-)

(limited to 'crates/ra_assists')

diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index 71d6d462b..8912ce645 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -1,8 +1,8 @@
 use crate::{Assist, AssistCtx, AssistId};
 
-use ast::{BlockExpr, Expr, LoopBodyOwner};
+use ast::{BlockExpr, Expr, ForExpr, IfExpr, LoopBodyOwner, LoopExpr, WhileExpr};
 use ra_fmt::unwrap_trivial_block;
-use ra_syntax::{ast, AstNode, TextRange};
+use ra_syntax::{ast, AstNode, TextRange, T};
 
 // Assist: unwrap_block
 //
@@ -22,15 +22,11 @@ use ra_syntax::{ast, AstNode, TextRange};
 // }
 // ```
 pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
-    let res = if let Some(if_expr) = ctx.find_node_at_offset::<ast::IfExpr>() {
+    let l_curly_token = ctx.find_token_at_offset(T!['{'])?;
+
+    let res = if let Some(if_expr) = l_curly_token.ancestors().find_map(IfExpr::cast) {
         // if expression
-        let mut expr_to_unwrap: Option<ast::Expr> = None;
-        for block_expr in if_expr.blocks() {
-            if let Some(expr) = excract_expr(ctx.frange.range, block_expr) {
-                expr_to_unwrap = Some(expr);
-                break;
-            }
-        }
+        let expr_to_unwrap = if_expr.blocks().find_map(|expr| extract_expr(ctx.frange.range, expr));
         let expr_to_unwrap = expr_to_unwrap?;
         // Find if we are in a else if block
         let ancestor = if_expr.syntax().ancestors().skip(1).find_map(ast::IfExpr::cast);
@@ -40,20 +36,20 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
         } else {
             Some((ast::Expr::IfExpr(if_expr), expr_to_unwrap))
         }
-    } else if let Some(for_expr) = ctx.find_node_at_offset::<ast::ForExpr>() {
+    } else if let Some(for_expr) = l_curly_token.ancestors().find_map(ForExpr::cast) {
         // for expression
         let block_expr = for_expr.loop_body()?;
-        excract_expr(ctx.frange.range, block_expr)
+        extract_expr(ctx.frange.range, block_expr)
             .map(|expr_to_unwrap| (ast::Expr::ForExpr(for_expr), expr_to_unwrap))
-    } else if let Some(while_expr) = ctx.find_node_at_offset::<ast::WhileExpr>() {
+    } else if let Some(while_expr) = l_curly_token.ancestors().find_map(WhileExpr::cast) {
         // while expression
         let block_expr = while_expr.loop_body()?;
-        excract_expr(ctx.frange.range, block_expr)
+        extract_expr(ctx.frange.range, block_expr)
             .map(|expr_to_unwrap| (ast::Expr::WhileExpr(while_expr), expr_to_unwrap))
-    } else if let Some(loop_expr) = ctx.find_node_at_offset::<ast::LoopExpr>() {
+    } else if let Some(loop_expr) = l_curly_token.ancestors().find_map(LoopExpr::cast) {
         // loop expression
         let block_expr = loop_expr.loop_body()?;
-        excract_expr(ctx.frange.range, block_expr)
+        extract_expr(ctx.frange.range, block_expr)
             .map(|expr_to_unwrap| (ast::Expr::LoopExpr(loop_expr), expr_to_unwrap))
     } else {
         None
@@ -80,7 +76,7 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
-fn excract_expr(cursor_range: TextRange, block_expr: BlockExpr) -> Option<Expr> {
+fn extract_expr(cursor_range: TextRange, block_expr: BlockExpr) -> Option<Expr> {
     let block = block_expr.block()?;
     let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
 
@@ -200,65 +196,6 @@ mod tests {
         );
     }
 
-    #[test]
-    fn issue_example_with_if() {
-        check_assist(
-            unwrap_block,
-            r#"
-            fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
-                if let Some(ty) = &ctx.expected_type {<|>
-                    if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
-                        let variants = enum_data.variants(ctx.db);
-
-                        let module = if let Some(module) = ctx.scope().module() {
-                            // Compute path from the completion site if available.
-                            module
-                        } else {
-                            // Otherwise fall back to the enum's definition site.
-                            enum_data.module(ctx.db)
-                        };
-
-                        for variant in variants {
-                            if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
-                                // Variants with trivial paths are already added by the existing completion logic,
-                                // so we should avoid adding these twice
-                                if path.segments.len() > 1 {
-                                    acc.add_enum_variant(ctx, variant, Some(path.to_string()));
-                                }
-                            }
-                        }
-                    }
-                }
-            }
-            "#,
-            r#"
-            fn complete_enum_variants(acc: &mut Completions, ctx: &CompletionContext, ty: &Type) {
-                <|>if let Some(Adt::Enum(enum_data)) = ty.as_adt() {
-                    let variants = enum_data.variants(ctx.db);
-
-                    let module = if let Some(module) = ctx.scope().module() {
-                        // Compute path from the completion site if available.
-                        module
-                    } else {
-                        // Otherwise fall back to the enum's definition site.
-                        enum_data.module(ctx.db)
-                    };
-
-                    for variant in variants {
-                        if let Some(path) = module.find_use_path(ctx.db, ModuleDef::from(variant)) {
-                            // Variants with trivial paths are already added by the existing completion logic,
-                            // so we should avoid adding these twice
-                            if path.segments.len() > 1 {
-                                acc.add_enum_variant(ctx, variant, Some(path.to_string()));
-                            }
-                        }
-                    }
-                }
-            }
-            "#,
-        );
-    }
-
     #[test]
     fn simple_for() {
         check_assist(
-- 
cgit v1.2.3


From 6d5f3922f7cf6d6c02521ad947abd63ab4764fca Mon Sep 17 00:00:00 2001
From: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
Date: Sat, 2 May 2020 12:31:11 +0200
Subject: Add unwrap block assist #4156

Signed-off-by: Benjamin Coenen <5719034+bnjjj@users.noreply.github.com>
---
 crates/ra_assists/src/handlers/unwrap_block.rs | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

(limited to 'crates/ra_assists')

diff --git a/crates/ra_assists/src/handlers/unwrap_block.rs b/crates/ra_assists/src/handlers/unwrap_block.rs
index 8912ce645..58649c47e 100644
--- a/crates/ra_assists/src/handlers/unwrap_block.rs
+++ b/crates/ra_assists/src/handlers/unwrap_block.rs
@@ -76,12 +76,11 @@ pub(crate) fn unwrap_block(ctx: AssistCtx) -> Option<Assist> {
     })
 }
 
-fn extract_expr(cursor_range: TextRange, block_expr: BlockExpr) -> Option<Expr> {
-    let block = block_expr.block()?;
+fn extract_expr(cursor_range: TextRange, block: BlockExpr) -> Option<Expr> {
     let cursor_in_range = block.l_curly_token()?.text_range().contains_range(cursor_range);
 
     if cursor_in_range {
-        Some(unwrap_trivial_block(block_expr))
+        Some(unwrap_trivial_block(block))
     } else {
         None
     }
-- 
cgit v1.2.3