1 use std::iter::{self, Peekable};
4 use hir::{Adt, Crate, HasAttrs, HasSource, ModuleDef, Semantics};
5 use ide_db::RootDatabase;
6 use ide_db::{famous_defs::FamousDefs, helpers::mod_path_to_ast};
7 use itertools::Itertools;
8 use syntax::ast::edit_in_place::Removable;
9 use syntax::ast::{self, make, AstNode, HasName, MatchArmList, MatchExpr, Pat};
12 utils::{self, render_snippet, Cursor},
13 AssistContext, AssistId, AssistKind, Assists,
16 // Assist: add_missing_match_arms
18 // Adds missing clauses to a `match` expression.
21 // enum Action { Move { distance: u32 }, Stop }
23 // fn handle(action: Action) {
31 // enum Action { Move { distance: u32 }, Stop }
33 // fn handle(action: Action) {
35 // $0Action::Move { distance } => todo!(),
36 // Action::Stop => todo!(),
40 pub(crate) fn add_missing_match_arms(acc: &mut Assists, ctx: &AssistContext<'_>) -> Option<()> {
41 let match_expr = ctx.find_node_at_offset_with_descend::<ast::MatchExpr>()?;
42 let match_arm_list = match_expr.match_arm_list()?;
43 let target_range = ctx.sema.original_range(match_expr.syntax()).range;
45 if let None = cursor_at_trivial_match_arm_list(ctx, &match_expr, &match_arm_list) {
46 let arm_list_range = ctx.sema.original_range(match_arm_list.syntax()).range;
47 let cursor_in_range = arm_list_range.contains_range(ctx.selection_trimmed());
49 cov_mark::hit!(not_applicable_outside_of_range_right);
54 let expr = match_expr.expr()?;
56 let mut has_catch_all_arm = false;
58 let top_lvl_pats: Vec<_> = match_arm_list
60 .filter_map(|arm| Some((arm.pat()?, arm.guard().is_some())))
61 .flat_map(|(pat, has_guard)| {
63 // Special case OrPat as separate top-level pats
64 Pat::OrPat(or_pat) => Either::Left(or_pat.pats()),
65 _ => Either::Right(iter::once(pat)),
67 .map(move |pat| (pat, has_guard))
69 .map(|(pat, has_guard)| {
70 has_catch_all_arm |= !has_guard && matches!(pat, Pat::WildcardPat(_));
73 // Exclude top level wildcards so that they are expanded by this assist, retains status quo in #8129.
74 .filter(|pat| !matches!(pat, Pat::WildcardPat(_)))
77 let module = ctx.sema.scope(expr.syntax())?.module();
78 let (mut missing_pats, is_non_exhaustive): (
79 Peekable<Box<dyn Iterator<Item = (ast::Pat, bool)>>>,
81 ) = if let Some(enum_def) = resolve_enum_def(&ctx.sema, &expr) {
82 let is_non_exhaustive = enum_def.is_non_exhaustive(ctx.db(), module.krate());
84 let variants = enum_def.variants(ctx.db());
86 let missing_pats = variants
88 .filter_map(|variant| {
90 build_pat(ctx.db(), module, variant, ctx.config.prefer_no_std)?,
91 variant.should_be_hidden(ctx.db(), module.krate()),
94 .filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));
96 let option_enum = FamousDefs(&ctx.sema, module.krate()).core_option_Option().map(lift_enum);
97 let missing_pats: Box<dyn Iterator<Item = _>> = if Some(enum_def) == option_enum {
98 // Match `Some` variant first.
99 cov_mark::hit!(option_order);
100 Box::new(missing_pats.rev())
102 Box::new(missing_pats)
104 (missing_pats.peekable(), is_non_exhaustive)
105 } else if let Some(enum_defs) = resolve_tuple_of_enum_def(&ctx.sema, &expr) {
106 let is_non_exhaustive =
107 enum_defs.iter().any(|enum_def| enum_def.is_non_exhaustive(ctx.db(), module.krate()));
110 let variants_of_enums: Vec<Vec<ExtendedVariant>> = enum_defs
112 .map(|enum_def| enum_def.variants(ctx.db()))
113 .inspect(|variants| n_arms *= variants.len())
116 // When calculating the match arms for a tuple of enums, we want
117 // to create a match arm for each possible combination of enum
118 // values. The `multi_cartesian_product` method transforms
119 // Vec<Vec<EnumVariant>> into Vec<(EnumVariant, .., EnumVariant)>
120 // where each tuple represents a proposed match arm.
122 // A number of arms grows very fast on even a small tuple of large enums.
123 // We skip the assist beyond an arbitrary threshold.
127 let missing_pats = variants_of_enums
129 .multi_cartesian_product()
130 .inspect(|_| cov_mark::hit!(add_missing_match_arms_lazy_computation))
132 let is_hidden = variants
134 .any(|variant| variant.should_be_hidden(ctx.db(), module.krate()));
135 let patterns = variants.into_iter().filter_map(|variant| {
136 build_pat(ctx.db(), module, variant, ctx.config.prefer_no_std)
139 (ast::Pat::from(make::tuple_pat(patterns)), is_hidden)
141 .filter(|(variant_pat, _)| is_variant_missing(&top_lvl_pats, variant_pat));
142 ((Box::new(missing_pats) as Box<dyn Iterator<Item = _>>).peekable(), is_non_exhaustive)
147 let mut needs_catch_all_arm = is_non_exhaustive && !has_catch_all_arm;
149 if !needs_catch_all_arm && missing_pats.peek().is_none() {
154 AssistId("add_missing_match_arms", AssistKind::QuickFix),
158 let new_match_arm_list = match_arm_list.clone_for_update();
159 let missing_arms = missing_pats
160 .map(|(pat, hidden)| {
161 (make::match_arm(iter::once(pat), None, make::ext::expr_todo()), hidden)
163 .map(|(it, hidden)| (it.clone_for_update(), hidden));
165 let catch_all_arm = new_match_arm_list
167 .find(|arm| matches!(arm.pat(), Some(ast::Pat::WildcardPat(_))));
168 if let Some(arm) = catch_all_arm {
169 let is_empty_expr = arm.expr().map_or(true, |e| match e {
170 ast::Expr::BlockExpr(b) => {
171 b.statements().next().is_none() && b.tail_expr().is_none()
173 ast::Expr::TupleExpr(t) => t.fields().next().is_none(),
179 cov_mark::hit!(add_missing_match_arms_empty_expr);
182 let mut first_new_arm = None;
183 for (arm, hidden) in missing_arms {
185 needs_catch_all_arm = !has_catch_all_arm;
187 first_new_arm.get_or_insert_with(|| arm.clone());
188 new_match_arm_list.add_arm(arm);
191 if needs_catch_all_arm && !has_catch_all_arm {
192 cov_mark::hit!(added_wildcard_pattern);
193 let arm = make::match_arm(
194 iter::once(make::wildcard_pat().into()),
196 make::ext::expr_todo(),
199 first_new_arm.get_or_insert_with(|| arm.clone());
200 new_match_arm_list.add_arm(arm);
203 let old_range = ctx.sema.original_range(match_arm_list.syntax()).range;
204 match (first_new_arm, ctx.config.snippet_cap) {
205 (Some(first_new_arm), Some(cap)) => {
208 match first_new_arm.syntax().descendants().find_map(ast::WildcardPat::cast)
211 extend_lifetime = it.syntax().clone();
212 Cursor::Replace(&extend_lifetime)
214 None => Cursor::Before(first_new_arm.syntax()),
216 let snippet = render_snippet(cap, new_match_arm_list.syntax(), cursor);
217 builder.replace_snippet(cap, old_range, snippet);
219 _ => builder.replace(old_range, new_match_arm_list.to_string()),
225 fn cursor_at_trivial_match_arm_list(
226 ctx: &AssistContext<'_>,
227 match_expr: &MatchExpr,
228 match_arm_list: &MatchArmList,
231 if match_arm_list.arms().next() == None {
232 cov_mark::hit!(add_missing_match_arms_empty_body);
240 if let Some(last_arm) = match_arm_list.arms().last() {
241 let last_arm_range = last_arm.syntax().text_range();
242 let match_expr_range = match_expr.syntax().text_range();
243 if last_arm_range.end() <= ctx.offset() && ctx.offset() < match_expr_range.end() {
244 cov_mark::hit!(add_missing_match_arms_end_of_last_arm);
249 // match { _$0 => {...} }
250 let wild_pat = ctx.find_node_at_offset_with_descend::<ast::WildcardPat>()?;
251 let arm = wild_pat.syntax().parent().and_then(ast::MatchArm::cast)?;
252 let arm_match_expr = arm.syntax().ancestors().nth(2).and_then(ast::MatchExpr::cast)?;
253 if arm_match_expr == *match_expr {
254 cov_mark::hit!(add_missing_match_arms_trivial_arm);
261 fn is_variant_missing(existing_pats: &[Pat], var: &Pat) -> bool {
262 !existing_pats.iter().any(|pat| does_pat_match_variant(pat, var))
265 // Fixme: this is still somewhat limited, use hir_ty::diagnostics::match_check?
266 fn does_pat_match_variant(pat: &Pat, var: &Pat) -> bool {
268 (Pat::WildcardPat(_), _) => true,
269 (Pat::TuplePat(tpat), Pat::TuplePat(tvar)) => {
270 tpat.fields().zip(tvar.fields()).all(|(p, v)| does_pat_match_variant(&p, &v))
272 _ => utils::does_pat_match_variant(pat, var),
276 #[derive(Eq, PartialEq, Clone, Copy)]
282 #[derive(Eq, PartialEq, Clone, Copy)]
283 enum ExtendedVariant {
286 Variant(hir::Variant),
289 impl ExtendedVariant {
290 fn should_be_hidden(self, db: &RootDatabase, krate: Crate) -> bool {
292 ExtendedVariant::Variant(var) => {
293 var.attrs(db).has_doc_hidden() && var.module(db).krate() != krate
300 fn lift_enum(e: hir::Enum) -> ExtendedEnum {
301 ExtendedEnum::Enum(e)
305 fn is_non_exhaustive(self, db: &RootDatabase, krate: Crate) -> bool {
307 ExtendedEnum::Enum(e) => {
308 e.attrs(db).by_key("non_exhaustive").exists() && e.module(db).krate() != krate
314 fn variants(self, db: &RootDatabase) -> Vec<ExtendedVariant> {
316 ExtendedEnum::Enum(e) => {
317 e.variants(db).into_iter().map(ExtendedVariant::Variant).collect::<Vec<_>>()
319 ExtendedEnum::Bool => {
320 Vec::<ExtendedVariant>::from([ExtendedVariant::True, ExtendedVariant::False])
326 fn resolve_enum_def(sema: &Semantics<'_, RootDatabase>, expr: &ast::Expr) -> Option<ExtendedEnum> {
327 sema.type_of_expr(expr)?.adjusted().autoderef(sema.db).find_map(|ty| match ty.as_adt() {
328 Some(Adt::Enum(e)) => Some(ExtendedEnum::Enum(e)),
329 _ => ty.is_bool().then(|| ExtendedEnum::Bool),
333 fn resolve_tuple_of_enum_def(
334 sema: &Semantics<'_, RootDatabase>,
336 ) -> Option<Vec<ExtendedEnum>> {
337 sema.type_of_expr(expr)?
339 .tuple_fields(sema.db)
342 ty.autoderef(sema.db).find_map(|ty| match ty.as_adt() {
343 Some(Adt::Enum(e)) => Some(lift_enum(e)),
344 // For now we only handle expansion for a tuple of enums. Here
345 // we map non-enum items to None and rely on `collect` to
346 // convert Vec<Option<hir::Enum>> into Option<Vec<hir::Enum>>.
347 _ => ty.is_bool().then(|| ExtendedEnum::Bool),
356 var: ExtendedVariant,
358 ) -> Option<ast::Pat> {
360 ExtendedVariant::Variant(var) => {
362 mod_path_to_ast(&module.find_use_path(db, ModuleDef::from(var), prefer_no_std)?);
364 // FIXME: use HIR for this; it doesn't currently expose struct vs. tuple vs. unit variants though
365 let pat: ast::Pat = match var.source(db)?.value.kind() {
366 ast::StructKind::Tuple(field_list) => {
368 iter::repeat(make::wildcard_pat().into()).take(field_list.fields().count());
369 make::tuple_struct_pat(path, pats).into()
371 ast::StructKind::Record(field_list) => {
372 let pats = field_list
374 .map(|f| make::ext::simple_ident_pat(f.name().unwrap()).into());
375 make::record_pat(path, pats).into()
377 ast::StructKind::Unit => make::path_pat(path),
382 ExtendedVariant::True => Some(ast::Pat::from(make::literal_pat("true"))),
383 ExtendedVariant::False => Some(ast::Pat::from(make::literal_pat("false"))),
390 check_assist, check_assist_not_applicable, check_assist_target, check_assist_unresolved,
393 use super::add_missing_match_arms;
396 fn all_match_arms_provided() {
397 check_assist_not_applicable(
398 add_missing_match_arms,
402 Bs{x:i32, y:Option<i32>},
403 Cs(i32, Option<i32>),
408 A::Bs{x,y:Some(_)} => {}
409 A::Cs(_, Some(_)) => {}
417 fn not_applicable_outside_of_range_left() {
418 check_assist_not_applicable(
419 add_missing_match_arms,
433 fn not_applicable_outside_of_range_right() {
434 cov_mark::check!(not_applicable_outside_of_range_right);
435 check_assist_not_applicable(
436 add_missing_match_arms,
450 fn all_boolean_match_arms_provided() {
451 check_assist_not_applicable(
452 add_missing_match_arms,
465 fn tuple_of_non_enum() {
466 // for now this case is not handled, although it potentially could be
468 check_assist_not_applicable(
469 add_missing_match_arms,
480 fn add_missing_match_arms_boolean() {
482 add_missing_match_arms,
501 fn partial_fill_boolean() {
503 add_missing_match_arms,
523 fn all_boolean_tuple_arms_provided() {
524 check_assist_not_applicable(
525 add_missing_match_arms,
540 fn fill_boolean_tuple() {
542 add_missing_match_arms,
552 $0(true, true) => todo!(),
553 (true, false) => todo!(),
554 (false, true) => todo!(),
555 (false, false) => todo!(),
563 fn partial_fill_boolean_tuple() {
565 add_missing_match_arms,
577 $0(true, true) => todo!(),
578 (true, false) => todo!(),
579 (false, false) => todo!(),
587 fn partial_fill_record_tuple() {
589 add_missing_match_arms,
593 Bs { x: i32, y: Option<i32> },
594 Cs(i32, Option<i32>),
598 A::Bs { x, y: Some(_) } => {}
599 A::Cs(_, Some(_)) => {}
606 Bs { x: i32, y: Option<i32> },
607 Cs(i32, Option<i32>),
611 A::Bs { x, y: Some(_) } => {}
612 A::Cs(_, Some(_)) => {}
621 fn partial_fill_option() {
623 add_missing_match_arms,
636 Some(${0:_}) => todo!(),
644 fn partial_fill_or_pat() {
646 add_missing_match_arms,
648 enum A { As, Bs, Cs(Option<i32>) }
651 A::Cs(_) | A::Bs => {}
656 enum A { As, Bs, Cs(Option<i32>) }
659 A::Cs(_) | A::Bs => {}
670 add_missing_match_arms,
672 enum A { As, Bs, Cs, Ds(String), Es(B) }
677 A::Ds(_value) => { let x = 1; }
683 enum A { As, Bs, Cs, Ds(String), Es(B) }
688 A::Ds(_value) => { let x = 1; }
699 fn partial_fill_bind_pat() {
701 add_missing_match_arms,
703 enum A { As, Bs, Cs(Option<i32>) }
712 enum A { As, Bs, Cs(Option<i32>) }
717 A::Cs(${0:_}) => todo!(),
725 fn add_missing_match_arms_empty_body() {
726 cov_mark::check!(add_missing_match_arms_empty_body);
728 add_missing_match_arms,
730 enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
738 enum A { As, Bs, Cs(String), Ds(String, String), Es { x: usize, y: usize } }
746 A::Ds(_, _) => todo!(),
747 A::Es { x, y } => todo!(),
755 fn add_missing_match_arms_end_of_last_arm() {
756 cov_mark::check!(add_missing_match_arms_end_of_last_arm);
758 add_missing_match_arms,
767 (A::Two, B::One) => {},$0
779 (A::Two, B::One) => {},
780 $0(A::One, B::One) => todo!(),
781 (A::One, B::Two) => todo!(),
782 (A::Two, B::Two) => todo!(),
790 fn add_missing_match_arms_tuple_of_enum() {
792 add_missing_match_arms,
811 $0(A::One, B::One) => todo!(),
812 (A::One, B::Two) => todo!(),
813 (A::Two, B::One) => todo!(),
814 (A::Two, B::Two) => todo!(),
822 fn add_missing_match_arms_tuple_of_enum_ref() {
824 add_missing_match_arms,
843 $0(A::One, B::One) => todo!(),
844 (A::One, B::Two) => todo!(),
845 (A::Two, B::One) => todo!(),
846 (A::Two, B::Two) => todo!(),
854 fn add_missing_match_arms_tuple_of_enum_partial() {
856 add_missing_match_arms,
865 (A::Two, B::One) => {}
877 (A::Two, B::One) => {}
878 $0(A::One, B::One) => todo!(),
879 (A::One, B::Two) => todo!(),
880 (A::Two, B::Two) => todo!(),
888 fn add_missing_match_arms_tuple_of_enum_partial_with_wildcards() {
890 add_missing_match_arms,
898 (None, Some(_)) => {}
908 (None, Some(_)) => {}
909 $0(None, None) => todo!(),
917 fn add_missing_match_arms_partial_with_deep_pattern() {
918 // Fixme: cannot handle deep patterns
919 check_assist_not_applicable(
920 add_missing_match_arms,
934 fn add_missing_match_arms_tuple_of_enum_not_applicable() {
935 check_assist_not_applicable(
936 add_missing_match_arms,
945 (A::Two, B::One) => {}
946 (A::One, B::One) => {}
947 (A::One, B::Two) => {}
948 (A::Two, B::Two) => {}
956 fn add_missing_match_arms_single_element_tuple_of_enum() {
958 add_missing_match_arms,
974 $0(A::One,) => todo!(),
975 (A::Two,) => todo!(),
983 fn test_fill_match_arm_refs() {
985 add_missing_match_arms,
1006 add_missing_match_arms,
1009 Es { x: usize, y: usize }
1019 Es { x: usize, y: usize }
1024 $0A::Es { x, y } => todo!(),
1032 fn add_missing_match_arms_target_simple() {
1033 check_assist_target(
1034 add_missing_match_arms,
1047 fn add_missing_match_arms_target_complex() {
1048 check_assist_target(
1049 add_missing_match_arms,
1066 fn add_missing_match_arms_trivial_arm() {
1067 cov_mark::check!(add_missing_match_arms_trivial_arm);
1069 add_missing_match_arms,
1093 fn wildcard_inside_expression_not_applicable() {
1094 check_assist_not_applicable(
1095 add_missing_match_arms,
1112 fn add_missing_match_arms_qualifies_path() {
1114 add_missing_match_arms,
1116 mod foo { pub enum E { X, Y } }
1126 mod foo { pub enum E { X, Y } }
1132 foo::E::Y => todo!(),
1140 fn add_missing_match_arms_preserves_comments() {
1142 add_missing_match_arms,
1149 // This is where the rest should be
1159 $0A::Two => todo!(),
1160 // This is where the rest should be
1168 fn add_missing_match_arms_preserves_comments_empty() {
1170 add_missing_match_arms,
1183 $0A::One => todo!(),
1193 fn add_missing_match_arms_placeholder() {
1195 add_missing_match_arms,
1197 enum A { One, Two, }
1205 enum A { One, Two, }
1208 $0A::One => todo!(),
1218 cov_mark::check!(option_order);
1220 add_missing_match_arms,
1222 //- minicore: option
1223 fn foo(opt: Option<i32>) {
1229 fn foo(opt: Option<i32>) {
1231 Some(${0:_}) => todo!(),
1240 fn works_inside_macro_call() {
1242 add_missing_match_arms,
1244 macro_rules! m { ($expr:expr) => {$expr}}
1255 macro_rules! m { ($expr:expr) => {$expr}}
1264 $0Test::A => todo!(),
1273 fn lazy_computation() {
1274 // Computing a single missing arm is enough to determine applicability of the assist.
1275 cov_mark::check_count!(add_missing_match_arms_lazy_computation, 1);
1276 check_assist_unresolved(
1277 add_missing_match_arms,
1279 enum A { One, Two, }
1280 fn foo(tuple: (A, A)) {
1288 fn adds_comma_before_new_arms() {
1290 add_missing_match_arms,
1308 fn does_not_add_extra_comma() {
1310 add_missing_match_arms,
1328 fn does_not_remove_catch_all_with_non_empty_expr() {
1329 cov_mark::check!(add_missing_match_arms_empty_expr);
1331 add_missing_match_arms,
1350 fn does_not_fill_hidden_variants() {
1351 cov_mark::check!(added_wildcard_pattern);
1353 add_missing_match_arms,
1355 //- /main.rs crate:main deps:e
1361 pub enum E { A, #[doc(hidden)] B, }
1366 $0e::E::A => todo!(),
1375 fn does_not_fill_hidden_variants_tuple() {
1376 cov_mark::check!(added_wildcard_pattern);
1378 add_missing_match_arms,
1380 //- /main.rs crate:main deps:e
1381 fn foo(t: (bool, ::e::E)) {
1386 pub enum E { A, #[doc(hidden)] B, }
1389 fn foo(t: (bool, ::e::E)) {
1391 $0(true, e::E::A) => todo!(),
1392 (false, e::E::A) => todo!(),
1401 fn fills_wildcard_with_only_hidden_variants() {
1402 cov_mark::check!(added_wildcard_pattern);
1404 add_missing_match_arms,
1406 //- /main.rs crate:main deps:e
1412 pub enum E { #[doc(hidden)] A, }
1425 fn does_not_fill_wildcard_when_hidden_variants_are_explicit() {
1426 check_assist_not_applicable(
1427 add_missing_match_arms,
1429 //- /main.rs crate:main deps:e
1436 pub enum E { #[doc(hidden)] A, }
1441 // FIXME: I don't think the assist should be applicable in this case
1443 fn does_not_fill_wildcard_with_wildcard() {
1445 add_missing_match_arms,
1447 //- /main.rs crate:main deps:e
1454 pub enum E { #[doc(hidden)] A, }
1467 fn fills_wildcard_on_non_exhaustive_with_explicit_matches() {
1468 cov_mark::check!(added_wildcard_pattern);
1470 add_missing_match_arms,
1472 //- /main.rs crate:main deps:e
1494 fn fills_wildcard_on_non_exhaustive_without_matches() {
1495 cov_mark::check!(added_wildcard_pattern);
1497 add_missing_match_arms,
1499 //- /main.rs crate:main deps:e
1511 $0e::E::A => todo!(),
1520 fn fills_wildcard_on_non_exhaustive_with_doc_hidden() {
1521 cov_mark::check!(added_wildcard_pattern);
1523 add_missing_match_arms,
1525 //- /main.rs crate:main deps:e
1532 pub enum E { A, #[doc(hidden)] B }"#,
1536 $0e::E::A => todo!(),
1545 fn fills_wildcard_on_non_exhaustive_with_doc_hidden_with_explicit_arms() {
1546 cov_mark::check!(added_wildcard_pattern);
1548 add_missing_match_arms,
1550 //- /main.rs crate:main deps:e
1558 pub enum E { A, #[doc(hidden)] B }"#,
1571 fn fill_wildcard_with_partial_wildcard() {
1572 cov_mark::check!(added_wildcard_pattern);
1574 add_missing_match_arms,
1576 //- /main.rs crate:main deps:e
1577 fn foo(t: ::e::E, b: bool) {
1583 pub enum E { #[doc(hidden)] A, }"#,
1585 fn foo(t: ::e::E, b: bool) {
1596 fn does_not_fill_wildcard_with_partial_wildcard_and_wildcard() {
1598 add_missing_match_arms,
1600 //- /main.rs crate:main deps:e
1601 fn foo(t: ::e::E, b: bool) {
1608 pub enum E { #[doc(hidden)] A, }"#,
1610 fn foo(t: ::e::E, b: bool) {
1621 fn non_exhaustive_doc_hidden_tuple_fills_wildcard() {
1622 cov_mark::check!(added_wildcard_pattern);
1624 add_missing_match_arms,
1626 //- /main.rs crate:main deps:e
1633 pub enum E { A, #[doc(hidden)] B, }"#,
1637 $0e::E::A => todo!(),
1646 fn ignores_doc_hidden_for_crate_local_enums() {
1648 add_missing_match_arms,
1650 enum E { A, #[doc(hidden)] B, }
1657 enum E { A, #[doc(hidden)] B, }
1669 fn ignores_non_exhaustive_for_crate_local_enums() {
1671 add_missing_match_arms,
1694 fn ignores_doc_hidden_and_non_exhaustive_for_crate_local_enums() {
1696 add_missing_match_arms,
1699 enum E { A, #[doc(hidden)] B, }
1707 enum E { A, #[doc(hidden)] B, }