Skip to content

Commit ca869e3

Browse files
NadrierilNadrieril
committed
Lint non_exhaustive_omitted_patterns per column
1 parent 2d45df3 commit ca869e3

10 files changed

+279
-232
lines changed

‎compiler/rustc_lint_defs/src/builtin.rs

+21-13
Original file line numberDiff line numberDiff line change
@@ -3993,8 +3993,13 @@ declare_lint! {
39933993
}
39943994

39953995
declare_lint! {
3996-
/// The `non_exhaustive_omitted_patterns` lint detects when a wildcard (`_` or `..`) in a
3997-
/// pattern for a `#[non_exhaustive]` struct or enum is reachable.
3996+
/// The `non_exhaustive_omitted_patterns` lint aims to help consumers of a `#[non_exhaustive]`
3997+
/// struct or enum who want to match all of its fields/variants explicitly.
3998+
///
3999+
/// The `#[non_exhaustive]` annotation forces matches to use wildcards, so exhaustiveness
4000+
/// checking cannot be used to ensure that all fields/variants are matched explicitly. To remedy
4001+
/// this, this allow-by-default lint warns the user when a match mentions some but not all of
4002+
/// the fields/variants of a `#[non_exhaustive]` struct or enum.
39984003
///
39994004
/// ### Example
40004005
///
@@ -4008,39 +4013,42 @@ declare_lint! {
40084013
///
40094014
/// // in crate B
40104015
/// #![feature(non_exhaustive_omitted_patterns_lint)]
4016+
/// #[warn(non_exhaustive_omitted_patterns)]
40114017
/// match Bar::A {
40124018
/// Bar::A => {},
4013-
/// #[warn(non_exhaustive_omitted_patterns)]
40144019
/// _ => {},
40154020
/// }
40164021
/// ```
40174022
///
40184023
/// This will produce:
40194024
///
40204025
/// ```text
4021-
/// warning: reachable patterns not covered of non exhaustive enum
4026+
/// warning: some variants are not matched explicitly
40224027
/// --> $DIR/reachable-patterns.rs:70:9
40234028
/// |
4024-
/// LL | _ => {}
4025-
/// | ^ pattern `B` not covered
4029+
/// LL | match Bar::A {
4030+
/// | ^ pattern `Bar::B` not covered
40264031
/// |
40274032
/// note: the lint level is defined here
40284033
/// --> $DIR/reachable-patterns.rs:69:16
40294034
/// |
40304035
/// LL | #[warn(non_exhaustive_omitted_patterns)]
40314036
/// | ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
4032-
/// = help: ensure that all possible cases are being handled by adding the suggested match arms
4037+
/// = help: ensure that all variants are matched explicitly by adding the suggested match arms
40334038
/// = note: the matched value is of type `Bar` and the `non_exhaustive_omitted_patterns` attribute was found
40344039
/// ```
40354040
///
4041+
/// Warning: setting this to `deny` will make upstream non-breaking changes (adding fields or
4042+
/// variants to a `#[non_exhaustive]` struct or enum) break your crate. This goes against
4043+
/// expected semver behavior.
4044+
///
40364045
/// ### Explanation
40374046
///
4038-
/// Structs and enums tagged with `#[non_exhaustive]` force the user to add a
4039-
/// (potentially redundant) wildcard when pattern-matching, to allow for future
4040-
/// addition of fields or variants. The `non_exhaustive_omitted_patterns` lint
4041-
/// detects when such a wildcard happens to actually catch some fields/variants.
4042-
/// In other words, when the match without the wildcard would not be exhaustive.
4043-
/// This lets the user be informed if new fields/variants were added.
4047+
/// Structs and enums tagged with `#[non_exhaustive]` force the user to add a (potentially
4048+
/// redundant) wildcard when pattern-matching, to allow for future addition of fields or
4049+
/// variants. The `non_exhaustive_omitted_patterns` lint detects when such a wildcard happens to
4050+
/// actually catch some fields/variants. In other words, when the match without the wildcard
4051+
/// would not be exhaustive. This lets the user be informed if new fields/variants were added.
40444052
pub NON_EXHAUSTIVE_OMITTED_PATTERNS,
40454053
Allow,
40464054
"detect when patterns of types marked `non_exhaustive` are missed",

‎compiler/rustc_mir_build/src/thir/pattern/check_match.rs

+4-3
Original file line numberDiff line numberDiff line change
@@ -269,7 +269,7 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
269269

270270
let scrut = &self.thir[scrut];
271271
let scrut_ty = scrut.ty;
272-
let report = compute_match_usefulness(&cx, &tarms, self.lint_level, scrut_ty);
272+
let report = compute_match_usefulness(&cx, &tarms, self.lint_level, scrut_ty, scrut.span);
273273

274274
match source {
275275
// Don't report arm reachability of desugared `match $iter.into_iter() { iter => .. }`
@@ -431,7 +431,8 @@ impl<'p, 'tcx> MatchVisitor<'_, 'p, 'tcx> {
431431
let pattern = self.lower_pattern(&mut cx, pat);
432432
let pattern_ty = pattern.ty();
433433
let arm = MatchArm { pat: pattern, hir_id: self.lint_level, has_guard: false };
434-
let report = compute_match_usefulness(&cx, &[arm], self.lint_level, pattern_ty);
434+
let report =
435+
compute_match_usefulness(&cx, &[arm], self.lint_level, pattern_ty, pattern.span());
435436

436437
// Note: we ignore whether the pattern is unreachable (i.e. whether the type is empty). We
437438
// only care about exhaustiveness here.
@@ -622,7 +623,7 @@ fn is_let_irrefutable<'p, 'tcx>(
622623
pat: &'p DeconstructedPat<'p, 'tcx>,
623624
) -> bool {
624625
let arms = [MatchArm { pat, hir_id: pat_id, has_guard: false }];
625-
let report = compute_match_usefulness(&cx, &arms, pat_id, pat.ty());
626+
let report = compute_match_usefulness(&cx, &arms, pat_id, pat.ty(), pat.span());
626627

627628
// Report if the pattern is unreachable, which can only occur when the type is uninhabited.
628629
// This also reports unreachable sub-patterns though, so we can't just replace it with an

‎compiler/rustc_mir_build/src/thir/pattern/deconstruct_pat.rs

+18-28
Original file line numberDiff line numberDiff line change
@@ -629,18 +629,11 @@ pub(super) enum Constructor<'tcx> {
629629
/// `#[doc(hidden)]` ones.
630630
Hidden,
631631
/// Fake extra constructor for constructors that are not seen in the matrix, as explained in the
632-
/// code for [`Constructor::split`]. The carried `bool` is used for the
633-
/// `non_exhaustive_omitted_patterns` lint.
634-
Missing {
635-
nonexhaustive_enum_missing_visible_variants: bool,
636-
},
632+
/// code for [`Constructor::split`].
633+
Missing,
637634
}
638635

639636
impl<'tcx> Constructor<'tcx> {
640-
pub(super) fn is_wildcard(&self) -> bool {
641-
matches!(self, Wildcard)
642-
}
643-
644637
pub(super) fn is_non_exhaustive(&self) -> bool {
645638
matches!(self, NonExhaustive)
646639
}
@@ -778,14 +771,8 @@ impl<'tcx> Constructor<'tcx> {
778771
let all_missing = split_set.present.is_empty();
779772
let report_when_all_missing =
780773
pcx.is_top_level && !IntRange::is_integral(pcx.ty);
781-
let ctor = if all_missing && !report_when_all_missing {
782-
Wildcard
783-
} else {
784-
Missing {
785-
nonexhaustive_enum_missing_visible_variants: split_set
786-
.nonexhaustive_enum_missing_visible_variants,
787-
}
788-
};
774+
let ctor =
775+
if all_missing && !report_when_all_missing { Wildcard } else { Missing };
789776
smallvec![ctor]
790777
} else {
791778
split_set.present
@@ -905,11 +892,9 @@ pub(super) enum ConstructorSet {
905892
/// either fully included in or disjoint from each constructor in the column. This avoids
906893
/// non-trivial intersections like between `0..10` and `5..15`.
907894
#[derive(Debug)]
908-
struct SplitConstructorSet<'tcx> {
909-
present: SmallVec<[Constructor<'tcx>; 1]>,
910-
missing: Vec<Constructor<'tcx>>,
911-
/// For the `non_exhaustive_omitted_patterns` lint.
912-
nonexhaustive_enum_missing_visible_variants: bool,
895+
pub(super) struct SplitConstructorSet<'tcx> {
896+
pub(super) present: SmallVec<[Constructor<'tcx>; 1]>,
897+
pub(super) missing: Vec<Constructor<'tcx>>,
913898
}
914899

915900
impl ConstructorSet {
@@ -1039,7 +1024,7 @@ impl ConstructorSet {
10391024
/// constructors to 1/ determine which constructors of the type (if any) are missing; 2/ split
10401025
/// constructors to handle non-trivial intersections e.g. on ranges or slices.
10411026
#[instrument(level = "debug", skip(self, pcx, ctors), ret)]
1042-
fn split<'a, 'tcx>(
1027+
pub(super) fn split<'a, 'tcx>(
10431028
&self,
10441029
pcx: &PatCtxt<'_, '_, 'tcx>,
10451030
ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone,
@@ -1051,7 +1036,6 @@ impl ConstructorSet {
10511036
let mut missing = Vec::new();
10521037
// Constructors in `ctors`, except wildcards.
10531038
let mut seen = ctors.filter(|c| !(matches!(c, Opaque | Wildcard)));
1054-
let mut nonexhaustive_enum_missing_visible_variants = false;
10551039
match self {
10561040
ConstructorSet::Single => {
10571041
if seen.next().is_none() {
@@ -1063,6 +1047,7 @@ impl ConstructorSet {
10631047
ConstructorSet::Variants { visible_variants, hidden_variants, non_exhaustive } => {
10641048
let seen_set: FxHashSet<_> = seen.map(|c| c.as_variant().unwrap()).collect();
10651049
let mut skipped_a_hidden_variant = false;
1050+
10661051
for variant in visible_variants {
10671052
let ctor = Variant(*variant);
10681053
if seen_set.contains(&variant) {
@@ -1071,8 +1056,6 @@ impl ConstructorSet {
10711056
missing.push(ctor);
10721057
}
10731058
}
1074-
nonexhaustive_enum_missing_visible_variants =
1075-
*non_exhaustive && !missing.is_empty();
10761059

10771060
for variant in hidden_variants {
10781061
let ctor = Variant(*variant);
@@ -1159,7 +1142,7 @@ impl ConstructorSet {
11591142
ConstructorSet::Uninhabited => {}
11601143
}
11611144

1162-
SplitConstructorSet { present, missing, nonexhaustive_enum_missing_visible_variants }
1145+
SplitConstructorSet { present, missing }
11631146
}
11641147

11651148
/// Compute the set of constructors missing from this column.
@@ -1519,6 +1502,13 @@ impl<'p, 'tcx> DeconstructedPat<'p, 'tcx> {
15191502
pub(super) fn is_or_pat(&self) -> bool {
15201503
matches!(self.ctor, Or)
15211504
}
1505+
pub(super) fn flatten_or_pat(&'p self) -> SmallVec<[&'p Self; 1]> {
1506+
if self.is_or_pat() {
1507+
self.iter_fields().flat_map(|p| p.flatten_or_pat()).collect()
1508+
} else {
1509+
smallvec![self]
1510+
}
1511+
}
15221512

15231513
pub(super) fn ctor(&self) -> &Constructor<'tcx> {
15241514
&self.ctor
@@ -1704,7 +1694,7 @@ impl<'p, 'tcx> fmt::Debug for DeconstructedPat<'p, 'tcx> {
17041694
#[derive(Debug, Clone)]
17051695
pub(crate) struct WitnessPat<'tcx> {
17061696
ctor: Constructor<'tcx>,
1707-
fields: Vec<WitnessPat<'tcx>>,
1697+
pub(crate) fields: Vec<WitnessPat<'tcx>>,
17081698
ty: Ty<'tcx>,
17091699
}
17101700

0 commit comments

Comments
 (0)