available_range,
move |edit| {
let match_expr = {
- let else_arm = make_else_arm(else_block);
+ let else_arm = make_else_arm(ctx, else_block, &cond_bodies);
let make_match_arm = |(pat, body): (_, ast::BlockExpr)| {
let body = body.reset_indent().indent(IndentLevel(1));
match pat {
)
}
-fn make_else_arm(else_block: Option<ast::BlockExpr>) -> ast::MatchArm {
+fn make_else_arm(
+ ctx: &AssistContext,
+ else_block: Option<ast::BlockExpr>,
+ conditionals: &[(Either<ast::Pat, ast::Expr>, ast::BlockExpr)],
+) -> ast::MatchArm {
if let Some(else_block) = else_block {
- let pattern = make::wildcard_pat().into();
+ let pattern = if let [(Either::Left(pat), _)] = conditionals {
+ ctx.sema
+ .type_of_pat(pat)
+ .and_then(|ty| TryEnum::from_ty(&ctx.sema, &ty.adjusted()))
+ .zip(Some(pat))
+ } else {
+ None
+ };
+ let pattern = match pattern {
+ Some((it, pat)) => {
+ if does_pat_match_variant(pat, &it.sad_pattern()) {
+ it.happy_pattern_wildcard()
+ } else {
+ it.sad_pattern()
+ }
+ }
+ None => make::wildcard_pat().into(),
+ };
make::match_arm(iter::once(pattern), None, unwrap_trivial_block(else_block))
} else {
make::match_arm(iter::once(make::wildcard_pat().into()), None, make::expr_unit())
fn foo(x: Option<i32>) {
match x {
Some(x) => println!("{}", x),
- _ => println!("none"),
+ None => println!("none"),
}
}
"#,
fn foo(x: Option<i32>) {
match x {
None => println!("none"),
- _ => println!("some"),
+ Some(_) => println!("some"),
}
}
"#,
fn foo(x: Result<i32, ()>) {
match x {
Ok(x) => println!("{}", x),
- _ => println!("none"),
+ Err(_) => println!("none"),
}
}
"#,
fn foo(x: Result<i32, ()>) {
match x {
Err(x) => println!("{}", x),
- _ => println!("ok"),
+ Ok(_) => println!("ok"),
}
}
"#,
)
}
- #[test]
- fn replace_if_let_with_match_nested_type() {
- check_assist(
- replace_if_let_with_match,
- r#"
-//- minicore: result
-fn foo(x: Result<i32, ()>) {
- let bar: Result<_, ()> = Ok(Some(1));
- $0if let Ok(Some(_)) = bar {
- ()
- } else {
- ()
- }
-}
-"#,
- r#"
-fn foo(x: Result<i32, ()>) {
- let bar: Result<_, ()> = Ok(Some(1));
- match bar {
- Ok(Some(_)) => (),
- _ => (),
- }
-}
-"#,
- );
- }
-
#[test]
fn test_replace_match_with_if_let_unwraps_simple_expressions() {
check_assist(
Bar(bar) => println!("bar {}", bar),
}
}
+"#,
+ );
+ }
+
+ #[test]
+ fn nested_type() {
+ check_assist(
+ replace_if_let_with_match,
+ r#"
+//- minicore: result
+fn foo(x: Result<i32, ()>) {
+ let bar: Result<_, ()> = Ok(Some(1));
+ $0if let Ok(Some(_)) = bar {
+ ()
+ } else {
+ ()
+ }
+}
+"#,
+ r#"
+fn foo(x: Result<i32, ()>) {
+ let bar: Result<_, ()> = Ok(Some(1));
+ match bar {
+ Ok(Some(_)) => (),
+ _ => (),
+ }
"#,
);
}