Let WitnessMatrix decide which constructors to report

Author: Nadrieril

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

@@ -1072,11 +1072,10 @@ impl ConstructorSet {
             ConstructorSet::Uninhabited => {}
         }
         if !missing.is_empty() {
-            let report_when_all_missing = is_top_level && !matches!(self, Self::Integers { .. });
-            if !split.is_empty() || report_when_all_missing {
-                split.push(Missing);
-            } else {
+            if split.is_empty() {
                 split.push(Wildcard);
+            } else {
+                split.push(Missing);
             }
         }
         (split, missing)

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

@@ -688,13 +688,14 @@ impl<'p, 'tcx> WitnessMatrix<'p, 'tcx> {
         pcx: &PatCtxt<'_, 'p, 'tcx>,
         missing_ctors: &[Constructor<'tcx>],
         ctor: &Constructor<'tcx>,
+        report_when_all_missing: bool,
     ) {
         if self.is_empty() {
             return;
         }
-        if matches!(ctor, Constructor::Wildcard) {
+        if matches!(ctor, Constructor::Wildcard) && !report_when_all_missing {
             self.push_wild_ctor(pcx, Constructor::Wildcard);
-        } else if matches!(ctor, Constructor::Missing { .. }) {
+        } else if matches!(ctor, Constructor::Wildcard | 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.
@@ -787,6 +788,9 @@ fn compute_usefulness<'p, 'tcx>(
     let ctor_set = ConstructorSet::new(pcx);
     let (split_ctors, missing_ctors) =
         ctor_set.split(pcx, matrix.heads().map(|p| p.ctor()), is_top_level);
+    // 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 { .. });
 
     // For each constructor, we compute whether there's a value that starts with it that would
     // witness the usefulness of `v`.
@@ -797,7 +801,7 @@ fn compute_usefulness<'p, 'tcx>(
         let mut spec_matrix = matrix.specialize_constructor(pcx, &ctor);
         let mut witnesses =
             ensure_sufficient_stack(|| compute_usefulness(cx, &mut spec_matrix, lint_root, false));
-        witnesses.apply_constructor(pcx, &missing_ctors, &ctor);
+        witnesses.apply_constructor(pcx, &missing_ctors, &ctor, report_when_all_missing);
         ret.extend(witnesses);
 
         // Lint on likely incorrect range patterns (#63987)
@@ -827,7 +831,8 @@ fn compute_usefulness<'p, 'tcx>(
         // When all the conditions are met we have a match with a `non_exhaustive` enum
         // that has the potential to trigger the `non_exhaustive_omitted_patterns` lint.
         if cx.refutable
-            && matches!(&ctor, Constructor::Missing)
+            && (matches!(&ctor, Constructor::Missing)
+                || (matches!(&ctor, Constructor::Wildcard) && is_top_level))
             && matches!(&ctor_set, ConstructorSet::Variants { non_exhaustive: true, .. })
             && spec_matrix.rows().len() != 0
         {