Clarify splitting by moving wildcard handling out of it

Author: Nadrieril

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

@@ -947,21 +947,16 @@ impl ConstructorSet {
     /// For this we first need to know about the full set of constructors for this type, which is
     /// represented by this `ConstructorSet`. We then construct two lists of constructors.
     ///
-    /// Formally, this returns two vecs `split` and `missing`, respecting the following constraints:
-    /// - `split` covers the whole type
-    /// - `split` is made of:
-    ///     - at most one wildcard (`Wildcard` or `Missing`)
-    ///     - non-wildcard constructors that are each covered by some non-wildcard constructor in `ctors`
-    ///     - together, the non-wildcard constructors in `split` cover all the non-wildcard
-    ///         constructor in `ctors`, including `Opaques`
+    /// Formally, this returns two vecs `present` and `missing`, respecting the following constraints:
+    /// - the union of `present` and `missing` covers the whole type
+    /// - `present` and `missing` are disjoint
+    /// - neither contains any wildcard
+    /// - each constructor in `present` is covered by some non-wildcard constructor in `ctors`
+    /// - together, the constructors in `present` cover all the non-wildcard constructor in `ctors`, including `Opaques`
     /// - non-wildcards in `ctors` do no cover anything in `missing`
-    /// - if we replace the `Wildcard`/`Missing` in `split` with all of `missing`, this also
-    ///     covers the whole type
-    /// - constructors in `split` and `missing` are split for the `ctors` list; in other words,
+    /// - constructors in `present` and `missing` are split for the `ctors` list; in other words,
     ///     they are either fully included in or disjoint from each constructor in `ctors`
     ///
-    /// Note in particular that wildcards in `ctors` are irrelevant; they do not change which
-    /// constructors are present.
     /// FIXME(Nadrieril): examples?
     pub(super) fn split<'a, 'tcx>(
         &self,
@@ -975,14 +970,15 @@ impl ConstructorSet {
         'tcx: 'a,
     {
         let mut missing = Vec::new();
-        let mut split = Vec::new();
+        let mut present = 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(..) => {
-                    split.push(ctor);
+                    present.push(ctor);
                 }
                 _ => {
                     seen.push(ctor);
@@ -994,7 +990,7 @@ impl ConstructorSet {
                 if seen.is_empty() {
                     missing.push(Single);
                 } else {
-                    split.push(Single);
+                    present.push(Single);
                 }
             }
             ConstructorSet::Variants { variants, non_exhaustive } => {
@@ -1003,7 +999,7 @@ impl ConstructorSet {
                 for variant in variants {
                     let ctor = Variant(*variant);
                     if seen_set.contains(&variant) {
-                        split.push(ctor);
+                        present.push(ctor);
                     } 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.
@@ -1029,7 +1025,7 @@ impl ConstructorSet {
                     let ctor = IntRange(splitted_range);
                     match seen {
                         Presence::Unseen => missing.push(ctor),
-                        Presence::Seen => split.push(ctor),
+                        Presence::Seen => present.push(ctor),
                     }
                 }
                 if *non_exhaustive {
@@ -1042,7 +1038,7 @@ impl ConstructorSet {
                     let ctor = Slice(splitted_slice);
                     match seen {
                         Presence::Unseen => missing.push(ctor),
-                        Presence::Seen => split.push(ctor),
+                        Presence::Seen => present.push(ctor),
                     }
                 }
             }
@@ -1052,13 +1048,13 @@ impl ConstructorSet {
                 if seen.is_empty() {
                     missing.push(slice);
                 } else {
-                    split.push(slice);
+                    present.push(slice);
                 }
             }
             ConstructorSet::Unlistable => {
                 // Since we can't list constructors, we take the ones in the matrix. This might list
                 // some constructors several times but there's not much we can do.
-                split.extend(seen);
+                present.extend(seen);
                 missing.push(NonExhaustive);
             }
             // If `exhaustive_patterns` is disabled and our scrutinee is an empty type, we cannot
@@ -1071,14 +1067,7 @@ impl ConstructorSet {
             }
             ConstructorSet::Uninhabited => {}
         }
-        if !missing.is_empty() {
-            if split.is_empty() {
-                split.push(Wildcard);
-            } else {
-                split.push(Missing);
-            }
-        }
-        (split, missing)
+        (present, missing)
     }
 }
 

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

@@ -786,8 +786,17 @@ fn compute_usefulness<'p, 'tcx>(
     let pcx = &PatCtxt { cx, ty };
 
     let ctor_set = ConstructorSet::new(pcx);
-    let (split_ctors, missing_ctors) =
+    let (mut split_ctors, missing_ctors) =
         ctor_set.split(pcx, matrix.heads().map(|p| p.ctor()), is_top_level);
+
+    // We want to iterate over a full set of constructors, so if any is missing we add a wildcard.
+    if !missing_ctors.is_empty() {
+        if split_ctors.is_empty() {
+            split_ctors.push(Constructor::Wildcard);
+        } else {
+            split_ctors.push(Constructor::Missing);
+        }
+    }
     // At the top level, we prefer to list all constructors when `_` could be reported as missing.
     let report_when_all_missing =
         is_top_level && !matches!(ctor_set, ConstructorSet::Integers { .. });