Extract for_each_immediate_subpat from THIR pattern visitors

compiler/rustc_middle/src/thir.rs

@@ -28,6 +28,7 @@ use tracing::instrument;
 use crate::middle::region;
 use crate::mir::interpret::AllocId;
 use crate::mir::{self, BinOp, BorrowKind, FakeReadCause, UnOp};
+use crate::thir::visit::for_each_immediate_subpat;
 use crate::ty::adjustment::PointerCoercion;
 use crate::ty::layout::IntegerExt;
 use crate::ty::{
@@ -672,27 +673,7 @@ impl<'tcx> Pat<'tcx> {
             return;
         }
 
-        use PatKind::*;
+        for_each_immediate_subpat(self, |p| p.walk_(it));
-        match &self.kind {
-            Wild
-            | Never
-            | Range(..)
-            | Binding { subpattern: None, .. }
-            | Constant { .. }
-            | Error(_) => {}
-            AscribeUserType { subpattern, .. }
-            | Binding { subpattern: Some(subpattern), .. }
-            | Deref { subpattern }
-            | DerefPattern { subpattern, .. }
-            | ExpandedConstant { subpattern, .. } => subpattern.walk_(it),
-            Leaf { subpatterns } | Variant { subpatterns, .. } => {
-                subpatterns.iter().for_each(|field| field.pattern.walk_(it))
-            }
-            Or { pats } => pats.iter().for_each(|p| p.walk_(it)),
-            Array { box prefix, slice, box suffix } | Slice { box prefix, slice, box suffix } => {
-                prefix.iter().chain(slice.as_deref()).chain(suffix.iter()).for_each(|p| p.walk_(it))
-            }
-        }
     }
 
     /// Whether the pattern has a `PatKind::Error` nested within.

compiler/rustc_middle/src/thir/visit.rs

@@ -240,36 +240,45 @@ pub fn walk_pat<'thir, 'tcx: 'thir, V: Visitor<'thir, 'tcx>>(
     visitor: &mut V,
     pat: &'thir Pat<'tcx>,
 ) {
-    use PatKind::*;
+    for_each_immediate_subpat(pat, |p| visitor.visit_pat(p));
-    match &pat.kind {
+}
-        AscribeUserType { subpattern, ascription: _ }
+
-        | Deref { subpattern }
+/// Invokes `callback` on each immediate subpattern of `pat`, if any.
-        | DerefPattern { subpattern, .. }
+/// A building block for assembling THIR pattern visitors.
-        | Binding { subpattern: Some(subpattern), .. } => visitor.visit_pat(subpattern),
+pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
-        Binding { .. } | Wild | Never | Error(_) => {}
+    pat: &'a Pat<'tcx>,
-        Variant { subpatterns, adt_def: _, args: _, variant_index: _ } | Leaf { subpatterns } => {
+    mut callback: impl FnMut(&'a Pat<'tcx>),
-            for subpattern in subpatterns {
+) {
-                visitor.visit_pat(&subpattern.pattern);
+    match &pat.kind {
-            }
+        PatKind::Wild
-        }
+        | PatKind::Binding { subpattern: None, .. }
-        Constant { value: _ } => {}
+        | PatKind::Constant { value: _ }
-        ExpandedConstant { def_id: _, is_inline: _, subpattern } => visitor.visit_pat(subpattern),
+        | PatKind::Range(_)
-        Range(_) => {}
+        | PatKind::Never
-        Slice { prefix, slice, suffix } | Array { prefix, slice, suffix } => {
+        | PatKind::Error(_) => {}
-            for subpattern in prefix.iter() {
+
-                visitor.visit_pat(subpattern);
+        PatKind::AscribeUserType { subpattern, .. }
-            }
+        | PatKind::Binding { subpattern: Some(subpattern), .. }
-            if let Some(pat) = slice {
+        | PatKind::Deref { subpattern }
-                visitor.visit_pat(pat);
+        | PatKind::DerefPattern { subpattern, .. }
-            }
+        | PatKind::ExpandedConstant { subpattern, .. } => callback(subpattern),
-            for subpattern in suffix.iter() {
+
-                visitor.visit_pat(subpattern);
+        PatKind::Variant { subpatterns, .. } | PatKind::Leaf { subpatterns } => {
-            }
+            for field_pat in subpatterns {
-        }
+                callback(&field_pat.pattern);
-        Or { pats } => {
+            }
-            for pat in pats.iter() {
+        }
-                visitor.visit_pat(pat);
+
-            }
+        PatKind::Slice { prefix, slice, suffix } | PatKind::Array { prefix, slice, suffix } => {
-        }
+            for pat in prefix.iter().chain(slice.as_deref()).chain(suffix) {
-    };
+                callback(pat);
+            }
+        }
+
+        PatKind::Or { pats } => {
+            for pat in pats {
+                callback(pat);
+            }
+        }
+    }
 }