rust/crates/ide_assists/src/handlers/add_missing_match_arms.rs

1711 lines
36 KiB
Rust
Raw Normal View History

2021-05-20 07:58:18 -05:00
use std::iter::{self, Peekable};
2019-02-03 12:26:35 -06:00
use either::Either;
use hir::{Adt, Crate, HasAttrs, HasSource, ModuleDef, Semantics};
2020-08-13 09:39:16 -05:00
use ide_db::RootDatabase;
2022-03-06 12:01:30 -06:00
use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast};
2020-03-23 07:19:09 -05:00
use itertools::Itertools;
use syntax::ast::{self, make, AstNode, HasName, MatchArmList, MatchExpr, Pat};
2019-02-03 12:26:35 -06:00
2020-05-20 07:00:37 -05:00
use crate::{
2021-04-18 06:43:12 -05:00
utils::{self, render_snippet, Cursor},
2020-06-28 17:36:05 -05:00
AssistContext, AssistId, AssistKind, Assists,
2020-05-20 07:00:37 -05:00
};
2019-06-23 23:05:50 -05:00
2021-09-20 16:53:05 -05:00
// Assist: add_missing_match_arms
2019-10-26 09:37:04 -05:00
//
// Adds missing clauses to a `match` expression.
//
// ```
// enum Action { Move { distance: u32 }, Stop }
//
// fn handle(action: Action) {
2021-10-15 07:14:21 -05:00
// match action {
// $0
2019-10-26 09:37:04 -05:00
// }
// }
// ```
// ->
// ```
// enum Action { Move { distance: u32 }, Stop }
//
// fn handle(action: Action) {
2021-10-15 07:14:21 -05:00
// match action {
// $0Action::Move { distance } => todo!(),
// Action::Stop => todo!(),
2019-10-26 09:37:04 -05:00
// }
// }
// ```
2021-09-20 16:53:05 -05:00
pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext) -> Option<()> {
2021-01-27 15:32:40 -06:00
let match_expr = ctx.find_node_at_offset_with_descend::<ast::MatchExpr>()?;
2019-08-22 13:31:21 -05:00
let match_arm_list = match_expr.match_arm_list()?;
let target_range = ctx.sema.original_range(match_expr.syntax()).range;
2019-02-03 12:26:35 -06:00
2022-03-12 06:04:13 -06:00
if let None = cursor_at_trivial_match_arm_list(ctx, &match_expr, &match_arm_list) {
let arm_list_range = ctx.sema.original_range(match_arm_list.syntax()).range;
let cursor_in_range = arm_list_range.contains_range(ctx.selection_trimmed());
if cursor_in_range {
cov_mark::hit!(not_applicable_outside_of_range_right);
return None;
}
}
2019-02-03 12:26:35 -06:00
let expr = match_expr.expr()?;
let mut has_catch_all_arm = false;
let top_lvl_pats: Vec<_> = match_arm_list
.arms()
.filter_map(|arm| Some((arm.pat()?, arm.guard().is_some())))
.flat_map(|(pat, has_guard)| {
match pat {
// Special case OrPat as separate top-level pats
Pat::OrPat(or_pat) => Either::Left(or_pat.pats()),
_ => Either::Right(iter::once(pat)),
}
.map(move |pat| (pat, has_guard))
})
.map(|(pat, has_guard)| {
has_catch_all_arm |= !has_guard && matches!(pat, Pat::WildcardPat(_));
pat
})
2021-04-18 10:17:30 -05:00
// Exclude top level wildcards so that they are expanded by this assist, retains status quo in #8129.
.filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
.collect();
let module = ctx.sema.scope(expr.syntax()).module()?;
let (mut missing_pats, is_non_exhaustive): (
Peekable<Box<dyn Iterator<Item = (ast::Pat, bool)>>>,
bool,
) = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());
2022-02-22 16:48:44 -06:00
let variants = enum_def.variants(ctx.db());
2021-05-20 07:58:18 -05:00
let missing_pats = variants
.into_iter()
.filter_map(|variant| {
Some((
build_pat(ctx.db(), module, variant)?,
variant.should_be_hidden(ctx.db(), module.krate()),
))
})
.filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));
2021-05-20 07:58:18 -05:00
let option_enum =
FamousDefs(&ctx.sema, Some(module.krate())).core_option_Option().map(lift_enum);
let missing_pats: Box<dyn Iterator<Item = _>> = if Some(enum_def) == option_enum {
2020-05-20 03:51:48 -05:00
// Match `Some` variant first.
2021-03-08 14:19:44 -06:00
cov_mark::hit!(option_order);
2021-05-20 07:58:18 -05:00
Box::new(missing_pats.rev())
} else {
Box::new(missing_pats)
};
(missing_pats.peekable(), is_non_exhaustive)
} else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
2022-02-22 16:41:03 -06:00
let is_non_exhaustive =
enum_defs.iter().any(|enum_def| enum_def.is_non_exhaustive(ctx.db(), module.krate()));
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();
2020-03-23 07:19:09 -05:00
// 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.
// 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()
.multi_cartesian_product()
2021-09-20 16:53:05 -05:00
.inspect(|_| cov_mark::hit!(add_missing_match_arms_lazy_computation))
.map(|variants| {
let is_hidden = variants
.iter()
.any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
2020-03-23 07:19:09 -05:00
let patterns =
2020-07-01 02:14:23 -05:00
variants.into_iter().filter_map(|variant| build_pat(ctx.db(), module, variant));
(ast::Pat::from(make::tuple_pat(patterns)), is_hidden)
})
.filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));
((Box::new(missing_pats) as Box<dyn Iterator<Item = _>>).peekable(), is_non_exhaustive)
} else {
return None;
};
let mut needs_catch_all_arm = is_non_exhaustive && !has_catch_all_arm;
if !needs_catch_all_arm && missing_pats.peek().is_none() {
return None;
}
2020-06-28 17:36:05 -05:00
acc.add(
2021-09-20 16:53:05 -05:00
AssistId("add_missing_match_arms", AssistKind::QuickFix),
2020-06-28 17:36:05 -05:00
"Fill match arms",
target_range,
2020-06-28 17:36:05 -05:00
|builder| {
let new_match_arm_list = match_arm_list.clone_for_update();
2021-05-20 07:58:18 -05:00
let missing_arms = missing_pats
.map(|(pat, hidden)| {
(make::match_arm(iter::once(pat), None, make::ext::expr_todo()), hidden)
})
.map(|(it, hidden)| (it.clone_for_update(), hidden));
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 {
let is_empty_expr = arm.expr().map_or(true, |e| match e {
ast::Expr::BlockExpr(b) => {
b.statements().next().is_none() && b.tail_expr().is_none()
}
ast::Expr::TupleExpr(t) => t.fields().next().is_none(),
_ => false,
});
if is_empty_expr {
arm.remove();
} else {
2021-09-20 16:53:05 -05:00
cov_mark::hit!(add_missing_match_arms_empty_expr);
}
}
let mut first_new_arm = None;
for (arm, hidden) in missing_arms {
if hidden {
needs_catch_all_arm = !has_catch_all_arm;
} else {
first_new_arm.get_or_insert_with(|| arm.clone());
new_match_arm_list.add_arm(arm);
}
}
if needs_catch_all_arm && !has_catch_all_arm {
cov_mark::hit!(added_wildcard_pattern);
let arm = make::match_arm(
iter::once(make::wildcard_pat().into()),
None,
make::ext::expr_todo(),
)
.clone_for_update();
first_new_arm.get_or_insert_with(|| arm.clone());
new_match_arm_list.add_arm(arm);
}
2021-01-27 15:32:40 -06:00
let old_range = ctx.sema.original_range(match_arm_list.syntax()).range;
2020-06-28 17:36:05 -05:00
match (first_new_arm, ctx.config.snippet_cap) {
(Some(first_new_arm), Some(cap)) => {
let extend_lifetime;
2020-07-31 13:07:21 -05:00
let cursor =
match first_new_arm.syntax().descendants().find_map(ast::WildcardPat::cast)
{
Some(it) => {
extend_lifetime = it.syntax().clone();
Cursor::Replace(&extend_lifetime)
}
None => Cursor::Before(first_new_arm.syntax()),
};
let snippet = render_snippet(cap, new_match_arm_list.syntax(), cursor);
2020-06-28 17:36:05 -05:00
builder.replace_snippet(cap, old_range, snippet);
}
_ => builder.replace(old_range, new_match_arm_list.to_string()),
2020-05-20 07:00:37 -05:00
}
2020-06-28 17:36:05 -05:00
},
)
2019-02-03 12:26:35 -06:00
}
2021-10-15 07:36:37 -05:00
fn cursor_at_trivial_match_arm_list(
ctx: &AssistContext,
match_expr: &MatchExpr,
match_arm_list: &MatchArmList,
) -> Option<()> {
2021-10-15 07:14:21 -05:00
// match x { $0 }
if match_arm_list.arms().next() == None {
cov_mark::hit!(add_missing_match_arms_empty_body);
2021-10-15 06:19:46 -05:00
return Some(());
}
2021-10-15 06:19:46 -05:00
2021-11-13 11:32:10 -06:00
// match x {
// bar => baz,
// $0
// }
if let Some(last_arm) = match_arm_list.arms().last() {
let last_arm_range = last_arm.syntax().text_range();
let match_expr_range = match_expr.syntax().text_range();
if last_arm_range.end() <= ctx.offset() && ctx.offset() < match_expr_range.end() {
cov_mark::hit!(add_missing_match_arms_end_of_last_arm);
return Some(());
}
}
2021-10-15 07:14:21 -05:00
// match { _$0 => {...} }
2021-10-15 06:19:46 -05:00
let wild_pat = ctx.find_node_at_offset_with_descend::<ast::WildcardPat>()?;
let arm = wild_pat.syntax().parent().and_then(ast::MatchArm::cast)?;
let arm_match_expr = arm.syntax().ancestors().nth(2).and_then(ast::MatchExpr::cast)?;
if arm_match_expr == *match_expr {
cov_mark::hit!(add_missing_match_arms_trivial_arm);
2021-10-15 07:36:37 -05:00
return Some(());
2021-10-15 06:19:46 -05:00
}
None
}
fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
2021-04-18 06:43:12 -05:00
!existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
}
// Fixme: this is still somewhat limited, use hir_ty::diagnostics::match_check?
fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
match (pat, var) {
(Pat::WildcardPat(_), _) => true,
(Pat::TuplePat(tpat), Pat::TuplePat(tvar)) => {
tpat.fields().zip(tvar.fields()).all(|(p, v)| does_pat_match_variant(&p, &v))
}
2021-04-18 06:43:12 -05:00
_ => utils::does_pat_match_variant(pat, var),
}
}
2021-05-20 07:58:18 -05:00
#[derive(Eq, PartialEq, Clone, Copy)]
enum ExtendedEnum {
Bool,
Enum(hir::Enum),
}
2021-05-20 07:58:18 -05:00
#[derive(Eq, PartialEq, Clone, Copy)]
enum ExtendedVariant {
True,
False,
Variant(hir::Variant),
}
2022-02-22 16:41:03 -06:00
impl ExtendedVariant {
fn should_be_hidden(self, db: &RootDatabase, krate: Crate) -> bool {
2022-02-22 16:41:03 -06:00
match self {
ExtendedVariant::Variant(var) => {
var.attrs(db).has_doc_hidden() && var.module(db).krate() != krate
}
2022-02-22 16:41:03 -06:00
_ => false,
}
}
}
fn lift_enum(e: hir::Enum) -> ExtendedEnum {
ExtendedEnum::Enum(e)
}
impl ExtendedEnum {
fn is_non_exhaustive(self, db: &RootDatabase, krate: Crate) -> bool {
2022-02-22 16:41:03 -06:00
match self {
2022-03-22 06:10:48 -05:00
ExtendedEnum::Enum(e) => {
e.attrs(db).by_key("non_exhaustive").exists() && e.module(db).krate() != krate
}
2022-02-22 16:41:03 -06:00
_ => false,
}
}
2021-05-20 07:58:18 -05:00
fn variants(self, db: &RootDatabase) -> Vec<ExtendedVariant> {
match self {
ExtendedEnum::Enum(e) => {
2021-06-12 22:59:36 -05:00
e.variants(db).into_iter().map(ExtendedVariant::Variant).collect::<Vec<_>>()
}
ExtendedEnum::Bool => {
Vec::<ExtendedVariant>::from([ExtendedVariant::True, ExtendedVariant::False])
}
}
}
}
fn resolve_enum_def(sema: &Semantics<RootDatabase>, expr: &ast::Expr) -> Option<ExtendedEnum> {
sema.type_of_expr(expr)?.adjusted().autoderef(sema.db).find_map(|ty| match ty.as_adt() {
Some(Adt::Enum(e)) => Some(ExtendedEnum::Enum(e)),
_ => ty.is_bool().then(|| ExtendedEnum::Bool),
})
2019-08-22 13:31:21 -05:00
}
fn resolve_tuple_of_enum_def(
sema: &Semantics<RootDatabase>,
expr: &ast::Expr,
) -> Option<Vec<ExtendedEnum>> {
2021-06-12 22:54:16 -05:00
sema.type_of_expr(expr)?
.adjusted()
2020-03-23 07:19:09 -05:00
.tuple_fields(sema.db)
.iter()
.map(|ty| {
ty.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
Some(Adt::Enum(e)) => Some(lift_enum(e)),
2020-03-23 07:19:09 -05:00
// For now we only handle expansion for a tuple of enums. Here
// we map non-enum items to None and rely on `collect` to
// convert Vec<Option<hir::Enum>> into Option<Vec<hir::Enum>>.
_ => ty.is_bool().then(|| ExtendedEnum::Bool),
})
2020-03-23 07:19:09 -05:00
})
.collect()
}
fn build_pat(db: &RootDatabase, module: hir::Module, var: ExtendedVariant) -> Option<ast::Pat> {
match var {
ExtendedVariant::Variant(var) => {
let path = mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var))?);
2019-08-22 13:31:21 -05:00
// FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
let pat: ast::Pat = match var.source(db)?.value.kind() {
ast::StructKind::Tuple(field_list) => {
let pats =
iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
make::tuple_struct_pat(path, pats).into()
}
ast::StructKind::Record(field_list) => {
2021-07-02 18:33:34 -05:00
let pats = field_list
.fields()
.map(|f| make::ext::simple_ident_pat(f.name().unwrap()).into());
make::record_pat(path, pats).into()
}
ast::StructKind::Unit => make::path_pat(path),
};
2019-08-22 13:31:21 -05:00
Some(pat)
}
ExtendedVariant::True => Some(ast::Pat::from(make::literal_pat("true"))),
ExtendedVariant::False => Some(ast::Pat::from(make::literal_pat("false"))),
}
2019-08-22 13:31:21 -05:00
}
2019-02-03 12:26:35 -06:00
#[cfg(test)]
mod tests {
use crate::tests::{
check_assist, check_assist_not_applicable, check_assist_target, check_assist_unresolved,
};
2019-02-03 12:26:35 -06:00
2021-09-20 16:53:05 -05:00
use super::add_missing_match_arms;
2019-02-03 12:26:35 -06:00
#[test]
fn all_match_arms_provided() {
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
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(_)) => {}
}
}
"#,
);
}
#[test]
fn not_applicable_outside_of_range_left() {
check_assist_not_applicable(
add_missing_match_arms,
2021-10-14 13:38:06 -05:00
r#"
enum A { X, Y }
fn foo(a: A) {
2021-10-14 12:31:27 -05:00
$0 match a {
A::X => { }
}
}
"#,
);
}
#[test]
fn not_applicable_outside_of_range_right() {
cov_mark::check!(not_applicable_outside_of_range_right);
check_assist_not_applicable(
add_missing_match_arms,
2021-10-14 13:38:06 -05:00
r#"
enum A { X, Y }
fn foo(a: A) {
match a {$0
A::X => { }
}
}
"#,
);
}
#[test]
fn all_boolean_match_arms_provided() {
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match a$0 {
true => {}
false => {}
}
}
"#,
)
}
2020-03-23 07:19:09 -05:00
#[test]
fn tuple_of_non_enum() {
// for now this case is not handled, although it potentially could be
// in the future
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2020-03-23 07:19:09 -05:00
r#"
2021-05-16 07:14:57 -05:00
fn main() {
match (0, false)$0 {
}
}
"#,
2020-03-23 07:19:09 -05:00
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_boolean() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match a$0 {
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match a {
$0true => todo!(),
false => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
)
}
#[test]
fn partial_fill_boolean() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match a$0 {
true => {}
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match a {
true => {}
$0false => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
)
}
#[test]
fn all_boolean_tuple_arms_provided() {
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match (a, a)$0 {
(true, true) => {}
(true, false) => {}
(false, true) => {}
(false, false) => {}
}
}
"#,
)
}
#[test]
fn fill_boolean_tuple() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match (a, a)$0 {
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match (a, a) {
$0(true, true) => todo!(),
(true, false) => todo!(),
(false, true) => todo!(),
(false, false) => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
)
}
#[test]
fn partial_fill_boolean_tuple() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match (a, a)$0 {
(false, true) => {}
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
fn foo(a: bool) {
match (a, a) {
(false, true) => {}
$0(true, true) => todo!(),
(true, false) => todo!(),
(false, false) => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
)
}
#[test]
fn partial_fill_record_tuple() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
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#"
2021-05-16 07:14:57 -05:00
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 => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
);
}
2021-01-22 16:15:38 -06:00
#[test]
fn partial_fill_option() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2021-01-22 16:15:38 -06:00
r#"
2021-06-18 15:38:19 -05:00
//- minicore: option
2021-01-22 16:15:38 -06:00
fn main() {
match None$0 {
None => {}
}
}
2021-06-18 15:38:19 -05:00
"#,
2021-01-22 16:15:38 -06:00
r#"
fn main() {
match None {
None => {}
Some(${0:_}) => todo!(),
2021-01-22 16:15:38 -06:00
}
}
2021-06-18 15:38:19 -05:00
"#,
2021-01-22 16:15:38 -06:00
);
}
#[test]
fn partial_fill_or_pat() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
enum A { As, Bs, Cs(Option<i32>) }
fn main() {
2021-01-06 14:15:48 -06:00
match A::As$0 {
A::Cs(_) | A::Bs => {}
}
}
"#,
r#"
enum A { As, Bs, Cs(Option<i32>) }
fn main() {
match A::As {
A::Cs(_) | A::Bs => {}
$0A::As => todo!(),
}
}
"#,
);
}
#[test]
fn partial_fill() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
enum A { As, Bs, Cs, Ds(String), Es(B) }
enum B { Xs, Ys }
fn main() {
2021-01-06 14:15:48 -06:00
match A::As$0 {
A::Bs if 0 < 1 => {}
A::Ds(_value) => { let x = 1; }
A::Es(B::Xs) => (),
}
}
"#,
r#"
enum A { As, Bs, Cs, Ds(String), Es(B) }
enum B { Xs, Ys }
fn main() {
match A::As {
A::Bs if 0 < 1 => {}
A::Ds(_value) => { let x = 1; }
A::Es(B::Xs) => (),
$0A::As => todo!(),
A::Cs => todo!(),
}
}
"#,
);
}
2020-06-14 16:43:16 -05:00
#[test]
fn partial_fill_bind_pat() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2020-06-14 16:43:16 -05:00
r#"
enum A { As, Bs, Cs(Option<i32>) }
fn main() {
2021-01-06 14:15:48 -06:00
match A::As$0 {
A::As(_) => {}
a @ A::Bs(_) => {}
}
}
"#,
2020-06-14 16:43:16 -05:00
r#"
enum A { As, Bs, Cs(Option<i32>) }
fn main() {
match A::As {
A::As(_) => {}
a @ A::Bs(_) => {}
A::Cs(${0:_}) => todo!(),
}
}
"#,
2020-06-14 16:43:16 -05:00
);
}
2019-02-03 12:26:35 -06:00
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_empty_body() {
cov_mark::check!(add_missing_match_arms_empty_body);
2019-02-03 12:26:35 -06:00
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2019-02-03 12:26:35 -06:00
r#"
enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
2019-02-03 12:26:35 -06:00
fn main() {
let a = A::As;
match a {$0}
}
"#,
2019-02-03 12:26:35 -06:00
r#"
enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
2019-02-03 12:26:35 -06:00
fn main() {
let a = A::As;
match a {
$0A::As => todo!(),
A::Bs => todo!(),
A::Cs(_) => todo!(),
A::Ds(_, _) => todo!(),
A::Es { x, y } => todo!(),
}
}
"#,
2019-02-03 12:26:35 -06:00
);
}
2021-11-13 11:32:10 -06:00
#[test]
fn add_missing_match_arms_end_of_last_arm() {
cov_mark::check!(add_missing_match_arms_end_of_last_arm);
check_assist(
add_missing_match_arms,
r#"
enum A { One, Two }
enum B { One, Two }
fn main() {
let a = A::One;
let b = B::One;
match (a, b) {
(A::Two, B::One) => {},$0
2021-11-13 11:32:10 -06:00
}
}
"#,
r#"
enum A { One, Two }
enum B { One, Two }
fn main() {
let a = A::One;
let b = B::One;
match (a, b) {
(A::Two, B::One) => {},
$0(A::One, B::One) => todo!(),
(A::One, B::Two) => todo!(),
(A::Two, B::Two) => todo!(),
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_tuple_of_enum() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
enum B { One, Two }
2021-05-16 07:14:57 -05:00
fn main() {
let a = A::One;
let b = B::One;
match (a$0, b) {}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
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) => todo!(),
(A::One, B::Two) => todo!(),
(A::Two, B::One) => todo!(),
(A::Two, B::Two) => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
);
}
2020-03-23 07:19:09 -05:00
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_tuple_of_enum_ref() {
2020-03-23 07:19:09 -05:00
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2020-03-23 07:19:09 -05:00
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
enum B { One, Two }
2020-03-23 07:19:09 -05:00
2021-05-16 07:14:57 -05:00
fn main() {
let a = A::One;
let b = B::One;
match (&a$0, &b) {}
}
"#,
2020-03-23 07:19:09 -05:00
r#"
2021-05-16 07:14:57 -05:00
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) => todo!(),
(A::One, B::Two) => todo!(),
(A::Two, B::One) => todo!(),
(A::Two, B::Two) => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
2020-03-23 07:19:09 -05:00
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_tuple_of_enum_partial() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_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) => {}
}
}
"#,
r#"
enum A { One, Two }
enum B { One, Two }
fn main() {
let a = A::One;
let b = B::One;
match (a, b) {
(A::Two, B::One) => {}
$0(A::One, B::One) => todo!(),
(A::One, B::Two) => todo!(),
(A::Two, B::Two) => todo!(),
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_tuple_of_enum_partial_with_wildcards() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
//- minicore: option
fn main() {
let a = Some(1);
let b = Some(());
match (a$0, b) {
(Some(_), _) => {}
(None, Some(_)) => {}
}
}
"#,
r#"
fn main() {
let a = Some(1);
let b = Some(());
match (a, b) {
(Some(_), _) => {}
(None, Some(_)) => {}
$0(None, None) => todo!(),
}
}
"#,
);
}
2021-04-18 06:43:12 -05:00
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_partial_with_deep_pattern() {
2021-04-18 06:43:12 -05:00
// Fixme: cannot handle deep patterns
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
//- minicore: option
2021-04-18 06:43:12 -05:00
fn main() {
match $0Some(true) {
Some(true) => {}
None => {}
}
}
"#,
2021-04-18 06:43:12 -05:00
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_tuple_of_enum_not_applicable() {
check_assist_not_applicable(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
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) => {}
}
}
"#,
);
}
2020-03-23 07:19:09 -05:00
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_single_element_tuple_of_enum() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2020-03-23 07:19:09 -05:00
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
2020-03-23 07:19:09 -05:00
2021-05-16 07:14:57 -05:00
fn main() {
let a = A::One;
match (a$0, ) {
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
2021-05-16 07:14:57 -05:00
fn main() {
let a = A::One;
match (a, ) {
$0(A::One,) => todo!(),
(A::Two,) => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
2020-03-23 07:19:09 -05:00
);
}
#[test]
fn test_fill_match_arm_refs() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A { As }
2021-05-16 07:14:57 -05:00
fn foo(a: &A) {
match a$0 {
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A { As }
2021-05-16 07:14:57 -05:00
fn foo(a: &A) {
match a {
$0A::As => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
);
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A {
Es { x: usize, y: usize }
}
2021-05-16 07:14:57 -05:00
fn foo(a: &mut A) {
match a$0 {
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A {
Es { x: usize, y: usize }
}
2021-05-16 07:14:57 -05:00
fn foo(a: &mut A) {
match a {
$0A::Es { x, y } => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
2019-02-03 12:26:35 -06:00
);
}
2019-02-08 17:34:05 -06:00
#[test]
fn add_missing_match_arms_target_simple() {
2019-02-08 17:34:05 -06:00
check_assist_target(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2019-02-08 17:34:05 -06:00
r#"
2021-05-16 07:14:57 -05:00
enum E { X, Y }
2019-02-08 17:34:05 -06:00
2021-05-16 07:14:57 -05:00
fn main() {
match E::X$0 {}
}
"#,
"match E::X {}",
);
}
#[test]
fn add_missing_match_arms_target_complex() {
check_assist_target(
add_missing_match_arms,
r#"
enum E { X, Y }
fn main() {
match E::X$0 {
E::X => {}
}
}
2021-05-16 07:14:57 -05:00
"#,
"match E::X {
E::X => {}
}",
2019-02-08 17:34:05 -06:00
);
}
2019-06-23 23:05:50 -05:00
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_trivial_arm() {
cov_mark::check!(add_missing_match_arms_trivial_arm);
2019-06-23 23:05:50 -05:00
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2019-06-23 23:05:50 -05:00
r#"
2021-05-16 07:14:57 -05:00
enum E { X, Y }
2019-06-23 23:05:50 -05:00
2021-05-16 07:14:57 -05:00
fn main() {
match E::X {
$0_ => {}
2021-05-16 07:14:57 -05:00
}
}
"#,
2019-06-23 23:05:50 -05:00
r#"
2021-05-16 07:14:57 -05:00
enum E { X, Y }
2019-06-23 23:05:50 -05:00
2021-05-16 07:14:57 -05:00
fn main() {
match E::X {
$0E::X => todo!(),
E::Y => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
2019-06-23 23:05:50 -05:00
);
}
2021-10-15 07:14:21 -05:00
#[test]
fn wildcard_inside_expression_not_applicable() {
check_assist_not_applicable(
add_missing_match_arms,
r#"
enum E { X, Y }
fn foo(e : E) {
match e {
_ => {
println!("1");$0
println!("2");
}
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_qualifies_path() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
mod foo { pub enum E { X, Y } }
use foo::E::X;
2021-05-16 07:14:57 -05:00
fn main() {
2021-10-15 07:45:11 -05:00
match X {
$0
2021-05-16 07:14:57 -05:00
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
mod foo { pub enum E { X, Y } }
use foo::E::X;
2021-05-16 07:14:57 -05:00
fn main() {
2021-10-15 07:45:11 -05:00
match X {
$0X => todo!(),
foo::E::Y => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_preserves_comments() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
fn foo(a: A) {
2021-10-14 12:31:27 -05:00
match a $0 {
// foo bar baz
2021-05-16 07:14:57 -05:00
A::One => {}
// This is where the rest should be
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
fn foo(a: A) {
2021-10-14 12:31:27 -05:00
match a {
2021-05-16 07:14:57 -05:00
// foo bar baz
A::One => {}
$0A::Two => todo!(),
2021-05-16 07:14:57 -05:00
// This is where the rest should be
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_preserves_comments_empty() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
fn foo(a: A) {
2021-10-15 07:45:11 -05:00
match a {
// foo bar baz$0
2021-05-16 07:14:57 -05:00
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two }
fn foo(a: A) {
2021-10-15 07:45:11 -05:00
match a {
$0A::One => todo!(),
A::Two => todo!(),
2021-05-16 07:14:57 -05:00
// foo bar baz
}
}
"#,
);
}
#[test]
2021-09-20 16:53:05 -05:00
fn add_missing_match_arms_placeholder() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two, }
fn foo(a: A) {
match a$0 {
_ => (),
}
}
"#,
r#"
2021-05-16 07:14:57 -05:00
enum A { One, Two, }
fn foo(a: A) {
match a {
$0A::One => todo!(),
A::Two => todo!(),
2021-05-16 07:14:57 -05:00
}
}
"#,
);
}
2020-05-20 03:51:48 -05:00
#[test]
fn option_order() {
2021-03-08 14:19:44 -06:00
cov_mark::check!(option_order);
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
//- minicore: option
2020-05-20 03:51:48 -05:00
fn foo(opt: Option<i32>) {
2021-01-06 14:15:48 -06:00
match opt$0 {
2020-05-20 03:51:48 -05:00
}
2020-06-23 17:30:34 -05:00
}
"#,
2020-05-20 03:51:48 -05:00
r#"
fn foo(opt: Option<i32>) {
2020-05-20 07:00:37 -05:00
match opt {
Some(${0:_}) => todo!(),
None => todo!(),
2020-05-20 03:51:48 -05:00
}
}
"#,
);
}
2021-01-27 15:32:40 -06:00
#[test]
fn works_inside_macro_call() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
2021-01-27 15:32:40 -06:00
r#"
macro_rules! m { ($expr:expr) => {$expr}}
enum Test {
A,
B,
C,
}
fn foo(t: Test) {
m!(match t$0 {});
}"#,
2021-05-16 07:14:57 -05:00
r#"
macro_rules! m { ($expr:expr) => {$expr}}
2021-01-27 15:32:40 -06:00
enum Test {
A,
B,
C,
}
fn foo(t: Test) {
m!(match t {
$0Test::A => todo!(),
Test::B => todo!(),
Test::C => todo!(),
2021-01-27 15:32:40 -06:00
});
}"#,
);
}
#[test]
fn lazy_computation() {
// Computing a single missing arm is enough to determine applicability of the assist.
2021-09-20 16:53:05 -05:00
cov_mark::check_count!(add_missing_match_arms_lazy_computation, 1);
check_assist_unresolved(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
enum A { One, Two, }
fn foo(tuple: (A, A)) {
match $0tuple {};
}
"#,
);
}
#[test]
fn adds_comma_before_new_arms() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
fn foo(t: bool) {
match $0t {
true => 1 + 2
}
}"#,
r#"
fn foo(t: bool) {
match t {
true => 1 + 2,
$0false => todo!(),
}
}"#,
);
}
#[test]
fn does_not_add_extra_comma() {
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
fn foo(t: bool) {
match $0t {
true => 1 + 2,
}
}"#,
r#"
fn foo(t: bool) {
match t {
true => 1 + 2,
$0false => todo!(),
}
}"#,
);
}
#[test]
fn does_not_remove_catch_all_with_non_empty_expr() {
2021-09-20 16:53:05 -05:00
cov_mark::check!(add_missing_match_arms_empty_expr);
check_assist(
2021-09-20 16:53:05 -05:00
add_missing_match_arms,
r#"
fn foo(t: bool) {
match $0t {
_ => 1 + 2,
}
}"#,
r#"
fn foo(t: bool) {
match t {
_ => 1 + 2,
$0true => todo!(),
false => todo!(),
}
}"#,
);
}
#[test]
fn does_not_fill_hidden_variants() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
}
}
//- /e.rs crate:e
pub enum E { A, #[doc(hidden)] B, }
"#,
r#"
fn foo(t: ::e::E) {
match t {
$0e::E::A => todo!(),
_ => todo!(),
}
}
"#,
);
}
#[test]
fn does_not_fill_hidden_variants_tuple() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: (bool, ::e::E)) {
match $0t {
}
}
//- /e.rs crate:e
pub enum E { A, #[doc(hidden)] B, }
"#,
r#"
fn foo(t: (bool, ::e::E)) {
match t {
$0(true, e::E::A) => todo!(),
(false, e::E::A) => todo!(),
_ => todo!(),
}
}
"#,
);
}
#[test]
fn fills_wildcard_with_only_hidden_variants() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
}
}
//- /e.rs crate:e
pub enum E { #[doc(hidden)] A, }
"#,
r#"
fn foo(t: ::e::E) {
match t {
${0:_} => todo!(),
}
}
"#,
);
}
#[test]
fn does_not_fill_wildcard_when_hidden_variants_are_explicit() {
check_assist_not_applicable(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
e::E::A => todo!(),
}
}
//- /e.rs crate:e
pub enum E { #[doc(hidden)] A, }
"#,
);
}
// FIXME: I don't think the assist should be applicable in this case
#[test]
fn does_not_fill_wildcard_with_wildcard() {
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
_ => todo!(),
}
}
//- /e.rs crate:e
pub enum E { #[doc(hidden)] A, }
"#,
r#"
fn foo(t: ::e::E) {
match t {
_ => todo!(),
}
}
"#,
);
}
#[test]
fn fills_wildcard_on_non_exhaustive_with_explicit_matches() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
e::E::A => todo!(),
}
}
//- /e.rs crate:e
#[non_exhaustive]
pub enum E { A, }
"#,
r#"
fn foo(t: ::e::E) {
match t {
e::E::A => todo!(),
${0:_} => todo!(),
}
}
"#,
);
}
#[test]
fn fills_wildcard_on_non_exhaustive_without_matches() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
}
}
//- /e.rs crate:e
#[non_exhaustive]
pub enum E { A, }
"#,
r#"
fn foo(t: ::e::E) {
match t {
$0e::E::A => todo!(),
_ => todo!(),
}
}
"#,
);
}
#[test]
fn fills_wildcard_on_non_exhaustive_with_doc_hidden() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
}
}
//- /e.rs crate:e
#[non_exhaustive]
pub enum E { A, #[doc(hidden)] B }"#,
r#"
fn foo(t: ::e::E) {
match t {
$0e::E::A => todo!(),
_ => todo!(),
}
}
"#,
);
}
#[test]
fn fills_wildcard_on_non_exhaustive_with_doc_hidden_with_explicit_arms() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
e::E::A => todo!(),
}
}
//- /e.rs crate:e
#[non_exhaustive]
pub enum E { A, #[doc(hidden)] B }"#,
r#"
fn foo(t: ::e::E) {
match t {
e::E::A => todo!(),
${0:_} => todo!(),
}
}
"#,
);
}
#[test]
fn fill_wildcard_with_partial_wildcard() {
cov_mark::check!(added_wildcard_pattern);
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E, b: bool) {
match $0t {
_ if b => todo!(),
}
}
//- /e.rs crate:e
pub enum E { #[doc(hidden)] A, }"#,
r#"
fn foo(t: ::e::E, b: bool) {
match t {
_ if b => todo!(),
${0:_} => todo!(),
}
}
"#,
);
}
#[test]
2022-02-22 16:48:44 -06:00
fn does_not_fill_wildcard_with_partial_wildcard_and_wildcard() {
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E, b: bool) {
match $0t {
_ if b => todo!(),
_ => todo!(),
}
}
//- /e.rs crate:e
pub enum E { #[doc(hidden)] A, }"#,
r#"
fn foo(t: ::e::E, b: bool) {
match t {
_ if b => todo!(),
_ => todo!(),
}
}
"#,
2022-02-22 16:48:44 -06:00
);
}
#[test]
fn non_exhaustive_doc_hidden_tuple_fills_wildcard() {
cov_mark::check!(added_wildcard_pattern);
2022-02-22 16:48:44 -06:00
check_assist(
add_missing_match_arms,
r#"
//- /main.rs crate:main deps:e
fn foo(t: ::e::E) {
match $0t {
}
}
//- /e.rs crate:e
#[non_exhaustive]
pub enum E { A, #[doc(hidden)] B, }"#,
r#"
fn foo(t: ::e::E) {
match t {
$0e::E::A => todo!(),
_ => todo!(),
}
}
"#,
);
}
#[test]
fn ignores_doc_hidden_for_crate_local_enums() {
check_assist(
add_missing_match_arms,
r#"
enum E { A, #[doc(hidden)] B, }
fn foo(t: E) {
match $0t {
}
}"#,
r#"
2022-02-22 16:48:44 -06:00
enum E { A, #[doc(hidden)] B, }
fn foo(t: E) {
match t {
$0E::A => todo!(),
E::B => todo!(),
}
}"#,
);
}
#[test]
fn ignores_non_exhaustive_for_crate_local_enums() {
check_assist(
add_missing_match_arms,
r#"
#[non_exhaustive]
enum E { A, B, }
fn foo(t: E) {
match $0t {
}
}"#,
r#"
#[non_exhaustive]
enum E { A, B, }
fn foo(t: E) {
match t {
$0E::A => todo!(),
E::B => todo!(),
}
}"#,
);
}
#[test]
fn ignores_doc_hidden_and_non_exhaustive_for_crate_local_enums() {
check_assist(
add_missing_match_arms,
r#"
#[non_exhaustive]
enum E { A, #[doc(hidden)] B, }
fn foo(t: E) {
match $0t {
2022-02-22 16:48:44 -06:00
}
}"#,
r#"
#[non_exhaustive]
2022-02-22 16:48:44 -06:00
enum E { A, #[doc(hidden)] B, }
fn foo(t: E) {
match t {
$0E::A => todo!(),
E::B => todo!(),
2022-02-22 16:48:44 -06:00
}
}"#,
);
}
2019-02-03 12:26:35 -06:00
}