diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 1532ca77f713e..1d6236730ce47 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -719,14 +719,14 @@ pub struct PatField {
 #[derive(Clone, Copy, Debug, Eq, PartialEq)]
 #[derive(Encodable, Decodable, HashStable_Generic)]
 pub enum ByRef {
-    Yes(Mutability),
+    Yes(Pinnedness, Mutability),
     No,
 }
 
 impl ByRef {
     #[must_use]
     pub fn cap_ref_mutability(mut self, mutbl: Mutability) -> Self {
-        if let ByRef::Yes(old_mutbl) = &mut self {
+        if let ByRef::Yes(_, old_mutbl) = &mut self {
             *old_mutbl = cmp::min(*old_mutbl, mutbl);
         }
         self
@@ -744,20 +744,33 @@ pub struct BindingMode(pub ByRef, pub Mutability);
 
 impl BindingMode {
     pub const NONE: Self = Self(ByRef::No, Mutability::Not);
-    pub const REF: Self = Self(ByRef::Yes(Mutability::Not), Mutability::Not);
+    pub const REF: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Not), Mutability::Not);
+    pub const REF_PIN: Self =
+        Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Not), Mutability::Not);
     pub const MUT: Self = Self(ByRef::No, Mutability::Mut);
-    pub const REF_MUT: Self = Self(ByRef::Yes(Mutability::Mut), Mutability::Not);
-    pub const MUT_REF: Self = Self(ByRef::Yes(Mutability::Not), Mutability::Mut);
-    pub const MUT_REF_MUT: Self = Self(ByRef::Yes(Mutability::Mut), Mutability::Mut);
+    pub const REF_MUT: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Mut), Mutability::Not);
+    pub const REF_PIN_MUT: Self =
+        Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Mut), Mutability::Not);
+    pub const MUT_REF: Self = Self(ByRef::Yes(Pinnedness::Not, Mutability::Not), Mutability::Mut);
+    pub const MUT_REF_PIN: Self =
+        Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Not), Mutability::Mut);
+    pub const MUT_REF_MUT: Self =
+        Self(ByRef::Yes(Pinnedness::Not, Mutability::Mut), Mutability::Mut);
+    pub const MUT_REF_PIN_MUT: Self =
+        Self(ByRef::Yes(Pinnedness::Pinned, Mutability::Mut), Mutability::Mut);
 
     pub fn prefix_str(self) -> &'static str {
         match self {
             Self::NONE => "",
             Self::REF => "ref ",
+            Self::REF_PIN => "ref pin const ",
             Self::MUT => "mut ",
             Self::REF_MUT => "ref mut ",
+            Self::REF_PIN_MUT => "ref pin mut ",
             Self::MUT_REF => "mut ref ",
+            Self::MUT_REF_PIN => "mut ref pin ",
             Self::MUT_REF_MUT => "mut ref mut ",
+            Self::MUT_REF_PIN_MUT => "mut ref pin mut ",
         }
     }
 }
diff --git a/compiler/rustc_ast_ir/src/lib.rs b/compiler/rustc_ast_ir/src/lib.rs
index 0898433a74c53..8f7a1986c5cdf 100644
--- a/compiler/rustc_ast_ir/src/lib.rs
+++ b/compiler/rustc_ast_ir/src/lib.rs
@@ -101,3 +101,10 @@ pub enum Pinnedness {
     Not,
     Pinned,
 }
