!! (WIP) 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(self, 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()
             {
@@ -686,23 +692,23 @@ impl<'tcx> Pat<'tcx> {
     /// 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_middle/src/thir/visit.rs

@@ -237,11 +237,11 @@ pub fn walk_pat<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
     visitor: &mut V,
     pat: &'thir Pat<'tcx>,
 ) {
-    for_each_immediate_subpat(pat, |p| visitor.visit_pat(p));
+    for_each_immediate_subpat(visitor.thir(), pat, |p| visitor.visit_pat(p));
 }
 
-/// Invokes `callback` on each immediate subpattern of `pat`, if any.
 pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
+    _thir: &'a Thir<'tcx>,
     pat: &'a Pat<'tcx>,
     mut callback: impl FnMut(&'a Pat<'tcx>),
 ) {

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/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_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)