Shortcut on single wildcard

Obtained by repeatedly inlining and simplifying, beyond the point of
reason.

Author: Nadrieril

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

@@ -867,6 +867,17 @@ impl ConstructorSet {
         }
     }
 
+    /// Whether `self.split().missing` is empty regardless of the column.
+    pub(super) fn is_empty(&self, cx: &MatchCheckCtxt<'_, '_>, is_top_level: bool) -> bool {
+        match self {
+            ConstructorSet::Variants {
+                visible_variants, hidden_variants, non_exhaustive, ..
+            } => visible_variants.is_empty() && hidden_variants.is_empty() && !*non_exhaustive,
+            ConstructorSet::Uninhabited => cx.tcx.features().exhaustive_patterns || is_top_level,
+            _ => false,
+        }
+    }
+
     /// 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.

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

@@ -1148,6 +1148,28 @@ pub(crate) fn compute_match_usefulness<'p, 'tcx>(
     scrut_ty: Ty<'tcx>,
     scrut_span: Span,
 ) -> UsefulnessReport<'p, 'tcx> {
+    // Shortcut on single wildcard.
+    if let [arm] = arms {
+        if arm.pat.ctor().is_wildcard() && !arm.has_guard {
+            let mut ty = scrut_ty;
+            // Opaque types can't get destructured/split, but the patterns can
+            // actually hint at hidden types, so we use the patterns' types instead.
+            if let ty::Alias(ty::Opaque, ..) = ty.kind() {
+                ty = arm.pat.ty();
+            }
+            let set = ConstructorSet::for_ty(cx, ty);
+            let reachability = if set.is_empty(cx, true) {
+                Reachability::Unreachable
+            } else {
+                Reachability::Reachable(vec![])
+            };
+            return UsefulnessReport {
+                arm_usefulness: vec![(*arm, reachability)],
+                non_exhaustiveness_witnesses: vec![],
+            };
+        }
+    }
+
     let mut matrix = Matrix::empty();
     for (row_id, arm) in arms.iter().enumerate() {
         let v = PatStack::from_pattern(arm.pat, row_id, arm.has_guard);