Remove RelativePathBuf from fixture

[rust.git] / crates / ra_assists / src / handlers / fill_match_arms.rs

diff --git a/crates/ra_assists/src/handlers/fill_match_arms.rs b/crates/ra_assists/src/handlers/fill_match_arms.rs
index b57ff75aedb9c3626d5fb853fc7e82704c58144a..3c12c1daa43d7852f2a34a1828ab125fbc99fac0 100644 (file)
--- a/crates/ra_assists/src/handlers/fill_match_arms.rs
+++ b/crates/ra_assists/src/handlers/fill_match_arms.rs
@@ -4,9 +4,12 @@
 use itertools::Itertools;
 use ra_ide_db::RootDatabase;
 use ra_syntax::ast::{self, make, AstNode, MatchArm, NameOwner, Pat};
-use test_utils::tested_by;
+use test_utils::mark;
 
-use crate::{utils::FamousDefs, AssistContext, AssistId, Assists};
+use crate::{
+    utils::{render_snippet, Cursor, FamousDefs},
+    AssistContext, AssistId, Assists,
+};
 
 // Assist: fill_match_arms
 //
@@ -27,7 +30,7 @@
 //
 // fn handle(action: Action) {
 //     match action {
-//         Action::Move { distance } => {}
+//         $0Action::Move { distance } => {}
 //         Action::Stop => {}
 //     }
 // }
@@ -58,7 +61,7 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
             .collect::<Vec<_>>();
         if Some(enum_def) == FamousDefs(&ctx.sema, module.krate()).core_option_Option() {
             // Match `Some` variant first.
-            tested_by!(option_order);
+            mark::hit!(option_order);
             variants.reverse()
         }
         variants
@@ -100,10 +103,23 @@ pub(crate) fn fill_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<
     }
 
     let target = match_expr.syntax().text_range();
-    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |edit| {
-        let new_arm_list = match_arm_list.remove_placeholder().append_arms(missing_arms);
-        edit.set_cursor(expr.syntax().text_range().start());
-        edit.replace_ast(match_arm_list, new_arm_list);
+    acc.add(AssistId("fill_match_arms"), "Fill match arms", target, |builder| {
+        let new_arm_list = match_arm_list.remove_placeholder();
+        let n_old_arms = new_arm_list.arms().count();
+        let new_arm_list = new_arm_list.append_arms(missing_arms);
+        let first_new_arm = new_arm_list.arms().nth(n_old_arms);
+        let old_range = match_arm_list.syntax().text_range();
+        match (first_new_arm, ctx.config.snippet_cap) {
+            (Some(first_new_arm), Some(cap)) => {
+                let snippet = render_snippet(
+                    cap,
+                    new_arm_list.syntax(),
+                    Cursor::Before(first_new_arm.syntax()),
+                );
+                builder.replace_snippet(cap, old_range, snippet);
+            }
+            _ => builder.replace(old_range, new_arm_list.to_string()),
+        }
     })
 }
 
@@ -120,8 +136,20 @@ fn is_variant_missing(existing_arms: &mut Vec<MatchArm>, var: &Pat) -> bool {
 }
 
 fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
-    let pat_head = pat.syntax().first_child().map(|node| node.text());
-    let var_head = var.syntax().first_child().map(|node| node.text());
+    let first_node_text = |pat: &Pat| pat.syntax().first_child().map(|node| node.text());
+
+    let pat_head = match pat {
+        Pat::BindPat(bind_pat) => {
+            if let Some(p) = bind_pat.pat() {
+                first_node_text(&p)
+            } else {
+                return false;
+            }
+        }
+        pat => first_node_text(pat),
+    };
+
+    let var_head = first_node_text(var);
 
     pat_head == var_head
 }
