Reimpl using a general CtorSet::split

Author: Nadrieril

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

@@ -1091,6 +1091,32 @@ pub(super) enum ConstructorSet {
     Uninhabited,
 }
 
+/// Describes the result of analyzing the constructors in a column of a match.
+///
+/// `present` is morally the set of constructors present in the column, and `missing` is the set of
+/// constructors that exist in the type but are not present in the column.
+///
+/// More formally, they respect the following constraints:
+/// - the union of `present` and `missing` covers the whole type
+/// - `present` and `missing` are disjoint
+/// - neither contains wildcards
+/// - each constructor in `present` is covered by some non-wildcard constructor in the column
+/// - together, the constructors in `present` cover all the non-wildcard constructor in the column
+/// - non-wildcards in the column do no cover anything in `missing`
+/// - constructors in `present` and `missing` are split for the column; in other words, they are
+///     either fully included in or disjoint from each constructor in the column. This rules out
+///     non-trivial intersections like between `0..10` and `5..15`.
+///
+/// FIXME(Nadrieril): examples?
+struct SplitConstructorSet<'tcx> {
+    present: SmallVec<[Constructor<'tcx>; 1]>,
+    missing: Vec<Constructor<'tcx>>,
+    /// Whether there were any non-wildcard constructors in the column.
+    seen_any_non_wildcards: bool,
+    /// For the `non_exhaustive_omitted_patterns` lint.
+    nonexhaustive_enum_missing_real_variants: bool,
+}
+
 impl ConstructorSet {
     pub(super) fn new<'p, 'tcx>(pcx: &PatCtxt<'_, 'p, 'tcx>) -> Self {
         debug!("ConstructorSet::new({:?})", pcx.ty);
@@ -1203,36 +1229,38 @@ impl ConstructorSet {
         }
     }
 
-    pub(super) fn compute_split_wildcard<'a, 'tcx>(
+    /// This is the core logical operation of exhaustiveness checking.
+    /// This analyzes a column a constructors to 1/ determine which constructors of the type (if
+    /// any) are missing; 2/ split constructors to handle non-trivial intersections e.g. on ranges
+    /// or slices.
+    fn split<'a, 'tcx>(
         &self,
         pcx: &PatCtxt<'_, '_, 'tcx>,
         ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone,
         // Whether the current pattern is the whole pattern as found in a match arm, or if it's a
         // subpattern.
         is_top_level: bool,
-    ) -> SmallVec<[Constructor<'tcx>; 1]>
+    ) -> SplitConstructorSet<'tcx>
     where
         'tcx: 'a,
     {
         let mut missing = Vec::new();
-        let mut any_missing = false;
         let mut present: SmallVec<[_; 1]> = SmallVec::new();
-        // Constructors in `ctors`, except wildcards and opaques.
+        // Constructors in `ctors`, except wildcards.
         let mut seen = Vec::new();
         for ctor in ctors.cloned() {
             match ctor {
                 // Wildcards in `ctors` are irrelevant to splitting
-                Wildcard => {}
-                Constructor::Opaque => {}
+                Opaque | Wildcard => {}
                 _ => {
                     seen.push(ctor);
                 }
             }
         }
+        let mut nonexhaustive_enum_missing_real_variants = false;
         match self {
             ConstructorSet::Single => {
                 if seen.is_empty() {
-                    any_missing = true;
                     missing.push(Single);
                 } else {
                     present.push(Single);
@@ -1251,15 +1279,16 @@ impl ConstructorSet {
                         skipped_a_hidden_variant = true;
                     } else {
                         missing.push(ctor);
-                        any_missing = true;
                     }
                 }
+
                 if *non_exhaustive {
+                    nonexhaustive_enum_missing_real_variants = !missing.is_empty();
                     missing.push(NonExhaustive);
-                    any_missing = true;
                 } else if skipped_a_hidden_variant {
+                    // FIXME(Nadrieril): This represents the skipped variants, but isn't super
+                    // clean. Using `NonExhaustive` breaks things elsewhere.
                     missing.push(Wildcard);
-                    any_missing = true;
                 }
             }
             ConstructorSet::Integers { range_1, range_2, non_exhaustive } => {
@@ -1271,27 +1300,21 @@ impl ConstructorSet {
                 for (seen, splitted_range) in range.split(seen_ranges.cloned()) {
                     let ctor = IntRange(splitted_range);
                     match seen {
-                        Presence::Unseen => {
-                            missing.push(ctor);
-                            any_missing = true;
-                        }
+                        Presence::Unseen => missing.push(ctor),
                         Presence::Seen => present.push(ctor),
                     }
                 }
+
                 if *non_exhaustive {
                     missing.push(NonExhaustive);
-                    any_missing = true;
                 }
             }
             &ConstructorSet::Slice(array_len) => {
                 let seen_slices = seen.iter().map(|c| c.as_slice().unwrap()).map(|s| s.kind);
                 for (seen, splitted_slice) in SplitVarLenSlice2::split(array_len, seen_slices) {
                     let ctor = Slice(splitted_slice);
                     match seen {
-                        Presence::Unseen => {
-                            missing.push(ctor);
-                            any_missing = true;
-                        }
+                        Presence::Unseen => missing.push(ctor),
                         Presence::Seen => present.push(ctor),
                     }
                 }
@@ -1301,17 +1324,15 @@ impl ConstructorSet {
                 let slice = Slice(Slice::new(None, FixedLen(0)));
                 if seen.is_empty() {
                     missing.push(slice);
-                    any_missing = true;
                 } else {
                     present.push(slice);
                 }
             }
             ConstructorSet::Unlistable => {
-                // Since we can't list constructors, we take the ones in the matrix. This might list
+                // Since we can't list constructors, we take the ones in the column. This might list
                 // some constructors several times but there's not much we can do.
                 present.extend(seen.iter().cloned());
                 missing.push(NonExhaustive);
-                any_missing = true;
             }
             // If `exhaustive_patterns` is disabled and our scrutinee is an empty type, we cannot
             // expose its emptiness. The exception is if the pattern is at the top level, because we
@@ -1320,14 +1341,33 @@ impl ConstructorSet {
                 if !pcx.cx.tcx.features().exhaustive_patterns && !is_top_level =>
             {
                 missing.push(NonExhaustive);
-                any_missing = true;
             }
             ConstructorSet::Uninhabited => {}
         }
 
-        if !missing.is_empty() {
+        SplitConstructorSet {
+            present,
+            missing,
+            seen_any_non_wildcards: !seen.is_empty(),
+            nonexhaustive_enum_missing_real_variants,
+        }
+    }
+
+    pub(super) fn compute_split_wildcard<'a, 'tcx>(
+        &self,
+        pcx: &PatCtxt<'_, '_, 'tcx>,
+        ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone,
+        // Whether the current pattern is the whole pattern as found in a match arm, or if it's a
+        // subpattern.
+        is_top_level: bool,
+    ) -> SmallVec<[Constructor<'tcx>; 1]>
+    where
+        'tcx: 'a,
+    {
+        let split_set = self.split(pcx, ctors, is_top_level);
+        if !split_set.missing.is_empty() {
             // Some constructors are missing, thus we can specialize with the special `Missing`
-            // constructor, which stands for those constructors that are not seen in the matrix,
+            // constructor, which stands for those constructors that are not seen in the column,
             // and matches the same rows as any of them (namely the wildcard rows). See the top of
             // the file for details.
             // However, when all constructors are missing we can also specialize with the full
@@ -1354,25 +1394,22 @@ impl ConstructorSet {
             // The exception is: if we are at the top-level, for example in an empty match, we
             // sometimes prefer reporting the list of constructors instead of just `_`.
             let report_when_all_missing = is_top_level && !matches!(self, Self::Integers { .. });
-            let ctor = if !seen.is_empty() || report_when_all_missing {
-                if pcx.is_non_exhaustive {
-                    Missing {
-                        nonexhaustive_enum_missing_real_variants: missing
-                            .iter()
-                            .any(|c| !(c.is_non_exhaustive() || c.is_unstable_variant(pcx))),
-                    }
-                } else {
-                    Missing { nonexhaustive_enum_missing_real_variants: false }
+            let ctor = if split_set.seen_any_non_wildcards || report_when_all_missing {
+                Missing {
+                    nonexhaustive_enum_missing_real_variants: split_set
+                        .nonexhaustive_enum_missing_real_variants,
                 }
             } else {
                 Wildcard
             };
             smallvec![ctor]
         } else {
-            present
+            split_set.present
         }
     }
 
+    /// Compute the set of constructors missing from this column.
+    /// This is only used for reporting to the user.
     pub(super) fn compute_missing<'a, 'tcx>(
         &self,
         pcx: &PatCtxt<'_, '_, 'tcx>,
@@ -1384,94 +1421,7 @@ impl ConstructorSet {
     where
         'tcx: 'a,
     {
-        let mut missing = Vec::new();
-        // Constructors in `ctors`, except wildcards and opaques.
-        let mut seen = Vec::new();
-        for ctor in ctors.cloned() {
-            match ctor {
-                // Wildcards in `ctors` are irrelevant to splitting
-                Wildcard => {}
-                Constructor::Opaque => {}
-                _ => {
-                    seen.push(ctor);
-                }
-            }
-        }
-        match self {
-            ConstructorSet::Single => {
-                if seen.is_empty() {
-                    missing.push(Single);
-                }
-            }
-            ConstructorSet::Variants { variants, non_exhaustive } => {
-                let seen_set: FxHashSet<_> = seen.iter().map(|c| c.as_variant().unwrap()).collect();
-                let mut skipped_a_hidden_variant = false;
-                for variant in variants {
-                    let ctor = Variant(*variant);
-                    if seen_set.contains(&variant) {
-                    } else if ctor.is_doc_hidden_variant(pcx) || ctor.is_unstable_variant(pcx) {
-                        // We don't want to mention any variants that are `doc(hidden)` or behind an
-                        // unstable feature gate if they aren't present in the match.
-                        skipped_a_hidden_variant = true;
-                    } else {
-                        missing.push(ctor);
-                    }
-                }
-                if *non_exhaustive {
-                    missing.push(NonExhaustive);
-                } else if skipped_a_hidden_variant {
-                    missing.push(Wildcard);
-                }
-            }
-            ConstructorSet::Integers { range_1, range_2, non_exhaustive } => {
-                if *non_exhaustive {
-                    missing.push(NonExhaustive);
-                } else {
-                    let range = match range_2 {
-                        None => SplitIntRange2::Single(range_1.clone()),
-                        Some(range_2) => SplitIntRange2::Double([range_1.clone(), range_2.clone()]),
-                    };
-                    let seen_ranges = seen.iter().map(|ctor| ctor.as_int_range().unwrap());
-                    for (seen, splitted_range) in range.split(seen_ranges.cloned()) {
-                        let ctor = IntRange(splitted_range);
-                        match seen {
-                            Presence::Unseen => missing.push(ctor),
-                            Presence::Seen => {}
-                        }
-                    }
-                }
-            }
-            &ConstructorSet::Slice(array_len) => {
-                let seen_slices = seen.iter().map(|c| c.as_slice().unwrap()).map(|s| s.kind);
-                for (seen, splitted_slice) in SplitVarLenSlice2::split(array_len, seen_slices) {
-                    let ctor = Slice(splitted_slice);
-                    match seen {
-                        Presence::Unseen => missing.push(ctor),
-                        Presence::Seen => {}
-                    }
-                }
-            }
-            ConstructorSet::SliceOfEmpty => {
-                if seen.is_empty() {
-                    // Behaves essentially like `Single`.
-                    let slice = Slice(Slice::new(None, FixedLen(0)));
-                    missing.push(slice);
-                }
-            }
-            ConstructorSet::Unlistable => {
-                missing.push(NonExhaustive);
-            }
-            // If `exhaustive_patterns` is disabled and our scrutinee is an empty type, we cannot
-            // expose its emptiness. The exception is if the pattern is at the top level, because we
-            // want empty matches to be considered exhaustive.
-            ConstructorSet::Uninhabited
-                if !pcx.cx.tcx.features().exhaustive_patterns && !is_top_level =>
-            {
-                missing.push(NonExhaustive);
-            }
-            ConstructorSet::Uninhabited => {}
-        }
-        missing
+        self.split(pcx, ctors, is_top_level).missing
     }
 }