Clarify the Wildcard/Missing situation

Author: Nadrieril

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

@@ -72,13 +72,7 @@
 //! The only place where we care about which constructors `Missing` represents is in diagnostics
 //! (see `super::usefulness::WitnessMatrix::apply_constructor`).
 //!
-//! Extra special implementation detail: in fact, in the case where all the constructors are
-//! missing, we replace `Missing` with `Wildcard` to signal this. It only makes a difference for
-//! diagnostics: for `Missing` we list the missing constructors; for `Wildcard` we only output `_`.
-//!
-//! FIXME(Nadrieril): maybe `Missing { report_all: bool }` would be less confusing.
-//!
-//! We choose whether to specialize with `Missing`/`Wildcard` in
+//! We choose whether to specialize with `Missing` in
 //! `super::usefulness::compute_exhaustiveness_and_reachability`.
 //!
 //!
@@ -720,8 +714,11 @@ pub(super) enum Constructor<'tcx> {
     /// `#[doc(hidden)]` ones.
     Hidden,
     /// Fake extra constructor for constructors that are not seen in the matrix, as explained at the
-    /// top of the file.
-    Missing,
+    /// top of the file. `report_individual_ctors` is for diagnostics; see
+    /// `WitnessMatrix::apply_constructor`.
+    Missing {
+        report_individual_ctors: bool,
+    },
 }
 
 impl<'tcx> Constructor<'tcx> {
@@ -809,10 +806,11 @@ impl<'tcx> Constructor<'tcx> {
     #[inline]
     pub(super) fn is_covered_by<'p>(&self, pcx: &PatCtxt<'_, 'p, 'tcx>, other: &Self) -> bool {
         match (self, other) {
+            (Wildcard, _) => bug!("Constructor splitting should not have returned `Wildcard`"),
             // Wildcards cover anything
             (_, Wildcard) => true,
             // Only a wildcard pattern can match these special constructors.
-            (Wildcard | Missing { .. } | NonExhaustive | Hidden, _) => false,
+            (Missing { .. } | NonExhaustive | Hidden, _) => false,
 
             (Single, Single) => true,
             (Variant(self_id), Variant(other_id)) => self_id == other_id,

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

@@ -926,7 +926,7 @@ impl<'tcx> WitnessMatrix<'tcx> {
     }
 
     /// Reverses specialization by the `Missing` constructor by pushing a whole new pattern.
-    fn push_pattern(&mut self, pat: &WitnessPat<'tcx>) {
+    fn push_pattern(&mut self, pat: WitnessPat<'tcx>) {
         for witness in self.0.iter_mut() {
             witness.push_pattern(pat.clone())
         }
@@ -942,31 +942,34 @@ impl<'tcx> WitnessMatrix<'tcx> {
         if self.is_empty() {
             return;
         }
-        if matches!(ctor, Constructor::Wildcard) {
-            let pat = WitnessPat::wild_from_ctor(pcx, Constructor::Wildcard);
-            self.push_pattern(&pat);
-        } else if matches!(ctor, Constructor::Missing) {
-            // We got the special `Missing` constructor, so each of the missing constructors gives a
-            // new pattern that is not caught by the match. We list those patterns and push them
-            // onto our current witnesses.
-            if missing_ctors.iter().any(|c| c.is_non_exhaustive()) {
-                // We only report `_` here; listing other constructors would be redundant.
-                let pat = WitnessPat::wild_from_ctor(pcx, Constructor::NonExhaustive);
-                self.push_pattern(&pat);
-            } else {
-                let old_witnesses = std::mem::replace(self, Self::empty());
-                for ctor in missing_ctors {
-                    let pat = WitnessPat::wild_from_ctor(pcx, ctor.clone());
-                    let mut witnesses_with_missing_ctor = old_witnesses.clone();
-                    witnesses_with_missing_ctor.push_pattern(&pat);
-                    self.extend(witnesses_with_missing_ctor)
+        if let Constructor::Missing { report_individual_ctors } = ctor {
+            // We got the special `Missing` constructor that stands for the constructors not present
+            // in the match.
+            if *report_individual_ctors {
+                if missing_ctors.iter().any(|c| c.is_non_exhaustive()) {
+                    // We only report `_` here; listing other constructors would be redundant.
+                    let pat = WitnessPat::wild_from_ctor(pcx, Constructor::NonExhaustive);
+                    self.push_pattern(pat);
+                } else {
+                    let old_witnesses = std::mem::replace(self, Self::empty());
+                    for ctor in missing_ctors {
+                        // For each missing constructor `c`, we push a `c(_, _, _)` witness
+                        // appropriately filled with wildcards.
+                        let pat = WitnessPat::wild_from_ctor(pcx, ctor.clone());
+                        let mut witnesses_with_missing_ctor = old_witnesses.clone();
+                        witnesses_with_missing_ctor.push_pattern(pat);
+                        self.extend(witnesses_with_missing_ctor)
+                    }
                 }
+            } else {
+                // Report only a wildcard.
+                let pat = WitnessPat::wild_from_ctor(pcx, Constructor::Wildcard);
+                self.push_pattern(pat);
             }
         } else if !missing_ctors.is_empty() {
-            // `ctor` isn't `Wildcard` or `Missing` and some ctors are missing, so we know
-            // `split_ctors` will contain `Wildcard` or `Missing`.
-            // For diagnostic purposes we choose to discard witnesses we got under `ctor`, which
-            // will let only the `Wildcard` or `Missing` be reported.
+            // `ctor` isn't `Missing` and some ctors are missing, so we know `split_ctors` will
+            // contain  `Missing`. For diagnostic purposes we choose to discard witnesses we got
+            // under `ctor`, which will let only the `Missing` be reported.
             self.0.clear();
         } else {
             for witness in self.0.iter_mut() {
@@ -1026,18 +1029,13 @@ fn compute_exhaustiveness_and_reachability<'p, 'tcx>(
     let ctors = matrix.heads().map(|p| p.ctor());
     let split_set = ConstructorSet::for_ty(pcx.cx, pcx.ty).split(pcx, ctors);
     let mut split_ctors = split_set.present;
-    // We want to iterate over a full set of constructors, so if any is missing we add a wildcard.
+    // We want to iterate over a full set of constructors, so if some are missing we add a `Missing`
+    // to represent them.
     if !split_set.missing.is_empty() {
         let all_missing = split_ctors.is_empty();
-        let always_report_missing = is_top_level && !IntRange::is_integral(pcx.ty);
-        let ctor = if all_missing && !always_report_missing {
-            Constructor::Wildcard
-        } else {
-            // Like `Wildcard`, except if it doesn't match a row this will report all the missing
-            // constructors instead of just `_`.
-            Constructor::Missing
-        };
-        split_ctors.push(ctor);
+        let always_report_all = is_top_level && !IntRange::is_integral(pcx.ty);
+        let report_individual_ctors = always_report_all || !all_missing;
+        split_ctors.push(Constructor::Missing { report_individual_ctors });
     }
 
     let mut ret = WitnessMatrix::empty();