6 files changed, 383 insertions, 26 deletions

diff --git a/crates/ra_assists/src/assist_ctx.rs b/crates/ra_assists/src/assist_ctx.rs
index 189cad7d0..e270c5d60 100644
--- a/crates/ra_assists/src/assist_ctx.rs
+++ b/crates/ra_assists/src/assist_ctx.rs
@@ -138,6 +138,7 @@ impl AssistBuilder {
 
     /// Replaces specified `node` of text with a given string, reindenting the
     /// string to maintain `node`'s existing indent.
+    // FIXME: remove in favor of ra_syntax::edit::IndentLevel::increase_indent
     pub(crate) fn replace_node_and_indent(
         &mut self,
         node: &SyntaxNode,
diff --git a/crates/ra_assists/src/assists/early_return.rs b/crates/ra_assists/src/assists/early_return.rs
new file mode 100644
index 000000000..8c975714c
--- /dev/null
+++ b/crates/ra_assists/src/assists/early_return.rs
@@ -0,0 +1,276 @@
+//! FIXME: write short doc here
+
+use crate::{
+    assist_ctx::{Assist, AssistCtx},
+    AssistId,
+};
+use hir::db::HirDatabase;
+use ra_syntax::{
+    algo::replace_children,
+    ast::edit::IndentLevel,
+    ast::make,
+    ast::Block,
+    ast::ContinueExpr,
+    ast::IfExpr,
+    ast::ReturnExpr,
+    AstNode,
+    SyntaxKind::{FN_DEF, LOOP_EXPR, L_CURLY, R_CURLY, WHILE_EXPR, WHITESPACE},
+};
+use std::ops::RangeInclusive;
+
+pub(crate) fn convert_to_guarded_return(mut ctx: AssistCtx<impl HirDatabase>) -> Option<Assist> {
+    let if_expr: IfExpr = ctx.node_at_offset()?;
+    let expr = if_expr.condition()?.expr()?;
+    let then_block = if_expr.then_branch()?.block()?;
+    if if_expr.else_branch().is_some() {
+        return None;
+    }
+
+    let parent_block = if_expr.syntax().parent()?.ancestors().find_map(Block::cast)?;
+
+    if parent_block.expr()? != if_expr.clone().into() {
+        return None;
+    }
+
+    // check for early return and continue
+    let first_in_then_block = then_block.syntax().first_child()?.clone();
+    if ReturnExpr::can_cast(first_in_then_block.kind())
+        || ContinueExpr::can_cast(first_in_then_block.kind())
+        || first_in_then_block
+            .children()
+            .any(|x| ReturnExpr::can_cast(x.kind()) || ContinueExpr::can_cast(x.kind()))
+    {
+        return None;
+    }
+
+    let parent_container = parent_block.syntax().parent()?.parent()?;
+
+    let early_expression = match parent_container.kind() {
+        WHILE_EXPR | LOOP_EXPR => Some("continue;"),
+        FN_DEF => Some("return;"),
+        _ => None,
+    }?;
+
+    if then_block.syntax().first_child_or_token().map(|t| t.kind() == L_CURLY).is_none() {
+        return None;
+    }
+
+    then_block.syntax().last_child_or_token().filter(|t| t.kind() == R_CURLY)?;
+    let cursor_position = ctx.frange.range.start();
+
+    ctx.add_action(AssistId("convert_to_guarded_return"), "convert to guarded return", |edit| {
+        let if_indent_level = IndentLevel::from_node(&if_expr.syntax());
+        let new_if_expr =
+            if_indent_level.increase_indent(make::if_expression(&expr, early_expression));
+        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 new_if_and_then_statements = new_if_expr.syntax().children_with_tokens().chain(
+            then_block_items
+                .syntax()
+                .children_with_tokens()
+                .skip(1)
+                .take_while(|i| *i != end_of_then),
+        );
+        let new_block = replace_children(
+            &parent_block.syntax(),
+            RangeInclusive::new(
+                if_expr.clone().syntax().clone().into(),
+                if_expr.syntax().clone().into(),
+            ),
+            &mut new_if_and_then_statements,
+        );
+        edit.target(if_expr.syntax().text_range());
+        edit.replace_ast(parent_block, Block::cast(new_block).unwrap());
+        edit.set_cursor(cursor_position);
+    });
+    ctx.build()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::helpers::{check_assist, check_assist_not_applicable};
+
+    #[test]
+    fn convert_inside_fn() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                bar();
+                if<|> true {
+                    foo();
+
+                    //comment
+                    bar();
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                bar();
+                if<|> !true {
+                    return;
+                }
+                foo();
+
+                //comment
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_inside_while() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                while true {
+                    if<|> true {
+                        foo();
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                while true {
+                    if<|> !true {
+                        continue;
+                    }
+                    foo();
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn convert_inside_loop() {
+        check_assist(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                loop {
+                    if<|> true {
+                        foo();
+                        bar();
+                    }
+                }
+            }
+            "#,
+            r#"
+            fn main() {
+                loop {
+                    if<|> !true {
+                        continue;
+                    }
+                    foo();
+                    bar();
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_already_converted_if() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    return;
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_already_converted_loop() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                loop {
+                    if<|> true {
+                        continue;
+                    }
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_return() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    return
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_else_branch() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    foo();
+                } else {
+                    bar()
+                }
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_statements_aftert_if() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if<|> true {
+                    foo();
+                }
+                bar();
+            }
+            "#,
+        );
+    }
+
+    #[test]
+    fn ignore_statements_inside_if() {
+        check_assist_not_applicable(
+            convert_to_guarded_return,
+            r#"
+            fn main() {
+                if false {
+                    if<|> true {
+                        foo();
+                    }
+                }
+            }
+            "#,
+        );
+    }
+}
diff --git a/crates/ra_assists/src/assists/fill_match_arms.rs b/crates/ra_assists/src/assists/fill_match_arms.rs
index 7335cce09..e3f30b5de 100644
--- a/crates/ra_assists/src/assists/fill_match_arms.rs
+++ b/crates/ra_assists/src/assists/fill_match_arms.rs
@@ -3,7 +3,7 @@
 use std::iter;
 
 use hir::{db::HirDatabase, Adt, HasSource};
-use ra_syntax::ast::{self, make, AstNode, NameOwner};
+use ra_syntax::ast::{self, edit::IndentLevel, make, AstNode, NameOwner};
 
 use crate::{Assist, AssistCtx, AssistId};
 
@@ -30,15 +30,19 @@ pub(crate) fn fill_match_arms(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
     let variant_list = enum_def.variant_list()?;
 
     ctx.add_action(AssistId("fill_match_arms"), "fill match arms", |edit| {
-        let variants = variant_list.variants();
-        let arms = variants
-            .filter_map(build_pat)
-            .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
-        let new_arm_list = make::match_arm_list(arms);
+        let indent_level = IndentLevel::from_node(match_arm_list.syntax());
+
+        let new_arm_list = {
+            let variants = variant_list.variants();
+            let arms = variants
+                .filter_map(build_pat)
+                .map(|pat| make::match_arm(iter::once(pat), make::expr_unit()));
+            indent_level.increase_indent(make::match_arm_list(arms))
+        };
 
         edit.target(match_expr.syntax().text_range());
         edit.set_cursor(expr.syntax().text_range().start());
-        edit.replace_node_and_indent(match_arm_list.syntax(), new_arm_list.syntax().text());
+        edit.replace_ast(match_arm_list, new_arm_list);
     });
 
     ctx.build()
diff --git a/crates/ra_assists/src/assists/move_bounds.rs b/crates/ra_assists/src/assists/move_bounds.rs
index f791d22b0..d2444b6b9 100644
--- a/crates/ra_assists/src/assists/move_bounds.rs
+++ b/crates/ra_assists/src/assists/move_bounds.rs
@@ -18,7 +18,7 @@ pub(crate) fn move_bounds_to_where_clause(mut ctx: AssistCtx<impl HirDatabase>)
     }
 
     let parent = type_param_list.syntax().parent()?;
-    if parent.children_with_tokens().find(|it| it.kind() == WHERE_CLAUSE).is_some() {
+    if parent.children_with_tokens().any(|it| it.kind() == WHERE_CLAUSE) {
         return None;
     }
 
diff --git a/crates/ra_assists/src/assists/raw_string.rs b/crates/ra_assists/src/assists/raw_string.rs
index 388ee7e97..2d2e31e51 100644
--- a/crates/ra_assists/src/assists/raw_string.rs
+++ b/crates/ra_assists/src/assists/raw_string.rs
@@ -2,6 +2,7 @@
 
 use hir::db::HirDatabase;
 use ra_syntax::{ast::AstNode, ast::Literal, TextRange, TextUnit};
+use rustc_lexer;
 
 use crate::{Assist, AssistCtx, AssistId};
 
@@ -10,13 +11,51 @@ pub(crate) fn make_raw_string(mut ctx: AssistCtx<impl HirDatabase>) -> Option<As
     if literal.token().kind() != ra_syntax::SyntaxKind::STRING {
         return None;
     }
+    let token = literal.token();
+    let text = token.text().as_str();
+    let usual_string_range = find_usual_string_range(text)?;
+    let start_of_inside = usual_string_range.start().to_usize() + 1;
+    let end_of_inside = usual_string_range.end().to_usize();
+    let inside_str = &text[start_of_inside..end_of_inside];
+    let mut unescaped = String::with_capacity(inside_str.len());
+    let mut error = Ok(());
+    rustc_lexer::unescape::unescape_str(
+        inside_str,
+        &mut |_, unescaped_char| match unescaped_char {
+            Ok(c) => unescaped.push(c),
+            Err(_) => error = Err(()),
+        },
+    );
+    if error.is_err() {
+        return None;
+    }
     ctx.add_action(AssistId("make_raw_string"), "make raw string", |edit| {
         edit.target(literal.syntax().text_range());
-        edit.insert(literal.syntax().text_range().start(), "r");
+        let max_hash_streak = count_hashes(&unescaped);
+        let mut hashes = String::with_capacity(max_hash_streak + 1);
+        for _ in 0..hashes.capacity() {
+            hashes.push('#');
+        }
+        edit.replace(
+            literal.syntax().text_range(),
+            format!("r{}\"{}\"{}", hashes, unescaped, hashes),
+        );
     });
     ctx.build()
 }
 
+fn count_hashes(s: &str) -> usize {
+    let mut max_hash_streak = 0usize;
+    for idx in s.match_indices("\"#").map(|(i, _)| i) {
+        let (_, sub) = s.split_at(idx + 1);
+        let nb_hash = sub.chars().take_while(|c| *c == '#').count();
+        if nb_hash > max_hash_streak {
+            max_hash_streak = nb_hash;
+        }
+    }
+    max_hash_streak
+}
+
 fn find_usual_string_range(s: &str) -> Option<TextRange> {
     Some(TextRange::from_to(
         TextUnit::from(s.find('"')? as u32),
@@ -94,10 +133,10 @@ mod test {
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>"random string";
+                let s = <|>"random\nstring";
             }
             "#,
-            r#""random string""#,
+            r#""random\nstring""#,
         );
     }
 
@@ -107,44 +146,69 @@ mod test {
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>"random string";
+                let s = <|>"random\nstring";
             }
             "#,
-            r#"
+            r##"
             fn f() {
-                let s = <|>r"random string";
+                let s = <|>r#"random
+string"#;
             }
-            "#,
+            "##,
         )
     }
 
     #[test]
-    fn make_raw_string_with_escaped_works() {
+    fn make_raw_string_hashes_inside_works() {
         check_assist(
             make_raw_string,
-            r#"
+            r###"
             fn f() {
-                let s = <|>"random\nstring";
+                let s = <|>"#random##\nstring";
             }
-            "#,
-            r#"
+            "###,
+            r####"
             fn f() {
-                let s = <|>r"random\nstring";
+                let s = <|>r#"#random##
+string"#;
             }
-            "#,
+            "####,
         )
     }
 
     #[test]
-    fn make_raw_string_not_works() {
-        check_assist_not_applicable(
+    fn make_raw_string_closing_hashes_inside_works() {
+        check_assist(
+            make_raw_string,
+            r###"
+            fn f() {
+                let s = <|>"#random\"##\nstring";
+            }
+            "###,
+            r####"
+            fn f() {
+                let s = <|>r###"#random"##
+string"###;
+            }
+            "####,
+        )
+    }
+
+    #[test]
+    fn make_raw_string_nothing_to_unescape_works() {
+        check_assist(
             make_raw_string,
             r#"
             fn f() {
-                let s = <|>r"random string";
+                let s = <|>"random string";
             }
             "#,
-        );
+            r##"
+            fn f() {
+                let s = <|>r#"random string"#;
+            }
+            "##,
+        )
     }
 
     #[test]
@@ -369,4 +433,14 @@ mod test {
             "#,
         );
     }
+
+    #[test]
+    fn count_hashes_test() {
+        assert_eq!(0, count_hashes("abc"));
+        assert_eq!(0, count_hashes("###"));
+        assert_eq!(1, count_hashes("\"#abc"));
+        assert_eq!(0, count_hashes("#abc"));
+        assert_eq!(2, count_hashes("#ab\"##c"));
+        assert_eq!(4, count_hashes("#ab\"##\"####c"));
+    }
 }
diff --git a/crates/ra_assists/src/lib.rs b/crates/ra_assists/src/lib.rs
index d2376c475..ab77b46a9 100644
--- a/crates/ra_assists/src/lib.rs
+++ b/crates/ra_assists/src/lib.rs
@@ -108,6 +108,7 @@ mod assists {
     mod add_missing_impl_members;
     mod move_guard;
     mod move_bounds;
+    mod early_return;
 
     pub(crate) fn all<DB: HirDatabase>() -> &'static [fn(AssistCtx<DB>) -> Option<Assist>] {
         &[
@@ -135,6 +136,7 @@ mod assists {
             raw_string::make_raw_string,
             raw_string::make_usual_string,
             raw_string::remove_hash,
+            early_return::convert_to_guarded_return,
         ]
     }
 }