store the kind of pattern adjustments in pat_adjustments

Author: dianne

compiler/rustc_hir_typeck/src/expr_use_visitor.rs

@@ -1228,9 +1228,9 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         // actually this is somewhat "disjoint" from the code below
         // that aims to account for `ref x`.
         if let Some(vec) = self.cx.typeck_results().pat_adjustments().get(pat.hir_id) {
-            if let Some(first_ty) = vec.first() {
-                debug!("pat_ty(pat={:?}) found adjusted ty `{:?}`", pat, first_ty);
-                return Ok(*first_ty);
+            if let Some(first_adjust) = vec.first() {
+                debug!("pat_ty(pat={:?}) found adjustment `{:?}`", pat, first_adjust);
+                return Ok(first_adjust.source);
             }
         } else if let PatKind::Ref(subpat, _) = pat.kind
             && self.cx.typeck_results().skipped_ref_pats().contains(pat.hir_id)
@@ -1677,12 +1677,12 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
         // `deref { deref { place_foo }}` instead of `place_foo` since the pattern is now `Some(x,)`
         // and not `&&Some(x,)`, even though its assigned type is that of `&&Some(x,)`.
         let typeck_results = self.cx.typeck_results();
-        let adjustments: &[Ty<'tcx>] =
+        let adjustments: &[adjustment::PatAdjustment<'tcx>] =
             typeck_results.pat_adjustments().get(pat.hir_id).map_or(&[], |v| &**v);
-        let mut ref_tys = adjustments.iter().peekable();
-        while let Some(ref_ty) = ref_tys.next() {
+        let mut adjusts = adjustments.iter().peekable();
+        while let Some(adjust) = adjusts.next() {
             debug!("applying adjustment to place_with_id={:?}", place_with_id);
-            place_with_id = match ref_ty.pat_adjust_kind() {
+            place_with_id = match adjust.kind {
                 adjustment::PatAdjust::BuiltinDeref => self.cat_deref(pat.hir_id, place_with_id)?,
                 adjustment::PatAdjust::OverloadedDeref => {
                     // This adjustment corresponds to an overloaded deref; it borrows the scrutinee to
@@ -1691,8 +1691,8 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     // HACK(dianne): giving the callback a fake deref pattern makes sure it behaves the
                     // same as it would if this were an explicit deref pattern.
                     op(&place_with_id, &hir::Pat { kind: PatKind::Deref(pat), ..*pat })?;
-                    let target_ty = match ref_tys.peek() {
-                        Some(&&target_ty) => target_ty,
+                    let target_ty = match adjusts.peek() {
+                        Some(&&next_adjust) => next_adjust.source,
                         // At the end of the deref chain, we get `pat`'s scrutinee.
                         None => self.pat_ty_unadjusted(pat)?,
                     };

compiler/rustc_hir_typeck/src/pat.rs

@@ -30,7 +30,7 @@ use rustc_trait_selection::infer::InferCtxtExt;
 use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
 use tracing::{debug, instrument, trace};
 use ty::VariantDef;
-use ty::adjustment::PatAdjust;
+use ty::adjustment::{PatAdjust, PatAdjustment};
 
 use super::report_unexpected_variant_res;
 use crate::expectation::Expectation;
@@ -486,12 +486,15 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         // If we implicitly inserted overloaded dereferences before matching, check the pattern to
         // see if the dereferenced types need `DerefMut` bounds.
         if let Some(derefed_tys) = self.typeck_results.borrow().pat_adjustments().get(pat.hir_id)
-            && derefed_tys.iter().any(|ty| ty.pat_adjust_kind() == PatAdjust::OverloadedDeref)
+            && derefed_tys.iter().any(|adjust| adjust.kind == PatAdjust::OverloadedDeref)
         {
             self.register_deref_mut_bounds_if_needed(
                 pat.span,
                 pat,
-                derefed_tys.iter().filter(|ty| !ty.is_ref()).copied(),
+                derefed_tys.iter().filter_map(|adjust| match adjust.kind {
+                    PatAdjust::OverloadedDeref => Some(adjust.source),
+                    PatAdjust::BuiltinDeref => None,
+                }),
             );
         }
 
@@ -721,7 +724,14 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             debug!("inspecting {:?}", expected);
             debug!("current discriminant can be dereferenced, inserting implicit deref");
             // Preserve the reference type. We'll need it later during THIR lowering.
-            pat_adjustments.push(expected);
+            pat_adjustments.push(PatAdjustment {
+                source: expected,
+                kind: if expected.is_ref() {
+                    PatAdjust::BuiltinDeref
+                } else {
+                    PatAdjust::OverloadedDeref
+                },
+            });
 
             expected = self.try_structurally_resolve_type(pat.span, inner_ty);
         }

compiler/rustc_middle/src/ty/adjustment.rs

@@ -215,8 +215,19 @@ pub enum CustomCoerceUnsized {
     Struct(FieldIdx),
 }
 
+/// Represents an implicit coercion applied to the scrutinee of a match before testing a pattern
+/// against it. Currently, this is used only for implicit dereferences.
+#[derive(Clone, Copy, TyEncodable, TyDecodable, HashStable, TypeFoldable, TypeVisitable)]
+pub struct PatAdjustment<'tcx> {
+    pub kind: PatAdjust,
+    /// The type of the scrutinee before the adjustment is applied, or the "adjusted type" of the
+    /// pattern.
+    pub source: Ty<'tcx>,
+}
+
 /// Represents implicit coercions of patterns' types, rather than values' types.
-#[derive(Copy, Clone, Debug, PartialEq, Eq)]
+#[derive(Clone, Copy, PartialEq, Debug, TyEncodable, TyDecodable, HashStable)]
+#[derive(TypeFoldable, TypeVisitable)]
 pub enum PatAdjust {
     /// An implicit dereference before matching, such as when matching the pattern `0` against a
     /// scrutinee of type `&u8` or `&mut u8`.
@@ -226,11 +237,3 @@ pub enum PatAdjust {
     /// pattern `[..]` against a scrutinee of type `Vec<T>`.
     OverloadedDeref,
 }
-
-impl<'tcx> Ty<'tcx> {
-    /// Given an adjusted pattern type (see [`ty::typeck_results::TypeckResults::pat_adjustments`]),
-    /// determine what operation dereferences it, e.g. for building the pattern's THIR.
-    pub fn pat_adjust_kind(self) -> PatAdjust {
-        if self.is_ref() { PatAdjust::BuiltinDeref } else { PatAdjust::OverloadedDeref }
-    }
-}

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -61,6 +61,12 @@ impl<'tcx> fmt::Debug for ty::adjustment::Adjustment<'tcx> {
     }
 }
 
+impl<'tcx> fmt::Debug for ty::adjustment::PatAdjustment<'tcx> {
+    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
+        write!(f, "{} -> {:?}", self.source, self.kind)
+    }
+}
+
 impl fmt::Debug for ty::BoundRegionKind {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -99,7 +99,7 @@ pub struct TypeckResults<'tcx> {
     ///
     /// See:
     /// <https://github.com/rust-lang/rfcs/blob/master/text/2005-match-ergonomics.md#definitions>
-    pat_adjustments: ItemLocalMap<Vec<Ty<'tcx>>>,
+    pat_adjustments: ItemLocalMap<Vec<ty::adjustment::PatAdjustment<'tcx>>>,
 
     /// Set of reference patterns that match against a match-ergonomics inserted reference
     /// (as opposed to against a reference in the scrutinee type).
@@ -412,11 +412,15 @@ impl<'tcx> TypeckResults<'tcx> {
         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_binding_modes }
     }
 
-    pub fn pat_adjustments(&self) -> LocalTableInContext<'_, Vec<Ty<'tcx>>> {
+    pub fn pat_adjustments(
+        &self,
+    ) -> LocalTableInContext<'_, Vec<ty::adjustment::PatAdjustment<'tcx>>> {
         LocalTableInContext { hir_owner: self.hir_owner, data: &self.pat_adjustments }
     }
 
-    pub fn pat_adjustments_mut(&mut self) -> LocalTableInContextMut<'_, Vec<Ty<'tcx>>> {
+    pub fn pat_adjustments_mut(
+        &mut self,
+    ) -> LocalTableInContextMut<'_, Vec<ty::adjustment::PatAdjustment<'tcx>>> {
         LocalTableInContextMut { hir_owner: self.hir_owner, data: &mut self.pat_adjustments }
     }
 

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

@@ -4,7 +4,7 @@ use rustc_data_structures::fx::FxIndexMap;
 use rustc_errors::MultiSpan;
 use rustc_hir::{BindingMode, ByRef, HirId, Mutability};
 use rustc_lint as lint;
-use rustc_middle::ty::{self, Rust2024IncompatiblePatInfo, Ty, TyCtxt};
+use rustc_middle::ty::{self, Rust2024IncompatiblePatInfo, TyCtxt};
 use rustc_span::{Ident, Span};
 
 use crate::errors::{Rust2024IncompatiblePat, Rust2024IncompatiblePatSugg};
@@ -92,12 +92,12 @@ impl<'a> PatMigration<'a> {
     pub(super) fn visit_implicit_derefs<'tcx>(
         &mut self,
         pat_span: Span,
-        adjustments: &[Ty<'tcx>],
+        adjustments: &[ty::adjustment::PatAdjustment<'tcx>],
     ) -> Option<(Span, Mutability)> {
         // Implicitly dereferencing references changes the default binding mode, but implicit derefs
         // of smart pointers do not. Thus, we only consider implicit derefs of reference types.
-        let implicit_deref_mutbls = adjustments.iter().filter_map(|ref_ty| {
-            if let &ty::Ref(_, _, mutbl) = ref_ty.kind() { Some(mutbl) } else { None }
+        let implicit_deref_mutbls = adjustments.iter().filter_map(|adjust| {
+            if let &ty::Ref(_, _, mutbl) = adjust.source.kind() { Some(mutbl) } else { None }
         });
 
         if !self.info.suggest_eliding_modes {

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

@@ -17,7 +17,7 @@ use rustc_middle::mir::interpret::LitToConstInput;
 use rustc_middle::thir::{
     Ascription, FieldPat, LocalVarId, Pat, PatKind, PatRange, PatRangeBoundary,
 };
-use rustc_middle::ty::adjustment::PatAdjust;
+use rustc_middle::ty::adjustment::{PatAdjust, PatAdjustment};
 use rustc_middle::ty::layout::IntegerExt;
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, TyCtxt, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
@@ -63,15 +63,15 @@ pub(super) fn pat_from_hir<'a, 'tcx>(
 
 impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
     fn lower_pattern(&mut self, pat: &'tcx hir::Pat<'tcx>) -> Box<Pat<'tcx>> {
-        let adjustments: &[Ty<'tcx>] =
+        let adjustments: &[PatAdjustment<'tcx>] =
             self.typeck_results.pat_adjustments().get(pat.hir_id).map_or(&[], |v| &**v);
 
         // Track the default binding mode for the Rust 2024 migration suggestion.
         // Implicitly dereferencing references changes the default binding mode, but implicit deref
         // patterns do not. Only track binding mode changes if a ref type is in the adjustments.
         let mut opt_old_mode_span = None;
         if let Some(s) = &mut self.rust_2024_migration
-            && adjustments.iter().any(|ty| ty.is_ref())
+            && adjustments.iter().any(|adjust| adjust.source.is_ref())
         {
             opt_old_mode_span = s.visit_implicit_derefs(pat.span, adjustments);
         }
@@ -104,10 +104,10 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
             _ => self.lower_pattern_unadjusted(pat),
         };
 
-        let adjusted_pat = adjustments.iter().rev().fold(unadjusted_pat, |thir_pat, ref_ty| {
-            debug!("{:?}: wrapping pattern with type {:?}", thir_pat, ref_ty);
+        let adjusted_pat = adjustments.iter().rev().fold(unadjusted_pat, |thir_pat, adjust| {
+            debug!("{:?}: wrapping pattern with adjustment {:?}", thir_pat, adjust);
             let span = thir_pat.span;
-            let kind = match ref_ty.pat_adjust_kind() {
+            let kind = match adjust.kind {
                 PatAdjust::BuiltinDeref => PatKind::Deref { subpattern: thir_pat },
                 PatAdjust::OverloadedDeref => {
                     let mutable = self.typeck_results.pat_has_ref_mut_binding(pat);
@@ -116,11 +116,11 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                     PatKind::DerefPattern { subpattern: thir_pat, mutability }
                 }
             };
-            Box::new(Pat { span, ty: *ref_ty, kind })
+            Box::new(Pat { span, ty: adjust.source, kind })
         });
 
         if let Some(s) = &mut self.rust_2024_migration
-            && adjustments.iter().any(|ty| ty.is_ref())
+            && adjustments.iter().any(|adjust| adjust.source.is_ref())
         {
             s.leave_ref(opt_old_mode_span);
         }

src/tools/clippy/clippy_lints/src/pattern_type_mismatch.rs

@@ -179,7 +179,7 @@ fn find_first_mismatch(cx: &LateContext<'_>, pat: &Pat<'_>) -> Option<(Span, Mut
         };
         if let Some(adjustments) = cx.typeck_results().pat_adjustments().get(adjust_pat.hir_id) {
             if let [first, ..] = **adjustments {
-                if let ty::Ref(.., mutability) = *first.kind() {
+                if let ty::Ref(.., mutability) = *first.source.kind() {
                     let level = if p.hir_id == pat.hir_id {
                         Level::Top
                     } else {