!! (WIP; squish) make Thir responsible for walking THIR patterns

Author: Zalathar

compiler/rustc_middle/src/thir.rs

@@ -640,11 +640,17 @@ impl<'tcx> Pat<'tcx> {
             _ => None,
         }
     }
+}
 
+impl<'tcx> Thir<'tcx> {
     /// Call `f` on every "binding" in a pattern, e.g., on `a` in
     /// `match foo() { Some(a) => (), None => () }`
-    pub fn each_binding(&self, mut f: impl FnMut(Symbol, ByRef, Ty<'tcx>, Span)) {
-        self.walk_always(|p| {
+    pub fn for_each_binding_in_pat(
+        &self,
+        pat: &Pat<'tcx>,
+        mut f: impl FnMut(Symbol, ByRef, Ty<'tcx>, Span),
+    ) {
+        self.walk_pat_always(pat, |p| {
             if let PatKind::Binding { name, mode, ty, .. } = p.kind {
                 f(name, mode.0, ty, p.span);
             }
@@ -654,22 +660,22 @@ impl<'tcx> Pat<'tcx> {
     /// Walk the pattern in left-to-right order.
     ///
     /// If `it(pat)` returns `false`, the children are not visited.
-    pub fn walk(&self, mut it: impl FnMut(&Pat<'tcx>) -> bool) {
-        self.walk_(&mut it)
+    pub fn walk_pat(&self, pat: &Pat<'tcx>, mut it: impl FnMut(&Pat<'tcx>) -> bool) {
+        self.walk_pat_inner(pat, &mut it)
     }
 
-    fn walk_(&self, it: &mut impl FnMut(&Pat<'tcx>) -> bool) {
-        if !it(self) {
+    fn walk_pat_inner(&self, pat: &Pat<'tcx>, it: &mut impl FnMut(&Pat<'tcx>) -> bool) {
+        if !it(pat) {
             return;
         }
 
-        for_each_immediate_subpat(self, |p| p.walk_(it));
+        for_each_immediate_subpat(pat, |p| self.walk_pat_inner(p, it));
     }
 
     /// Whether the pattern has a `PatKind::Error` nested within.
-    pub fn pat_error_reported(&self) -> Result<(), ErrorGuaranteed> {
+    pub fn pat_error_reported(&self, pat: &Pat<'tcx>) -> Result<(), ErrorGuaranteed> {
         let mut error = None;
-        self.walk(|pat| {
+        self.walk_pat(pat, |pat| {
             if let PatKind::Error(e) = pat.kind
                 && error.is_none()
             {
@@ -683,26 +689,39 @@ impl<'tcx> Pat<'tcx> {
         }
     }
 
+    pub fn pat_references_error(&self, pat: &Pat<'tcx>) -> bool {
+        use rustc_type_ir::visit::TypeVisitableExt;
+
+        let mut references_error = TypeVisitableExt::references_error(pat);
+        if !references_error {
+            for_each_immediate_subpat(pat, |p| {
+                references_error = references_error || self.pat_references_error(p);
+            });
+        }
+
+        references_error
+    }
+
     /// Walk the pattern in left-to-right order.
     ///
     /// If you always want to recurse, prefer this method over `walk`.
-    pub fn walk_always(&self, mut it: impl FnMut(&Pat<'tcx>)) {
-        self.walk(|p| {
+    pub fn walk_pat_always(&self, pat: &Pat<'tcx>, mut it: impl FnMut(&Pat<'tcx>)) {
+        self.walk_pat(pat, |p| {
             it(p);
             true
         })
     }
 
     /// Whether this a never pattern.
-    pub fn is_never_pattern(&self) -> bool {
+    pub fn is_never_pattern(&self, pat: &Pat<'tcx>) -> bool {
         let mut is_never_pattern = false;
-        self.walk(|pat| match &pat.kind {
+        self.walk_pat(pat, |pat| match &pat.kind {
             PatKind::Never => {
                 is_never_pattern = true;
                 false
             }
             PatKind::Or { pats } => {
-                is_never_pattern = pats.iter().all(|p| p.is_never_pattern());
+                is_never_pattern = pats.iter().all(|p| self.is_never_pattern(p));
                 false
             }
             _ => true,

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -861,7 +861,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         pattern: &Pat<'tcx>,
         f: &mut impl FnMut(&mut Self, LocalVarId, Span),
     ) {
-        pattern.walk_always(|pat| {
+        self.thir.walk_pat_always(pattern, |pat| {
             if let PatKind::Binding { var, is_primary: true, .. } = pat.kind {
                 f(self, var, pat.span);
             }
@@ -1037,7 +1037,7 @@ impl<'tcx> FlatPat<'tcx> {
             span: pattern.span,
             bindings: Vec::new(),
             ascriptions: Vec::new(),
-            is_never: pattern.is_never_pattern(),
+            is_never: cx.thir.is_never_pattern(pattern),
         };
         // Recursively remove irrefutable match pairs, while recording their
         // bindings/ascriptions, and sort or-patterns after other match pairs.

compiler/rustc_mir_build/src/thir/cx/mod.rs

@@ -120,7 +120,7 @@ impl<'tcx> ThirBuildCx<'tcx> {
 
     #[instrument(level = "debug", skip(self))]
     fn pattern_from_hir(&mut self, p: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        pat_from_hir(self.tcx, self.typing_env, self.typeck_results, p)
+        pat_from_hir(self.tcx, &mut self.thir, self.typing_env, self.typeck_results, p)
     }
 
     fn closure_env_param(&self, owner_def: LocalDefId, expr_id: HirId) -> Option<Param<'tcx>> {

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

@@ -277,14 +277,14 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
         cx: &PatCtxt<'p, 'tcx>,
         pat: &'p Pat<'tcx>,
     ) -> Result<&'p DeconstructedPat<'p, 'tcx>, ErrorGuaranteed> {
-        if let Err(err) = pat.pat_error_reported() {
+        if let Err(err) = cx.thir.pat_error_reported(pat) {
             self.error = Err(err);
             Err(err)
         } else {
             // Check the pattern for some things unrelated to exhaustiveness.
             let refutable = if cx.refutable { Refutable } else { Irrefutable };
             let mut err = Ok(());
-            pat.walk_always(|pat| {
+            cx.thir.walk_pat_always(pat, |pat| {
                 check_borrow_conflicts_in_at_patterns(self, pat);
                 check_for_bindings_named_same_as_variants(self, pat, refutable);
                 err = err.and(check_never_pattern(cx, pat));
@@ -385,6 +385,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             scrutinee.map(|scrut| self.is_known_valid_scrutinee(scrut)).unwrap_or(true);
         PatCtxt {
             tcx: self.tcx,
+            thir: self.thir,
             typeck_results: self.typeck_results,
             typing_env: self.typing_env,
             module: self.tcx.parent_module(self.lint_level).to_def_id(),
@@ -704,7 +705,7 @@ impl<'p, 'tcx> MatchVisitor<'p, 'tcx> {
             && scrut.is_some()
         {
             let mut bindings = vec![];
-            pat.each_binding(|name, _, _, _| bindings.push(name));
+            self.thir.for_each_binding_in_pat(pat, |name, _, _, _| bindings.push(name));
 
             let semi_span = span.shrink_to_hi();
             let start_span = span.shrink_to_lo();
@@ -780,7 +781,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
         ByRef::No if is_binding_by_move(ty) => {
             // We have `x @ pat` where `x` is by-move. Reject all borrows in `pat`.
             let mut conflicts_ref = Vec::new();
-            sub.each_binding(|_, mode, _, span| {
+            cx.thir.for_each_binding_in_pat(sub, |_, mode, _, span| {
                 if matches!(mode, ByRef::Yes(_)) {
                     conflicts_ref.push(span)
                 }
@@ -809,7 +810,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
     let mut conflicts_move = Vec::new();
     let mut conflicts_mut_mut = Vec::new();
     let mut conflicts_mut_ref = Vec::new();
-    sub.each_binding(|name, mode, ty, span| {
+    cx.thir.for_each_binding_in_pat(sub, |name, mode, ty, span| {
         match mode {
             ByRef::Yes(mut_inner) => match (mut_outer, mut_inner) {
                 // Both sides are `ref`.

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

@@ -9,10 +9,8 @@ use rustc_index::Idx;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_infer::traits::Obligation;
 use rustc_middle::mir::interpret::ErrorHandled;
-use rustc_middle::thir::{FieldPat, Pat, PatKind};
-use rustc_middle::ty::{
-    self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitableExt, TypeVisitor, ValTree,
-};
+use rustc_middle::thir::{FieldPat, Pat, PatKind, Thir};
+use rustc_middle::ty::{self, Ty, TyCtxt, TypeSuperVisitable, TypeVisitor, ValTree};
 use rustc_middle::{mir, span_bug};
 use rustc_span::def_id::DefId;
 use rustc_span::{Span, sym};
@@ -36,7 +34,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
     /// so we have to carry one ourselves.
     #[instrument(level = "debug", skip(self), ret)]
     pub(super) fn const_to_pat(
-        &self,
+        &mut self,
         c: ty::Const<'tcx>,
         ty: Ty<'tcx>,
         id: hir::HirId,
@@ -52,8 +50,9 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
     }
 }
 
-struct ConstToPat<'tcx> {
+struct ConstToPat<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
+    thir: &'a Thir<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     span: Span,
     id: hir::HirId,
@@ -63,11 +62,17 @@ struct ConstToPat<'tcx> {
     c: ty::Const<'tcx>,
 }
 
-impl<'tcx> ConstToPat<'tcx> {
-    fn new(pat_ctxt: &PatCtxt<'_, 'tcx>, id: hir::HirId, span: Span, c: ty::Const<'tcx>) -> Self {
+impl<'a, 'tcx> ConstToPat<'a, 'tcx> {
+    fn new(
+        pat_ctxt: &'a PatCtxt<'_, 'tcx>,
+        id: hir::HirId,
+        span: Span,
+        c: ty::Const<'tcx>,
+    ) -> Self {
         trace!(?pat_ctxt.typeck_results.hir_owner);
         ConstToPat {
             tcx: pat_ctxt.tcx,
+            thir: pat_ctxt.thir,
             typing_env: pat_ctxt.typing_env,
             span,
             id,
@@ -187,7 +192,7 @@ impl<'tcx> ConstToPat<'tcx> {
         // Convert the valtree to a const.
         let inlined_const_as_pat = self.valtree_to_pat(valtree, ty);
 
-        if !inlined_const_as_pat.references_error() {
+        if !self.thir.pat_references_error(&inlined_const_as_pat) {
             // Always check for `PartialEq` if we had no other errors yet.
             if !type_has_partial_eq_impl(self.tcx, typing_env, ty).has_impl {
                 let mut err = self.tcx.dcx().create_err(TypeNotPartialEq { span: self.span, ty });

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

@@ -15,7 +15,7 @@ use rustc_hir::{self as hir, RangeEnd};
 use rustc_index::Idx;
 use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
-    Ascription, FieldPat, LocalVarId, Pat, PatKind, PatRange, PatRangeBoundary,
+    Ascription, FieldPat, LocalVarId, Pat, PatKind, PatRange, PatRangeBoundary, Thir,
 };
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt, TypeVisitableExt};
@@ -30,6 +30,7 @@ use crate::errors::*;
 
 struct PatCtxt<'a, 'tcx> {
     tcx: TyCtxt<'tcx>,
+    thir: &'a Thir<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'a ty::TypeckResults<'tcx>,
 
@@ -39,12 +40,14 @@ struct PatCtxt<'a, 'tcx> {
 
 pub(super) fn pat_from_hir<'a, 'tcx>(
     tcx: TyCtxt<'tcx>,
+    thir: &'a Thir<'tcx>,
     typing_env: ty::TypingEnv<'tcx>,
     typeck_results: &'a ty::TypeckResults<'tcx>,
     pat: &'tcx hir::Pat<'tcx>,
 ) -> Box<Pat<'tcx>> {
     let mut pcx = PatCtxt {
         tcx,
+        thir,
         typing_env,
         typeck_results,
         rust_2024_migration: typeck_results

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -8,7 +8,7 @@ use rustc_hir::def_id::DefId;
 use rustc_index::{Idx, IndexVec};
 use rustc_middle::middle::stability::EvalResult;
 use rustc_middle::mir::{self, Const};
-use rustc_middle::thir::{self, Pat, PatKind, PatRange, PatRangeBoundary};
+use rustc_middle::thir::{self, Pat, PatKind, PatRange, PatRangeBoundary, Thir};
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{
     self, FieldDef, OpaqueTypeKey, ScalarInt, Ty, TyCtxt, TypeVisitableExt, VariantDef,
@@ -76,8 +76,9 @@ impl<'tcx> RevealedTy<'tcx> {
 }
 
 #[derive(Clone)]
-pub struct RustcPatCtxt<'p, 'tcx: 'p> {
+pub struct RustcPatCtxt<'p, 'tcx> {
     pub tcx: TyCtxt<'tcx>,
+    pub thir: &'p Thir<'tcx>,
     pub typeck_results: &'tcx ty::TypeckResults<'tcx>,
     /// The module in which the match occurs. This is necessary for
     /// checking inhabited-ness of types because whether a type is (visibly)