-use std::iter;
+use std::iter::{self, Peekable};
use either::Either;
use hir::{Adt, HasSource, ModuleDef, Semantics};
let module = ctx.sema.scope(expr.syntax()).module()?;
- let missing_arms: Vec<MatchArm> = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
+ let mut missing_pats: Peekable<Box<dyn Iterator<Item = ast::Pat>>> = if let Some(enum_def) =
+ resolve_enum_def(&ctx.sema, &expr)
+ {
let variants = enum_def.variants(ctx.db());
- let mut variants = variants
+ let missing_pats = variants
.into_iter()
.filter_map(|variant| build_pat(ctx.db(), module, variant))
- .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
- .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
- .collect::<Vec<_>>();
- if Some(enum_def)
- == FamousDefs(&ctx.sema, Some(module.krate()))
- .core_option_Option()
- .map(|x| lift_enum(x))
+ .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat));
+
+ let missing_pats: Box<dyn Iterator<Item = _>> = if Some(enum_def)
+ == FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option().map(lift_enum)
{
// Match `Some` variant first.
cov_mark::hit!(option_order);
- variants.reverse()
- }
- variants
+ Box::new(missing_pats.rev())
+ } else {
+ Box::new(missing_pats)
+ };
+ missing_pats.peekable()
} else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
+ let mut n_arms = 1;
+ let variants_of_enums: Vec<Vec<ExtendedVariant>> = enum_defs
+ .into_iter()
+ .map(|enum_def| enum_def.variants(ctx.db()))
+ .inspect(|variants| n_arms *= variants.len())
+ .collect();
+
// When calculating the match arms for a tuple of enums, we want
// to create a match arm for each possible combination of enum
// values. The `multi_cartesian_product` method transforms
// Vec<Vec<EnumVariant>> into Vec<(EnumVariant, .., EnumVariant)>
// where each tuple represents a proposed match arm.
- enum_defs
+
+ // A number of arms grows very fast on even a small tuple of large enums.
+ // We skip the assist beyond an arbitrary threshold.
+ if n_arms > 256 {
+ return None;
+ }
+ let missing_pats = variants_of_enums
.into_iter()
- .map(|enum_def| enum_def.variants(ctx.db()))
.multi_cartesian_product()
+ .inspect(|_| cov_mark::hit!(fill_match_arms_lazy_computation))
.map(|variants| {
let patterns =
variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
ast::Pat::from(make::tuple_pat(patterns))
})
- .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat))
- .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
- .collect()
+ .filter(|variant_pat| is_variant_missing(&top_lvl_pats, variant_pat));
+ (Box::new(missing_pats) as Box<dyn Iterator<Item = _>>).peekable()
} else {
return None;
};
- if missing_arms.is_empty() {
+ if missing_pats.peek().is_none() {
return None;
}
"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 new_match_arm_list = match_arm_list.clone_for_update();
+ let missing_arms = missing_pats
+ .map(|pat| make::match_arm(iter::once(pat), make::expr_empty_block()))
+ .map(|it| it.clone_for_update());
+
+ let catch_all_arm = new_match_arm_list
+ .arms()
+ .find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))));
+ if let Some(arm) = catch_all_arm {
+ arm.remove()
+ }
+ let mut first_new_arm = None;
+ for arm in missing_arms {
+ first_new_arm.get_or_insert_with(|| arm.clone());
+ new_match_arm_list.add_arm(arm);
+ }
+
let old_range = ctx.sema.original_range(match_arm_list.syntax()).range;
match (first_new_arm, ctx.config.snippet_cap) {
(Some(first_new_arm), Some(cap)) => {
}
None => Cursor::Before(first_new_arm.syntax()),
};
- let snippet = render_snippet(cap, new_arm_list.syntax(), cursor);
+ let snippet = render_snippet(cap, new_match_arm_list.syntax(), cursor);
builder.replace_snippet(cap, old_range, snippet);
}
- _ => builder.replace(old_range, new_arm_list.to_string()),
+ _ => builder.replace(old_range, new_match_arm_list.to_string()),
}
},
)
}
}
-#[derive(Eq, PartialEq, Clone)]
+#[derive(Eq, PartialEq, Clone, Copy)]
enum ExtendedEnum {
Bool,
Enum(hir::Enum),
}
-#[derive(Eq, PartialEq, Clone)]
+#[derive(Eq, PartialEq, Clone, Copy)]
enum ExtendedVariant {
True,
False,
}
impl ExtendedEnum {
- fn variants(&self, db: &RootDatabase) -> Vec<ExtendedVariant> {
+ fn variants(self, db: &RootDatabase) -> Vec<ExtendedVariant> {
match self {
ExtendedEnum::Enum(e) => {
e.variants(db).into_iter().map(|x| ExtendedVariant::Variant(x)).collect::<Vec<_>>()
mod tests {
use ide_db::helpers::FamousDefs;
- use crate::tests::{check_assist, check_assist_not_applicable, check_assist_target};
+ use crate::tests::{
+ check_assist, check_assist_not_applicable, check_assist_target, check_assist_unresolved,
+ };
use super::fill_match_arms;
check_assist_not_applicable(
fill_match_arms,
r#"
- enum A {
- As,
- Bs{x:i32, y:Option<i32>},
- Cs(i32, Option<i32>),
- }
- fn main() {
- match A::As$0 {
- A::As,
- A::Bs{x,y:Some(_)} => {}
- A::Cs(_, Some(_)) => {}
- }
- }
+enum A {
+ As,
+ Bs{x:i32, y:Option<i32>},
+ Cs(i32, Option<i32>),
+}
+fn main() {
+ match A::As$0 {
+ A::As,
+ A::Bs{x,y:Some(_)} => {}
+ A::Cs(_, Some(_)) => {}
+ }
+}
"#,
);
}
check_assist_not_applicable(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match a$0 {
- true => {}
- false => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match a$0 {
+ true => {}
+ false => {}
+ }
+}
+"#,
)
}
check_assist_not_applicable(
fill_match_arms,
r#"
- fn main() {
- match (0, false)$0 {
- }
- }
- "#,
+fn main() {
+ match (0, false)$0 {
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match a$0 {
- }
- }
- "#,
+fn foo(a: bool) {
+ match a$0 {
+ }
+}
+"#,
r#"
- fn foo(a: bool) {
- match a {
- $0true => {}
- false => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match a {
+ $0true => {}
+ false => {}
+ }
+}
+"#,
)
}
check_assist(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match a$0 {
- true => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match a$0 {
+ true => {}
+ }
+}
+"#,
r#"
- fn foo(a: bool) {
- match a {
- true => {}
- $0false => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match a {
+ true => {}
+ $0false => {}
+ }
+}
+"#,
)
}
check_assist_not_applicable(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match (a, a)$0 {
- (true, true) => {}
- (true, false) => {}
- (false, true) => {}
- (false, false) => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match (a, a)$0 {
+ (true, true) => {}
+ (true, false) => {}
+ (false, true) => {}
+ (false, false) => {}
+ }
+}
+"#,
)
}
check_assist(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match (a, a)$0 {
- }
- }
- "#,
+fn foo(a: bool) {
+ match (a, a)$0 {
+ }
+}
+"#,
r#"
- fn foo(a: bool) {
- match (a, a) {
- $0(true, true) => {}
- (true, false) => {}
- (false, true) => {}
- (false, false) => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match (a, a) {
+ $0(true, true) => {}
+ (true, false) => {}
+ (false, true) => {}
+ (false, false) => {}
+ }
+}
+"#,
)
}
check_assist(
fill_match_arms,
r#"
- fn foo(a: bool) {
- match (a, a)$0 {
- (false, true) => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match (a, a)$0 {
+ (false, true) => {}
+ }
+}
+"#,
r#"
- fn foo(a: bool) {
- match (a, a) {
- (false, true) => {}
- $0(true, true) => {}
- (true, false) => {}
- (false, false) => {}
- }
- }
- "#,
+fn foo(a: bool) {
+ match (a, a) {
+ (false, true) => {}
+ $0(true, true) => {}
+ (true, false) => {}
+ (false, false) => {}
+ }
+}
+"#,
)
}
check_assist(
fill_match_arms,
r#"
- enum A {
- As,
- Bs { x: i32, y: Option<i32> },
- Cs(i32, Option<i32>),
- }
- fn main() {
- match A::As$0 {
- A::Bs { x, y: Some(_) } => {}
- A::Cs(_, Some(_)) => {}
- }
- }
- "#,
+enum A {
+ As,
+ Bs { x: i32, y: Option<i32> },
+ Cs(i32, Option<i32>),
+}
+fn main() {
+ match A::As$0 {
+ A::Bs { x, y: Some(_) } => {}
+ A::Cs(_, Some(_)) => {}
+ }
+}
+"#,
r#"
- enum A {
- As,
- Bs { x: i32, y: Option<i32> },
- Cs(i32, Option<i32>),
- }
- fn main() {
- match A::As {
- A::Bs { x, y: Some(_) } => {}
- A::Cs(_, Some(_)) => {}
- $0A::As => {}
- }
- }
- "#,
+enum A {
+ As,
+ Bs { x: i32, y: Option<i32> },
+ Cs(i32, Option<i32>),
+}
+fn main() {
+ match A::As {
+ A::Bs { x, y: Some(_) } => {}
+ A::Cs(_, Some(_)) => {}
+ $0A::As => {}
+ }
+}
+"#,
);
}
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;
- let b = B::One;
- match (a$0, b) {}
- }
- "#,
+fn main() {
+ let a = A::One;
+ let b = B::One;
+ match (a$0, b) {}
+}
+"#,
r#"
- enum A { One, Two }
- enum B { One, Two }
-
- fn main() {
- let a = A::One;
- let b = B::One;
- match (a, b) {
- $0(A::One, B::One) => {}
- (A::One, B::Two) => {}
- (A::Two, B::One) => {}
- (A::Two, B::Two) => {}
- }
- }
- "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+ let a = A::One;
+ let b = B::One;
+ match (a, b) {
+ $0(A::One, B::One) => {}
+ (A::One, B::Two) => {}
+ (A::Two, B::One) => {}
+ (A::Two, B::Two) => {}
+ }
+}
+"#,
);
}
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;
- let b = B::One;
- match (&a$0, &b) {}
- }
- "#,
+fn main() {
+ let a = A::One;
+ let b = B::One;
+ match (&a$0, &b) {}
+}
+"#,
r#"
- enum A { One, Two }
- enum B { One, Two }
-
- fn main() {
- let a = A::One;
- let b = B::One;
- match (&a, &b) {
- $0(A::One, B::One) => {}
- (A::One, B::Two) => {}
- (A::Two, B::One) => {}
- (A::Two, B::Two) => {}
- }
- }
- "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+ let a = A::One;
+ let b = B::One;
+ match (&a, &b) {
+ $0(A::One, B::One) => {}
+ (A::One, B::Two) => {}
+ (A::Two, B::One) => {}
+ (A::Two, B::Two) => {}
+ }
+}
+"#,
);
}
check_assist_not_applicable(
fill_match_arms,
r#"
- enum A { One, Two }
- enum B { One, Two }
-
- fn main() {
- let a = A::One;
- let b = B::One;
- match (a$0, b) {
- (A::Two, B::One) => {}
- (A::One, B::One) => {}
- (A::One, B::Two) => {}
- (A::Two, B::Two) => {}
- }
- }
- "#,
+enum A { One, Two }
+enum B { One, Two }
+
+fn main() {
+ let a = A::One;
+ let b = B::One;
+ match (a$0, b) {
+ (A::Two, B::One) => {}
+ (A::One, B::One) => {}
+ (A::One, B::Two) => {}
+ (A::Two, B::Two) => {}
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- enum A { One, Two }
+enum A { One, Two }
- fn main() {
- let a = A::One;
- match (a$0, ) {
- }
- }
- "#,
+fn main() {
+ let a = A::One;
+ match (a$0, ) {
+ }
+}
+"#,
r#"
- enum A { One, Two }
+enum A { One, Two }
- fn main() {
- let a = A::One;
- match (a, ) {
- $0(A::One,) => {}
- (A::Two,) => {}
- }
- }
- "#,
+fn main() {
+ let a = A::One;
+ match (a, ) {
+ $0(A::One,) => {}
+ (A::Two,) => {}
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- enum A { As }
+enum A { As }
- fn foo(a: &A) {
- match a$0 {
- }
- }
- "#,
+fn foo(a: &A) {
+ match a$0 {
+ }
+}
+"#,
r#"
- enum A { As }
+enum A { As }
- fn foo(a: &A) {
- match a {
- $0A::As => {}
- }
- }
- "#,
+fn foo(a: &A) {
+ match a {
+ $0A::As => {}
+ }
+}
+"#,
);
check_assist(
fill_match_arms,
r#"
- enum A {
- Es { x: usize, y: usize }
- }
+enum A {
+ Es { x: usize, y: usize }
+}
- fn foo(a: &mut A) {
- match a$0 {
- }
- }
- "#,
+fn foo(a: &mut A) {
+ match a$0 {
+ }
+}
+"#,
r#"
- enum A {
- Es { x: usize, y: usize }
- }
+enum A {
+ Es { x: usize, y: usize }
+}
- fn foo(a: &mut A) {
- match a {
- $0A::Es { x, y } => {}
- }
- }
- "#,
+fn foo(a: &mut A) {
+ match a {
+ $0A::Es { x, y } => {}
+ }
+}
+"#,
);
}
check_assist_target(
fill_match_arms,
r#"
- enum E { X, Y }
+enum E { X, Y }
- fn main() {
- match E::X$0 {}
- }
- "#,
+fn main() {
+ match E::X$0 {}
+}
+"#,
"match E::X {}",
);
}
check_assist(
fill_match_arms,
r#"
- enum E { X, Y }
+enum E { X, Y }
- fn main() {
- match E::X {
- $0_ => {}
- }
- }
- "#,
+fn main() {
+ match E::X {
+ $0_ => {}
+ }
+}
+"#,
r#"
- enum E { X, Y }
+enum E { X, Y }
- fn main() {
- match E::X {
- $0E::X => {}
- E::Y => {}
- }
- }
- "#,
+fn main() {
+ match E::X {
+ $0E::X => {}
+ E::Y => {}
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- mod foo { pub enum E { X, Y } }
- use foo::E::X;
+mod foo { pub enum E { X, Y } }
+use foo::E::X;
- fn main() {
- match X {
- $0
- }
- }
- "#,
+fn main() {
+ match X {
+ $0
+ }
+}
+"#,
r#"
- mod foo { pub enum E { X, Y } }
- use foo::E::X;
+mod foo { pub enum E { X, Y } }
+use foo::E::X;
- fn main() {
- match X {
- $0X => {}
- foo::E::Y => {}
- }
- }
- "#,
+fn main() {
+ match X {
+ $0X => {}
+ foo::E::Y => {}
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- enum A { One, Two }
- fn foo(a: A) {
- match a {
- // foo bar baz$0
- A::One => {}
- // This is where the rest should be
- }
- }
- "#,
+enum A { One, Two }
+fn foo(a: A) {
+ match a {
+ // foo bar baz$0
+ A::One => {}
+ // This is where the rest should be
+ }
+}
+"#,
r#"
- enum A { One, Two }
- fn foo(a: A) {
- match a {
- // foo bar baz
- A::One => {}
- // This is where the rest should be
- $0A::Two => {}
- }
- }
- "#,
+enum A { One, Two }
+fn foo(a: A) {
+ match a {
+ // foo bar baz
+ A::One => {}
+ $0A::Two => {}
+ // This is where the rest should be
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- enum A { One, Two }
- fn foo(a: A) {
- match a {
- // foo bar baz$0
- }
- }
- "#,
+enum A { One, Two }
+fn foo(a: A) {
+ match a {
+ // foo bar baz$0
+ }
+}
+"#,
r#"
- enum A { One, Two }
- fn foo(a: A) {
- match a {
- // foo bar baz
- $0A::One => {}
- A::Two => {}
- }
- }
- "#,
+enum A { One, Two }
+fn foo(a: A) {
+ match a {
+ $0A::One => {}
+ A::Two => {}
+ // foo bar baz
+ }
+}
+"#,
);
}
check_assist(
fill_match_arms,
r#"
- enum A { One, Two, }
- fn foo(a: A) {
- match a$0 {
- _ => (),
- }
- }
- "#,
+enum A { One, Two, }
+fn foo(a: A) {
+ match a$0 {
+ _ => (),
+ }
+}
+"#,
r#"
- enum A { One, Two, }
- fn foo(a: A) {
- match a {
- $0A::One => {}
- A::Two => {}
- }
- }
- "#,
+enum A { One, Two, }
+fn foo(a: A) {
+ match a {
+ $0A::One => {}
+ A::Two => {}
+ }
+}
+"#,
);
}
fn foo(t: Test) {
m!(match t$0 {});
}"#,
- r#"macro_rules! m { ($expr:expr) => {$expr}}
+ r#"
+macro_rules! m { ($expr:expr) => {$expr}}
enum Test {
A,
B,
}"#,
);
}
+
+ #[test]
+ fn lazy_computation() {
+ // Computing a single missing arm is enough to determine applicability of the assist.
+ cov_mark::check_count!(fill_match_arms_lazy_computation, 1);
+ check_assist_unresolved(
+ fill_match_arms,
+ r#"
+enum A { One, Two, }
+fn foo(tuple: (A, A)) {
+ match $0tuple {};
+}
+"#,
+ );
+ }
}
projects / rust.git / blobdiff