Move is_top_level out of pcx

Author: Nadrieril

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

@@ -956,6 +956,9 @@ impl ConstructorSet {
         &self,
         pcx: &PatCtxt<'_, '_, 'tcx>,
         ctors: impl Iterator<Item = &'a Constructor<'tcx>> + Clone,
+        // Whether the current pattern is the whole pattern as found in a match arm, or if it's a
+        // subpattern.
+        is_top_level: bool,
     ) -> SplitConstructorSet<'tcx>
     where
         'tcx: 'a,
@@ -1072,7 +1075,7 @@ impl ConstructorSet {
             // expose its emptiness. The exception is if the pattern is at the top level, because we
             // want empty matches to be considered exhaustive.
             ConstructorSet::Uninhabited
-                if !pcx.cx.tcx.features().exhaustive_patterns && !pcx.is_top_level =>
+                if !pcx.cx.tcx.features().exhaustive_patterns && !is_top_level =>
             {
                 missing.push(NonExhaustive);
             }

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

@@ -362,9 +362,6 @@ pub(super) struct PatCtxt<'a, 'p, 'tcx> {
     pub(super) ty: Ty<'tcx>,
     /// Span of the current pattern under investigation.
     pub(super) span: Span,
-    /// Whether the current pattern is the whole pattern as found in a match arm, or if it's a
-    /// subpattern.
-    pub(super) is_top_level: bool,
 }
 
 impl<'a, 'p, 'tcx> fmt::Debug for PatCtxt<'a, 'p, 'tcx> {
@@ -791,10 +788,10 @@ fn compute_usefulness<'p, 'tcx>(
 
     let ty = matrix.head_ty();
     debug!("ty: {ty:?}");
-    let pcx = &PatCtxt { cx, ty, span: DUMMY_SP, is_top_level };
+    let pcx = &PatCtxt { cx, ty, span: DUMMY_SP };
 
     let ctors = matrix.heads().map(|p| p.ctor());
-    let split_set = ConstructorSet::for_ty(pcx.cx, pcx.ty).split(pcx, ctors);
+    let split_set = ConstructorSet::for_ty(pcx.cx, pcx.ty).split(pcx, ctors, is_top_level);
     let mut split_ctors = split_set.present;
     let missing_ctors = split_set.missing;
     if !missing_ctors.is_empty() {
@@ -842,7 +839,7 @@ fn compute_usefulness<'p, 'tcx>(
         // usually prefer to report the full list of constructors.
         let all_missing = split_ctors.is_empty();
         let report_when_all_missing =
-            pcx.is_top_level && !super::deconstruct_pat::IntRange::is_integral(pcx.ty);
+            is_top_level && !super::deconstruct_pat::IntRange::is_integral(pcx.ty);
         let ctor = if all_missing && !report_when_all_missing {
             Constructor::Wildcard
         } else {
@@ -918,9 +915,10 @@ fn collect_nonexhaustive_missing_variants<'p, 'tcx>(
     column: &[&DeconstructedPat<'p, 'tcx>],
 ) -> Vec<WitnessPat<'tcx>> {
     let ty = column[0].ty();
-    let pcx = &PatCtxt { cx, ty, span: DUMMY_SP, is_top_level: false };
+    let pcx = &PatCtxt { cx, ty, span: DUMMY_SP };
 
-    let set = ConstructorSet::for_ty(pcx.cx, pcx.ty).split(pcx, column.iter().map(|p| p.ctor()));
+    let column_ctors = column.iter().map(|p| p.ctor());
+    let set = ConstructorSet::for_ty(pcx.cx, pcx.ty).split(pcx, column_ctors, false);
     if set.present.is_empty() {
         // We can't consistently handle the case where no constructors are present (since this would
         // require digging deep through any type in case there's a non_exhaustive enum somewhere),