Let WitnessMatrix decide which witnesses to keep

Author: Nadrieril

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

@@ -692,23 +692,35 @@ impl<'p, 'tcx> WitnessMatrix<'p, 'tcx> {
         if self.is_empty() {
             return;
         }
-        if !matches!(ctor, Constructor::Missing { .. }) {
-            for witness in self.0.iter_mut() {
-                witness.apply_constructor(pcx, ctor)
+        if matches!(ctor, Constructor::Wildcard) {
+            self.push_wild_ctor(pcx, Constructor::Wildcard);
+        } else if matches!(ctor, Constructor::Missing { .. }) {
+            if missing_ctors.iter().any(|c| c.is_non_exhaustive()) {
+                // Here we don't want the user to try to list all variants, we want them to add a
+                // wildcard, so we only suggest that.
+                self.push_wild_ctor(pcx, Constructor::NonExhaustive);
+            } else {
+                // 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.
+                let old_witnesses = std::mem::replace(self, Self::new_empty());
+                for missing_ctor in missing_ctors {
+                    let mut witnesses_with_missing_ctor = old_witnesses.clone();
+                    witnesses_with_missing_ctor.push_wild_ctor(pcx, missing_ctor.clone());
+                    self.extend(witnesses_with_missing_ctor)
+                }
             }
-        } else if missing_ctors.iter().any(|c| c.is_non_exhaustive()) {
-            // Here we don't want the user to try to list all variants, we want them to add a
-            // wildcard, so we only suggest that.
-            self.push_wild_ctor(pcx, Constructor::NonExhaustive);
         } else {
-            // 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.
-            let old_witnesses = std::mem::replace(self, Self::new_empty());
-            for missing_ctor in missing_ctors {
-                let mut witnesses_with_missing_ctor = old_witnesses.clone();
-                witnesses_with_missing_ctor.push_wild_ctor(pcx, missing_ctor.clone());
-                self.extend(witnesses_with_missing_ctor)
+            // If some ctors are missing we want to only report them (so we discard non-missing
+            // ones). This is guaranteed to report *some* witnesses because
+            // `!missing_ctors.is_empty()` implies there is a `Missing` or `Wildcard` in
+            // `split_ctors`.
+            if !missing_ctors.is_empty() {
+                *self = Self::new_empty();
+            } else {
+                for witness in self.0.iter_mut() {
+                    witness.apply_constructor(pcx, ctor)
+                }
             }
         }
     }
@@ -745,7 +757,6 @@ impl<'p, 'tcx> WitnessMatrix<'p, 'tcx> {
 fn compute_usefulness<'p, 'tcx>(
     cx: &MatchCheckCtxt<'p, 'tcx>,
     matrix: &mut Matrix<'p, 'tcx>,
-    collect_witnesses: bool,
     lint_root: HirId,
     is_top_level: bool,
 ) -> WitnessMatrix<'p, 'tcx> {
@@ -762,7 +773,7 @@ fn compute_usefulness<'p, 'tcx>(
                 break;
             }
         }
-        if useful && collect_witnesses {
+        if useful {
             return WitnessMatrix::new_unit();
         } else {
             return WitnessMatrix::new_empty();
@@ -782,20 +793,12 @@ fn compute_usefulness<'p, 'tcx>(
     let mut ret = WitnessMatrix::new_empty();
     let orig_column_count = matrix.column_count();
     for ctor in split_ctors {
-        // If some ctors are missing we only report those. Could report all if that's useful for
-        // some applications.
-        let collect_witnesses = collect_witnesses
-            && (missing_ctors.is_empty()
-                || matches!(ctor, Constructor::Wildcard | Constructor::Missing));
         debug!("specialize({:?})", ctor);
         let mut spec_matrix = matrix.specialize_constructor(pcx, &ctor);
-        let mut witnesses = ensure_sufficient_stack(|| {
-            compute_usefulness(cx, &mut spec_matrix, collect_witnesses, lint_root, false)
-        });
-        if collect_witnesses {
-            witnesses.apply_constructor(pcx, &missing_ctors, &ctor);
-            ret.extend(witnesses);
-        }
+        let mut witnesses =
+            ensure_sufficient_stack(|| compute_usefulness(cx, &mut spec_matrix, lint_root, false));
+        witnesses.apply_constructor(pcx, &missing_ctors, &ctor);
+        ret.extend(witnesses);
 
         // Lint on likely incorrect range patterns (#63987)
         if spec_matrix.rows().len() >= 2 {
@@ -920,7 +923,7 @@ pub(crate) fn compute_match_usefulness<'p, 'tcx>(
         matrix.push(v);
     }
 
-    let non_exhaustiveness_witnesses = compute_usefulness(cx, &mut matrix, true, lint_root, true);
+    let non_exhaustiveness_witnesses = compute_usefulness(cx, &mut matrix, lint_root, true);
     let non_exhaustiveness_witnesses: Vec<_> = non_exhaustiveness_witnesses.single_column();
     let arm_usefulness: Vec<_> = arms
         .iter()