@@ -174,13 +202,14 @@ fn build_pat(db: &RootDatabase, module: hir::Module, var: hir::EnumVariant) -> O
 
 #[cfg(test)]
 mod tests {
+    use test_utils::mark;
+
     use crate::{
         tests::{check_assist, check_assist_not_applicable, check_assist_target},
         utils::FamousDefs,
     };
 
     use super::fill_match_arms;
-    use test_utils::covers;
 
     #[test]
     fn all_match_arms_provided() {
@@ -225,12 +254,12 @@ fn partial_fill_record_tuple() {
             r#"
             enum A {
                 As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                 Cs(i32, Option<i32>),
             }
             fn main() {
                 match A::As<|> {
-                    A::Bs{x,y:Some(_)} => {}
+                    A::Bs { x, y: Some(_) } => {}
                     A::Cs(_, Some(_)) => {}
                 }
             }
@@ -238,14 +267,14 @@ fn main() {
             r#"
             enum A {
                 As,
-                Bs{x:i32, y:Option<i32>},
+                Bs { x: i32, y: Option<i32> },
                 Cs(i32, Option<i32>),
             }
             fn main() {
-                match <|>A::As {
-                    A::Bs{x,y:Some(_)} => {}
+                match A::As {
+                    A::Bs { x, y: Some(_) } => {}
                     A::Cs(_, Some(_)) => {}
-                    A::As => {}
+                    $0A::As => {}
                 }
             }
             "#,
@@ -275,9 +304,9 @@ enum A {
                 Cs(Option<i32>),
             }
             fn main() {
-                match <|>A::As {
+                match A::As {
                     A::Cs(_) | A::Bs => {}
-                    A::As => {}
+                    $0A::As => {}
                 }
             }
             "#,
@@ -321,11 +350,11 @@ enum B {
                 Ys,
             }
             fn main() {
-                match <|>A::As {
+                match A::As {
                     A::Bs if 0 < 1 => {}
                     A::Ds(_value) => { let x = 1; }
                     A::Es(B::Xs) => (),
-                    A::As => {}
+                    $0A::As => {}
                     A::Cs => {}
                 }
             }
@@ -333,6 +362,40 @@ fn main() {
         );
     }
 
+    #[test]
+    fn partial_fill_bind_pat() {
+        check_assist(
+            fill_match_arms,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As<|> {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                }
+            }
+            "#,
+            r#"
+            enum A {
+                As,
+                Bs,
+                Cs(Option<i32>),
+            }
+            fn main() {
+                match A::As {
+                    A::As(_) => {}
+                    a @ A::Bs(_) => {}
+                    $0A::Cs(_) => {}
+                }
+            }
+            "#,
+        );
+    }
+
     #[test]
     fn fill_match_arms_empty_body() {
         check_assist(
@@ -343,7 +406,7 @@ enum A {
                 Bs,
                 Cs(String),
                 Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn main() {
@@ -357,13 +420,13 @@ enum A {
                 Bs,
                 Cs(String),
                 Ds(String, String),
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn main() {
                 let a = A::As;
-                match <|>a {
-                    A::As => {}
+                match a {
+                    $0A::As => {}
                     A::Bs => {}
                     A::Cs(_) => {}
                     A::Ds(_, _) => {}
@@ -379,14 +442,8 @@ fn fill_match_arms_tuple_of_enum() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -395,20 +452,14 @@ fn main() {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
                 let b = B::One;
-                match <|>(a, b) {
-                    (A::One, B::One) => {}
+                match (a, b) {
+                    $0(A::One, B::One) => {}
                     (A::One, B::Two) => {}
                     (A::Two, B::One) => {}
                     (A::Two, B::Two) => {}
@@ -423,14 +474,8 @@ fn fill_match_arms_tuple_of_enum_ref() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -439,20 +484,14 @@ fn main() {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
                 let b = B::One;
-                match <|>(&a, &b) {
-                    (A::One, B::One) => {}
+                match (&a, &b) {
+                    $0(A::One, B::One) => {}
                     (A::One, B::Two) => {}
                     (A::Two, B::One) => {}
                     (A::Two, B::Two) => {}
@@ -467,14 +506,8 @@ fn fill_match_arms_tuple_of_enum_partial() {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -492,14 +525,8 @@ fn fill_match_arms_tuple_of_enum_not_applicable() {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
-            enum B {
-                One,
-                Two,
-            }
+            enum A { One, Two }
+            enum B { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -523,10 +550,7 @@ fn fill_match_arms_single_element_tuple_of_enum() {
         check_assist_not_applicable(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
 
             fn main() {
                 let a = A::One;
@@ -542,9 +566,7 @@ fn test_fill_match_arm_refs() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                As,
-            }
+            enum A { As }
 
             fn foo(a: &A) {
                 match a<|> {
@@ -552,13 +574,11 @@ fn foo(a: &A) {
             }
             "#,
             r#"
-            enum A {
-                As,
-            }
+            enum A { As }
 
             fn foo(a: &A) {
-                match <|>a {
-                    A::As => {}
+                match a {
+                    $0A::As => {}
                 }
             }
             "#,
@@ -568,7 +588,7 @@ fn foo(a: &A) {
             fill_match_arms,
             r#"
             enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn foo(a: &mut A) {
@@ -578,12 +598,12 @@ fn foo(a: &mut A) {
             "#,
             r#"
             enum A {
-                Es{ x: usize, y: usize }
+                Es { x: usize, y: usize }
             }
 
             fn foo(a: &mut A) {
-                match <|>a {
-                    A::Es { x, y } => {}
+                match a {
+                    $0A::Es { x, y } => {}
                 }
             }
             "#,
@@ -622,8 +642,8 @@ fn main() {
             enum E { X, Y }
 
             fn main() {
-                match <|>E::X {
-                    E::X => {}
+                match E::X {
+                    $0E::X => {}
                     E::Y => {}
                 }
             }
@@ -650,8 +670,8 @@ mod foo { pub enum E { X, Y } }
             use foo::E::X;
 
             fn main() {
-                match <|>X {
-                    X => {}
+                match X {
+                    $0X => {}
                     foo::E::Y => {}
                 }
             }
@@ -664,10 +684,7 @@ fn fill_match_arms_preserves_comments() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
                 match a {
                     // foo bar baz<|>
@@ -677,16 +694,13 @@ fn foo(a: A) {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
-                match <|>a {
+                match a {
                     // foo bar baz
                     A::One => {}
                     // This is where the rest should be
-                    A::Two => {}
+                    $0A::Two => {}
                 }
             }
             "#,
@@ -698,10 +712,7 @@ fn fill_match_arms_preserves_comments_empty() {
         check_assist(
             fill_match_arms,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
                 match a {
                     // foo bar baz<|>
@@ -709,14 +720,11 @@ fn foo(a: A) {
             }
             "#,
             r#"
-            enum A {
-                One,
-                Two,
-            }
+            enum A { One, Two }
             fn foo(a: A) {
-                match <|>a {
+                match a {
                     // foo bar baz
-                    A::One => {}
+                    $0A::One => {}
                     A::Two => {}
                 }
             }
@@ -739,8 +747,8 @@ fn foo(a: A) {
             r#"
             enum A { One, Two, }
             fn foo(a: A) {
-                match <|>a {
-                    A::One => {}
+                match a {
+                    $0A::One => {}
                     A::Two => {}
                 }
             }
@@ -750,22 +758,22 @@ fn foo(a: A) {
 
     #[test]
     fn option_order() {
-        covers!(option_order);
+        mark::check!(option_order);
         let before = r#"
 fn foo(opt: Option<i32>) {
     match opt<|> {
     }
 }"#;
         let before =
-            &format!("//- main.rs crate:main deps:core\n{}{}", before, FamousDefs::FIXTURE);
+            &format!("//- /main.rs crate:main deps:core\n{}{}", before, FamousDefs::FIXTURE);
 
         check_assist(
             fill_match_arms,
             before,
             r#"
 fn foo(opt: Option<i32>) {
-    match <|>opt {
-        Some(_) => {}
+    match opt {
+        $0Some(_) => {}
         None => {}
     }
 }