+
+impl Pinnedness {
+    /// Return `true` if self is pinned
+    pub fn is_pinned(self) -> bool {
+        matches!(self, Self::Pinned)
+    }
+}
diff --git a/compiler/rustc_ast_pretty/src/pprust/state.rs b/compiler/rustc_ast_pretty/src/pprust/state.rs
index 0985ebf945bbd..ee993d13c8d69 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1624,10 +1624,15 @@ impl<'a> State<'a> {
                 if mutbl.is_mut() {
                     self.word_nbsp("mut");
                 }
-                if let ByRef::Yes(rmutbl) = by_ref {
+                if let ByRef::Yes(pinnedness, rmutbl) = by_ref {
                     self.word_nbsp("ref");
+                    if pinnedness.is_pinned() {
+                        self.word_nbsp("pin");
+                    }
                     if rmutbl.is_mut() {
                         self.word_nbsp("mut");
+                    } else if pinnedness.is_pinned() {
+                        self.word_nbsp("const");
                     }
                 }
                 self.print_ident(*ident);
diff --git a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
index 56cc432758511..0078f560249a3 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -1225,7 +1225,7 @@ impl<'infcx, 'tcx> MirBorrowckCtxt<'_, 'infcx, 'tcx> {
             }
 
             LocalInfo::User(mir::BindingForm::Var(mir::VarBindingForm {
-                binding_mode: BindingMode(ByRef::Yes(_), _),
+                binding_mode: BindingMode(ByRef::Yes(..), _),
                 ..
             })) => {
                 let pattern_span: Span = local_decl.source_info.span;
diff --git a/compiler/rustc_borrowck/src/lib.rs b/compiler/rustc_borrowck/src/lib.rs
index 3b66142eb2cec..5a99364458abf 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -2472,7 +2472,7 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
 
                         // Check the kind of deref to decide
                         match base_ty.kind() {
-                            ty::Ref(_, _, mutbl) => {
+                            _ if let &ty::Ref(_, _, mutbl) = base_ty.kind() => {
                                 match mutbl {
                                     // Shared borrowed data is never mutable
                                     hir::Mutability::Not => Err(place),
@@ -2513,6 +2513,16 @@ impl<'a, 'tcx> MirBorrowckCtxt<'a, '_, 'tcx> {
                             _ => bug!("Deref of unexpected type: {:?}", base_ty),
                         }
                     }
+                    // Check as the inner reference type if it is a field projection
+                    // from the `&pin` pattern
+                    ProjectionElem::Field(FieldIdx::ZERO, _)
+                        if let Some(adt) =
+                            place_base.ty(self.body(), self.infcx.tcx).ty.ty_adt_def()
+                            && adt.is_pin()
+                            && self.infcx.tcx.features().pin_ergonomics() =>
+                    {
+                        self.is_mutable(place_base, is_local_mutation_allowed)
+                    }
                     // All other projections are owned by their base path, so mutable if
                     // base path is mutable
                     ProjectionElem::Field(..)
diff --git a/compiler/rustc_borrowck/src/type_check/mod.rs b/compiler/rustc_borrowck/src/type_check/mod.rs
index 3c00b819a96bb..e498f6461a26b 100644
--- a/compiler/rustc_borrowck/src/type_check/mod.rs
+++ b/compiler/rustc_borrowck/src/type_check/mod.rs
@@ -2360,7 +2360,8 @@ impl<'a, 'tcx> TypeChecker<'a, 'tcx> {
 
                     debug!("add_reborrow_constraint - base_ty = {:?}", base_ty);
                     match base_ty.kind() {
-                        ty::Ref(ref_region, _, mutbl) => {
+                        _ if let &ty::Ref(ref_region, _, mutbl) = base_ty.kind() => {
+                            // FIXME(pin_ergonomics): handle `&pin mut|const T`
                             constraints.outlives_constraints.push(OutlivesConstraint {
                                 sup: ref_region.as_var(),
                                 sub: borrow_region.as_var(),
diff --git a/compiler/rustc_codegen_cranelift/src/base.rs b/compiler/rustc_codegen_cranelift/src/base.rs
index adaa754491e56..0483a23826b81 100644
--- a/compiler/rustc_codegen_cranelift/src/base.rs
+++ b/compiler/rustc_codegen_cranelift/src/base.rs
@@ -729,7 +729,7 @@ fn codegen_stmt<'tcx>(
                     let to_ty = fx.monomorphize(to_ty);
 
                     fn is_wide_ptr<'tcx>(fx: &FunctionCx<'_, '_, 'tcx>, ty: Ty<'tcx>) -> bool {
-                        ty.builtin_deref(true).is_some_and(|pointee_ty| {
+                        ty.builtin_deref(true, fx.tcx).is_some_and(|pointee_ty| {
                             fx.tcx
                                 .type_has_metadata(pointee_ty, ty::TypingEnv::fully_monomorphized())
                         })
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
index d3f47ad726334..1a897d9075721 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/mod.rs
@@ -583,7 +583,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             intrinsic_args!(fx, args => (base, offset); intrinsic);
             let offset = offset.load_scalar(fx);
 
-            let pointee_ty = base.layout().ty.builtin_deref(true).unwrap();
+            let pointee_ty = base.layout().ty.builtin_deref(true, fx.tcx).unwrap();
             let pointee_size = fx.layout_of(pointee_ty).size.bytes();
             let ptr_diff = if pointee_size != 1 {
                 fx.bcx.ins().imul_imm(offset, pointee_size as i64)
@@ -609,7 +609,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
             let val = val.load_scalar(fx);
             let count = count.load_scalar(fx);
 
-            let pointee_ty = dst.layout().ty.builtin_deref(true).unwrap();
+            let pointee_ty = dst.layout().ty.builtin_deref(true, fx.tcx).unwrap();
             let pointee_size = fx.layout_of(pointee_ty).size.bytes();
             let count = if pointee_size != 1 {
                 fx.bcx.ins().imul_imm(count, pointee_size as i64)
@@ -717,7 +717,7 @@ fn codegen_regular_intrinsic_call<'tcx>(
 
             // Cranelift treats loads as volatile by default
             // FIXME correctly handle unaligned_volatile_load
-            let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true).unwrap());
+            let inner_layout = fx.layout_of(ptr.layout().ty.builtin_deref(true, fx.tcx).unwrap());
             let val = CValue::by_ref(Pointer::new(ptr.load_scalar(fx)), inner_layout);
             ret.write_cvalue(fx, val);
         }
diff --git a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
index dd6d8dbb6f5e0..4d483616db467 100644
--- a/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
+++ b/compiler/rustc_codegen_cranelift/src/intrinsics/simd.rs
@@ -897,7 +897,7 @@ pub(super) fn codegen_simd_intrinsic_call<'tcx>(
             intrinsic_args!(fx, args => (ptr, offset); intrinsic);
 
             let (lane_count, ptr_lane_ty) = ptr.layout().ty.simd_size_and_type(fx.tcx);
-            let pointee_ty = ptr_lane_ty.builtin_deref(true).unwrap();
+            let pointee_ty = ptr_lane_ty.builtin_deref(true, fx.tcx).unwrap();
             let pointee_size = fx.layout_of(pointee_ty).size.bytes();
             let (ret_lane_count, ret_lane_ty) = ret.layout().ty.simd_size_and_type(fx.tcx);
             let ret_lane_layout = fx.layout_of(ret_lane_ty);
diff --git a/compiler/rustc_codegen_cranelift/src/num.rs b/compiler/rustc_codegen_cranelift/src/num.rs
index 2a4d1e3ae571d..f961b42c8b6f2 100644
--- a/compiler/rustc_codegen_cranelift/src/num.rs
+++ b/compiler/rustc_codegen_cranelift/src/num.rs
@@ -398,7 +398,7 @@ pub(crate) fn codegen_ptr_binop<'tcx>(
     let is_thin_ptr = in_lhs
         .layout()
         .ty
-        .builtin_deref(true)
+        .builtin_deref(true, fx.tcx)
         .map(|ty| !fx.tcx.type_has_metadata(ty, ty::TypingEnv::fully_monomorphized()))
         .unwrap_or(true);
 
@@ -411,7 +411,7 @@ pub(crate) fn codegen_ptr_binop<'tcx>(
                 codegen_compare_bin_op(fx, bin_op, false, lhs, rhs)
             }
             BinOp::Offset => {
-                let pointee_ty = in_lhs.layout().ty.builtin_deref(true).unwrap();
+                let pointee_ty = in_lhs.layout().ty.builtin_deref(true, fx.tcx).unwrap();
                 let (base, offset) = (in_lhs, in_rhs.load_scalar(fx));
                 let pointee_size = fx.layout_of(pointee_ty).size.bytes();
                 let ptr_diff = fx.bcx.ins().imul_imm(offset, pointee_size as i64);
diff --git a/compiler/rustc_codegen_cranelift/src/unsize.rs b/compiler/rustc_codegen_cranelift/src/unsize.rs
index f8bbb21492015..a8d6f23967a51 100644
--- a/compiler/rustc_codegen_cranelift/src/unsize.rs
+++ b/compiler/rustc_codegen_cranelift/src/unsize.rs
@@ -138,7 +138,7 @@ pub(crate) fn coerce_unsized_into<'tcx>(
     let dst_ty = dst.layout().ty;
     let mut coerce_ptr = || {
         let (base, info) =
-            if fx.layout_of(src.layout().ty.builtin_deref(true).unwrap()).is_unsized() {
+            if fx.layout_of(src.layout().ty.builtin_deref(true, fx.tcx).unwrap()).is_unsized() {
                 let (old_base, old_info) = src.load_scalar_pair(fx);
                 unsize_ptr(fx, old_base, src.layout(), dst.layout(), Some(old_info))
             } else {
diff --git a/compiler/rustc_codegen_cranelift/src/value_and_place.rs b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
index f8a19589fdd72..6eacf4c71754c 100644
--- a/compiler/rustc_codegen_cranelift/src/value_and_place.rs
+++ b/compiler/rustc_codegen_cranelift/src/value_and_place.rs
@@ -831,7 +831,7 @@ impl<'tcx> CPlace<'tcx> {
     }
 
     pub(crate) fn place_deref(self, fx: &mut FunctionCx<'_, '_, 'tcx>) -> CPlace<'tcx> {
-        let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true).unwrap());
+        let inner_layout = fx.layout_of(self.layout().ty.builtin_deref(true, fx.tcx).unwrap());
         if fx.tcx.type_has_metadata(inner_layout.ty, ty::TypingEnv::fully_monomorphized()) {
             let (addr, extra) = self.to_cvalue(fx).load_scalar_pair(fx);
             CPlace::for_ptr_with_extra(Pointer::new(addr), extra, inner_layout)
diff --git a/compiler/rustc_codegen_cranelift/src/vtable.rs b/compiler/rustc_codegen_cranelift/src/vtable.rs
index 9d9e0462a9b72..691853a972afa 100644
--- a/compiler/rustc_codegen_cranelift/src/vtable.rs
+++ b/compiler/rustc_codegen_cranelift/src/vtable.rs
@@ -59,7 +59,8 @@ pub(crate) fn get_ptr_and_method_ref<'tcx>(
 
         if let ty::Ref(_, ty, _) = arg.layout().ty.kind() {
             if ty.is_dyn_star() {
-                let inner_layout = fx.layout_of(arg.layout().ty.builtin_deref(true).unwrap());
+                let inner_layout =
+                    fx.layout_of(arg.layout().ty.builtin_deref(true, fx.tcx).unwrap());
                 let dyn_star = CPlace::for_ptr(Pointer::new(arg.load_scalar(fx)), inner_layout);
                 let ptr = dyn_star.place_field(fx, FieldIdx::ZERO).to_ptr();
                 let vtable =
diff --git a/compiler/rustc_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index d02c767ea677a..87424712b6d54 100644
--- a/compiler/rustc_hir/src/hir.rs
+++ b/compiler/rustc_hir/src/hir.rs
@@ -12,7 +12,7 @@ use rustc_ast::{
 pub use rustc_ast::{
     AssignOp, AssignOpKind, AttrId, AttrStyle, BinOp, BinOpKind, BindingMode, BorrowKind,
     BoundConstness, BoundPolarity, ByRef, CaptureBy, DelimArgs, ImplPolarity, IsAuto,
-    MetaItemInner, MetaItemLit, Movability, Mutability, UnOp,
+    MetaItemInner, MetaItemLit, Movability, Mutability, Pinnedness, UnOp,
 };
 use rustc_attr_data_structures::AttributeKind;
 use rustc_data_structures::fingerprint::Fingerprint;
diff --git a/compiler/rustc_hir_analysis/src/check/region.rs b/compiler/rustc_hir_analysis/src/check/region.rs
index 7cb31a64e13e6..9da8ca6f7a2a5 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -659,7 +659,7 @@ fn resolve_local<'tcx>(
         // & expression, and its lifetime would be extended to the end of the block (due
         // to a different rule, not the below code).
         match pat.kind {
-            PatKind::Binding(hir::BindingMode(hir::ByRef::Yes(_), _), ..) => true,
+            PatKind::Binding(hir::BindingMode(hir::ByRef::Yes(..), _), ..) => true,
 
             PatKind::Struct(_, field_pats, _) => field_pats.iter().any(|fp| is_binding_pat(fp.pat)),
 
diff --git a/compiler/rustc_hir_pretty/src/lib.rs b/compiler/rustc_hir_pretty/src/lib.rs
index ff4385c3bccec..17d9ca6d04587 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1882,10 +1882,15 @@ impl<'a> State<'a> {
                 if mutbl.is_mut() {
                     self.word_nbsp("mut");
                 }
-                if let ByRef::Yes(rmutbl) = by_ref {
+                if let ByRef::Yes(pinnedness, rmutbl) = by_ref {
                     self.word_nbsp("ref");
+                    if pinnedness.is_pinned() {
+                        self.word_nbsp("pin");
+                    }
                     if rmutbl.is_mut() {
                         self.word_nbsp("mut");
+                    } else if pinnedness.is_pinned() {
+                        self.word_nbsp("const");
                     }
                 }
                 self.print_ident(ident);
diff --git a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
index f5e0f01e4c573..c740f79250fbf 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -985,7 +985,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     // of the pattern, as this just looks confusing, instead use the span
                     // of the discriminant.
                     match bm.0 {
-                        hir::ByRef::Yes(m) => {
+                        hir::ByRef::Yes(_, m) => {
                             let bk = ty::BorrowKind::from_mutbl(m);
                             self.delegate.borrow_mut().borrow(place, discr_place.hir_id, bk);
                         }
@@ -1258,25 +1258,34 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     .get(pat.hir_id)
                     .expect("missing binding mode");
 
-                if matches!(bm.0, hir::ByRef::Yes(_)) {
-                    // a bind-by-ref means that the base_ty will be the type of the ident itself,
-                    // but what we want here is the type of the underlying value being borrowed.
-                    // So peel off one-level, turning the &T into T.
-                    match self
-                        .cx
-                        .try_structurally_resolve_type(pat.span, base_ty)
-                        .builtin_deref(false)
-                    {
-                        Some(ty) => Ok(ty),
-                        None => {
-                            debug!("By-ref binding of non-derefable type");
-                            Err(self
-                                .cx
-                                .report_bug(pat.span, "by-ref binding of non-derefable type"))
+                match bm.0 {
+                    hir::ByRef::Yes(pinnedness, _) => {
+                        let base_ty = if pinnedness.is_pinned() {
+                            base_ty.pinned_ty().ok_or_else(|| {
+                                debug!("By-pin-ref binding of non-`Pin` type");
+                                self.cx.report_bug(pat.span, "by-pin-ref binding of non-`Pin` type")
+                            })?
+                        } else {
+                            base_ty
+                        };
+                        // a bind-by-ref means that the base_ty will be the type of the ident itself,
+                        // but what we want here is the type of the underlying value being borrowed.
+                        // So peel off one-level, turning the &T into T.
+                        match self
+                            .cx
+                            .try_structurally_resolve_type(pat.span, base_ty)
+                            .builtin_deref(false)
+                        {
+                            Some(ty) => Ok(ty),
+                            None => {
+                                debug!("By-ref binding of non-derefable type");
+                                Err(self
+                                    .cx
+                                    .report_bug(pat.span, "by-ref binding of non-derefable type"))
+                            }
                         }
                     }
-                } else {
-                    Ok(base_ty)
+                    _ => Ok(base_ty),
                 }
             }
             _ => Ok(base_ty),
@@ -1704,6 +1713,16 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     };
                     self.pat_deref_temp(pat.hir_id, pat, target_ty)?
                 }
+                adjustment::PatAdjust::PinDeref => {
+                    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)?,
+                    };
+                    let kind = ProjectionKind::Field(FieldIdx::ZERO, FIRST_VARIANT);
+                    place_with_id = self.cat_projection(pat.hir_id, place_with_id, target_ty, kind);
+                    self.cat_deref(pat.hir_id, place_with_id)?
+                }
             };
         }
         drop(typeck_results); // explicitly release borrow of typeck results, just in case.
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index e5e4fc7f8b77f..585d67d865cf9 100644
--- a/compiler/rustc_hir_typeck/src/pat.rs
+++ b/compiler/rustc_hir_typeck/src/pat.rs
@@ -18,7 +18,7 @@ use rustc_hir::{
 use rustc_hir_analysis::autoderef::report_autoderef_recursion_limit_error;
 use rustc_infer::infer;
 use rustc_middle::traits::PatternOriginExpr;
-use rustc_middle::ty::{self, Ty, TypeVisitableExt};
+use rustc_middle::ty::{self, Pinnedness, Ty, TypeVisitableExt};
 use rustc_middle::{bug, span_bug};
 use rustc_session::lint::builtin::NON_EXHAUSTIVE_OMITTED_PATTERNS;
 use rustc_session::parse::feature_err;
@@ -409,7 +409,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 pat,
                 derefed_tys.iter().filter_map(|adjust| match adjust.kind {
                     PatAdjust::OverloadedDeref => Some(adjust.source),
-                    PatAdjust::BuiltinDeref => None,
+                    PatAdjust::BuiltinDeref | PatAdjust::PinDeref => None,
                 }),
             );
         }
@@ -467,7 +467,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         pat_info: PatInfo<'tcx>,
     ) -> Ty<'tcx> {
         #[cfg(debug_assertions)]
-        if pat_info.binding_mode == ByRef::Yes(Mutability::Mut)
+        if matches!(pat_info.binding_mode, ByRef::Yes(_, Mutability::Mut))
             && pat_info.max_ref_mutbl != MutblCap::Mut
             && self.downgrade_mut_inside_shared()
         {
@@ -485,12 +485,28 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let old_pat_info = pat_info;
         let pat_info = PatInfo { current_depth: old_pat_info.current_depth + 1, ..old_pat_info };
 
+        let adjust_binding_mode = |inner_pinnedness, inner_mutability| {
+            match pat_info.binding_mode {
+                // If default binding mode is by value, make it `ref`, `ref mut`, `ref pin const`
+                // or `ref pin mut` (depending on whether we observe `&`, `&mut`, `&pin const` or
+                // `&pin mut`).
+                ByRef::No => ByRef::Yes(inner_pinnedness, inner_mutability),
+                // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`).
+                // Pinnedness is preserved.
+                ByRef::Yes(pinnedness, Mutability::Mut) => ByRef::Yes(pinnedness, inner_mutability),
+                // Once a `ref`, always a `ref`.
+                // This is because a `& &mut` cannot mutate the underlying value.
+                // Pinnedness is preserved.
+                ByRef::Yes(pinnedness, Mutability::Not) => ByRef::Yes(pinnedness, Mutability::Not),
+            }
+        };
+
         match pat.kind {
-            // Peel off a `&` or `&mut` from the scrutinee type. See the examples in
-            // `tests/ui/rfcs/rfc-2005-default-binding-mode`.
+            // Peel off a `&`, `&mut`from the scrutinee type.
+            // See the examples in `tests/ui/rfcs/rfc-2005-default-binding-mode`.
             _ if let AdjustMode::Peel { .. } = adjust_mode
                 && pat.default_binding_modes
-                && let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind() =>
+                && let &ty::Ref(_, inner_ty, inner_mutability) = expected.kind() =>
             {
                 debug!("inspecting {:?}", expected);
 
@@ -503,22 +519,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     .or_default()
                     .push(PatAdjustment { kind: PatAdjust::BuiltinDeref, source: expected });
 
-                let mut binding_mode = ByRef::Yes(match pat_info.binding_mode {
-                    // If default binding mode is by value, make it `ref` or `ref mut`
-                    // (depending on whether we observe `&` or `&mut`).
-                    ByRef::No |
-                    // When `ref mut`, stay a `ref mut` (on `&mut`) or downgrade to `ref` (on `&`).
-                    ByRef::Yes(Mutability::Mut) => inner_mutability,
-                    // Once a `ref`, always a `ref`.
-                    // This is because a `& &mut` cannot mutate the underlying value.
-                    ByRef::Yes(Mutability::Not) => Mutability::Not,
-                });
+                let mut binding_mode = adjust_binding_mode(Pinnedness::Not, inner_mutability);
 
                 let mut max_ref_mutbl = pat_info.max_ref_mutbl;
                 if self.downgrade_mut_inside_shared() {
                     binding_mode = binding_mode.cap_ref_mutability(max_ref_mutbl.as_mutbl());
                 }
-                if binding_mode == ByRef::Yes(Mutability::Not) {
+                if matches!(binding_mode, ByRef::Yes(_, Mutability::Not)) {
                     max_ref_mutbl = MutblCap::Not;
                 }
                 debug!("default binding mode is now {:?}", binding_mode);
@@ -530,7 +537,9 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             // If `deref_patterns` is enabled, peel a smart pointer from the scrutinee type. See the
             // examples in `tests/ui/pattern/deref_patterns/`.
-            _ if self.tcx.features().deref_patterns()
+            // Or `pin_ergonomics` is enabled, peel the `&pin` from the pinned reference type. See the
+            // examples in `tests/ui/async-await/pin-ergonomics/`.
+            _ if (self.tcx.features().deref_patterns() || self.tcx.features().pin_ergonomics())
                 && let AdjustMode::Peel { kind: PeelKind::Implicit { until_adt } } = adjust_mode
                 && pat.default_binding_modes
                 // For simplicity, only apply overloaded derefs if `expected` is a known ADT.
@@ -549,7 +558,46 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 && self
                     .type_implements_trait(deref_trait, [expected], self.param_env)
                     .may_apply() =>
-            {
+            'deref_pattern: {
+                if self.tcx.features().pin_ergonomics()
+                    && let Some(pinned_ty) = expected.pinned_ty()
+                    // Currently, only pinned reference is specially handled, leaving other
+                    // pinned types (e.g. `Pin<Box<T>>` to deref patterns) handled as a
+                    // deref pattern.
+                    && let &ty::Ref(_, inner_ty, inner_mutability) = pinned_ty.kind()
+                {
+                    debug!("scrutinee ty {expected:?} is a pinned reference, inserting pin deref");
+                    // Preserve the pinned type. We'll need it later during THIR lowering.
+                    self.typeck_results
+                        .borrow_mut()
+                        .pat_adjustments_mut()
+                        .entry(pat.hir_id)
+                        .or_default()
+                        .push(PatAdjustment { kind: PatAdjust::PinDeref, source: expected });
+
+                    let binding_mode = adjust_binding_mode(Pinnedness::Pinned, inner_mutability);
+                    // If the pinnedness is `Not`, it means the pattern is unpinned
+                    // and thus requires an `Unpin` bound.
+                    if binding_mode == ByRef::Yes(Pinnedness::Not, Mutability::Mut) {
+                        self.register_bound(
+                            inner_ty,
+                            self.tcx.require_lang_item(hir::LangItem::Unpin, Some(pat.span)),
+                            self.misc(pat.span),
+                        );
+                    }
+                    // Use the old pat info to keep `current_depth` to its old value.
+                    let new_pat_info = PatInfo { binding_mode, ..old_pat_info };
+                    // Recurse with the new expected type.
+                    // using `break` instead of `return` in case where any shared codes are added
+                    // after the `match pat.kind {}`.
+                    break 'deref_pattern self.check_pat_inner(
+                        pat,
+                        opt_path_res,
+                        adjust_mode,
+                        inner_ty,
+                        new_pat_info,
+                    );
+                }
                 debug!("scrutinee ty {expected:?} is a smart pointer, inserting overloaded deref");
                 // The scrutinee is a smart pointer; implicitly dereference it. This adds a
                 // requirement that `expected: DerefPure`.
@@ -960,7 +1008,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         // Determine the binding mode...
         let bm = match user_bind_annot {
-            BindingMode(ByRef::No, Mutability::Mut) if let ByRef::Yes(def_br_mutbl) = def_br => {
+            BindingMode(ByRef::No, Mutability::Mut) if let ByRef::Yes(_, def_br_mutbl) = def_br => {
                 // Only mention the experimental `mut_ref` feature if if we're in edition 2024 and
                 // using other experimental matching features compatible with it.
                 if pat.span.at_least_rust_2024()
@@ -990,8 +1038,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 }
             }
             BindingMode(ByRef::No, mutbl) => BindingMode(def_br, mutbl),
-            BindingMode(ByRef::Yes(user_br_mutbl), _) => {
-                if let ByRef::Yes(def_br_mutbl) = def_br {
+            BindingMode(ByRef::Yes(_, user_br_mutbl), _) => {
+                if let ByRef::Yes(_, def_br_mutbl) = def_br {
                     // `ref`/`ref mut` overrides the binding mode on edition <= 2021
                     self.add_rust_2024_migration_desugared_pat(
                         pat_info.top_info.hir_id,
@@ -1007,7 +1055,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
         };
 
-        if bm.0 == ByRef::Yes(Mutability::Mut)
+        if matches!(bm.0, ByRef::Yes(_, Mutability::Mut))
             && let MutblCap::WeaklyNot(and_pat_span) = pat_info.max_ref_mutbl
         {
             let mut err = struct_span_code_err!(
@@ -1035,7 +1083,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
 
         let local_ty = self.local_ty(pat.span, pat.hir_id);
         let eq_ty = match bm.0 {
-            ByRef::Yes(mutbl) => {
+            ByRef::Yes(Pinnedness::Not, mutbl) => {
                 // If the binding is like `ref x | ref mut x`,
                 // then `x` is assigned a value of type `&M T` where M is the
                 // mutability and T is the expected type.
@@ -1045,6 +1093,12 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // See (note_1) for an explanation.
                 self.new_ref_ty(pat.span, mutbl, expected)
             }
+            // Wrapping the type into `Pin` if the binding is like `ref pin const|mut x`
+            ByRef::Yes(Pinnedness::Pinned, mutbl) => Ty::new_adt(
+                self.tcx,
+                self.tcx.adt_def(self.tcx.require_lang_item(hir::LangItem::Pin, Some(pat.span))),
+                self.tcx.mk_args(&[self.new_ref_ty(pat.span, mutbl, expected).into()]),
+            ),
             // Otherwise, the type of x is the expected type `T`.
             ByRef::No => expected, // As above, `T <: typeof(x)` is required, but we use equality, see (note_1).
         };
@@ -2508,7 +2562,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         expected = self.try_structurally_resolve_type(pat.span, expected);
         // Determine whether we're consuming an inherited reference and resetting the default
         // binding mode, based on edition and enabled experimental features.
-        if let ByRef::Yes(inh_mut) = pat_info.binding_mode {
+        if let ByRef::Yes(_, inh_mut) = pat_info.binding_mode {
             match self.ref_pat_matches_inherited_ref(pat.span.edition()) {
                 InheritedRefMatchRule::EatOuter => {
                     // ref pattern attempts to consume inherited reference
@@ -3029,8 +3083,8 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // If the user-provided binding modifier doesn't match the default binding mode, we'll
             // need to suggest reference patterns, which can affect other bindings.
             // For simplicity, we opt to suggest making the pattern fully explicit.
-            info.suggest_eliding_modes &=
-                user_bind_annot == BindingMode(ByRef::Yes(def_br_mutbl), Mutability::Not);
+            info.suggest_eliding_modes &= user_bind_annot
+                == BindingMode(ByRef::Yes(Pinnedness::Not, def_br_mutbl), Mutability::Not);
             "binding modifier"
         } else {
             info.bad_ref_pats = true;
diff --git a/compiler/rustc_hir_typeck/src/writeback.rs b/compiler/rustc_hir_typeck/src/writeback.rs
index 6ba7435cb790d..e9e976b1d6b1b 100644
--- a/compiler/rustc_hir_typeck/src/writeback.rs
+++ b/compiler/rustc_hir_typeck/src/writeback.rs
@@ -317,8 +317,11 @@ impl<'cx, 'tcx> Visitor<'tcx> for WritebackCx<'cx, 'tcx> {
     fn visit_pat(&mut self, p: &'tcx hir::Pat<'tcx>) {
         match p.kind {
             hir::PatKind::Binding(..) => {
-                let typeck_results = self.fcx.typeck_results.borrow();
-                let bm = typeck_results.extract_binding_mode(self.tcx().sess, p.hir_id, p.span);
+                let bm = self.fcx.typeck_results.borrow().extract_binding_mode(
+                    self.tcx().sess,
+                    p.hir_id,
+                    p.span,
+                );
                 self.typeck_results.pat_binding_modes_mut().insert(p.hir_id, bm);
             }
             hir::PatKind::Struct(_, fields, _) => {
diff --git a/compiler/rustc_lint/src/static_mut_refs.rs b/compiler/rustc_lint/src/static_mut_refs.rs
index 50021157ddab7..8f3d28ec345f2 100644
--- a/compiler/rustc_lint/src/static_mut_refs.rs
+++ b/compiler/rustc_lint/src/static_mut_refs.rs
@@ -108,7 +108,7 @@ impl<'tcx> LateLintPass<'tcx> for StaticMutRefs {
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &Stmt<'_>) {
         if let hir::StmtKind::Let(loc) = stmt.kind
             && let hir::PatKind::Binding(ba, _, _, _) = loc.pat.kind
-            && let hir::ByRef::Yes(m) = ba.0
+            && let hir::ByRef::Yes(_, m) = ba.0
             && let Some(init) = loc.init
             && let Some(err_span) = path_is_static_mut(init, init.span)
         {
diff --git a/compiler/rustc_middle/src/thir.rs b/compiler/rustc_middle/src/thir.rs
index c168142fb1ecd..b62ca2ae7f229 100644
--- a/compiler/rustc_middle/src/thir.rs
+++ b/compiler/rustc_middle/src/thir.rs
@@ -796,6 +796,11 @@ pub enum PatKind<'tcx> {
         subpattern: Box<Pat<'tcx>>,
     },
 
+    /// `&pin const P` or `&pin mut P`.
+    RefPin {
+        subpattern: Box<Pat<'tcx>>,
+    },
+
     /// Deref pattern, written `box P` for now.
     DerefPattern {
         subpattern: Box<Pat<'tcx>>,
diff --git a/compiler/rustc_middle/src/thir/visit.rs b/compiler/rustc_middle/src/thir/visit.rs
index f3da2a5cc8e4e..4152b27ba633c 100644
--- a/compiler/rustc_middle/src/thir/visit.rs
+++ b/compiler/rustc_middle/src/thir/visit.rs
@@ -261,6 +261,7 @@ pub(crate) fn for_each_immediate_subpat<'a, 'tcx>(
         PatKind::AscribeUserType { subpattern, .. }
         | PatKind::Binding { subpattern: Some(subpattern), .. }
         | PatKind::Deref { subpattern }
+        | PatKind::RefPin { subpattern }
         | PatKind::DerefPattern { subpattern, .. }
         | PatKind::ExpandedConstant { subpattern, .. } => callback(subpattern),
 
diff --git a/compiler/rustc_middle/src/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
index a61a6c571a2cd..550e5bd639644 100644
--- a/compiler/rustc_middle/src/ty/adjustment.rs
+++ b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -235,4 +235,7 @@ pub enum PatAdjust {
     /// An implicit call to `Deref(Mut)::deref(_mut)` before matching, such as when matching the
     /// pattern `[..]` against a scrutinee of type `Vec<T>`.
     OverloadedDeref,
+    /// An implicit dereference before matching a `&pin` reference (under feature `pin_ergonomics`),
+    /// which will be lowered as a builtin deref of the private field `__pointer` in `Pin`
+    PinDeref,
 }
diff --git a/compiler/rustc_middle/src/ty/adt.rs b/compiler/rustc_middle/src/ty/adt.rs
index d92b4f9c06beb..a90e13d461342 100644
--- a/compiler/rustc_middle/src/ty/adt.rs
+++ b/compiler/rustc_middle/src/ty/adt.rs
@@ -55,6 +55,8 @@ bitflags::bitflags! {
         const IS_UNSAFE_CELL              = 1 << 9;
         /// Indicates whether the type is `UnsafePinned`.
         const IS_UNSAFE_PINNED              = 1 << 10;
+        /// Indicates whether the type is `Pin`.
+        const IS_PIN                        = 1 << 11;
     }
 }
 rustc_data_structures::external_bitflags_debug! { AdtFlags }
@@ -307,6 +309,9 @@ impl AdtDefData {
         if tcx.is_lang_item(did, LangItem::UnsafePinned) {
             flags |= AdtFlags::IS_UNSAFE_PINNED;
         }
+        if tcx.is_lang_item(did, LangItem::Pin) {
+            flags |= AdtFlags::IS_PIN;
+        }
 
         AdtDefData { did, variants, flags, repr }
     }
@@ -422,6 +427,12 @@ impl<'tcx> AdtDef<'tcx> {
         self.flags().contains(AdtFlags::IS_MANUALLY_DROP)
     }
 
+    /// Returns `true` if this is `Pin<T>`.
+    #[inline]
+    pub fn is_pin(self) -> bool {
+        self.flags().contains(AdtFlags::IS_PIN)
+    }
+
     /// Returns `true` if this type has a destructor.
     pub fn has_dtor(self, tcx: TyCtxt<'tcx>) -> bool {
         self.destructor(tcx).is_some()
diff --git a/compiler/rustc_middle/src/ty/sty.rs b/compiler/rustc_middle/src/ty/sty.rs
index 301ae60457434..e6a20ca5a36c7 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1274,6 +1274,13 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    pub fn pinned_ty(self) -> Option<Ty<'tcx>> {
+        match self.kind() {
+            Adt(def, args) if def.is_pin() => Some(args.type_at(0)),
+            _ => None,
+        }
+    }
+
     /// Panics if called on any type other than `Box<T>`.
     pub fn expect_boxed_ty(self) -> Ty<'tcx> {
         self.boxed_ty()
diff --git a/compiler/rustc_middle/src/ty/typeck_results.rs b/compiler/rustc_middle/src/ty/typeck_results.rs
index 4c5c669771fb5..ca1ad08fd021e 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -462,7 +462,7 @@ impl<'tcx> TypeckResults<'tcx> {
         let mut has_ref_mut = false;
         pat.walk(|pat| {
             if let hir::PatKind::Binding(_, id, _, _) = pat.kind
-                && let Some(BindingMode(ByRef::Yes(Mutability::Mut), _)) =
+                && let Some(BindingMode(ByRef::Yes(_, Mutability::Mut), _)) =
                     self.pat_binding_modes().get(id)
             {
                 has_ref_mut = true;
diff --git a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
index d66b38c5b005c..0b9e24610bb5e 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -1,5 +1,6 @@
 use std::sync::Arc;
 
+use rustc_abi::FieldIdx;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
 use rustc_middle::ty::{self, Ty, TypeVisitableExt};
@@ -271,6 +272,20 @@ impl<'tcx> MatchPairTree<'tcx> {
                 None
             }
 
+            PatKind::RefPin { ref subpattern } => {
+                let Some(ref_ty) = pattern.ty.pinned_ty() else {
+                    rustc_middle::bug!("RefPin pattern on non-`Pin` type {:?}", pattern.ty);
+                };
+                MatchPairTree::for_pattern(
+                    place_builder.field(FieldIdx::ZERO, ref_ty).deref(),
+                    subpattern,
+                    cx,
+                    &mut subpairs,
+                    extra_data,
+                );
+                None
+            }
+
             PatKind::DerefPattern { ref subpattern, mutability } => {
                 // Create a new temporary for each deref pattern.
                 // FIXME(deref_patterns): dedup temporaries to avoid multiple `deref()` calls?
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 977d4f3e931b5..d62c69436cdce 100644
--- a/compiler/rustc_mir_build/src/builder/matches/mod.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/mod.rs
@@ -5,20 +5,20 @@
 //! This also includes code for pattern bindings in `let` statements and
 //! function parameters.
 
-use std::assert_matches::assert_matches;
+use std::assert_matches::{assert_matches, debug_assert_matches};
 use std::borrow::Borrow;
 use std::mem;
 use std::sync::Arc;
 
-use rustc_abi::VariantIdx;
+use rustc_abi::{FIRST_VARIANT, FieldIdx, VariantIdx};
 use rustc_data_structures::fx::FxIndexMap;
 use rustc_data_structures::stack::ensure_sufficient_stack;
-use rustc_hir::{BindingMode, ByRef, LetStmt, LocalSource, Node};
-use rustc_middle::bug;
+use rustc_hir::{BindingMode, ByRef, LangItem, LetStmt, LocalSource, Node};
 use rustc_middle::middle::region;
 use rustc_middle::mir::{self, *};
 use rustc_middle::thir::{self, *};
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty};
+use rustc_middle::{bug, span_bug};
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
 use tracing::{debug, instrument};
 
@@ -929,6 +929,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 visit_subpat(self, subpattern, &user_tys.deref(), f);
             }
 
+            PatKind::RefPin { ref subpattern } => {
+                visit_subpat(self, subpattern, &user_tys.leaf(FieldIdx::ZERO).deref(), f);
+            }
+
             PatKind::DerefPattern { ref subpattern, .. } => {
                 visit_subpat(self, subpattern, &ProjectedUserTypesNode::None, f);
             }
@@ -2703,7 +2707,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                     let rvalue = Rvalue::Ref(re_erased, BorrowKind::Shared, binding.source);
                     self.cfg.push_assign(block, source_info, ref_for_guard, rvalue);
                 }
-                ByRef::Yes(mutbl) => {
+                ByRef::Yes(pinnedness, mutbl) => {
                     // The arm binding will be by reference, so eagerly create it now.
                     let value_for_arm = self.storage_live_binding(
                         block,
@@ -2715,6 +2719,12 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
 
                     let rvalue =
                         Rvalue::Ref(re_erased, util::ref_pat_borrow_kind(mutbl), binding.source);
+                    let rvalue = match pinnedness {
+                        ty::Pinnedness::Not => rvalue,
+                        ty::Pinnedness::Pinned => {
+                            self.pin_borrowed_local(block, value_for_arm.local, rvalue, source_info)
+                        }
+                    };
                     self.cfg.push_assign(block, source_info, value_for_arm, rvalue);
                     // For the guard binding, take a shared reference to that reference.
                     let rvalue = Rvalue::Ref(re_erased, BorrowKind::Shared, value_for_arm);
@@ -2757,14 +2767,59 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
             }
             let rvalue = match binding.binding_mode.0 {
                 ByRef::No => Rvalue::Use(self.consume_by_copy_or_move(binding.source)),
-                ByRef::Yes(mutbl) => {
-                    Rvalue::Ref(re_erased, util::ref_pat_borrow_kind(mutbl), binding.source)
+                ByRef::Yes(pinnedness, mutbl) => {
+                    let rvalue =
+                        Rvalue::Ref(re_erased, util::ref_pat_borrow_kind(mutbl), binding.source);
+                    match pinnedness {
+                        ty::Pinnedness::Not => rvalue,
+                        ty::Pinnedness::Pinned => {
+                            self.pin_borrowed_local(block, local.local, rvalue, source_info)
+                        }
+                    }
                 }
             };
             self.cfg.push_assign(block, source_info, local, rvalue);
         }
     }
 
+    /// Given an rvalue `&[mut]borrow` and a local `local`, generate the pinned borrow for it:
+    /// ```ignore (illustrative)
+    /// pinned_temp = &borrow;
+    /// local = Pin { __pointer: move pinned_temp };
+    /// ```
+    fn pin_borrowed_local(
+        &mut self,
+        block: BasicBlock,
+        local: Local,
+        borrow: Rvalue<'tcx>,
+        source_info: SourceInfo,
+    ) -> Rvalue<'tcx> {
+        debug_assert_matches!(borrow, Rvalue::Ref(..));
+
+        let local_ty = self.local_decls[local].ty;
+
+        let pinned_ty = local_ty.pinned_ty().unwrap_or_else(|| {
+            span_bug!(
+                source_info.span,
+                "expect type `Pin` for a pinned binding, found type {:?}",
+                local_ty
+            )
+        });
+        let pinned_temp =
+            Place::from(self.local_decls.push(LocalDecl::new(pinned_ty, source_info.span)));
+        self.cfg.push_assign(block, source_info, pinned_temp, borrow);
+        Rvalue::Aggregate(
+            Box::new(AggregateKind::Adt(
+                self.tcx.require_lang_item(LangItem::Pin, Some(source_info.span)),
+                FIRST_VARIANT,
+                self.tcx.mk_args(&[pinned_ty.into()]),
+                None,
+                None,
+            )),
+            std::iter::once(Operand::Move(pinned_temp)).collect(),
+        )
+    }
+
     /// Each binding (`ref mut var`/`ref var`/`mut var`/`var`, where the bound
     /// `var` has type `T` in the arm body) in a pattern maps to 2 locals. The
     /// first local is a binding for occurrences of `var` in the guard, which
diff --git a/compiler/rustc_mir_build/src/check_unsafety.rs b/compiler/rustc_mir_build/src/check_unsafety.rs
index adfce99a9b537..686274bf09563 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -323,6 +323,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 | PatKind::Variant { .. }
                 | PatKind::Leaf { .. }
                 | PatKind::Deref { .. }
+                | PatKind::RefPin { .. }
                 | PatKind::DerefPattern { .. }
                 | PatKind::Range { .. }
                 | PatKind::Slice { .. }
@@ -377,7 +378,7 @@ impl<'a, 'tcx> Visitor<'a, 'tcx> for UnsafetyVisitor<'a, 'tcx> {
                 }
                 visit::walk_pat(self, pat);
             }
-            PatKind::Binding { mode: BindingMode(ByRef::Yes(rm), _), ty, .. } => {
+            PatKind::Binding { mode: BindingMode(ByRef::Yes(_, rm), _), ty, .. } => {
                 if self.inside_adt {
                     let ty::Ref(_, ty, _) = ty.kind() else {
                         span_bug!(
diff --git a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
index 78583a402fe9a..ad6761590957b 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -782,7 +782,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
             // 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| {
-                if matches!(mode, ByRef::Yes(_)) {
+                if matches!(mode, ByRef::Yes(..)) {
                     conflicts_ref.push(span)
                 }
             });
@@ -798,7 +798,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
             return;
         }
         ByRef::No => return,
-        ByRef::Yes(m) => m,
+        ByRef::Yes(_, m) => m,
     };
 
     // We now have `ref $mut_outer binding @ sub` (semantically).
@@ -808,7 +808,7 @@ fn check_borrow_conflicts_in_at_patterns<'tcx>(cx: &MatchVisitor<'_, 'tcx>, pat:
     let mut conflicts_mut_ref = Vec::new();
     sub.each_binding(|name, mode, ty, span| {
         match mode {
-            ByRef::Yes(mut_inner) => match (mut_outer, mut_inner) {
+            ByRef::Yes(_, mut_inner) => match (mut_outer, mut_inner) {
                 // Both sides are `ref`.
                 (Mutability::Not, Mutability::Not) => {}
                 // 2x `ref mut`.
diff --git a/compiler/rustc_mir_build/src/thir/pattern/migration.rs b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
index 12c457f13fc12..b1824575cfaea 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/migration.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/migration.rs
@@ -164,7 +164,7 @@ impl<'a> PatMigration<'a> {
         }
         if !self.info.suggest_eliding_modes
             && explicit_ba.0 == ByRef::No
-            && let ByRef::Yes(mutbl) = mode.0
+            && let ByRef::Yes(_, mutbl) = mode.0
         {
             // If we can't fix the pattern by eliding modifiers, we'll need to make the pattern
             // fully explicit. i.e. we'll need to suggest reference patterns for this.
diff --git a/compiler/rustc_mir_build/src/thir/pattern/mod.rs b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
index 8f058efdfacdb..25eeaf3d4d0ca 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -116,6 +116,7 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                         if mutable { hir::Mutability::Mut } else { hir::Mutability::Not };
                     PatKind::DerefPattern { subpattern: thir_pat, mutability }
                 }
+                PatAdjust::PinDeref => PatKind::RefPin { subpattern: thir_pat },
             };
             Box::new(Pat { span, ty: adjust.source, kind })
         });
@@ -356,11 +357,22 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                 // A ref x pattern is the same node used for x, and as such it has
                 // x's type, which is &T, where we want T (the type being matched).
                 let var_ty = ty;
-                if let hir::ByRef::Yes(_) = mode.0 {
-                    if let ty::Ref(_, rty, _) = ty.kind() {
-                        ty = *rty;
-                    } else {
-                        bug!("`ref {}` has wrong type {}", ident, ty);
+                if let hir::ByRef::Yes(pinnedness, _) = mode.0 {
+                    match pinnedness {
+                        hir::Pinnedness::Pinned
+                            if let Some(pty) = ty.pinned_ty()
+                                && let &ty::Ref(_, rty, _) = pty.kind() =>
+                        {
+                            debug_assert!(
+                                self.tcx.features().pin_ergonomics(),
+                                "`pin_ergonomics` must be enabled to have a by-pin-ref binding"
+                            );
+                            ty = rty;
+                        }
+                        hir::Pinnedness::Not if let &ty::Ref(_, rty, _) = ty.kind() => {
+                            ty = rty;
+                        }
+                        _ => bug!("`ref {}` has wrong type {}", ident, ty),
                     }
                 };
 
diff --git a/compiler/rustc_mir_build/src/thir/print.rs b/compiler/rustc_mir_build/src/thir/print.rs
index 37248941e2c45..240bdc964272e 100644
--- a/compiler/rustc_mir_build/src/thir/print.rs
+++ b/compiler/rustc_mir_build/src/thir/print.rs
@@ -730,6 +730,12 @@ impl<'a, 'tcx> ThirPrinter<'a, 'tcx> {
                 self.print_pat(subpattern, depth_lvl + 2);
                 print_indented!(self, "}", depth_lvl + 1);
             }
+            PatKind::RefPin { subpattern } => {
+                print_indented!(self, "PinRef { ", depth_lvl + 1);
+                print_indented!(self, "subpattern:", depth_lvl + 2);
+                self.print_pat(subpattern, depth_lvl + 2);
+                print_indented!(self, "}", depth_lvl + 1);
+            }
             PatKind::DerefPattern { subpattern, .. } => {
                 print_indented!(self, "DerefPattern { ", depth_lvl + 1);
                 print_indented!(self, "subpattern:", depth_lvl + 2);
diff --git a/compiler/rustc_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 2221a261b4c59..3f0b0ec9c809f 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -30,8 +30,8 @@ use rustc_ast::tokenstream::{AttrsTarget, Spacing, TokenStream, TokenTree};
 use rustc_ast::util::case::Case;
 use rustc_ast::{
     self as ast, AnonConst, AttrArgs, AttrId, ByRef, Const, CoroutineKind, DUMMY_NODE_ID,
-    DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Recovered, Safety, StrLit,
-    Visibility, VisibilityKind,
+    DelimArgs, Expr, ExprKind, Extern, HasAttrs, HasTokens, Mutability, Pinnedness, Recovered,
+    Safety, StrLit, Visibility, VisibilityKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_data_structures::fx::FxHashMap;
@@ -1425,7 +1425,11 @@ impl<'a> Parser<'a> {
 
     /// Parses reference binding mode (`ref`, `ref mut`, or nothing).
     fn parse_byref(&mut self) -> ByRef {
-        if self.eat_keyword(exp!(Ref)) { ByRef::Yes(self.parse_mutability()) } else { ByRef::No }
+        if self.eat_keyword(exp!(Ref)) {
+            ByRef::Yes(Pinnedness::Not, self.parse_mutability())
+        } else {
+            ByRef::No
+        }
     }
 
     /// Possibly parses mutability (`const` or `mut`).
diff --git a/compiler/rustc_parse/src/parser/pat.rs b/compiler/rustc_parse/src/parser/pat.rs
index d5f469f9aa9ef..5fa2046275b86 100644
--- a/compiler/rustc_parse/src/parser/pat.rs
+++ b/compiler/rustc_parse/src/parser/pat.rs
@@ -8,7 +8,8 @@ use rustc_ast::util::parser::ExprPrecedence;
 use rustc_ast::visit::{self, Visitor};
 use rustc_ast::{
     self as ast, Arm, AttrVec, BindingMode, ByRef, Expr, ExprKind, LocalKind, MacCall, Mutability,
-    Pat, PatField, PatFieldsRest, PatKind, Path, QSelf, RangeEnd, RangeSyntax, Stmt, StmtKind,
+    Pat, PatField, PatFieldsRest, PatKind, Path, Pinnedness, QSelf, RangeEnd, RangeSyntax, Stmt,
+    StmtKind,
 };
 use rustc_ast_pretty::pprust;
 use rustc_errors::{Applicability, Diag, DiagArgValue, PResult, StashKey};
@@ -776,7 +777,11 @@ impl<'a> Parser<'a> {
             }
             // Parse ref ident @ pat / ref mut ident @ pat
             let mutbl = self.parse_mutability();
-            self.parse_pat_ident(BindingMode(ByRef::Yes(mutbl), Mutability::Not), syntax_loc)?
+            self.parse_pat_ident(
+                // FIXME(pin_ergonomics): support `ref pin const|mut` bindings
+                BindingMode(ByRef::Yes(Pinnedness::Not, mutbl), Mutability::Not),
+                syntax_loc,
+            )?
         } else if self.eat_keyword(exp!(Box)) {
             self.parse_pat_box()?
         } else if self.check_inline_const(0) {
@@ -1083,7 +1088,7 @@ impl<'a> Parser<'a> {
             self.ban_mut_general_pat(mut_span, &pat, changed_any_binding);
         }
 
-        if matches!(pat.kind, PatKind::Ident(BindingMode(ByRef::Yes(_), Mutability::Mut), ..)) {
+        if matches!(pat.kind, PatKind::Ident(BindingMode(ByRef::Yes(..), Mutability::Mut), ..)) {
             self.psess.gated_spans.gate(sym::mut_ref, pat.span);
         }
         Ok(pat.into_inner().kind)
diff --git a/compiler/rustc_pattern_analysis/src/constructor.rs b/compiler/rustc_pattern_analysis/src/constructor.rs
index 4ce868f014f42..0169e960dc631 100644
--- a/compiler/rustc_pattern_analysis/src/constructor.rs
+++ b/compiler/rustc_pattern_analysis/src/constructor.rs
@@ -681,6 +681,8 @@ pub enum Constructor<Cx: PatCx> {
     Variant(Cx::VariantIdx),
     /// References
     Ref,
+    /// Pinned references (enabled by the `pin_ergonomics` feature)
+    RefPin,
     /// Array and slice patterns.
     Slice(Slice),
     /// Union field accesses.
@@ -731,6 +733,7 @@ impl<Cx: PatCx> Clone for Constructor<Cx> {
             Constructor::Struct => Constructor::Struct,
             Constructor::Variant(idx) => Constructor::Variant(*idx),
             Constructor::Ref => Constructor::Ref,
+            Constructor::RefPin => Constructor::RefPin,
             Constructor::Slice(slice) => Constructor::Slice(*slice),
             Constructor::UnionField => Constructor::UnionField,
             Constructor::Bool(b) => Constructor::Bool(*b),
@@ -809,6 +812,7 @@ impl<Cx: PatCx> Constructor<Cx> {
 
             (Struct, Struct) => true,
             (Ref, Ref) => true,
+            (RefPin, RefPin) => true,
             (UnionField, UnionField) => true,
             (Variant(self_id), Variant(other_id)) => self_id == other_id,
             (Bool(self_b), Bool(other_b)) => self_b == other_b,
@@ -904,6 +908,9 @@ impl<Cx: PatCx> Constructor<Cx> {
             Ref => {
                 write!(f, "&{:?}", fields.next().unwrap())?;
             }
+            RefPin => {
+                write!(f, "&pin {:?}", fields.next().unwrap())?;
+            }
             Slice(slice) => {
                 write!(f, "[")?;
                 match slice.kind {
@@ -972,8 +979,10 @@ pub enum ConstructorSet<Cx: PatCx> {
     /// This type has the following list of constructors. If `variants` is empty and
     /// `non_exhaustive` is false, don't use this; use `NoConstructors` instead.
     Variants { variants: IndexVec<Cx::VariantIdx, VariantVisibility>, non_exhaustive: bool },
-    /// The type is `&T`.
+    /// The type is `&T`
     Ref,
+    /// The type is `&pin T`
+    RefPin,
     /// The type is a union.
     Union,
     /// Booleans.
@@ -1064,6 +1073,13 @@ impl<Cx: PatCx> ConstructorSet<Cx> {
                     missing.push(Ref);
                 }
             }
+            ConstructorSet::RefPin => {
+                if !seen.is_empty() {
+                    present.push(RefPin);
+                } else {
+                    missing.push(RefPin);
+                }
+            }
             ConstructorSet::Union => {
                 if !seen.is_empty() {
                     present.push(UnionField);
@@ -1180,6 +1196,7 @@ impl<Cx: PatCx> ConstructorSet<Cx> {
             ConstructorSet::Bool
             | ConstructorSet::Integers { .. }
             | ConstructorSet::Ref
+            | ConstructorSet::RefPin
             | ConstructorSet::Union
             | ConstructorSet::Unlistable => false,
             ConstructorSet::NoConstructors => true,
diff --git a/compiler/rustc_pattern_analysis/src/rustc.rs b/compiler/rustc_pattern_analysis/src/rustc.rs
index 7c12f69f14c1a..327d261ca110a 100644
--- a/compiler/rustc_pattern_analysis/src/rustc.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc.rs
@@ -239,6 +239,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                         // The only legal patterns of type `Box` (outside `std`) are `_` and box
                         // patterns. If we're here we can assume this is a box pattern.
                         reveal_and_alloc(cx, once(args.type_at(0)))
+                    } else if adt.is_pin()
+                        && let ty::Ref(_, rty, _) = args.type_at(0).kind()
+                        && self.tcx.features().pin_ergonomics()
+                    {
+                        reveal_and_alloc(cx, once(*rty))
                     } else {
                         let variant =
                             &adt.variant(RustcPatCtxt::variant_index_for_adt(&ctor, *adt));
@@ -262,6 +267,10 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 ty::Ref(_, rty, _) => reveal_and_alloc(cx, once(*rty)),
                 _ => bug!("Unexpected type for `Ref` constructor: {ty:?}"),
             },
+            RefPin => match ty.pinned_ty().map(|ty| ty.kind()) {
+                Some(ty::Ref(_, rty, _)) => reveal_and_alloc(cx, once(*rty)),
+                _ => bug!("Unexpected type for `RefPin` constructor: {ty:?}"),
+            },
             Slice(slice) => match *ty.kind() {
                 ty::Slice(ty) | ty::Array(ty, _) => {
                     let arity = slice.arity();
@@ -296,7 +305,7 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 }
                 _ => bug!("Unexpected type for constructor `{ctor:?}`: {ty:?}"),
             },
-            Ref => 1,
+            Ref | RefPin => 1,
             Slice(slice) => slice.arity(),
             Bool(..) | IntRange(..) | F16Range(..) | F32Range(..) | F64Range(..)
             | F128Range(..) | Str(..) | Opaque(..) | Never | NonExhaustive | Hidden | Missing
@@ -373,6 +382,13 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     subtype_is_empty: cx.is_uninhabited(*sub_ty),
                 }
             }
+            ty::Adt(adt, args)
+                if adt.is_pin()
+                    && args.type_at(0).is_ref()
+                    && self.tcx.features().pin_ergonomics() =>
+            {
+                ConstructorSet::RefPin
+            }
             ty::Adt(def, args) if def.is_enum() => {
                 let is_declared_nonexhaustive = cx.is_foreign_non_exhaustive_enum(ty);
                 if def.variants().is_empty() && !is_declared_nonexhaustive {
@@ -484,6 +500,14 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 ctor = match ty.kind() {
                     // This is a box pattern.
                     ty::Adt(adt, ..) if adt.is_box() => Struct,
+                    // This is a pin ref pattern.
+                    ty::Adt(adt, args)
+                        if adt.is_pin()
+                            && args.type_at(0).is_ref()
+                            && self.tcx.features().pin_ergonomics() =>
+                    {
+                        todo!()
+                    }
                     ty::Ref(..) => Ref,
                     _ => span_bug!(
                         pat.span,
@@ -493,6 +517,11 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                     ),
                 };
             }
+            PatKind::RefPin { subpattern } => {
+                fields = vec![self.lower_pat(subpattern).at_index(0)];
+                arity = 1;
+                ctor = RefPin;
+            }
             PatKind::DerefPattern { .. } => {
                 // FIXME(deref_patterns): At least detect that `box _` is irrefutable.
                 fields = vec![];
@@ -874,6 +903,12 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                 print::write_ref_like(&mut s, pat.ty().inner(), &print(&pat.fields[0])).unwrap();
                 s
             }
+            RefPin => {
+                let mut s = String::new();
+                print::write_ref_pin_like(&mut s, pat.ty().inner(), &print(&pat.fields[0]))
+                    .unwrap();
+                s
+            }
             Slice(slice) => {
                 let (prefix_len, has_dot_dot) = match slice.kind {
                     SliceKind::FixedLen(len) => (len, false),
diff --git a/compiler/rustc_pattern_analysis/src/rustc/print.rs b/compiler/rustc_pattern_analysis/src/rustc/print.rs
index 7649f72f8681b..4126d8602431b 100644
--- a/compiler/rustc_pattern_analysis/src/rustc/print.rs
+++ b/compiler/rustc_pattern_analysis/src/rustc/print.rs
@@ -139,6 +139,21 @@ pub(crate) fn write_ref_like<'tcx>(
     write!(f, "{subpattern}")
 }
 
+pub(crate) fn write_ref_pin_like<'tcx>(
+    f: &mut impl fmt::Write,
+    ty: Ty<'tcx>,
+    subpattern: &str,
+) -> fmt::Result {
+    if let Some(ty) = ty.pinned_ty()
+        && let ty::Ref(_, _, mutbl) = ty.kind()
+    {
+        write!(f, "&pin {} ", mutbl.ptr_str())?;
+    } else {
+        bug!("{ty} is a bad ref pin pattern type");
+    }
+    write!(f, "{subpattern}")
+}
+
 pub(crate) fn write_slice_like(
     f: &mut impl fmt::Write,
     prefix: &[String],
diff --git a/compiler/rustc_pattern_analysis/src/usefulness.rs b/compiler/rustc_pattern_analysis/src/usefulness.rs
index 11ebbea07fa4e..6162d15e04498 100644
--- a/compiler/rustc_pattern_analysis/src/usefulness.rs
+++ b/compiler/rustc_pattern_analysis/src/usefulness.rs
@@ -866,7 +866,7 @@ impl PlaceValidity {
     /// inside `&` and union fields where validity is reset to `MaybeInvalid`.
     fn specialize<Cx: PatCx>(self, ctor: &Constructor<Cx>) -> Self {
         // We preserve validity except when we go inside a reference or a union field.
-        if matches!(ctor, Constructor::Ref | Constructor::UnionField) {
+        if matches!(ctor, Constructor::Ref | Constructor::RefPin | Constructor::UnionField) {
             // Validity of `x: &T` does not imply validity of `*x: T`.
             MaybeInvalid
         } else {
diff --git a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
index 989997d69f7c7..8e54020ded3bc 100644
--- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
@@ -94,7 +94,7 @@ fn find_slice_values(cx: &LateContext<'_>, pat: &hir::Pat<'_>) -> FxIndexMap<Hir
         // We'll just ignore mut and ref mut for simplicity sake right now
         if let hir::PatKind::Binding(hir::BindingMode(by_ref, hir::Mutability::Not), value_hir_id, ident, sub_pat) =
             pat.kind
-            && by_ref != hir::ByRef::Yes(hir::Mutability::Mut)
+            && !matches!(by_ref, hir::ByRef::Yes(_, hir::Mutability::Mut))
         {
             // This block catches bindings with sub patterns. It would be hard to build a correct suggestion
             // for them and it's likely that the user knows what they are doing in such a case.
diff --git a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
index 1cb4b512a30e5..f07644d3ee31c 100644
--- a/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/match_as_ref.rs
@@ -59,7 +59,7 @@ pub(crate) fn check(cx: &LateContext<'_>, ex: &Expr<'_>, arms: &[Arm<'_>], expr:
 fn is_ref_some_arm(cx: &LateContext<'_>, arm: &Arm<'_>) -> Option<Mutability> {
     if let PatKind::TupleStruct(ref qpath, [first_pat, ..], _) = arm.pat.kind
         && is_res_lang_ctor(cx, cx.qpath_res(qpath, arm.pat.hir_id), LangItem::OptionSome)
-        && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., ident, _) = first_pat.kind
+        && let PatKind::Binding(BindingMode(ByRef::Yes(_, mutabl), _), .., ident, _) = first_pat.kind
         && let ExprKind::Call(e, [arg]) = peel_blocks(arm.body).kind
         && is_res_lang_ctor(cx, path_res(cx, e), LangItem::OptionSome)
         && let ExprKind::Path(QPath::Resolved(_, path2)) = arg.kind
diff --git a/src/tools/clippy/clippy_lints/src/matches/needless_match.rs b/src/tools/clippy/clippy_lints/src/matches/needless_match.rs
index 7e65d586110e5..398ea946ad779 100644
--- a/src/tools/clippy/clippy_lints/src/matches/needless_match.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/needless_match.rs
@@ -182,7 +182,7 @@ fn pat_same_as_expr(pat: &Pat<'_>, expr: &Expr<'_>) -> bool {
                 },
             )),
         ) => {
-            return !matches!(annot, BindingMode(ByRef::Yes(_), _)) && pat_ident.name == first_seg.ident.name;
+            return !matches!(annot, BindingMode(ByRef::Yes(..), _)) && pat_ident.name == first_seg.ident.name;
         },
         // Example: `Custom::TypeA => Custom::TypeB`, or `None => None`
         (
diff --git a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
index 9bbef8da0a466..0e37be9835ac2 100644
--- a/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/redundant_guards.rs
@@ -175,7 +175,7 @@ fn get_pat_binding<'tcx>(
             if let PatKind::Binding(bind_annot, hir_id, ident, _) = pat.kind
                 && hir_id == local
             {
-                if matches!(bind_annot.0, rustc_ast::ByRef::Yes(_)) {
+                if matches!(bind_annot.0, rustc_ast::ByRef::Yes(..)) {
                     let _ = byref_ident.insert(ident);
                 }
                 // the second call of `replace()` returns a `Some(span)`, meaning a multi-binding pattern
diff --git a/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs b/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs
index 1ee27d90d0545..5bc7a8aa24cab 100644
--- a/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs
+++ b/src/tools/clippy/clippy_lints/src/methods/clone_on_copy.rs
@@ -69,7 +69,7 @@ pub(super) fn check(
                 _ => false,
             },
             // local binding capturing a reference
-            Node::LetStmt(l) if matches!(l.pat.kind, PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..)) => {
+            Node::LetStmt(l) if matches!(l.pat.kind, PatKind::Binding(BindingMode(ByRef::Yes(..), _), ..)) => {
                 return;
             },
             _ => false,
diff --git a/src/tools/clippy/clippy_lints/src/misc.rs b/src/tools/clippy/clippy_lints/src/misc.rs
index 09ee6f7037c64..a79b20903bc7c 100644
--- a/src/tools/clippy/clippy_lints/src/misc.rs
+++ b/src/tools/clippy/clippy_lints/src/misc.rs
@@ -158,7 +158,7 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
     ) {
         if !matches!(k, FnKind::Closure) {
             for arg in iter_input_pats(decl, body) {
-                if let PatKind::Binding(BindingMode(ByRef::Yes(_), _), ..) = arg.pat.kind
+                if let PatKind::Binding(BindingMode(ByRef::Yes(..), _), ..) = arg.pat.kind
                     && is_lint_allowed(cx, REF_PATTERNS, arg.pat.hir_id)
                     && !arg.span.in_external_macro(cx.tcx.sess.source_map())
                 {
@@ -177,7 +177,7 @@ impl<'tcx> LateLintPass<'tcx> for LintPass {
 
     fn check_stmt(&mut self, cx: &LateContext<'tcx>, stmt: &'tcx Stmt<'_>) {
         if let StmtKind::Let(local) = stmt.kind
-            && let PatKind::Binding(BindingMode(ByRef::Yes(mutabl), _), .., name, None) = local.pat.kind
+            && let PatKind::Binding(BindingMode(ByRef::Yes(_,mutabl), _), .., name, None) = local.pat.kind
             && let Some(init) = local.init
             // Do not emit if clippy::ref_patterns is not allowed to avoid having two lints for the same issue.
             && is_lint_allowed(cx, REF_PATTERNS, local.pat.hir_id)
diff --git a/src/tools/clippy/clippy_lints/src/question_mark.rs b/src/tools/clippy/clippy_lints/src/question_mark.rs
index a80e1f79bbc77..bad8fc415d783 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -147,7 +147,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         let init_expr_str = snippet_with_applicability(cx, init_expr.span, "..", &mut applicability);
         // Take care when binding is `ref`
         let sugg = if let PatKind::Binding(
-            BindingMode(ByRef::Yes(ref_mutability), binding_mutability),
+            BindingMode(ByRef::Yes(_,ref_mutability), binding_mutability),
             _hir_id,
             ident,
             subpattern,
@@ -166,7 +166,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
             // Handle subpattern (@ subpattern)
             let maybe_subpattern = match subpattern {
                 Some(Pat {
-                    kind: PatKind::Binding(BindingMode(ByRef::Yes(_), _), _, subident, None),
+                    kind: PatKind::Binding(BindingMode(ByRef::Yes(..), _), _, subident, None),
                     ..
                 }) => {
                     // avoid `&ref`
@@ -475,8 +475,8 @@ fn check_if_let_some_or_err_and_early_return<'tcx>(cx: &LateContext<'tcx>, expr:
         let receiver_str = snippet_with_applicability(cx, let_expr.span, "..", &mut applicability);
         let requires_semi = matches!(cx.tcx.parent_hir_node(expr.hir_id), Node::Stmt(_));
         let method_call_str = match by_ref {
-            ByRef::Yes(Mutability::Mut) => ".as_mut()",
-            ByRef::Yes(Mutability::Not) => ".as_ref()",
+            ByRef::Yes(_, Mutability::Mut) => ".as_mut()",
+            ByRef::Yes(_, Mutability::Not) => ".as_ref()",
             ByRef::No => "",
         };
         let sugg = format!(
diff --git a/src/tools/clippy/clippy_lints/src/utils/author.rs b/src/tools/clippy/clippy_lints/src/utils/author.rs
index b7dcd2ffb0eea..1d4509946c15f 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -685,10 +685,14 @@ impl<'a, 'tcx> PrintVisitor<'a, 'tcx> {
                 let ann = match ann {
                     BindingMode::NONE => "NONE",
                     BindingMode::REF => "REF",
+                    BindingMode::REF_PIN => "REF_PIN",
                     BindingMode::MUT => "MUT",
                     BindingMode::REF_MUT => "REF_MUT",
+                    BindingMode::REF_PIN_MUT => "REF_PIN_MUT",
                     BindingMode::MUT_REF => "MUT_REF",
+                    BindingMode::MUT_REF_PIN => "MUT_REF_PIN",
                     BindingMode::MUT_REF_MUT => "MUT_REF_MUT",
+                    BindingMode::MUT_REF_PIN_MUT => "MUT_REF_PIN_MUT",
                 };
                 kind!("Binding(BindingMode::{ann}, _, {name}, {sub})");
                 self.ident(name);
diff --git a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
index 4543a20cc2cd4..db8653ee36e7c 100644
--- a/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
+++ b/src/tools/clippy/clippy_utils/src/eager_or_lazy.rs
@@ -212,7 +212,12 @@ fn expr_eagerness<'tcx>(cx: &LateContext<'tcx>, e: &'tcx Expr<'_>) -> EagernessS
 
                 // Custom `Deref` impl might have side effects
                 ExprKind::Unary(UnOp::Deref, e)
-                    if self.cx.typeck_results().expr_ty(e).builtin_deref(true).is_none() =>
+                    if self
+                        .cx
+                        .typeck_results()
+                        .expr_ty(e)
+                        .builtin_deref(true)
+                        .is_none() =>
                 {
                     self.eagerness |= NoChange;
                 },
diff --git a/src/tools/clippy/clippy_utils/src/lib.rs b/src/tools/clippy/clippy_utils/src/lib.rs
index f715fc86e4e5d..9b7107e8210cb 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -1177,7 +1177,7 @@ pub fn capture_local_usage(cx: &LateContext<'_>, e: &Expr<'_>) -> CaptureKind {
             ByRef::No if !is_copy(cx, cx.typeck_results().node_type(id)) => {
                 capture = CaptureKind::Value;
             },
-            ByRef::Yes(Mutability::Mut) if capture != CaptureKind::Value => {
+            ByRef::Yes(_, Mutability::Mut) if capture != CaptureKind::Value => {
                 capture = CaptureKind::Ref(Mutability::Mut);
             },
             _ => (),
@@ -2195,7 +2195,7 @@ fn is_body_identity_function(cx: &LateContext<'_>, func: &Body<'_>) -> bool {
             .typeck_results()
             .pat_binding_modes()
             .get(pat.hir_id)
-            .is_some_and(|mode| matches!(mode.0, ByRef::Yes(_)))
+            .is_some_and(|mode| matches!(mode.0, ByRef::Yes(..)))
         {
             // If a tuple `(x, y)` is of type `&(i32, i32)`, then due to match ergonomics,
             // the inner patterns become references. Don't consider this the identity function
diff --git a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
index 18a5a0612bb06..dbce919519e82 100644
--- a/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/stacked_borrows/mod.rs
@@ -127,7 +127,7 @@ impl NewPermission {
 
     fn from_box_ty<'tcx>(ty: Ty<'tcx>, kind: RetagKind, cx: &crate::MiriInterpCx<'tcx>) -> Self {
         // `ty` is not the `Box` but the field of the Box with this pointer (due to allocator handling).
-        let pointee = ty.builtin_deref(true).unwrap();
+        let pointee = ty.builtin_deref(true, *cx.tcx).unwrap();
         if pointee.is_unpin(*cx.tcx, cx.typing_env()) {
             // A regular box. On `FnEntry` this is `noalias`, but not `dereferenceable` (hence only
             // a weak protector).
diff --git a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
index f39a606513d5c..6f771d8b2029a 100644
--- a/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
+++ b/src/tools/miri/src/borrow_tracker/tree_borrows/mod.rs
@@ -164,7 +164,7 @@ impl<'tcx> NewPermission {
         cx: &crate::MiriInterpCx<'tcx>,
         zero_size: bool,
     ) -> Option<Self> {
-        let pointee = ty.builtin_deref(true).unwrap();
+        let pointee = ty.builtin_deref(true, *cx.tcx).unwrap();
         pointee.is_unpin(*cx.tcx, cx.typing_env()).then_some(()).map(|()| {
             // Regular `Unpin` box, give it `noalias` but only a weak protector
             // because it is valid to deallocate it within the function.
diff --git a/src/tools/miri/src/intrinsics/simd.rs b/src/tools/miri/src/intrinsics/simd.rs
index de5da6ec898a4..c520e58031b51 100644
--- a/src/tools/miri/src/intrinsics/simd.rs
+++ b/src/tools/miri/src/intrinsics/simd.rs
@@ -275,7 +275,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                         Op::WrappingOffset => {
                             let ptr = left.to_scalar().to_pointer(this)?;
                             let offset_count = right.to_scalar().to_target_isize(this)?;
-                            let pointee_ty = left.layout.ty.builtin_deref(true).unwrap();
+                            let pointee_ty = left.layout.ty.builtin_deref(true, *this.tcx).unwrap();
 
                             let pointee_size = i64::try_from(this.layout_of(pointee_ty)?.size.bytes()).unwrap();
                             let offset_bytes = offset_count.wrapping_mul(pointee_size);
diff --git a/src/tools/miri/src/shims/unix/foreign_items.rs b/src/tools/miri/src/shims/unix/foreign_items.rs
index 5e6259c35744b..3edd9d762f4ae 100644
--- a/src/tools/miri/src/shims/unix/foreign_items.rs
+++ b/src/tools/miri/src/shims/unix/foreign_items.rs
@@ -469,7 +469,7 @@ pub trait EvalContextExt<'tcx>: crate::MiriInterpCxExt<'tcx> {
                 // Figure out how large a pthread TLS key actually is.
                 // To this end, deref the argument type. This is `libc::pthread_key_t`.
                 let key_type = key.layout.ty
-                    .builtin_deref(true)
+                    .builtin_deref(true, *this.tcx)
                     .ok_or_else(|| err_ub_format!(
                         "wrong signature used for `pthread_key_create`: first argument must be a raw pointer."
                     ))?;
diff --git a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
index 91eb59fb3140f..5f45993d4ae68 100644
--- a/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
+++ b/src/tools/rust-analyzer/crates/hir-ty/src/diagnostics/match_check/pat_analysis.rs
@@ -165,7 +165,7 @@ impl<'db> MatchCheckCtx<'db> {
                 ctor = match pat.ty.kind(Interner) {
                     // This is a box pattern.
                     TyKind::Adt(adt, _) if is_box(self.db, adt.0) => Struct,
-                    TyKind::Ref(..) => Ref,
+                    TyKind::Ref(..) => Ref(rustc_ast_ir::Pinnedness::Not),
                     _ => {
                         never!("pattern has unexpected type: pat: {:?}, ty: {:?}", pat, &pat.ty);
                         Wildcard
@@ -349,7 +349,7 @@ impl PatCx for MatchCheckCtx<'_> {
                     0
                 }
             },
-            Ref => 1,
+            Ref(_) => 1,
             Slice(..) => unimplemented!(),
             Never | Bool(..) | IntRange(..) | F16Range(..) | F32Range(..) | F64Range(..)
             | F128Range(..) | Str(..) | Opaque(..) | NonExhaustive | PrivateUninhabited
@@ -404,7 +404,7 @@ impl PatCx for MatchCheckCtx<'_> {
                     single(ty.clone())
                 }
             },
-            Ref => match ty.kind(Interner) {
+            Ref(_) => match ty.kind(Interner) {
                 TyKind::Ref(.., rty) => single(rty.clone()),
                 ty_kind => {
                     never!("Unexpected type for `{:?}` constructor: {:?}", ctor, ty_kind);
@@ -474,7 +474,7 @@ impl PatCx for MatchCheckCtx<'_> {
             TyKind::Adt(..) | TyKind::Tuple(..) => {
                 ConstructorSet::Struct { empty: cx.is_uninhabited(ty) }
             }
-            TyKind::Ref(..) => ConstructorSet::Ref,
+            TyKind::Ref(..) => ConstructorSet::Ref(rustc_ast_ir::Pinnedness::Not),
             TyKind::Never => ConstructorSet::NoConstructors,
             // This type is one for which we cannot list constructors, like `str` or `f64`.
             _ => ConstructorSet::Unlistable,
diff --git a/src/tools/rustfmt/src/patterns.rs b/src/tools/rustfmt/src/patterns.rs
index cb3879f4be8c9..50aa99fe3d7c2 100644
--- a/src/tools/rustfmt/src/patterns.rs
+++ b/src/tools/rustfmt/src/patterns.rs
@@ -135,7 +135,7 @@ impl Rewrite for Pat {
                 let mut_prefix = format_mutability(mutability).trim();
 
                 let (ref_kw, mut_infix) = match by_ref {
-                    ByRef::Yes(rmutbl) => ("ref", format_mutability(rmutbl).trim()),
+                    ByRef::Yes(_, rmutbl) => ("ref", format_mutability(rmutbl).trim()),
                     ByRef::No => ("", ""),
                 };
                 let id_str = rewrite_ident(context, ident);
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_const.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_const.built.after.mir
new file mode 100644
index 0000000000000..15f7446cc5912
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_const.built.after.mir
@@ -0,0 +1,33 @@
+// MIR for `bar_const` after built
+
+fn bar_const(_1: Pin<&Bar<T, U>>) -> () {
+    debug bar => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&T>;
+    let _3: std::pin::Pin<&U>;
+    let mut _4: &T;
+    let mut _5: &U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _4 = &((*(_1.0: &Bar<T, U>)).0: T);
+        _2 = Pin::<&T> { pointer: move _4 };
+        StorageLive(_3);
+        _5 = &((*(_1.0: &Bar<T, U>)).1: U);
+        _3 = Pin::<&U> { pointer: move _5 };
+        _0 = const ();
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_mut.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_mut.built.after.mir
new file mode 100644
index 0000000000000..46fd15502ffb1
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.bar_mut.built.after.mir
@@ -0,0 +1,33 @@
+// MIR for `bar_mut` after built
+
+fn bar_mut(_1: Pin<&mut Bar<T, U>>) -> () {
+    debug bar => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&mut T>;
+    let _3: std::pin::Pin<&mut U>;
+    let mut _4: &mut T;
+    let mut _5: &mut U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _4 = &mut ((*(_1.0: &mut Bar<T, U>)).0: T);
+        _2 = Pin::<&mut T> { pointer: move _4 };
+        StorageLive(_3);
+        _5 = &mut ((*(_1.0: &mut Bar<T, U>)).1: U);
+        _3 = Pin::<&mut U> { pointer: move _5 };
+        _0 = const ();
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_const.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_const.built.after.mir
new file mode 100644
index 0000000000000..8cfaf50a5f876
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_const.built.after.mir
@@ -0,0 +1,422 @@
+// MIR for `baz_baz_const` after built
+
+fn baz_baz_const(_1: Pin<&Baz<Baz<T, U>, Baz<T, U>>>) -> () {
+    debug baz => _1;
+    let mut _0: ();
+    let mut _2: isize;
+    let mut _3: isize;
+    let mut _4: isize;
+    let mut _5: isize;
+    let mut _6: isize;
+    let mut _7: isize;
+    let mut _8: isize;
+    let _9: std::pin::Pin<&T>;
+    let _10: std::pin::Pin<&U>;
+    let _11: std::pin::Pin<&T>;
+    let _12: std::pin::Pin<&U>;
+    let mut _13: &T;
+    let mut _14: &U;
+    let mut _15: &T;
+    let mut _16: &U;
+    let _17: std::pin::Pin<&T>;
+    let _18: std::pin::Pin<&U>;
+    let _19: std::pin::Pin<&T>;
+    let _20: std::pin::Pin<&U>;
+    let mut _21: &T;
+    let mut _22: &U;
+    let mut _23: &T;
+    let mut _24: &U;
+    let _25: std::pin::Pin<&T>;
+    let _26: std::pin::Pin<&U>;
+    let _27: std::pin::Pin<&T>;
+    let _28: std::pin::Pin<&U>;
+    let mut _29: &T;
+    let mut _30: &U;
+    let mut _31: &T;
+    let mut _32: &U;
+    let _33: std::pin::Pin<&T>;
+    let _34: std::pin::Pin<&U>;
+    let _35: std::pin::Pin<&T>;
+    let _36: std::pin::Pin<&U>;
+    let mut _37: &T;
+    let mut _38: &U;
+    let mut _39: &T;
+    let mut _40: &U;
+    let _41: std::pin::Pin<&T>;
+    let _42: std::pin::Pin<&U>;
+    let _43: std::pin::Pin<&T>;
+    let _44: std::pin::Pin<&U>;
+    let mut _45: &T;
+    let mut _46: &U;
+    let mut _47: &T;
+    let mut _48: &U;
+    let _49: std::pin::Pin<&T>;
+    let _50: std::pin::Pin<&U>;
+    let _51: std::pin::Pin<&T>;
+    let _52: std::pin::Pin<&U>;
+    let mut _53: &T;
+    let mut _54: &U;
+    let mut _55: &T;
+    let mut _56: &U;
+    let _57: std::pin::Pin<&T>;
+    let _58: std::pin::Pin<&U>;
+    let _59: std::pin::Pin<&T>;
+    let _60: std::pin::Pin<&U>;
+    let mut _61: &T;
+    let mut _62: &U;
+    let mut _63: &T;
+    let mut _64: &U;
+    let _65: std::pin::Pin<&T>;
+    let _66: std::pin::Pin<&U>;
+    let _67: std::pin::Pin<&T>;
+    let _68: std::pin::Pin<&U>;
+    let mut _69: &T;
+    let mut _70: &U;
+    let mut _71: &T;
+    let mut _72: &U;
+    scope 1 {
+        debug x => _9;
+        debug y => _10;
+        debug z => _11;
+        debug w => _12;
+    }
+    scope 2 {
+        debug x => _17;
+        debug y => _18;
+        debug z => _19;
+        debug w => _20;
+    }
+    scope 3 {
+        debug x => _25;
+        debug y => _26;
+        debug z => _27;
+        debug w => _28;
+    }
+    scope 4 {
+        debug x => _33;
+        debug y => _34;
+        debug z => _35;
+        debug w => _36;
+    }
+    scope 5 {
+        debug x => _41;
+        debug y => _42;
+        debug z => _43;
+        debug w => _44;
+    }
+    scope 6 {
+        debug x => _49;
+        debug y => _50;
+        debug z => _51;
+        debug w => _52;
+    }
+    scope 7 {
+        debug x => _57;
+        debug y => _58;
+        debug z => _59;
+        debug w => _60;
+    }
+    scope 8 {
+        debug x => _65;
+        debug y => _66;
+        debug z => _67;
+        debug w => _68;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _8 = discriminant((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)));
+        switchInt(move _8) -> [0: bb2, 1: bb16, otherwise: bb1];
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+
+    bb2: {
+        _4 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>));
+        switchInt(move _4) -> [0: bb4, 1: bb10, otherwise: bb3];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        _2 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>));
+        switchInt(move _2) -> [0: bb6, 1: bb8, otherwise: bb5];
+    }
+
+    bb5: {
+        goto -> bb3;
+    }
+
+    bb6: {
+        falseEdge -> [real: bb36, imaginary: bb8];
+    }
+
+    bb7: {
+        goto -> bb5;
+    }
+
+    bb8: {
+        falseEdge -> [real: bb35, imaginary: bb10];
+    }
+
+    bb9: {
+        goto -> bb5;
+    }
+
+    bb10: {
+        _3 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>));
+        switchInt(move _3) -> [0: bb12, 1: bb14, otherwise: bb11];
+    }
+
+    bb11: {
+        goto -> bb3;
+    }
+
+    bb12: {
+        falseEdge -> [real: bb34, imaginary: bb14];
+    }
+
+    bb13: {
+        goto -> bb11;
+    }
+
+    bb14: {
+        falseEdge -> [real: bb33, imaginary: bb16];
+    }
+
+    bb15: {
+        goto -> bb11;
+    }
+
+    bb16: {
+        _7 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>));
+        switchInt(move _7) -> [0: bb18, 1: bb24, otherwise: bb17];
+    }
+
+    bb17: {
+        goto -> bb1;
+    }
+
+    bb18: {
+        _5 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>));
+        switchInt(move _5) -> [0: bb20, 1: bb22, otherwise: bb19];
+    }
+
+    bb19: {
+        goto -> bb17;
+    }
+
+    bb20: {
+        falseEdge -> [real: bb32, imaginary: bb22];
+    }
+
+    bb21: {
+        goto -> bb19;
+    }
+
+    bb22: {
+        falseEdge -> [real: bb31, imaginary: bb24];
+    }
+
+    bb23: {
+        goto -> bb19;
+    }
+
+    bb24: {
+        _6 = discriminant((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>));
+        switchInt(move _6) -> [0: bb26, 1: bb28, otherwise: bb25];
+    }
+
+    bb25: {
+        goto -> bb17;
+    }
+
+    bb26: {
+        falseEdge -> [real: bb30, imaginary: bb28];
+    }
+
+    bb27: {
+        goto -> bb25;
+    }
+
+    bb28: {
+        StorageLive(_65);
+        _69 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).0: T);
+        _65 = Pin::<&T> { pointer: move _69 };
+        StorageLive(_66);
+        _70 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).1: U);
+        _66 = Pin::<&U> { pointer: move _70 };
+        StorageLive(_67);
+        _71 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).0: T);
+        _67 = Pin::<&T> { pointer: move _71 };
+        StorageLive(_68);
+        _72 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).1: U);
+        _68 = Pin::<&U> { pointer: move _72 };
+        _0 = const ();
+        StorageDead(_68);
+        StorageDead(_67);
+        StorageDead(_66);
+        StorageDead(_65);
+        goto -> bb37;
+    }
+
+    bb29: {
+        goto -> bb25;
+    }
+
+    bb30: {
+        StorageLive(_57);
+        _61 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).0: T);
+        _57 = Pin::<&T> { pointer: move _61 };
+        StorageLive(_58);
+        _62 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).1: U);
+        _58 = Pin::<&U> { pointer: move _62 };
+        StorageLive(_59);
+        _63 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).0: T);
+        _59 = Pin::<&T> { pointer: move _63 };
+        StorageLive(_60);
+        _64 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).1: U);
+        _60 = Pin::<&U> { pointer: move _64 };
+        _0 = const ();
+        StorageDead(_60);
+        StorageDead(_59);
+        StorageDead(_58);
+        StorageDead(_57);
+        goto -> bb37;
+    }
+
+    bb31: {
+        StorageLive(_49);
+        _53 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).0: T);
+        _49 = Pin::<&T> { pointer: move _53 };
+        StorageLive(_50);
+        _54 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).1: U);
+        _50 = Pin::<&U> { pointer: move _54 };
+        StorageLive(_51);
+        _55 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).0: T);
+        _51 = Pin::<&T> { pointer: move _55 };
+        StorageLive(_52);
+        _56 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).1: U);
+        _52 = Pin::<&U> { pointer: move _56 };
+        _0 = const ();
+        StorageDead(_52);
+        StorageDead(_51);
+        StorageDead(_50);
+        StorageDead(_49);
+        goto -> bb37;
+    }
+
+    bb32: {
+        StorageLive(_41);
+        _45 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).0: T);
+        _41 = Pin::<&T> { pointer: move _45 };
+        StorageLive(_42);
+        _46 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).1: U);
+        _42 = Pin::<&U> { pointer: move _46 };
+        StorageLive(_43);
+        _47 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).0: T);
+        _43 = Pin::<&T> { pointer: move _47 };
+        StorageLive(_44);
+        _48 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).1: U);
+        _44 = Pin::<&U> { pointer: move _48 };
+        _0 = const ();
+        StorageDead(_44);
+        StorageDead(_43);
+        StorageDead(_42);
+        StorageDead(_41);
+        goto -> bb37;
+    }
+
+    bb33: {
+        StorageLive(_33);
+        _37 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).0: T);
+        _33 = Pin::<&T> { pointer: move _37 };
+        StorageLive(_34);
+        _38 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).1: U);
+        _34 = Pin::<&U> { pointer: move _38 };
+        StorageLive(_35);
+        _39 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).0: T);
+        _35 = Pin::<&T> { pointer: move _39 };
+        StorageLive(_36);
+        _40 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).1: U);
+        _36 = Pin::<&U> { pointer: move _40 };
+        _0 = const ();
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_34);
+        StorageDead(_33);
+        goto -> bb37;
+    }
+
+    bb34: {
+        StorageLive(_25);
+        _29 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).0: T);
+        _25 = Pin::<&T> { pointer: move _29 };
+        StorageLive(_26);
+        _30 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).1: U);
+        _26 = Pin::<&U> { pointer: move _30 };
+        StorageLive(_27);
+        _31 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).0: T);
+        _27 = Pin::<&T> { pointer: move _31 };
+        StorageLive(_28);
+        _32 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).1: U);
+        _28 = Pin::<&U> { pointer: move _32 };
+        _0 = const ();
+        StorageDead(_28);
+        StorageDead(_27);
+        StorageDead(_26);
+        StorageDead(_25);
+        goto -> bb37;
+    }
+
+    bb35: {
+        StorageLive(_17);
+        _21 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).0: T);
+        _17 = Pin::<&T> { pointer: move _21 };
+        StorageLive(_18);
+        _22 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).1: U);
+        _18 = Pin::<&U> { pointer: move _22 };
+        StorageLive(_19);
+        _23 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).0: T);
+        _19 = Pin::<&T> { pointer: move _23 };
+        StorageLive(_20);
+        _24 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).1: U);
+        _20 = Pin::<&U> { pointer: move _24 };
+        _0 = const ();
+        StorageDead(_20);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_17);
+        goto -> bb37;
+    }
+
+    bb36: {
+        StorageLive(_9);
+        _13 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).0: T);
+        _9 = Pin::<&T> { pointer: move _13 };
+        StorageLive(_10);
+        _14 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).1: U);
+        _10 = Pin::<&U> { pointer: move _14 };
+        StorageLive(_11);
+        _15 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).0: T);
+        _11 = Pin::<&T> { pointer: move _15 };
+        StorageLive(_12);
+        _16 = &(((((*(_1.0: &Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).1: U);
+        _12 = Pin::<&U> { pointer: move _16 };
+        _0 = const ();
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageDead(_9);
+        goto -> bb37;
+    }
+
+    bb37: {
+        return;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_mut.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_mut.built.after.mir
new file mode 100644
index 0000000000000..43c523cbf5717
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_baz_mut.built.after.mir
@@ -0,0 +1,422 @@
+// MIR for `baz_baz_mut` after built
+
+fn baz_baz_mut(_1: Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>) -> () {
+    debug baz => _1;
+    let mut _0: ();
+    let mut _2: isize;
+    let mut _3: isize;
+    let mut _4: isize;
+    let mut _5: isize;
+    let mut _6: isize;
+    let mut _7: isize;
+    let mut _8: isize;
+    let _9: std::pin::Pin<&mut T>;
+    let _10: std::pin::Pin<&mut U>;
+    let _11: std::pin::Pin<&mut T>;
+    let _12: std::pin::Pin<&mut U>;
+    let mut _13: &mut T;
+    let mut _14: &mut U;
+    let mut _15: &mut T;
+    let mut _16: &mut U;
+    let _17: std::pin::Pin<&mut T>;
+    let _18: std::pin::Pin<&mut U>;
+    let _19: std::pin::Pin<&mut T>;
+    let _20: std::pin::Pin<&mut U>;
+    let mut _21: &mut T;
+    let mut _22: &mut U;
+    let mut _23: &mut T;
+    let mut _24: &mut U;
+    let _25: std::pin::Pin<&mut T>;
+    let _26: std::pin::Pin<&mut U>;
+    let _27: std::pin::Pin<&mut T>;
+    let _28: std::pin::Pin<&mut U>;
+    let mut _29: &mut T;
+    let mut _30: &mut U;
+    let mut _31: &mut T;
+    let mut _32: &mut U;
+    let _33: std::pin::Pin<&mut T>;
+    let _34: std::pin::Pin<&mut U>;
+    let _35: std::pin::Pin<&mut T>;
+    let _36: std::pin::Pin<&mut U>;
+    let mut _37: &mut T;
+    let mut _38: &mut U;
+    let mut _39: &mut T;
+    let mut _40: &mut U;
+    let _41: std::pin::Pin<&mut T>;
+    let _42: std::pin::Pin<&mut U>;
+    let _43: std::pin::Pin<&mut T>;
+    let _44: std::pin::Pin<&mut U>;
+    let mut _45: &mut T;
+    let mut _46: &mut U;
+    let mut _47: &mut T;
+    let mut _48: &mut U;
+    let _49: std::pin::Pin<&mut T>;
+    let _50: std::pin::Pin<&mut U>;
+    let _51: std::pin::Pin<&mut T>;
+    let _52: std::pin::Pin<&mut U>;
+    let mut _53: &mut T;
+    let mut _54: &mut U;
+    let mut _55: &mut T;
+    let mut _56: &mut U;
+    let _57: std::pin::Pin<&mut T>;
+    let _58: std::pin::Pin<&mut U>;
+    let _59: std::pin::Pin<&mut T>;
+    let _60: std::pin::Pin<&mut U>;
+    let mut _61: &mut T;
+    let mut _62: &mut U;
+    let mut _63: &mut T;
+    let mut _64: &mut U;
+    let _65: std::pin::Pin<&mut T>;
+    let _66: std::pin::Pin<&mut U>;
+    let _67: std::pin::Pin<&mut T>;
+    let _68: std::pin::Pin<&mut U>;
+    let mut _69: &mut T;
+    let mut _70: &mut U;
+    let mut _71: &mut T;
+    let mut _72: &mut U;
+    scope 1 {
+        debug x => _9;
+        debug y => _10;
+        debug z => _11;
+        debug w => _12;
+    }
+    scope 2 {
+        debug x => _17;
+        debug y => _18;
+        debug z => _19;
+        debug w => _20;
+    }
+    scope 3 {
+        debug x => _25;
+        debug y => _26;
+        debug z => _27;
+        debug w => _28;
+    }
+    scope 4 {
+        debug x => _33;
+        debug y => _34;
+        debug z => _35;
+        debug w => _36;
+    }
+    scope 5 {
+        debug x => _41;
+        debug y => _42;
+        debug z => _43;
+        debug w => _44;
+    }
+    scope 6 {
+        debug x => _49;
+        debug y => _50;
+        debug z => _51;
+        debug w => _52;
+    }
+    scope 7 {
+        debug x => _57;
+        debug y => _58;
+        debug z => _59;
+        debug w => _60;
+    }
+    scope 8 {
+        debug x => _65;
+        debug y => _66;
+        debug z => _67;
+        debug w => _68;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _8 = discriminant((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)));
+        switchInt(move _8) -> [0: bb2, 1: bb16, otherwise: bb1];
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+
+    bb2: {
+        _4 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>));
+        switchInt(move _4) -> [0: bb4, 1: bb10, otherwise: bb3];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        _2 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>));
+        switchInt(move _2) -> [0: bb6, 1: bb8, otherwise: bb5];
+    }
+
+    bb5: {
+        goto -> bb3;
+    }
+
+    bb6: {
+        falseEdge -> [real: bb36, imaginary: bb8];
+    }
+
+    bb7: {
+        goto -> bb5;
+    }
+
+    bb8: {
+        falseEdge -> [real: bb35, imaginary: bb10];
+    }
+
+    bb9: {
+        goto -> bb5;
+    }
+
+    bb10: {
+        _3 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>));
+        switchInt(move _3) -> [0: bb12, 1: bb14, otherwise: bb11];
+    }
+
+    bb11: {
+        goto -> bb3;
+    }
+
+    bb12: {
+        falseEdge -> [real: bb34, imaginary: bb14];
+    }
+
+    bb13: {
+        goto -> bb11;
+    }
+
+    bb14: {
+        falseEdge -> [real: bb33, imaginary: bb16];
+    }
+
+    bb15: {
+        goto -> bb11;
+    }
+
+    bb16: {
+        _7 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>));
+        switchInt(move _7) -> [0: bb18, 1: bb24, otherwise: bb17];
+    }
+
+    bb17: {
+        goto -> bb1;
+    }
+
+    bb18: {
+        _5 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>));
+        switchInt(move _5) -> [0: bb20, 1: bb22, otherwise: bb19];
+    }
+
+    bb19: {
+        goto -> bb17;
+    }
+
+    bb20: {
+        falseEdge -> [real: bb32, imaginary: bb22];
+    }
+
+    bb21: {
+        goto -> bb19;
+    }
+
+    bb22: {
+        falseEdge -> [real: bb31, imaginary: bb24];
+    }
+
+    bb23: {
+        goto -> bb19;
+    }
+
+    bb24: {
+        _6 = discriminant((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>));
+        switchInt(move _6) -> [0: bb26, 1: bb28, otherwise: bb25];
+    }
+
+    bb25: {
+        goto -> bb17;
+    }
+
+    bb26: {
+        falseEdge -> [real: bb30, imaginary: bb28];
+    }
+
+    bb27: {
+        goto -> bb25;
+    }
+
+    bb28: {
+        StorageLive(_65);
+        _69 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).0: T);
+        _65 = Pin::<&mut T> { pointer: move _69 };
+        StorageLive(_66);
+        _70 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).1: U);
+        _66 = Pin::<&mut U> { pointer: move _70 };
+        StorageLive(_67);
+        _71 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).0: T);
+        _67 = Pin::<&mut T> { pointer: move _71 };
+        StorageLive(_68);
+        _72 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).1: U);
+        _68 = Pin::<&mut U> { pointer: move _72 };
+        _0 = const ();
+        StorageDead(_68);
+        StorageDead(_67);
+        StorageDead(_66);
+        StorageDead(_65);
+        goto -> bb37;
+    }
+
+    bb29: {
+        goto -> bb25;
+    }
+
+    bb30: {
+        StorageLive(_57);
+        _61 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).0: T);
+        _57 = Pin::<&mut T> { pointer: move _61 };
+        StorageLive(_58);
+        _62 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Bar).1: U);
+        _58 = Pin::<&mut U> { pointer: move _62 };
+        StorageLive(_59);
+        _63 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).0: T);
+        _59 = Pin::<&mut T> { pointer: move _63 };
+        StorageLive(_60);
+        _64 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).1: U);
+        _60 = Pin::<&mut U> { pointer: move _64 };
+        _0 = const ();
+        StorageDead(_60);
+        StorageDead(_59);
+        StorageDead(_58);
+        StorageDead(_57);
+        goto -> bb37;
+    }
+
+    bb31: {
+        StorageLive(_49);
+        _53 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).0: T);
+        _49 = Pin::<&mut T> { pointer: move _53 };
+        StorageLive(_50);
+        _54 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).1: U);
+        _50 = Pin::<&mut U> { pointer: move _54 };
+        StorageLive(_51);
+        _55 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).0: T);
+        _51 = Pin::<&mut T> { pointer: move _55 };
+        StorageLive(_52);
+        _56 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Bar).1: U);
+        _52 = Pin::<&mut U> { pointer: move _56 };
+        _0 = const ();
+        StorageDead(_52);
+        StorageDead(_51);
+        StorageDead(_50);
+        StorageDead(_49);
+        goto -> bb37;
+    }
+
+    bb32: {
+        StorageLive(_41);
+        _45 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).0: T);
+        _41 = Pin::<&mut T> { pointer: move _45 };
+        StorageLive(_42);
+        _46 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).0: Baz<T, U>) as Foo).1: U);
+        _42 = Pin::<&mut U> { pointer: move _46 };
+        StorageLive(_43);
+        _47 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).0: T);
+        _43 = Pin::<&mut T> { pointer: move _47 };
+        StorageLive(_44);
+        _48 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Bar).1: Baz<T, U>) as Foo).1: U);
+        _44 = Pin::<&mut U> { pointer: move _48 };
+        _0 = const ();
+        StorageDead(_44);
+        StorageDead(_43);
+        StorageDead(_42);
+        StorageDead(_41);
+        goto -> bb37;
+    }
+
+    bb33: {
+        StorageLive(_33);
+        _37 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).0: T);
+        _33 = Pin::<&mut T> { pointer: move _37 };
+        StorageLive(_34);
+        _38 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).1: U);
+        _34 = Pin::<&mut U> { pointer: move _38 };
+        StorageLive(_35);
+        _39 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).0: T);
+        _35 = Pin::<&mut T> { pointer: move _39 };
+        StorageLive(_36);
+        _40 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).1: U);
+        _36 = Pin::<&mut U> { pointer: move _40 };
+        _0 = const ();
+        StorageDead(_36);
+        StorageDead(_35);
+        StorageDead(_34);
+        StorageDead(_33);
+        goto -> bb37;
+    }
+
+    bb34: {
+        StorageLive(_25);
+        _29 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).0: T);
+        _25 = Pin::<&mut T> { pointer: move _29 };
+        StorageLive(_26);
+        _30 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Bar).1: U);
+        _26 = Pin::<&mut U> { pointer: move _30 };
+        StorageLive(_27);
+        _31 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).0: T);
+        _27 = Pin::<&mut T> { pointer: move _31 };
+        StorageLive(_28);
+        _32 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).1: U);
+        _28 = Pin::<&mut U> { pointer: move _32 };
+        _0 = const ();
+        StorageDead(_28);
+        StorageDead(_27);
+        StorageDead(_26);
+        StorageDead(_25);
+        goto -> bb37;
+    }
+
+    bb35: {
+        StorageLive(_17);
+        _21 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).0: T);
+        _17 = Pin::<&mut T> { pointer: move _21 };
+        StorageLive(_18);
+        _22 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).1: U);
+        _18 = Pin::<&mut U> { pointer: move _22 };
+        StorageLive(_19);
+        _23 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).0: T);
+        _19 = Pin::<&mut T> { pointer: move _23 };
+        StorageLive(_20);
+        _24 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Bar).1: U);
+        _20 = Pin::<&mut U> { pointer: move _24 };
+        _0 = const ();
+        StorageDead(_20);
+        StorageDead(_19);
+        StorageDead(_18);
+        StorageDead(_17);
+        goto -> bb37;
+    }
+
+    bb36: {
+        StorageLive(_9);
+        _13 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).0: T);
+        _9 = Pin::<&mut T> { pointer: move _13 };
+        StorageLive(_10);
+        _14 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).0: Baz<T, U>) as Foo).1: U);
+        _10 = Pin::<&mut U> { pointer: move _14 };
+        StorageLive(_11);
+        _15 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).0: T);
+        _11 = Pin::<&mut T> { pointer: move _15 };
+        StorageLive(_12);
+        _16 = &mut (((((*(_1.0: &mut Baz<Baz<T, U>, Baz<T, U>>)) as Foo).1: Baz<T, U>) as Foo).1: U);
+        _12 = Pin::<&mut U> { pointer: move _16 };
+        _0 = const ();
+        StorageDead(_12);
+        StorageDead(_11);
+        StorageDead(_10);
+        StorageDead(_9);
+        goto -> bb37;
+    }
+
+    bb37: {
+        return;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_const.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_const.built.after.mir
new file mode 100644
index 0000000000000..5538449cc43cc
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_const.built.after.mir
@@ -0,0 +1,76 @@
+// MIR for `baz_const` after built
+
+fn baz_const(_1: Pin<&Baz<T, U>>) -> () {
+    debug baz => _1;
+    let mut _0: ();
+    let mut _2: isize;
+    let _3: std::pin::Pin<&T>;
+    let _4: std::pin::Pin<&U>;
+    let mut _5: &T;
+    let mut _6: &U;
+    let _7: std::pin::Pin<&T>;
+    let _8: std::pin::Pin<&U>;
+    let mut _9: &T;
+    let mut _10: &U;
+    scope 1 {
+        debug x => _3;
+        debug y => _4;
+    }
+    scope 2 {
+        debug x => _7;
+        debug y => _8;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _2 = discriminant((*(_1.0: &Baz<T, U>)));
+        switchInt(move _2) -> [0: bb2, 1: bb4, otherwise: bb1];
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+
+    bb2: {
+        falseEdge -> [real: bb6, imaginary: bb4];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        StorageLive(_7);
+        _9 = &(((*(_1.0: &Baz<T, U>)) as Bar).0: T);
+        _7 = Pin::<&T> { pointer: move _9 };
+        StorageLive(_8);
+        _10 = &(((*(_1.0: &Baz<T, U>)) as Bar).1: U);
+        _8 = Pin::<&U> { pointer: move _10 };
+        _0 = const ();
+        StorageDead(_8);
+        StorageDead(_7);
+        goto -> bb7;
+    }
+
+    bb5: {
+        goto -> bb1;
+    }
+
+    bb6: {
+        StorageLive(_3);
+        _5 = &(((*(_1.0: &Baz<T, U>)) as Foo).0: T);
+        _3 = Pin::<&T> { pointer: move _5 };
+        StorageLive(_4);
+        _6 = &(((*(_1.0: &Baz<T, U>)) as Foo).1: U);
+        _4 = Pin::<&U> { pointer: move _6 };
+        _0 = const ();
+        StorageDead(_4);
+        StorageDead(_3);
+        goto -> bb7;
+    }
+
+    bb7: {
+        return;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_mut.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_mut.built.after.mir
new file mode 100644
index 0000000000000..4ae472cba3a58
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.baz_mut.built.after.mir
@@ -0,0 +1,76 @@
+// MIR for `baz_mut` after built
+
+fn baz_mut(_1: Pin<&mut Baz<T, U>>) -> () {
+    debug baz => _1;
+    let mut _0: ();
+    let mut _2: isize;
+    let _3: std::pin::Pin<&mut T>;
+    let _4: std::pin::Pin<&mut U>;
+    let mut _5: &mut T;
+    let mut _6: &mut U;
+    let _7: std::pin::Pin<&mut T>;
+    let _8: std::pin::Pin<&mut U>;
+    let mut _9: &mut T;
+    let mut _10: &mut U;
+    scope 1 {
+        debug x => _3;
+        debug y => _4;
+    }
+    scope 2 {
+        debug x => _7;
+        debug y => _8;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        _2 = discriminant((*(_1.0: &mut Baz<T, U>)));
+        switchInt(move _2) -> [0: bb2, 1: bb4, otherwise: bb1];
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+
+    bb2: {
+        falseEdge -> [real: bb6, imaginary: bb4];
+    }
+
+    bb3: {
+        goto -> bb1;
+    }
+
+    bb4: {
+        StorageLive(_7);
+        _9 = &mut (((*(_1.0: &mut Baz<T, U>)) as Bar).0: T);
+        _7 = Pin::<&mut T> { pointer: move _9 };
+        StorageLive(_8);
+        _10 = &mut (((*(_1.0: &mut Baz<T, U>)) as Bar).1: U);
+        _8 = Pin::<&mut U> { pointer: move _10 };
+        _0 = const ();
+        StorageDead(_8);
+        StorageDead(_7);
+        goto -> bb7;
+    }
+
+    bb5: {
+        goto -> bb1;
+    }
+
+    bb6: {
+        StorageLive(_3);
+        _5 = &mut (((*(_1.0: &mut Baz<T, U>)) as Foo).0: T);
+        _3 = Pin::<&mut T> { pointer: move _5 };
+        StorageLive(_4);
+        _6 = &mut (((*(_1.0: &mut Baz<T, U>)) as Foo).1: U);
+        _4 = Pin::<&mut U> { pointer: move _6 };
+        _0 = const ();
+        StorageDead(_4);
+        StorageDead(_3);
+        goto -> bb7;
+    }
+
+    bb7: {
+        return;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_const.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_const.built.after.mir
new file mode 100644
index 0000000000000..8b397ffd18142
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_const.built.after.mir
@@ -0,0 +1,47 @@
+// MIR for `foo_bar_const` after built
+
+fn foo_bar_const(_1: Pin<&Foo<Bar<T, U>, Bar<T, U>>>) -> () {
+    debug foo => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&T>;
+    let _3: std::pin::Pin<&U>;
+    let _4: std::pin::Pin<&T>;
+    let _5: std::pin::Pin<&U>;
+    let mut _6: &T;
+    let mut _7: &U;
+    let mut _8: &T;
+    let mut _9: &U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+        debug z => _4;
+        debug w => _5;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _6 = &(((*(_1.0: &Foo<Bar<T, U>, Bar<T, U>>)).0: Bar<T, U>).0: T);
+        _2 = Pin::<&T> { pointer: move _6 };
+        StorageLive(_3);
+        _7 = &(((*(_1.0: &Foo<Bar<T, U>, Bar<T, U>>)).0: Bar<T, U>).1: U);
+        _3 = Pin::<&U> { pointer: move _7 };
+        StorageLive(_4);
+        _8 = &(((*(_1.0: &Foo<Bar<T, U>, Bar<T, U>>)).1: Bar<T, U>).0: T);
+        _4 = Pin::<&T> { pointer: move _8 };
+        StorageLive(_5);
+        _9 = &(((*(_1.0: &Foo<Bar<T, U>, Bar<T, U>>)).1: Bar<T, U>).1: U);
+        _5 = Pin::<&U> { pointer: move _9 };
+        _0 = const ();
+        StorageDead(_5);
+        StorageDead(_4);
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_mut.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_mut.built.after.mir
new file mode 100644
index 0000000000000..2e8128bb9d1e4
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_bar_mut.built.after.mir
@@ -0,0 +1,47 @@
+// MIR for `foo_bar_mut` after built
+
+fn foo_bar_mut(_1: Pin<&mut Foo<Bar<T, U>, Bar<T, U>>>) -> () {
+    debug foo => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&mut T>;
+    let _3: std::pin::Pin<&mut U>;
+    let _4: std::pin::Pin<&mut T>;
+    let _5: std::pin::Pin<&mut U>;
+    let mut _6: &mut T;
+    let mut _7: &mut U;
+    let mut _8: &mut T;
+    let mut _9: &mut U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+        debug z => _4;
+        debug w => _5;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _6 = &mut (((*(_1.0: &mut Foo<Bar<T, U>, Bar<T, U>>)).0: Bar<T, U>).0: T);
+        _2 = Pin::<&mut T> { pointer: move _6 };
+        StorageLive(_3);
+        _7 = &mut (((*(_1.0: &mut Foo<Bar<T, U>, Bar<T, U>>)).0: Bar<T, U>).1: U);
+        _3 = Pin::<&mut U> { pointer: move _7 };
+        StorageLive(_4);
+        _8 = &mut (((*(_1.0: &mut Foo<Bar<T, U>, Bar<T, U>>)).1: Bar<T, U>).0: T);
+        _4 = Pin::<&mut T> { pointer: move _8 };
+        StorageLive(_5);
+        _9 = &mut (((*(_1.0: &mut Foo<Bar<T, U>, Bar<T, U>>)).1: Bar<T, U>).1: U);
+        _5 = Pin::<&mut U> { pointer: move _9 };
+        _0 = const ();
+        StorageDead(_5);
+        StorageDead(_4);
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_const.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_const.built.after.mir
new file mode 100644
index 0000000000000..b77b341d4ef76
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_const.built.after.mir
@@ -0,0 +1,33 @@
+// MIR for `foo_const` after built
+
+fn foo_const(_1: Pin<&Foo<T, U>>) -> () {
+    debug foo => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&T>;
+    let _3: std::pin::Pin<&U>;
+    let mut _4: &T;
+    let mut _5: &U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _4 = &((*(_1.0: &Foo<T, U>)).0: T);
+        _2 = Pin::<&T> { pointer: move _4 };
+        StorageLive(_3);
+        _5 = &((*(_1.0: &Foo<T, U>)).1: U);
+        _3 = Pin::<&U> { pointer: move _5 };
+        _0 = const ();
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_mut.built.after.mir b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_mut.built.after.mir
new file mode 100644
index 0000000000000..c7b88d239f87a
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.foo_mut.built.after.mir
@@ -0,0 +1,33 @@
+// MIR for `foo_mut` after built
+
+fn foo_mut(_1: Pin<&mut Foo<T, U>>) -> () {
+    debug foo => _1;
+    let mut _0: ();
+    let _2: std::pin::Pin<&mut T>;
+    let _3: std::pin::Pin<&mut U>;
+    let mut _4: &mut T;
+    let mut _5: &mut U;
+    scope 1 {
+        debug x => _2;
+        debug y => _3;
+    }
+
+    bb0: {
+        PlaceMention(_1);
+        StorageLive(_2);
+        _4 = &mut ((*(_1.0: &mut Foo<T, U>)).0: T);
+        _2 = Pin::<&mut T> { pointer: move _4 };
+        StorageLive(_3);
+        _5 = &mut ((*(_1.0: &mut Foo<T, U>)).1: U);
+        _3 = Pin::<&mut U> { pointer: move _5 };
+        _0 = const ();
+        StorageDead(_3);
+        StorageDead(_2);
+        return;
+    }
+
+    bb1: {
+        FakeRead(ForMatchedPlace(None), _1);
+        unreachable;
+    }
+}
diff --git a/tests/mir-opt/pin-ergonomics/project_pattern_match.rs b/tests/mir-opt/pin-ergonomics/project_pattern_match.rs
new file mode 100644
index 0000000000000..8808111f303b3
--- /dev/null
+++ b/tests/mir-opt/pin-ergonomics/project_pattern_match.rs
@@ -0,0 +1,95 @@
+// skip-filecheck
+#![feature(pin_ergonomics)]
+#![allow(incomplete_features)]
+
+// This test verifies that a `&pin mut Foo` can be projected to a pinned
+// reference `&pin mut T` of a `?Unpin` field , and can be projected to
+// an unpinned reference `&mut U` of an `Unpin` field .
+
+struct Foo<T, U> {
+    x: T,
+    y: U,
+}
+
+struct Bar<T, U>(T, U);
+
+enum Baz<T, U> {
+    Foo(T, U),
+    Bar { x: T, y: U },
+}
+
+// EMIT_MIR project_pattern_match.foo_mut.built.after.mir
+fn foo_mut<T, U: Unpin>(foo: &pin mut Foo<T, U>) {
+    let Foo { x, y } = foo;
+}
+
+// EMIT_MIR project_pattern_match.foo_const.built.after.mir
+fn foo_const<T, U: Unpin>(foo: &pin const Foo<T, U>) {
+    let Foo { x, y } = foo;
+}
+
+// EMIT_MIR project_pattern_match.bar_mut.built.after.mir
+fn bar_mut<T, U: Unpin>(bar: &pin mut Bar<T, U>) {
+    let Bar(x, y) = bar;
+}
+
+// EMIT_MIR project_pattern_match.bar_const.built.after.mir
+fn bar_const<T, U: Unpin>(bar: &pin const Bar<T, U>) {
+    let Bar(x, y) = bar;
+}
+
+// EMIT_MIR project_pattern_match.foo_bar_mut.built.after.mir
+fn foo_bar_mut<T, U: Unpin>(foo: &pin mut Foo<Bar<T, U>, Bar<T, U>>) {
+    let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+}
+
+// EMIT_MIR project_pattern_match.foo_bar_const.built.after.mir
+fn foo_bar_const<T, U: Unpin>(foo: &pin const Foo<Bar<T, U>, Bar<T, U>>) {
+    let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+}
+
+// EMIT_MIR project_pattern_match.baz_mut.built.after.mir
+fn baz_mut<T, U: Unpin>(baz: &pin mut Baz<T, U>) {
+    match baz {
+        Baz::Foo(x, y) => {}
+        Baz::Bar { x, y } => {}
+    }
+}
+
+// EMIT_MIR project_pattern_match.baz_const.built.after.mir
+fn baz_const<T, U: Unpin>(baz: &pin const Baz<T, U>) {
+    match baz {
+        Baz::Foo(x, y) => {}
+        Baz::Bar { x, y } => {}
+    }
+}
+
+// EMIT_MIR project_pattern_match.baz_baz_mut.built.after.mir
+fn baz_baz_mut<T, U: Unpin>(baz: &pin mut Baz<Baz<T, U>, Baz<T, U>>) {
+    match baz {
+        Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w)) => {}
+        Baz::Foo(Baz::Foo(x, y), Baz::Bar { x: z, y: w }) => {}
+        Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w)) => {}
+        Baz::Foo(Baz::Bar { x, y }, Baz::Bar { x: z, y: w }) => {}
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) } => {}
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Bar { x: z, y: w } } => {}
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) } => {}
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Bar { x: z, y: w } } => {}
+    }
+}
+
+// EMIT_MIR project_pattern_match.baz_baz_const.built.after.mir
+fn baz_baz_const<T, U: Unpin>(baz: &pin const Baz<Baz<T, U>, Baz<T, U>>) {
+    match baz {
+        Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w)) => {}
+        Baz::Foo(Baz::Foo(x, y), Baz::Bar { x: z, y: w }) => {}
+        Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w)) => {}
+        Baz::Foo(Baz::Bar { x, y }, Baz::Bar { x: z, y: w }) => {}
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) } => {}
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Bar { x: z, y: w } } => {}
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) } => {}
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Bar { x: z, y: w } } => {}
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/async-await/pin-ergonomics/project-pattern-match.normal.stderr b/tests/ui/async-await/pin-ergonomics/project-pattern-match.normal.stderr
new file mode 100644
index 0000000000000..0f8368dc47e93
--- /dev/null
+++ b/tests/ui/async-await/pin-ergonomics/project-pattern-match.normal.stderr
@@ -0,0 +1,313 @@
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:35:9
+   |
+LL |     let Foo { x, y } = foo;
+   |         ^^^^^^^^^^^^   --- this expression has type `Pin<&mut Foo<T, U>>`
+   |         |
+   |         expected `Pin<&mut Foo<T, U>>`, found `Foo<_, _>`
+   |
+   = note: expected struct `Pin<&mut Foo<T, U>>`
+              found struct `Foo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Foo { x, y } = *foo;
+   |                        +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:42:9
+   |
+LL |     let Foo { x, y } = foo;
+   |         ^^^^^^^^^^^^   --- this expression has type `Pin<&Foo<T, U>>`
+   |         |
+   |         expected `Pin<&Foo<T, U>>`, found `Foo<_, _>`
+   |
+   = note: expected struct `Pin<&Foo<T, U>>`
+              found struct `Foo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Foo { x, y } = *foo;
+   |                        +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:49:9
+   |
+LL |     let Bar(x, y) = bar;
+   |         ^^^^^^^^^   --- this expression has type `Pin<&mut Bar<T, U>>`
+   |         |
+   |         expected `Pin<&mut Bar<T, U>>`, found `Bar<_, _>`
+   |
+   = note: expected struct `Pin<&mut Bar<T, U>>`
+              found struct `Bar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Bar(x, y) = *bar;
+   |                     +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:56:9
+   |
+LL |     let Bar(x, y) = bar;
+   |         ^^^^^^^^^   --- this expression has type `Pin<&Bar<T, U>>`
+   |         |
+   |         expected `Pin<&Bar<T, U>>`, found `Bar<_, _>`
+   |
+   = note: expected struct `Pin<&Bar<T, U>>`
+              found struct `Bar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Bar(x, y) = *bar;
+   |                     +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:63:9
+   |
+LL |     let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   --- this expression has type `Pin<&mut Foo<Bar<T, U>, Bar<T, U>>>`
+   |         |
+   |         expected `Pin<&mut Foo<Bar<T, U>, Bar<T, U>>>`, found `Foo<_, _>`
+   |
+   = note: expected struct `Pin<&mut Foo<Bar<T, U>, Bar<T, U>>>`
+              found struct `Foo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Foo { x: Bar(x, y), y: Bar(z, w) } = *foo;
+   |                                              +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:72:9
+   |
+LL |     let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^   --- this expression has type `Pin<&Foo<Bar<T, U>, Bar<T, U>>>`
+   |         |
+   |         expected `Pin<&Foo<Bar<T, U>, Bar<T, U>>>`, found `Foo<_, _>`
+   |
+   = note: expected struct `Pin<&Foo<Bar<T, U>, Bar<T, U>>>`
+              found struct `Foo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let Foo { x: Bar(x, y), y: Bar(z, w) } = *foo;
+   |                                              +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:82:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<T, U>>`
+LL |         Baz::Foo(x, y) => {
+   |         ^^^^^^^^^^^^^^ expected `Pin<&mut Baz<T, U>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<T, U>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:87:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<T, U>>`
+...
+LL |         Baz::Bar { x, y } => {
+   |         ^^^^^^^^^^^^^^^^^ expected `Pin<&mut Baz<T, U>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<T, U>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:97:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<T, U>>`
+LL |         Baz::Foo(x, y) => {
+   |         ^^^^^^^^^^^^^^ expected `Pin<&Baz<T, U>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<T, U>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:102:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<T, U>>`
+...
+LL |         Baz::Bar { x, y } => {
+   |         ^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<T, U>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<T, U>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:112:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+LL |         Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:119:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:126:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:133:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:145:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+LL |         Baz::Foo(foo, _) if let Baz::Foo(x, y) = foo => {
+   |         ^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:150:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Bar { x: _, y: bar } if let Baz::Bar { x, y } = bar => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:155:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:162:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:169:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/project-pattern-match.rs:176:9
+   |
+LL |     match baz {
+   |           --- this expression has type `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+...
+LL |         Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`, found `Baz<_, _>`
+   |
+   = note: expected struct `Pin<&Baz<Baz<T, U>, Baz<T, U>>>`
+                found enum `Baz<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *baz {
+   |           +
+
+error: aborting due to 20 previous errors
+
+For more information about this error, try `rustc --explain E0308`.
diff --git a/tests/ui/async-await/pin-ergonomics/project-pattern-match.rs b/tests/ui/async-await/pin-ergonomics/project-pattern-match.rs
new file mode 100644
index 0000000000000..06b6d76daf114
--- /dev/null
+++ b/tests/ui/async-await/pin-ergonomics/project-pattern-match.rs
@@ -0,0 +1,186 @@
+//@ revisions: pin_project normal
+//@ edition:2024
+//@[pin_project] check-pass
+#![cfg_attr(pin_project, feature(pin_ergonomics))]
+#![feature(if_let_guard)]
+#![allow(incomplete_features)]
+
+use std::pin::Pin;
+
+// This test verifies that a `&pin mut Foo` can be projected to a pinned
+// reference `&pin mut T` of a `?Unpin` field , and can be projected to
+// an unpinned reference `&mut U` of an `Unpin` field .
+
+struct Foo<T, U> {
+    x: T,
+    y: U,
+}
+
+struct Bar<T, U>(T, U);
+
+enum Baz<T, U> {
+    Foo(T, U),
+    Bar { x: T, y: U },
+}
+
+trait IsPinMut {}
+trait IsPinConst {}
+impl<T: ?Sized> IsPinMut for Pin<&mut T> {}
+impl<T: ?Sized> IsPinConst for Pin<&T> {}
+
+fn assert_pin_mut<T: IsPinMut>(_: T) {}
+fn assert_pin_const<T: IsPinConst>(_: T) {}
+
+fn foo_mut<T, U: Unpin>(foo: Pin<&mut Foo<T, U>>) {
+    let Foo { x, y } = foo;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+}
+
+fn foo_const<T, U: Unpin>(foo: Pin<&Foo<T, U>>) {
+    let Foo { x, y } = foo;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+fn bar_mut<T, U: Unpin>(bar: Pin<&mut Bar<T, U>>) {
+    let Bar(x, y) = bar;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+}
+
+fn bar_const<T, U: Unpin>(bar: Pin<&Bar<T, U>>) {
+    let Bar(x, y) = bar;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+fn foo_bar_mut<T, U: Unpin>(foo: Pin<&mut Foo<Bar<T, U>, Bar<T, U>>>) {
+    let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+    assert_pin_mut(z);
+    assert_pin_mut(w);
+}
+
+fn foo_bar_const<T, U: Unpin>(foo: Pin<&Foo<Bar<T, U>, Bar<T, U>>>) {
+    let Foo { x: Bar(x, y), y: Bar(z, w) } = foo;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+    assert_pin_const(z);
+    assert_pin_const(w);
+}
+
+fn baz_mut<T, U: Unpin>(baz: Pin<&mut Baz<T, U>>) {
+    match baz {
+        Baz::Foo(x, y) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+        }
+        Baz::Bar { x, y } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+        }
+    }
+}
+
+fn baz_const<T, U: Unpin>(baz: Pin<&Baz<T, U>>) {
+    match baz {
+        Baz::Foo(x, y) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+        Baz::Bar { x, y } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+    }
+}
+
+fn baz_baz_mut<T, U: Unpin>(baz: Pin<&mut Baz<Baz<T, U>, Baz<T, U>>>) {
+    match baz {
+        Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+            assert_pin_mut(z);
+            assert_pin_mut(w);
+        }
+        Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+            assert_pin_mut(z);
+            assert_pin_mut(w);
+        }
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+            assert_pin_mut(z);
+            assert_pin_mut(w);
+        }
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+            assert_pin_mut(z);
+            assert_pin_mut(w);
+        }
+    }
+}
+
+fn baz_baz_const<T, U: Unpin>(baz: Pin<&Baz<Baz<T, U>, Baz<T, U>>>) {
+    match baz {
+        Baz::Foo(foo, _) if let Baz::Foo(x, y) = foo => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+        Baz::Bar { x: _, y: bar } if let Baz::Bar { x, y } = bar => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+        Baz::Foo(Baz::Foo(x, y), Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+            assert_pin_const(z);
+            assert_pin_const(w);
+        }
+        Baz::Foo(Baz::Bar { x, y }, Baz::Foo(z, w) | Baz::Bar { x: z, y: w }) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+            assert_pin_const(z);
+            assert_pin_const(w);
+        }
+        Baz::Bar { x: Baz::Foo(x, y), y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+            assert_pin_const(z);
+            assert_pin_const(w);
+        }
+        Baz::Bar { x: Baz::Bar { x, y }, y: Baz::Foo(z, w) | Baz::Bar { x: z, y: w } } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+            assert_pin_const(z);
+            assert_pin_const(w);
+        }
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/thir-print/thir-tree-match.stdout b/tests/ui/thir-print/thir-tree-match.stdout
index 910582ae4d9e9..282459103bb12 100644
--- a/tests/ui/thir-print/thir-tree-match.stdout
+++ b/tests/ui/thir-print/thir-tree-match.stdout
@@ -12,6 +12,7 @@ params: [
                 kind: PatKind {
                     Binding {
                         name: "foo"
+                        pinnedness: Not
                         mode: BindingMode(No, Not)
                         var: LocalVarId(HirId(DefId(0:16 ~ thir_tree_match[fcf8]::has_match).2))
                         ty: Foo