diff --git a/compiler/rustc_ast/src/ast.rs b/compiler/rustc_ast/src/ast.rs
index 8c2b521c560d9..c9dadc6c7861c 100644
--- a/compiler/rustc_ast/src/ast.rs
+++ b/compiler/rustc_ast/src/ast.rs
@@ -786,14 +786,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
@@ -811,20 +811,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 def0cb74d295b..4da33fd495a60 100644
--- a/compiler/rustc_ast_pretty/src/pprust/state.rs
+++ b/compiler/rustc_ast_pretty/src/pprust/state.rs
@@ -1713,10 +1713,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 a06540f832507..1245b8f83be83 100644
--- a/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
+++ b/compiler/rustc_borrowck/src/diagnostics/mutability_errors.rs
@@ -1218,7 +1218,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 321b18c9b78b2..6c745e9343077 100644
--- a/compiler/rustc_borrowck/src/lib.rs
+++ b/compiler/rustc_borrowck/src/lib.rs
@@ -2498,6 +2498,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_hir/src/hir.rs b/compiler/rustc_hir/src/hir.rs
index e7898648c2b05..2d4545a9f1ab6 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 95f6fba6487a6..c55afe3df24ff 100644
--- a/compiler/rustc_hir_analysis/src/check/region.rs
+++ b/compiler/rustc_hir_analysis/src/check/region.rs
@@ -559,7 +559,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 bda02042aa66b..9448ce05b8d4f 100644
--- a/compiler/rustc_hir_pretty/src/lib.rs
+++ b/compiler/rustc_hir_pretty/src/lib.rs
@@ -1919,10 +1919,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 2034131882820..b9f1463d8007d 100644
--- a/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
+++ b/compiler/rustc_hir_typeck/src/expr_use_visitor.rs
@@ -986,7 +986,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);
                         }
@@ -1004,7 +1004,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     // Deref patterns on boxes don't borrow, so we ignore them here.
                     // HACK: this could be a fake pattern corresponding to a deref inserted by match
                     // ergonomics, in which case `pat.hir_id` will be the id of the subpattern.
-                    if let hir::ByRef::Yes(mutability) =
+                    if let hir::ByRef::Yes(_, mutability) =
                         self.cx.typeck_results().deref_pat_borrow_mode(place.place.ty(), subpattern)
                     {
                         let bk = ty::BorrowKind::from_mutbl(mutability);
@@ -1256,7 +1256,15 @@ 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(_)) {
+                if let hir::ByRef::Yes(pinnedness, _) = bm.0 {
+                    let base_ty = if pinnedness.is_pinned() {
+                        base_ty.pinned_ty().ok_or_else(|| {
+                            debug!("By-pin-ref binding of non-`Pin` type: {base_ty:?}");
+                            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.
@@ -1264,7 +1272,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     {
                         Some(ty) => Ok(ty),
                         None => {
-                            debug!("By-ref binding of non-derefable type");
+                            debug!("By-ref binding of non-derefable type: {base_ty:?}");
                             Err(self
                                 .cx
                                 .report_bug(pat.span, "by-ref binding of non-derefable type"))
@@ -1706,6 +1714,18 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
                     };
                     self.pat_deref_place(pat.hir_id, place_with_id, pat, target_ty)?
                 }
+                adjustment::PatAdjust::PinDeref => {
+                    debug!("`PinDeref` of non-pinned-reference type: {:?}", adjust.source);
+                    let target_ty = adjust.source.pinned_ty().ok_or_else(|| {
+                        self.cx.report_bug(
+                            self.cx.tcx().hir_span(pat.hir_id),
+                            "`PinDeref` of non-pinned-reference type",
+                        )
+                    })?;
+                    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.
@@ -1877,7 +1897,7 @@ impl<'tcx, Cx: TypeInformationCtxt<'tcx>, D: Delegate<'tcx>> ExprUseVisitor<'tcx
             // Deref patterns on boxes are lowered using a built-in deref.
             hir::ByRef::No => self.cat_deref(hir_id, base_place),
             // For other types, we create a temporary to match on.
-            hir::ByRef::Yes(mutability) => {
+            hir::ByRef::Yes(_, mutability) => {
                 let re_erased = self.cx.tcx().lifetimes.re_erased;
                 let ty = Ty::new_ref(self.cx.tcx(), re_erased, target_ty, mutability);
                 // A deref pattern stores the result of `Deref::deref` or `DerefMut::deref_mut` ...
diff --git a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
index 0b3d50ff2199f..422c28edea0a4 100644
--- a/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
+++ b/compiler/rustc_hir_typeck/src/fn_ctxt/_impl.rs
@@ -23,7 +23,7 @@ use rustc_lint::builtin::SELF_CONSTRUCTOR_FROM_OUTER_ITEM;
 use rustc_middle::ty::adjustment::{Adjust, Adjustment, AutoBorrow, AutoBorrowMutability};
 use rustc_middle::ty::{
     self, AdtKind, CanonicalUserType, GenericArgsRef, GenericParamDefKind, IsIdentity,
-    SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitableExt, UserArgs,
+    SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitableExt, Upcast, UserArgs,
     UserSelfTy,
 };
 use rustc_middle::{bug, span_bug};
@@ -463,6 +463,29 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    pub(crate) fn register_negative_bound(
+        &self,
+        ty: Ty<'tcx>,
+        def_id: DefId,
+        cause: traits::ObligationCause<'tcx>,
+    ) {
+        if !ty.references_error() {
+            let trait_ref = ty::TraitRef::new(self.tcx, def_id, [ty]);
+            let predicate =
+                ty::TraitPredicate { trait_ref, polarity: ty::PredicatePolarity::Negative }
+                    .upcast(self.tcx);
+            self.fulfillment_cx.borrow_mut().register_predicate_obligation(
+                self,
+                traits::Obligation {
+                    cause,
+                    recursion_depth: 0,
+                    param_env: self.param_env,
+                    predicate,
+                },
+            );
+        }
+    }
+
     pub(crate) fn lower_ty(&self, hir_ty: &hir::Ty<'tcx>) -> LoweredTy<'tcx> {
         let ty = self.lowerer().lower_ty(hir_ty);
         self.register_wf_obligation(ty.into(), hir_ty.span, ObligationCauseCode::WellFormed(None));
diff --git a/compiler/rustc_hir_typeck/src/pat.rs b/compiler/rustc_hir_typeck/src/pat.rs
index bf4611e1e34a0..bc18934f6b923 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::RegionVariableOrigin;
 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;
@@ -27,7 +27,7 @@ use rustc_span::edition::Edition;
 use rustc_span::source_map::Spanned;
 use rustc_span::{BytePos, DUMMY_SP, Ident, Span, kw, sym};
 use rustc_trait_selection::infer::InferCtxtExt;
-use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
+use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode, ObligationCtxt};
 use tracing::{debug, instrument, trace};
 use ty::VariantDef;
 use ty::adjustment::{PatAdjust, PatAdjustment};
@@ -402,19 +402,38 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         let ty = self.check_pat_inner(pat, opt_path_res, adjust_mode, expected, pat_info);
         self.write_ty(pat.hir_id, ty);
 
-        // If we implicitly inserted overloaded dereferences before matching, check the pattern to
-        // see if the dereferenced types need `DerefMut` bounds.
-        if let Some(derefed_tys) = self.typeck_results.borrow().pat_adjustments().get(pat.hir_id)
-            && derefed_tys.iter().any(|adjust| adjust.kind == PatAdjust::OverloadedDeref)
-        {
-            self.register_deref_mut_bounds_if_needed(
-                pat.span,
-                pat,
-                derefed_tys.iter().filter_map(|adjust| match adjust.kind {
-                    PatAdjust::OverloadedDeref => Some(adjust.source),
-                    PatAdjust::BuiltinDeref => None,
-                }),
-            );
+        // If we implicitly inserted overloaded dereferences and pinned dereferences before matching,
+        // check the pattern to see if the dereferenced types need `DerefMut` or `!Unpin` bounds.
+        if let Some(derefed_tys) = self.typeck_results.borrow().pat_adjustments().get(pat.hir_id) {
+            let mut has_overloaded_deref = false;
+            let mut has_pin_deref = false;
+            derefed_tys.iter().for_each(|adjust| match adjust.kind {
+                PatAdjust::BuiltinDeref => {}
+                PatAdjust::OverloadedDeref => has_overloaded_deref = true,
+                PatAdjust::PinDeref => has_pin_deref = true,
+            });
+            if has_overloaded_deref {
+                self.register_deref_mut_bounds_if_needed(
+                    pat.span,
+                    pat,
+                    derefed_tys.iter().filter_map(|adjust| match adjust.kind {
+                        PatAdjust::OverloadedDeref => Some(adjust.source),
+                        PatAdjust::BuiltinDeref | PatAdjust::PinDeref => None,
+                    }),
+                );
+            }
+            if has_pin_deref {
+                self.register_not_unpin_bounds_if_needed(
+                    pat.span,
+                    pat,
+                    derefed_tys.iter().filter_map(|adjust| match adjust.kind {
+                        PatAdjust::BuiltinDeref | PatAdjust::OverloadedDeref => None,
+                        PatAdjust::PinDeref => {
+                            Some(adjust.source.pinned_ref().expect("expected pinned reference").0)
+                        }
+                    }),
+                );
+            }
         }
 
         // (note_1): In most of the cases where (note_1) is referenced
@@ -470,7 +489,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()
         {
@@ -488,12 +507,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
+            // Peel off a `&` or `&mut`from the scrutinee type. See the examples in
             // `tests/ui/rfcs/rfc-2005-default-binding-mode`.
             _ if let AdjustMode::Peel { kind: peel_kind } = adjust_mode
                 && pat.default_binding_modes
-                && let ty::Ref(_, inner_ty, inner_mutability) = *expected.kind()
+                && let &ty::Ref(_, inner_ty, inner_mutability) = expected.kind()
                 && self.should_peel_ref(peel_kind, expected) =>
             {
                 debug!("inspecting {:?}", expected);
@@ -507,22 +542,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);
@@ -532,6 +558,48 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 // Recurse with the new expected type.
                 self.check_pat_inner(pat, opt_path_res, adjust_mode, inner_ty, new_pat_info)
             }
+            // If `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().pin_ergonomics()
+                && let AdjustMode::Peel { kind: peel_kind } = adjust_mode
+                && pat.default_binding_modes
+                && self.should_peel_smart_pointer(peel_kind, expected)
+                && 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");
+
+                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, pat.span),
+                        self.misc(pat.span),
+                    )
+                }
+                // Once we've checked `pat`, we'll add a `!Unpin` bound if it contains any
+                // `ref pin` bindings. See `Self::register_not_unpin_bounds_if_needed`.
+
+                debug!("default binding mode is now {:?}", binding_mode);
+
+                // Use the old pat info to keep `current_depth` to its old value.
+                let new_pat_info = PatInfo { binding_mode, ..old_pat_info };
+
+                self.check_deref_pattern(
+                    pat,
+                    opt_path_res,
+                    adjust_mode,
+                    expected,
+                    inner_ty,
+                    PatAdjust::PinDeref,
+                    new_pat_info,
+                )
+            }
             // 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()
@@ -539,35 +607,23 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 && pat.default_binding_modes
                 && self.should_peel_smart_pointer(peel_kind, expected) =>
             {
-                debug!("scrutinee ty {expected:?} is a smart pointer, inserting overloaded deref");
+                debug!("scrutinee ty {expected:?} is a smart pointer, inserting pin deref");
+
                 // The scrutinee is a smart pointer; implicitly dereference it. This adds a
                 // requirement that `expected: DerefPure`.
-                let mut inner_ty = self.deref_pat_target(pat.span, expected);
+                let inner_ty = self.deref_pat_target(pat.span, expected);
                 // Once we've checked `pat`, we'll add a `DerefMut` bound if it contains any
                 // `ref mut` bindings. See `Self::register_deref_mut_bounds_if_needed`.
 
-                let mut typeck_results = self.typeck_results.borrow_mut();
-                let mut pat_adjustments_table = typeck_results.pat_adjustments_mut();
-                let pat_adjustments = pat_adjustments_table.entry(pat.hir_id).or_default();
-                // We may reach the recursion limit if a user matches on a type `T` satisfying
-                // `T: Deref<Target = T>`; error gracefully in this case.
-                // FIXME(deref_patterns): If `deref_patterns` stabilizes, it may make sense to move
-                // this check out of this branch. Alternatively, this loop could be implemented with
-                // autoderef and this check removed. For now though, don't break code compiling on
-                // stable with lots of `&`s and a low recursion limit, if anyone's done that.
-                if self.tcx.recursion_limit().value_within_limit(pat_adjustments.len()) {
-                    // Preserve the smart pointer type for THIR lowering and closure upvar analysis.
-                    pat_adjustments
-                        .push(PatAdjustment { kind: PatAdjust::OverloadedDeref, source: expected });
-                } else {
-                    let guar = report_autoderef_recursion_limit_error(self.tcx, pat.span, expected);
-                    inner_ty = Ty::new_error(self.tcx, guar);
-                }
-                drop(typeck_results);
-
-                // Recurse, using the old pat info to keep `current_depth` to its old value.
-                // Peeling smart pointers does not update the default binding mode.
-                self.check_pat_inner(pat, opt_path_res, adjust_mode, inner_ty, old_pat_info)
+                self.check_deref_pattern(
+                    pat,
+                    opt_path_res,
+                    adjust_mode,
+                    expected,
+                    inner_ty,
+                    PatAdjust::OverloadedDeref,
+                    old_pat_info,
+                )
             }
             PatKind::Missing | PatKind::Wild | PatKind::Err(_) => expected,
             // We allow any type here; we ensure that the type is uninhabited during match checking.
@@ -638,6 +694,44 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    fn check_deref_pattern(
+        &self,
+        pat: &'tcx Pat<'tcx>,
+        opt_path_res: Option<Result<ResolvedPat<'tcx>, ErrorGuaranteed>>,
+        adjust_mode: AdjustMode,
+        expected: Ty<'tcx>,
+        mut inner_ty: Ty<'tcx>,
+        pat_adjust_kind: PatAdjust,
+        pat_info: PatInfo<'tcx>,
+    ) -> Ty<'tcx> {
+        debug_assert!(
+            !matches!(pat_adjust_kind, PatAdjust::BuiltinDeref),
+            "unexpected deref pattern for builtin reference type {expected:?}",
+        );
+
+        let mut typeck_results = self.typeck_results.borrow_mut();
+        let mut pat_adjustments_table = typeck_results.pat_adjustments_mut();
+        let pat_adjustments = pat_adjustments_table.entry(pat.hir_id).or_default();
+        // We may reach the recursion limit if a user matches on a type `T` satisfying
+        // `T: Deref<Target = T>`; error gracefully in this case.
+        // FIXME(deref_patterns): If `deref_patterns` stabilizes, it may make sense to move
+        // this check out of this branch. Alternatively, this loop could be implemented with
+        // autoderef and this check removed. For now though, don't break code compiling on
+        // stable with lots of `&`s and a low recursion limit, if anyone's done that.
+        if self.tcx.recursion_limit().value_within_limit(pat_adjustments.len()) {
+            // Preserve the smart pointer type for THIR lowering and closure upvar analysis.
+            pat_adjustments.push(PatAdjustment { kind: pat_adjust_kind, source: expected });
+        } else {
+            let guar = report_autoderef_recursion_limit_error(self.tcx, pat.span, expected);
+            inner_ty = Ty::new_error(self.tcx, guar);
+        }
+        drop(typeck_results);
+
+        // Recurse, using the old pat info to keep `current_depth` to its old value.
+        // Peeling smart pointers does not update the default binding mode.
+        self.check_pat_inner(pat, opt_path_res, adjust_mode, inner_ty, pat_info)
+    }
+
     /// How should the binding mode and expected type be adjusted?
     ///
     /// When the pattern contains a path, `opt_path_res` must be `Some(path_res)`.
@@ -1052,7 +1146,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()
@@ -1082,8 +1176,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,
@@ -1099,7 +1193,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!(
@@ -1127,7 +1221,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.
@@ -1137,6 +1231,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, 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).
         };
@@ -2577,6 +2677,44 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
         }
     }
 
+    /// Check if the interior of a pin pattern (either explicit or implicit) has any `ref pin`
+    /// bindings of non-`Unpin` types, which would require `!Unpin` to be emitted.
+    fn register_not_unpin_bounds_if_needed(
+        &self,
+        span: Span,
+        inner: &'tcx Pat<'tcx>,
+        derefed_tys: impl IntoIterator<Item = Ty<'tcx>>,
+    ) {
+        // Check if there are subpatterns with `ref pin` binding modes of non-`Unpin` types.
+        let unpin = self.tcx.require_lang_item(hir::LangItem::Unpin, span);
+        let cause = self.misc(span);
+        let unpin_obligations = self.probe(|_| {
+            let ocx = ObligationCtxt::new(&self);
+            self.typeck_results.borrow().pat_walk_ref_pin_binding_of_non_unpin_type(inner, |ty| {
+                let ty = ocx
+                    .normalize(&cause, self.param_env, ty)
+                    .pinned_ref()
+                    .expect("expect pinned reference")
+                    .0;
+                debug!("check if `Unpin` is implemented for `{ty:?}`");
+                ocx.register_bound(cause.clone(), self.param_env, ty, unpin);
+            });
+            ocx.select_all_or_error()
+        });
+
+        // If any, the current pattern type should implement `!Unpin`.
+        if !unpin_obligations.is_empty() {
+            for pinned_derefed_ty in derefed_tys {
+                debug!("register `!Unpin` for `{pinned_derefed_ty:?}`");
+                self.register_negative_bound(
+                    pinned_derefed_ty,
+                    self.tcx.require_lang_item(hir::LangItem::Unpin, span),
+                    self.misc(span),
+                );
+            }
+        }
+    }
+
     // Precondition: Pat is Ref(inner)
     fn check_pat_ref(
         &self,
@@ -2603,7 +2741,9 @@ 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 {
+        // FIXME(pin_ergonomics): since `&pin` pattern is supported, the condition here
+        // should be adjusted to `pat_pin == inh_pin`
+        if let ByRef::Yes(Pinnedness::Not, 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
@@ -2622,9 +2762,22 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                     return expected;
                 }
                 InheritedRefMatchRule::EatInner => {
-                    if let ty::Ref(_, _, r_mutbl) = *expected.kind()
-                        && pat_mutbl <= r_mutbl
-                    {
+                    let expected_ref_or_pinned_ref = || {
+                        if self.tcx.features().pin_ergonomics()
+                            && let Some(ty::Ref(_, _, r_mutbl)) =
+                                expected.pinned_ty().map(|ty| *ty.kind())
+                            && pat_mutbl <= r_mutbl
+                        {
+                            return Some((Pinnedness::Pinned, r_mutbl));
+                        }
+                        if let ty::Ref(_, _, r_mutbl) = *expected.kind()
+                            && pat_mutbl <= r_mutbl
+                        {
+                            return Some((Pinnedness::Not, r_mutbl));
+                        }
+                        None
+                    };
+                    if let Some((_, r_mutbl)) = expected_ref_or_pinned_ref() {
                         // Match against the reference type; don't consume the inherited ref.
                         // NB: The check for compatible pattern and ref type mutability assumes that
                         // `&` patterns can match against mutable references (RFC 3627, Rule 5). If
@@ -3124,8 +3277,10 @@ 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 &= matches!(
+                user_bind_annot,
+                BindingMode(ByRef::Yes(_, mutbl), Mutability::Not) if mutbl == def_br_mutbl
+            );
             "binding modifier"
         } else {
             info.bad_ref_pats = true;
diff --git a/compiler/rustc_lint/src/static_mut_refs.rs b/compiler/rustc_lint/src/static_mut_refs.rs
index 4dda3c7951b87..59142a0d12711 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/ty/adjustment.rs b/compiler/rustc_middle/src/ty/adjustment.rs
index 74573455f531a..2920c9cb42ab4 100644
--- a/compiler/rustc_middle/src/ty/adjustment.rs
+++ b/compiler/rustc_middle/src/ty/adjustment.rs
@@ -232,4 +232,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 275458fc85f8d..f82e7fe891578 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 }
@@ -313,6 +315,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 }
     }
@@ -428,6 +433,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 8bb3b3f1263fa..b6c5f43e8c1e8 100644
--- a/compiler/rustc_middle/src/ty/sty.rs
+++ b/compiler/rustc_middle/src/ty/sty.rs
@@ -1286,6 +1286,23 @@ 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,
+        }
+    }
+
+    pub fn pinned_ref(self) -> Option<(Ty<'tcx>, ty::Mutability)> {
+        if let Adt(def, args) = self.kind()
+            && def.is_pin()
+            && let &ty::Ref(_, ty, mutbl) = args.type_at(0).kind()
+        {
+            return Some((ty, mutbl));
+        }
+        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 88583407d25d7..efdfca82d681e 100644
--- a/compiler/rustc_middle/src/ty/typeck_results.rs
+++ b/compiler/rustc_middle/src/ty/typeck_results.rs
@@ -11,6 +11,7 @@ use rustc_hir::def_id::{DefId, LocalDefId, LocalDefIdMap};
 use rustc_hir::hir_id::OwnerId;
 use rustc_hir::{
     self as hir, BindingMode, ByRef, HirId, ItemLocalId, ItemLocalMap, ItemLocalSet, Mutability,
+    Pinnedness,
 };
 use rustc_index::IndexVec;
 use rustc_macros::{HashStable, TyDecodable, TyEncodable, TypeFoldable, TypeVisitable};
@@ -462,7 +463,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;
@@ -475,6 +476,32 @@ impl<'tcx> TypeckResults<'tcx> {
         has_ref_mut
     }
 
+    /// Visits the pattern recursively whether it contains a `ref pin` binding
+    /// of non-`Unpin` type in it.
+    ///
+    /// This is used to determined whether a `&pin` pattern should emit a `!Unpin`
+    /// call for its pattern scrutinee.
+    ///
+    /// This is computed from the typeck results since we want to make
+    /// sure to apply any match-ergonomics adjustments, which we cannot
+    /// determine from the HIR alone.
+    pub fn pat_walk_ref_pin_binding_of_non_unpin_type<'a>(
+        &self,
+        pat: &hir::Pat<'_>,
+        mut ty_visitor: impl FnMut(Ty<'tcx>) + 'a,
+    ) {
+        pat.walk(|pat| {
+            if let hir::PatKind::Binding(_, id, _, _) = pat.kind
+                && let Some(BindingMode(ByRef::Yes(Pinnedness::Pinned, _), _)) =
+                    self.pat_binding_modes().get(id)
+            {
+                let ty = self.pat_ty(pat);
+                ty_visitor(ty);
+            }
+            true
+        });
+    }
+
     /// How should a deref pattern find the place for its inner pattern to match on?
     ///
     /// In most cases, if the pattern recursively contains a `ref mut` binding, we find the inner
@@ -486,7 +513,7 @@ impl<'tcx> TypeckResults<'tcx> {
             ByRef::No
         } else {
             let mutable = self.pat_has_ref_mut_binding(inner);
-            ByRef::Yes(if mutable { Mutability::Mut } else { Mutability::Not })
+            ByRef::Yes(Pinnedness::Not, if mutable { Mutability::Mut } else { Mutability::Not })
         }
     }
 
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 3a7854a5e118d..45367be4cd91b 100644
--- a/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
+++ b/compiler/rustc_mir_build/src/builder/matches/match_pair.rs
@@ -1,9 +1,10 @@
 use std::sync::Arc;
 
+use rustc_abi::FieldIdx;
 use rustc_hir::ByRef;
 use rustc_middle::mir::*;
 use rustc_middle::thir::*;
-use rustc_middle::ty::{self, Ty, TypeVisitableExt};
+use rustc_middle::ty::{self, Pinnedness, Ty, TypeVisitableExt};
 
 use crate::builder::Builder;
 use crate::builder::expr::as_place::{PlaceBase, PlaceBuilder};
@@ -278,7 +279,24 @@ impl<'tcx> MatchPairTree<'tcx> {
                 None
             }
 
-            PatKind::DerefPattern { ref subpattern, borrow: ByRef::Yes(mutability) } => {
+            PatKind::DerefPattern { ref subpattern, borrow: ByRef::Yes(Pinnedness::Pinned, _) } => {
+                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,
+                borrow: ByRef::Yes(Pinnedness::Not, mutability),
+            } => {
                 // Create a new temporary for each deref pattern.
                 // FIXME(deref_patterns): dedup temporaries to avoid multiple `deref()` calls?
                 let temp = cx.temp(
diff --git a/compiler/rustc_mir_build/src/builder/matches/mod.rs b/compiler/rustc_mir_build/src/builder/matches/mod.rs
index 2c29b8628417f..ab3613584d9ff 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, Pinnedness};
 use rustc_middle::middle::region;
 use rustc_middle::mir::{self, *};
 use rustc_middle::thir::{self, *};
 use rustc_middle::ty::{self, CanonicalUserTypeAnnotation, Ty, ValTree, ValTreeKind};
+use rustc_middle::{bug, span_bug};
 use rustc_pattern_analysis::constructor::RangeEnd;
 use rustc_pattern_analysis::rustc::{DeconstructedPat, RustcPatCtxt};
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
@@ -931,6 +931,10 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
                 visit_subpat(self, subpattern, &user_tys.deref(), f);
             }
 
+            PatKind::DerefPattern { ref subpattern, borrow: ByRef::Yes(Pinnedness::Pinned, _) } => {
+                visit_subpat(self, subpattern, &user_tys.leaf(FieldIdx::ZERO).deref(), f);
+            }
+
             PatKind::DerefPattern { ref subpattern, .. } => {
                 visit_subpat(self, subpattern, &ProjectedUserTypesNode::None, f);
             }
@@ -2704,7 +2708,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,
@@ -2716,6 +2720,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);
@@ -2758,14 +2768,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, 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 0b6b36640e92b..078e4e3186a2a 100644
--- a/compiler/rustc_mir_build/src/check_unsafety.rs
+++ b/compiler/rustc_mir_build/src/check_unsafety.rs
@@ -382,7 +382,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 7f47754f6bcd0..32e51c5519646 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/check_match.rs
@@ -797,7 +797,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)
                 }
             });
@@ -813,7 +813,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).
@@ -823,7 +823,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 a44afed5492d3..206165823b125 100644
--- a/compiler/rustc_mir_build/src/thir/pattern/mod.rs
+++ b/compiler/rustc_mir_build/src/thir/pattern/mod.rs
@@ -11,7 +11,7 @@ use rustc_abi::{FieldIdx, Integer};
 use rustc_errors::codes::*;
 use rustc_hir::def::{CtorOf, DefKind, Res};
 use rustc_hir::pat_util::EnumerateAndAdjustIterator;
-use rustc_hir::{self as hir, LangItem, RangeEnd};
+use rustc_hir::{self as hir, ByRef, LangItem, Mutability, Pinnedness, RangeEnd};
 use rustc_index::Idx;
 use rustc_infer::infer::TyCtxtInferExt;
 use rustc_middle::mir::interpret::LitToConstInput;
@@ -114,6 +114,16 @@ impl<'a, 'tcx> PatCtxt<'a, 'tcx> {
                     let borrow = self.typeck_results.deref_pat_borrow_mode(adjust.source, pat);
                     PatKind::DerefPattern { subpattern: thir_pat, borrow }
                 }
+                PatAdjust::PinDeref => {
+                    let mutable = self.typeck_results.pat_has_ref_mut_binding(pat);
+                    PatKind::DerefPattern {
+                        subpattern: thir_pat,
+                        borrow: ByRef::Yes(
+                            Pinnedness::Pinned,
+                            if mutable { Mutability::Mut } else { Mutability::Not },
+                        ),
+                    }
+                }
             };
             Box::new(Pat { span, ty: adjust.source, kind })
         });
@@ -354,11 +364,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_parse/src/parser/mod.rs b/compiler/rustc_parse/src/parser/mod.rs
index 90491e5324912..767447773443d 100644
--- a/compiler/rustc_parse/src/parser/mod.rs
+++ b/compiler/rustc_parse/src/parser/mod.rs
@@ -35,8 +35,8 @@ use rustc_ast::tokenstream::{
 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;
@@ -1316,7 +1316,12 @@ 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)) {
+            // FIXME(pin_ergonomics): support `ref pin const|mut` bindings
+            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 64653ee2a04c9..81cbe13923591 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.kind)
diff --git a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
index 2c7089507a897..816389426c921 100644
--- a/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs
@@ -52,20 +52,35 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
 
         let mut candidates = SelectionCandidateSet { vec: Vec::new(), ambiguous: false };
 
+        let def_id = obligation.predicate.def_id();
+        let tcx = self.tcx();
+
+        let lang_item = tcx.as_lang_item(def_id);
+
         // Negative trait predicates have different rules than positive trait predicates.
         if obligation.polarity() == ty::PredicatePolarity::Negative {
             self.assemble_candidates_for_trait_alias(obligation, &mut candidates);
             self.assemble_candidates_from_impls(obligation, &mut candidates);
             self.assemble_candidates_from_caller_bounds(stack, &mut candidates)?;
+
+            match lang_item {
+                Some(LangItem::Unpin) if tcx.features().pin_ergonomics() => {
+                    debug!(obligation_self_ty = ?obligation.predicate.skip_binder().self_ty());
+
+                    // impl `!Unpin` automatically for tuples, slices, and arrays
+                    // to support projections for pinned patterns.
+                    self.assemble_builtin_neg_unpin_candidate(
+                        obligation.predicate.self_ty().skip_binder(),
+                        &mut candidates,
+                    );
+                }
+                _ => {}
+            }
         } else {
             self.assemble_candidates_for_trait_alias(obligation, &mut candidates);
 
             // Other bounds. Consider both in-scope bounds from fn decl
             // and applicable impls. There is a certain set of precedence rules here.
-            let def_id = obligation.predicate.def_id();
-            let tcx = self.tcx();
-
-            let lang_item = tcx.as_lang_item(def_id);
             match lang_item {
                 Some(LangItem::Copy | LangItem::Clone) => {
                     debug!(obligation_self_ty = ?obligation.predicate.skip_binder().self_ty());
@@ -1218,6 +1233,59 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
         }
     }
 
+    /// Assembles `!Unpin` candidates for built-in types with no libcore-defined
+    /// `!Unpin` impls.
+    #[instrument(level = "debug", skip(self, candidates))]
+    fn assemble_builtin_neg_unpin_candidate(
+        &mut self,
+        self_ty: Ty<'tcx>,
+        candidates: &mut SelectionCandidateSet<'tcx>,
+    ) {
+        match *self_ty.kind() {
+            // `Unpin` types
+            ty::FnDef(..)
+            | ty::FnPtr(..)
+            | ty::Error(_)
+            | ty::Uint(_)
+            | ty::Int(_)
+            | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+            | ty::Bool
+            | ty::Float(_)
+            | ty::Char
+            | ty::RawPtr(..)
+            | ty::Never
+            | ty::Ref(..)
+            | ty::Dynamic(..)
+            | ty::Str
+            | ty::Foreign(..)
+            | ty::UnsafeBinder(_)
+            | ty::Pat(..) => {}
+
+            ty::Array(..) | ty::Slice(_) | ty::Tuple(_) => {
+                candidates.vec.push(BuiltinCandidate);
+            }
+
+            // FIXME(pin_ergonomics): should we impl `!Unpin` for coroutines or closures?
+            ty::Coroutine(..)
+            | ty::CoroutineWitness(..)
+            | ty::Closure(..)
+            | ty::CoroutineClosure(..) => {}
+
+            ty::Adt(..) | ty::Alias(..) | ty::Param(..) | ty::Placeholder(..) => {}
+
+            ty::Infer(ty::TyVar(_)) => {
+                candidates.ambiguous = true;
+            }
+
+            // We can make this an ICE if/once we actually instantiate the trait obligation eagerly.
+            ty::Bound(..) => {}
+
+            ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty);
+            }
+        }
+    }
+
     /// Assembles the `Sized` and `MetaSized` traits which are built-in to the language itself.
     #[instrument(level = "debug", skip(self, candidates))]
     fn assemble_builtin_sized_candidate(
diff --git a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
index 488094b15ac60..92040b1b5d584 100644
--- a/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/confirmation.rs
@@ -269,6 +269,9 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 bug!("`PointeeSized` is removing during lowering");
             }
             Some(LangItem::Copy | LangItem::Clone) => self.copy_clone_conditions(self_ty),
+            Some(LangItem::Unpin) if obligation.polarity() == ty::PredicatePolarity::Negative => {
+                self.neg_unpin_conditions(self_ty)
+            }
             Some(LangItem::FusedIterator) => {
                 if self.coroutine_is_gen(self_ty) {
                     ty::Binder::dummy(vec![])
@@ -294,6 +297,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             cause,
             obligation.recursion_depth + 1,
             trait_def,
+            obligation.polarity(),
             types,
         )
     }
@@ -420,6 +424,7 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 cause.clone(),
                 obligation.recursion_depth + 1,
                 obligation.predicate.def_id(),
+                obligation.polarity(),
                 constituents.types,
             );
 
diff --git a/compiler/rustc_trait_selection/src/traits/select/mod.rs b/compiler/rustc_trait_selection/src/traits/select/mod.rs
index 2b563c5b8d5fa..2a751d055a33d 100644
--- a/compiler/rustc_trait_selection/src/traits/select/mod.rs
+++ b/compiler/rustc_trait_selection/src/traits/select/mod.rs
@@ -2240,6 +2240,52 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         }
     }
 
+    fn neg_unpin_conditions(&mut self, self_ty: Ty<'tcx>) -> ty::Binder<'tcx, Vec<Ty<'tcx>>> {
+        match *self_ty.kind() {
+            ty::Array(ty, _) | ty::Slice(ty) => {
+                // (*) binder moved here
+                ty::Binder::dummy(vec![ty])
+            }
+            ty::Tuple(tys) => {
+                // (*) binder moved here
+                ty::Binder::dummy(tys.iter().collect())
+            }
+
+            // `Unpin` types
+            ty::FnDef(..)
+            | ty::FnPtr(..)
+            | ty::Error(_)
+            | ty::Uint(_)
+            | ty::Int(_)
+            | ty::Infer(ty::IntVar(_) | ty::FloatVar(_))
+            | ty::Bool
+            | ty::Float(_)
+            | ty::Char
+            | ty::RawPtr(..)
+            | ty::Never
+            | ty::Ref(..)
+            | ty::Dynamic(..)
+            | ty::Str
+            | ty::Foreign(..)
+            | ty::UnsafeBinder(_)
+            | ty::Pat(..) => bug!("`Unpin` type cannot have `!Unpin` bound"),
+
+            ty::Coroutine(..)
+            | ty::CoroutineWitness(..)
+            | ty::Closure(..)
+            | ty::CoroutineClosure(..)
+            | ty::Infer(ty::TyVar(_))
+            | ty::Bound(..)
+            | ty::Adt(..)
+            | ty::Alias(..)
+            | ty::Param(..)
+            | ty::Placeholder(..)
+            | ty::Infer(ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)) => {
+                bug!("asked to assemble builtin bounds of unexpected type: {:?}", self_ty)
+            }
+        }
+    }
+
     fn coroutine_is_gen(&mut self, self_ty: Ty<'tcx>) -> bool {
         matches!(*self_ty.kind(), ty::Coroutine(did, ..)
             if self.tcx().coroutine_is_gen(did))
@@ -2389,6 +2435,7 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
         cause: ObligationCause<'tcx>,
         recursion_depth: usize,
         trait_def_id: DefId,
+        polarity: ty::PredicatePolarity,
         types: Vec<Ty<'tcx>>,
     ) -> PredicateObligations<'tcx> {
         // Because the types were potentially derived from
@@ -2433,7 +2480,10 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                     ty::TraitRef::new_from_args(tcx, trait_def_id, err_args)
                 };
 
-                let obligation = Obligation::new(self.tcx(), cause.clone(), param_env, trait_ref);
+                let trait_predicate = ty::TraitPredicate { trait_ref, polarity };
+
+                let obligation =
+                    Obligation::new(self.tcx(), cause.clone(), param_env, trait_predicate);
                 obligations.push(obligation);
                 obligations
             })
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 3d131a7825aff..deee514afd21c 100644
--- a/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
+++ b/src/tools/clippy/clippy_lints/src/index_refutable_slice.rs
@@ -93,7 +93,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 b04db03f8d2e7..80e53fb06e1a3 100644
--- a/src/tools/clippy/clippy_lints/src/matches/needless_match.rs
+++ b/src/tools/clippy/clippy_lints/src/matches/needless_match.rs
@@ -172,7 +172,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 7c6d45e424006..0f631b1258c06 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 2ecf3eb897988..35f03070e65f1 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 de12a25b03dff..a0e36ecd29a8b 100644
--- a/src/tools/clippy/clippy_lints/src/question_mark.rs
+++ b/src/tools/clippy/clippy_lints/src/question_mark.rs
@@ -148,7 +148,7 @@ fn check_let_some_else_return_none(cx: &LateContext<'_>, stmt: &Stmt<'_>) {
         let init_expr_str = Sugg::hir_with_applicability(cx, init_expr, "..", &mut applicability).maybe_paren();
         // 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,
@@ -167,7 +167,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`
@@ -476,8 +476,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 ac92ab5a245cc..35223bf7ca3b5 100644
--- a/src/tools/clippy/clippy_lints/src/utils/author.rs
+++ b/src/tools/clippy/clippy_lints/src/utils/author.rs
@@ -716,10 +716,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 9d38672efada9..d0ea267224212 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 ff1ee663f9bf2..037c346444a6c 100644
--- a/src/tools/clippy/clippy_utils/src/lib.rs
+++ b/src/tools/clippy/clippy_utils/src/lib.rs
@@ -898,7 +898,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);
             },
             _ => (),
@@ -1905,7 +1905,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/rustfmt/src/patterns.rs b/src/tools/rustfmt/src/patterns.rs
index cb3879f4be8c9..41db29c42b25a 100644
--- a/src/tools/rustfmt/src/patterns.rs
+++ b/src/tools/rustfmt/src/patterns.rs
@@ -135,7 +135,8 @@ 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()),
+                    // FIXME(pin_ergonomics): format the pinnedness
+                    ByRef::Yes(_, rmutbl) => ("ref", format_mutability(rmutbl).trim()),
                     ByRef::No => ("", ""),
                 };
                 let id_str = rewrite_ident(context, ident);
diff --git a/tests/ui/pin-ergonomics/pattern-matching-deref-pattern.rs b/tests/ui/pin-ergonomics/pattern-matching-deref-pattern.rs
new file mode 100644
index 0000000000000..23d29e6f9dae4
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching-deref-pattern.rs
@@ -0,0 +1,91 @@
+//@ revisions: pin_ergonomics normal
+//@ edition:2024
+//@ check-pass
+// //@[normal] check-pass
+// //@[pin_ergonomics] rustc-env:RUSTC_LOG=rustc_hir_typeck::expr_use_visitor=DEBUG
+#![cfg_attr(pin_ergonomics, feature(pin_ergonomics))]
+#![feature(deref_patterns)]
+#![allow(incomplete_features)]
+
+// This test verifies that the `pin_ergonomics` feature works well
+// together with the `deref_patterns` feature.
+
+use std::pin::Pin;
+
+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 },
+}
+
+fn foo_mut<T: Unpin, U: Unpin>(foo: Pin<&mut Foo<T, U>>) {
+    let Foo { .. } = foo;
+    let Pin { .. } = foo;
+    let _ = || {
+        let Foo { .. } = foo;
+        let Pin { .. } = foo;
+    };
+
+    #[cfg(pin_ergonomics)]
+    let Foo { x, y } = foo;
+    #[cfg(pin_ergonomics)]
+    let _ = || {
+        let Foo { x, y } = foo;
+    };
+}
+
+fn foo_const<T: Unpin, U: Unpin>(foo: Pin<&Foo<T, U>>) {
+    let Foo { .. } = foo;
+    let Pin { .. } = foo;
+    let _ = || {
+        let Foo { .. } = foo;
+        let Pin { .. } = foo;
+    };
+
+    #[cfg(pin_ergonomics)]
+    let Foo { x, y } = foo;
+    #[cfg(pin_ergonomics)]
+    let _ = || {
+        let Foo { x, y } = foo;
+    };
+}
+
+fn bar_mut<T: Unpin, U: Unpin>(bar: Pin<&mut Bar<T, U>>) {
+    let Bar(..) = bar;
+    let Pin { .. } = bar;
+    let _ = || {
+        let Bar(..) = bar;
+        let Pin { .. } = bar;
+    };
+
+    #[cfg(pin_ergonomics)]
+    let Bar(x, y) = bar;
+    #[cfg(pin_ergonomics)]
+    let _ = || {
+        let Bar(x, y) = bar;
+    };
+}
+
+fn bar_const<T: Unpin, U: Unpin>(bar: Pin<&Bar<T, U>>) {
+    let Bar(..) = bar;
+    let Pin { .. } = bar;
+    let _ = || {
+        let Bar(..) = bar;
+        let Pin { .. } = bar;
+    };
+
+    #[cfg(pin_ergonomics)]
+    let Bar(x, y) = bar;
+    #[cfg(pin_ergonomics)]
+    let _ = || {
+        let Bar(x, y) = bar;
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr
new file mode 100644
index 0000000000000..2389fe9ed98cd
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.normal.stderr
@@ -0,0 +1,66 @@
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:27:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:31:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:49:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:53:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:71:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:75:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:93:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:97:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: aborting due to 8 previous errors
+
diff --git a/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.pin_ergonomics.stderr b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.pin_ergonomics.stderr
new file mode 100644
index 0000000000000..f23e5cf72a45e
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.pin_ergonomics.stderr
@@ -0,0 +1,130 @@
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:27:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:37:9
+   |
+LL |         Foo { x, y } => {}
+   |         ^^^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:31:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:42:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:49:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:59:9
+   |
+LL |         Foo { x, y } => {}
+   |         ^^^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:53:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:64:9
+   |
+LL |         Foo { .. } => {}
+   |         ^^^^^^^^^^ matches on the result of dereferencing `Pin<&Foo<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Foo<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:71:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:81:9
+   |
+LL |         Bar(x, y) => {}
+   |         ^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:75:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:86:9
+   |
+LL |         Bar(x, y) => {}
+   |         ^^^^^^^^^ matches on the result of dereferencing `Pin<&mut Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&mut Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:93:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:103:9
+   |
+LL |         Bar(x, y) => {}
+   |         ^^^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:97:9
+   |
+LL |         Bar(..) => {}
+   |         ^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: mix of deref patterns and normal constructors
+  --> $DIR/pattern-matching-mix-deref-pattern.rs:108:9
+   |
+LL |         Bar(x, y) => {}
+   |         ^^^^^^^^^ matches on the result of dereferencing `Pin<&Bar<T, U>>`
+LL |         Pin { .. } => {}
+   |         ^^^^^^^^^^ matches directly on `Pin<&Bar<T, U>>`
+
+error: aborting due to 16 previous errors
+
diff --git a/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.rs b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.rs
new file mode 100644
index 0000000000000..c5ba9dbeb2e6e
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching-mix-deref-pattern.rs
@@ -0,0 +1,113 @@
+//@ revisions: pin_ergonomics normal
+//@ edition:2024
+#![cfg_attr(pin_ergonomics, feature(pin_ergonomics))]
+#![feature(deref_patterns)]
+#![allow(incomplete_features)]
+
+// This test verifies that the `pin_ergonomics` feature works well
+// together with the `deref_patterns` feature under the error:
+// "mix of deref patterns and normal constructors".
+
+use std::pin::Pin;
+
+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 },
+}
+
+fn foo_mut<T: Unpin, U: Unpin>(foo: Pin<&mut Foo<T, U>>) {
+    match foo {
+        Foo { .. } => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    let _ = || match foo {
+        Foo { .. } => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+
+    #[cfg(pin_ergonomics)]
+    match foo {
+        Foo { x, y } => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    #[cfg(pin_ergonomics)]
+    let _ = || match foo {
+        Foo { .. } => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+}
+
+fn foo_const<T: Unpin, U: Unpin>(foo: Pin<&Foo<T, U>>) {
+    match foo {
+        Foo { .. } => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    let _ = || match foo {
+        Foo { .. } => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+
+    #[cfg(pin_ergonomics)]
+    match foo {
+        Foo { x, y } => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    #[cfg(pin_ergonomics)]
+    let _ = || match foo {
+        Foo { .. } => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+}
+
+fn bar_mut<T: Unpin, U: Unpin>(bar: Pin<&mut Bar<T, U>>) {
+    match bar {
+        Bar(..) => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    let _ = || match bar {
+        Bar(..) => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+
+    #[cfg(pin_ergonomics)]
+    match bar {
+        Bar(x, y) => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    #[cfg(pin_ergonomics)]
+    let _ = || match bar {
+        Bar(x, y) => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+}
+
+fn bar_const<T: Unpin, U: Unpin>(bar: Pin<&Bar<T, U>>) {
+    match bar {
+        Bar(..) => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    let _ = || match bar {
+        Bar(..) => {} //~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+
+    #[cfg(pin_ergonomics)]
+    match bar {
+        Bar(x, y) => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    }
+    #[cfg(pin_ergonomics)]
+    let _ = || match bar {
+        Bar(x, y) => {} //[pin_ergonomics]~ ERROR mix of deref patterns and normal constructors
+        Pin { .. } => {}
+    };
+}
+
+fn main() {}
diff --git a/tests/ui/pin-ergonomics/pattern-matching.normal.stderr b/tests/ui/pin-ergonomics/pattern-matching.normal.stderr
new file mode 100644
index 0000000000000..5e91fae18cca5
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching.normal.stderr
@@ -0,0 +1,208 @@
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:41:9
+   |
+LL |     let Foo { x, y } = foo_mut;
+   |         ^^^^^^^^^^^^   ------- 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_mut;
+   |                        +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:46:9
+   |
+LL |     let Foo { x, y } = foo_const;
+   |         ^^^^^^^^^^^^   --------- 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_const;
+   |                        +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:54:9
+   |
+LL |     let Foo { x, .. } = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- 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, .. } = *foo_mut;
+   |                         +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:58:9
+   |
+LL |     let Foo { x, .. } = foo_const;
+   |         ^^^^^^^^^^^^^   --------- 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, .. } = *foo_const;
+   |                         +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:68:9
+   |
+LL |     let NegUnpinFoo { x, y } = foo_mut;
+   |         ^^^^^^^^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NegUnpinFoo<T, U>>`
+   |         |
+   |         expected `Pin<&mut NegUnpinFoo<T, U>>`, found `NegUnpinFoo<_, _>`
+   |
+   = note: expected struct `Pin<&mut NegUnpinFoo<T, U>>`
+              found struct `NegUnpinFoo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let NegUnpinFoo { x, y } = *foo_mut;
+   |                                +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:73:9
+   |
+LL |     let NegUnpinFoo { x, y } = foo_const;
+   |         ^^^^^^^^^^^^^^^^^^^^   --------- this expression has type `Pin<&NegUnpinFoo<T, U>>`
+   |         |
+   |         expected `Pin<&NegUnpinFoo<T, U>>`, found `NegUnpinFoo<_, _>`
+   |
+   = note: expected struct `Pin<&NegUnpinFoo<T, U>>`
+              found struct `NegUnpinFoo<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let NegUnpinFoo { x, y } = *foo_const;
+   |                                +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:85:9
+   |
+LL |     match bar_mut {
+   |           ------- this expression has type `Pin<&mut NegUnpinBar<T, U>>`
+LL |         NegUnpinBar::Foo(x, y) => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&mut NegUnpinBar<T, U>>`, found `NegUnpinBar<_, _>`
+   |
+   = note: expected struct `Pin<&mut NegUnpinBar<T, U>>`
+                found enum `NegUnpinBar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *bar_mut {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:90:18
+   |
+LL |         _ if let NegUnpinBar::Bar { x, y } = bar_mut => {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NegUnpinBar<T, U>>`
+   |                  |
+   |                  expected `Pin<&mut NegUnpinBar<T, U>>`, found `NegUnpinBar<_, _>`
+   |
+   = note: expected struct `Pin<&mut NegUnpinBar<T, U>>`
+                found enum `NegUnpinBar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |         _ if let NegUnpinBar::Bar { x, y } = *bar_mut => {
+   |                                              +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:98:9
+   |
+LL |     match bar_const {
+   |           --------- this expression has type `Pin<&NegUnpinBar<T, U>>`
+LL |         NegUnpinBar::Bar { x, y } => {
+   |         ^^^^^^^^^^^^^^^^^^^^^^^^^ expected `Pin<&NegUnpinBar<T, U>>`, found `NegUnpinBar<_, _>`
+   |
+   = note: expected struct `Pin<&NegUnpinBar<T, U>>`
+                found enum `NegUnpinBar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     match *bar_const {
+   |           +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:103:18
+   |
+LL |         _ if let NegUnpinBar::Foo(x, y) = bar_const => {
+   |                  ^^^^^^^^^^^^^^^^^^^^^^   --------- this expression has type `Pin<&NegUnpinBar<T, U>>`
+   |                  |
+   |                  expected `Pin<&NegUnpinBar<T, U>>`, found `NegUnpinBar<_, _>`
+   |
+   = note: expected struct `Pin<&NegUnpinBar<T, U>>`
+                found enum `NegUnpinBar<_, _>`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |         _ if let NegUnpinBar::Foo(x, y) = *bar_const => {
+   |                                           +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:116:9
+   |
+LL |     let (NegUnpinFoo { x, y },) = foo_mut;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut (NegUnpinFoo<T, U>,)>`
+   |         |
+   |         expected `Pin<&mut (NegUnpinFoo<T, U>,)>`, found `(_,)`
+   |
+   = note: expected struct `Pin<&mut (NegUnpinFoo<T, U>,)>`
+               found tuple `(_,)`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let (NegUnpinFoo { x, y },) = *foo_mut;
+   |                                   +
+
+error[E0308]: mismatched types
+  --> $DIR/pattern-matching.rs:120:9
+   |
+LL |     let (NegUnpinFoo { x, y },) = foo_const;
+   |         ^^^^^^^^^^^^^^^^^^^^^^^   --------- this expression has type `Pin<&(NegUnpinFoo<T, U>,)>`
+   |         |
+   |         expected `Pin<&(NegUnpinFoo<T, U>,)>`, found `(_,)`
+   |
+   = note: expected struct `Pin<&(NegUnpinFoo<T, U>,)>`
+               found tuple `(_,)`
+help: consider dereferencing to access the inner value using the Deref trait
+   |
+LL |     let (NegUnpinFoo { x, y },) = *foo_const;
+   |                                   +
+
+error[E0529]: expected an array or slice, found `Pin<&mut [NegUnpinFoo<T, U>; 1]>`
+  --> $DIR/pattern-matching.rs:130:9
+   |
+LL |     let [NegUnpinFoo { x, y }] = foo_mut;
+   |         ^^^^^^^^^^^^^^^^^^^^^^ pattern cannot match with input type `Pin<&mut [NegUnpinFoo<T, U>; 1]>`
+
+error[E0529]: expected an array or slice, found `Pin<&[NegUnpinFoo<T, U>; 1]>`
+  --> $DIR/pattern-matching.rs:134:9
+   |
+LL |     let [NegUnpinFoo { x, y }] = foo_const;
+   |         ^^^^^^^^^^^^^^^^^^^^^^ pattern cannot match with input type `Pin<&[NegUnpinFoo<T, U>; 1]>`
+
+error[E0529]: expected an array or slice, found `Pin<&mut [NegUnpinFoo<T, U>]>`
+  --> $DIR/pattern-matching.rs:144:12
+   |
+LL |     if let [NegUnpinFoo { x, y }] = foo_mut {
+   |            ^^^^^^^^^^^^^^^^^^^^^^ pattern cannot match with input type `Pin<&mut [NegUnpinFoo<T, U>]>`
+
+error[E0529]: expected an array or slice, found `Pin<&[NegUnpinFoo<T, U>]>`
+  --> $DIR/pattern-matching.rs:149:12
+   |
+LL |     if let [NegUnpinFoo { x, y }] = foo_const {
+   |            ^^^^^^^^^^^^^^^^^^^^^^ pattern cannot match with input type `Pin<&[NegUnpinFoo<T, U>]>`
+
+error: aborting due to 16 previous errors
+
+Some errors have detailed explanations: E0308, E0529.
+For more information about an error, try `rustc --explain E0308`.
diff --git a/tests/ui/pin-ergonomics/pattern-matching.rs b/tests/ui/pin-ergonomics/pattern-matching.rs
new file mode 100644
index 0000000000000..42cb86d7fdc6f
--- /dev/null
+++ b/tests/ui/pin-ergonomics/pattern-matching.rs
@@ -0,0 +1,156 @@
+//@ revisions: pin_ergonomics normal
+//@ edition:2024
+//@[pin_ergonomics] check-pass
+#![cfg_attr(pin_ergonomics, feature(pin_ergonomics))]
+#![feature(if_let_guard, negative_impls)]
+#![allow(incomplete_features)]
+
+use std::pin::Pin;
+
+// This test verifies that a `&pin mut T` can be projected to a pinned
+// reference field `&pin mut T.U` when `T: !Unpin` or when `U: Unpin`.
+
+struct Foo<T, U> {
+    x: T,
+    y: U,
+}
+
+struct NegUnpinFoo<T, U> {
+    x: T,
+    y: U,
+}
+
+enum NegUnpinBar<T, U> {
+    Foo(T, U),
+    Bar { x: T, y: U },
+}
+
+impl<T, U> !Unpin for NegUnpinFoo<T, U> {}
+impl<T, U> !Unpin for NegUnpinBar<T, 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) {}
+
+// Pinned references can be projected to pinned references of `Unpin` fields
+fn unpin2unpin<T: Unpin, U: Unpin>(foo_mut: Pin<&mut Foo<T, U>>, foo_const: Pin<&Foo<T, U>>) {
+    let Foo { x, y } = foo_mut;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+
+    let Foo { x, y } = foo_const;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+// Pinned references can be only projected to pinned references of `Unpin` fields
+fn unpin2partial_unpin<T: Unpin, U>(foo_mut: Pin<&mut Foo<T, U>>, foo_const: Pin<&Foo<T, U>>) {
+    let Foo { x, .. } = foo_mut;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+
+    let Foo { x, .. } = foo_const;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+}
+
+// Pinned references of `!Unpin` types can be projected to pinned references
+fn neg_unpin2not_unpin<T, U>(
+    foo_mut: Pin<&mut NegUnpinFoo<T, U>>,
+    foo_const: Pin<&NegUnpinFoo<T, U>>,
+) {
+    let NegUnpinFoo { x, y } = foo_mut;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+
+    let NegUnpinFoo { x, y } = foo_const;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+// Pinned references of `!Unpin` types can be projected to pinned references of `Unpin` fields
+fn neg_unpin2unpin<T: Unpin, U: Unpin>(
+    bar_mut: Pin<&mut NegUnpinBar<T, U>>,
+    bar_const: Pin<&NegUnpinBar<T, U>>,
+) {
+    match bar_mut {
+        NegUnpinBar::Foo(x, y) => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+        }
+        _ if let NegUnpinBar::Bar { x, y } = bar_mut => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_mut(x);
+            assert_pin_mut(y);
+        }
+        _ => {}
+    }
+    match bar_const {
+        NegUnpinBar::Bar { x, y } => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+        _ if let NegUnpinBar::Foo(x, y) = bar_const => {
+            //[normal]~^ ERROR mismatched types
+            assert_pin_const(x);
+            assert_pin_const(y);
+        }
+        _ => {}
+    }
+}
+
+fn neg_unpin_tuple<T, U>(
+    foo_mut: Pin<&mut (NegUnpinFoo<T, U>,)>,
+    foo_const: Pin<&(NegUnpinFoo<T, U>,)>,
+) {
+    let (NegUnpinFoo { x, y },) = foo_mut;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+    let (NegUnpinFoo { x, y },) = foo_const;
+    //[normal]~^ ERROR mismatched types
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+fn neg_unpin_array<T, U>(
+    foo_mut: Pin<&mut [NegUnpinFoo<T, U>; 1]>,
+    foo_const: Pin<&[NegUnpinFoo<T, U>; 1]>,
+) {
+    let [NegUnpinFoo { x, y }] = foo_mut;
+    //[normal]~^ ERROR expected an array or slice, found `Pin<&mut [NegUnpinFoo<T, U>; 1]>`
+    assert_pin_mut(x);
+    assert_pin_mut(y);
+    let [NegUnpinFoo { x, y }] = foo_const;
+    //[normal]~^ ERROR expected an array or slice, found `Pin<&[NegUnpinFoo<T, U>; 1]>`
+    assert_pin_const(x);
+    assert_pin_const(y);
+}
+
+fn neg_unpin_slice<T, U>(
+    foo_mut: Pin<&mut [NegUnpinFoo<T, U>]>,
+    foo_const: Pin<&[NegUnpinFoo<T, U>]>,
+) {
+    if let [NegUnpinFoo { x, y }] = foo_mut {
+        //[normal]~^ ERROR expected an array or slice, found `Pin<&mut [NegUnpinFoo<T, U>]>`
+        assert_pin_mut(x);
+        assert_pin_mut(y);
+    }
+    if let [NegUnpinFoo { x, y }] = foo_const {
+        //[normal]~^ ERROR expected an array or slice, found `Pin<&[NegUnpinFoo<T, U>]>`
+        assert_pin_const(x);
+        assert_pin_const(y);
+    }
+}
+
+fn main() {}
diff --git a/tests/ui/pin-ergonomics/projection-unpin-checks.rs b/tests/ui/pin-ergonomics/projection-unpin-checks.rs
new file mode 100644
index 0000000000000..3a7c4f04c6903
--- /dev/null
+++ b/tests/ui/pin-ergonomics/projection-unpin-checks.rs
@@ -0,0 +1,132 @@
+//@ edition:2024
+#![feature(pin_ergonomics, negative_impls)]
+#![allow(incomplete_features)]
+
+// This test verifies that a `&pin mut T` cannot be projected to a pinned
+// reference field `&pin mut T.U` if neither `T: !Unpin` nor `U: Unpin`.
+
+struct Foo<T>(T);
+struct NotUnpinFoo<T>(T, std::marker::PhantomPinned);
+struct NegUnpinFoo<T>(T);
+
+impl<T> !Unpin for NegUnpinFoo<T> {}
+
+fn unpin2not_unpin<T>(foo_mut: &pin mut Foo<T>, foo_const: &pin const Foo<T>) {
+    let Foo(_x) = foo_mut; //~ ERROR the trait bound `Foo<T>: !Unpin` is not satisfied [E0277]
+    let Foo(_x) = foo_const; //~ ERROR the trait bound `Foo<T>: !Unpin` is not satisfied [E0277]
+    let Foo(_x) = (|| foo_mut)(); //~ ERROR the trait bound `Foo<T>: !Unpin` is not satisfied [E0277]
+    let Foo(_x) = (|| foo_const)(); //~ ERROR the trait bound `Foo<T>: !Unpin` is not satisfied [E0277]
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // error
+    // let &pin mut _foo_const = foo_const; // error
+}
+
+fn unpin2unpin<T: Unpin>(foo_mut: &pin mut Foo<T>, foo_const: &pin const Foo<T>) {
+    let Foo(_x) = foo_mut; // ok
+    let Foo(_x) = foo_const; // ok
+    let Foo(_x) = (|| foo_mut)(); // ok
+    let Foo(_x) = (|| foo_const)(); // ok
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // ok
+    // let &pin mut _foo_const = foo_const; // ok
+}
+
+fn not_unpin2not_unpin<T>(foo_mut: &pin mut NotUnpinFoo<T>, foo_const: &pin const NotUnpinFoo<T>) {
+    let NotUnpinFoo(_x, _) = foo_mut; //~ ERROR the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied [E0277]
+    let NotUnpinFoo(_x, _) = foo_const; //~ ERROR the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied [E0277]
+    let NotUnpinFoo(_x, _) = (|| foo_mut)(); //~ ERROR the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied [E0277]
+    let NotUnpinFoo(_x, _) = (|| foo_const)(); //~ ERROR the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied [E0277]
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // error
+    // let &pin mut _foo_const = foo_const; // error
+}
+
+fn not_unpin2unpin<T: Unpin>(
+    foo_mut: &pin mut NotUnpinFoo<T>,
+    foo_const: &pin const NotUnpinFoo<T>,
+) {
+    let NotUnpinFoo(_x, _) = foo_mut; // ok
+    let NotUnpinFoo(_x, _) = foo_const; // ok
+    let NotUnpinFoo(_x, _) = (|| foo_mut)(); // ok
+    let NotUnpinFoo(_x, _) = (|| foo_const)(); // ok
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // ok
+    // let &pin mut _foo_const = foo_const; // ok
+}
+
+fn neg_unpin2not_unpin<T>(foo_mut: &pin mut NegUnpinFoo<T>, foo_const: &pin const NegUnpinFoo<T>) {
+    let NegUnpinFoo(_x) = foo_mut; // ok
+    let NegUnpinFoo(_x) = foo_const; // ok
+    let NegUnpinFoo(_x) = (|| foo_mut)(); // ok
+    let NegUnpinFoo(_x) = (|| foo_const)(); // ok
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // ok
+    // let &pin mut _foo_const = foo_const; // ok
+}
+
+fn neg_unpin2unpin<T: Unpin>(
+    foo_mut: &pin mut NegUnpinFoo<T>,
+    foo_const: &pin const NegUnpinFoo<T>,
+) {
+    let NegUnpinFoo(_x) = foo_mut; // ok
+    let NegUnpinFoo(_x) = foo_const; // ok
+    let NegUnpinFoo(_x) = (|| foo_mut)(); // ok
+    let NegUnpinFoo(_x) = (|| foo_const)(); // ok
+    let &mut _foo_mut = foo_mut; //~ ERROR mismatched types
+    let &_foo_const = foo_const; //~ ERROR mismatched types
+    // FIXME(pin_ergonomics): add these tests since `&pin` pattern is ready
+    // let &pin mut _foo_mut = foo_mut; // ok
+    // let &pin mut _foo_const = foo_const; // ok
+}
+
+fn tuple_ref_mut_pat_and_pin_mut_of_tuple_mut_ty<'a, T>(
+    (&mut x,): &'a pin mut (&'a mut NegUnpinFoo<T>,),
+    //~^ ERROR the trait bound `&'a mut NegUnpinFoo<T>: !Unpin` is not satisfied in `(&'a mut NegUnpinFoo<T>,)` [E0277]
+) -> &'a pin mut NegUnpinFoo<T> {
+    x
+}
+
+fn tuple_ref_mut_pat_and_pin_mut_of_mut_tuple_ty<'a, T>(
+    (&mut x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+    //~^ ERROR mismatched type
+    //~| ERROR the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied [E0277]
+) -> &'a pin mut NegUnpinFoo<T> {
+    x
+}
+
+fn ref_mut_tuple_pat_and_pin_mut_of_tuple_mut_ty<'a, T>(
+    &mut (x,): &'a pin mut (&'a mut NegUnpinFoo<T>,), //~ ERROR mismatched type
+) -> &'a pin mut NegUnpinFoo<T> {
+    x
+}
+
+fn ref_mut_tuple_pat_and_pin_mut_of_mut_tuple_ty<'a, T>(
+    &mut (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,), //~ ERROR mismatched type
+) -> &'a pin mut NegUnpinFoo<T> {
+    x
+}
+
+fn tuple_pat_and_pin_mut_of_tuple_mut_ty<'a, T>(
+    (x,): &'a pin mut (&'a mut NegUnpinFoo<T>,),
+) -> &'a pin mut &'a mut NegUnpinFoo<T> {
+    x // ok
+}
+
+fn tuple_pat_and_pin_mut_of_mut_tuple_ty<'a, T>(
+    (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+    //~^ ERROR the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied [E0277]
+) -> &'a pin mut NegUnpinFoo<T> {
+    x
+}
+
+fn main() {}
diff --git a/tests/ui/pin-ergonomics/projection-unpin-checks.stderr b/tests/ui/pin-ergonomics/projection-unpin-checks.stderr
new file mode 100644
index 0000000000000..c79e1e11b0771
--- /dev/null
+++ b/tests/ui/pin-ergonomics/projection-unpin-checks.stderr
@@ -0,0 +1,333 @@
+error[E0277]: the trait bound `Foo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:15:9
+   |
+LL |     let Foo(_x) = foo_mut;
+   |         ^^^^^^^ the trait bound `Foo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `Foo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:16:9
+   |
+LL |     let Foo(_x) = foo_const;
+   |         ^^^^^^^ the trait bound `Foo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `Foo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:17:9
+   |
+LL |     let Foo(_x) = (|| foo_mut)();
+   |         ^^^^^^^ the trait bound `Foo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `Foo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:18:9
+   |
+LL |     let Foo(_x) = (|| foo_const)();
+   |         ^^^^^^^ the trait bound `Foo<T>: !Unpin` is not satisfied
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:19:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut Foo<T>>`
+   |         |
+   |         expected `Pin<&mut Foo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut Foo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut Foo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:20:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&Foo<T>>`
+   |         |
+   |         expected `Pin<&Foo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&Foo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&Foo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:31:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut Foo<T>>`
+   |         |
+   |         expected `Pin<&mut Foo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut Foo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut Foo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:32:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&Foo<T>>`
+   |         |
+   |         expected `Pin<&Foo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&Foo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&Foo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0277]: the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:39:9
+   |
+LL |     let NotUnpinFoo(_x, _) = foo_mut;
+   |         ^^^^^^^^^^^^^^^^^^ the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:40:9
+   |
+LL |     let NotUnpinFoo(_x, _) = foo_const;
+   |         ^^^^^^^^^^^^^^^^^^ the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:41:9
+   |
+LL |     let NotUnpinFoo(_x, _) = (|| foo_mut)();
+   |         ^^^^^^^^^^^^^^^^^^ the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+
+error[E0277]: the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:42:9
+   |
+LL |     let NotUnpinFoo(_x, _) = (|| foo_const)();
+   |         ^^^^^^^^^^^^^^^^^^ the trait bound `NotUnpinFoo<T>: !Unpin` is not satisfied
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:43:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NotUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&mut NotUnpinFoo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut NotUnpinFoo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut NotUnpinFoo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:44:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&NotUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&NotUnpinFoo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&NotUnpinFoo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&NotUnpinFoo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:58:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NotUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&mut NotUnpinFoo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut NotUnpinFoo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut NotUnpinFoo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:59:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&NotUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&NotUnpinFoo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&NotUnpinFoo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&NotUnpinFoo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:70:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NegUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&mut NegUnpinFoo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut NegUnpinFoo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut NegUnpinFoo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:71:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&NegUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&NegUnpinFoo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&NegUnpinFoo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&NegUnpinFoo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:85:9
+   |
+LL |     let &mut _foo_mut = foo_mut;
+   |         ^^^^^^^^^^^^^   ------- this expression has type `Pin<&mut NegUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&mut NegUnpinFoo<T>>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&mut NegUnpinFoo<T>>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&mut NegUnpinFoo<T>`
+   |
+LL |     let &mut _foo_mut = foo_mut.pointer;
+   |                                ++++++++
+help: to declare a mutable variable use
+   |
+LL -     let &mut _foo_mut = foo_mut;
+LL +     let mut _foo_mut = foo_mut;
+   |
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:86:9
+   |
+LL |     let &_foo_const = foo_const;
+   |         ^^^^^^^^^^^   --------- this expression has type `Pin<&NegUnpinFoo<T>>`
+   |         |
+   |         expected `Pin<&NegUnpinFoo<T>>`, found `&_`
+   |
+   = note: expected struct `Pin<&NegUnpinFoo<T>>`
+           found reference `&_`
+help: you might have meant to use field `pointer` whose type is `&NegUnpinFoo<T>`
+   |
+LL |     let &_foo_const = foo_const.pointer;
+   |                                ++++++++
+
+error[E0277]: the trait bound `&'a mut NegUnpinFoo<T>: !Unpin` is not satisfied in `(&'a mut NegUnpinFoo<T>,)`
+  --> $DIR/projection-unpin-checks.rs:93:5
+   |
+LL |     (&mut x,): &'a pin mut (&'a mut NegUnpinFoo<T>,),
+   |     ^^^^^^^^^ within `(&'a mut NegUnpinFoo<T>,)`, the trait bound `&'a mut NegUnpinFoo<T>: !Unpin` is not satisfied
+   |
+   = note: required because it appears within the type `(&'a mut NegUnpinFoo<T>,)`
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:100:6
+   |
+LL |     (&mut x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |      ^^^^^^    ------------------------------------- expected due to this
+   |      |
+   |      expected `NegUnpinFoo<T>`, found `&mut _`
+   |
+   = note:         expected struct `NegUnpinFoo<T>`
+           found mutable reference `&mut _`
+note: to declare a mutable binding use: `mut x`
+  --> $DIR/projection-unpin-checks.rs:100:6
+   |
+LL |     (&mut x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |      ^^^^^^
+help: consider removing `&mut` from the pattern
+   |
+LL -     (&mut x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+LL +     (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |
+
+error[E0277]: the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:100:5
+   |
+LL |     (&mut x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |     ^^^^^^^^^ the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:108:5
+   |
+LL |     &mut (x,): &'a pin mut (&'a mut NegUnpinFoo<T>,),
+   |     ^^^^^^^^^  ------------------------------------- expected due to this
+   |     |
+   |     expected `Pin<&mut (&mut NegUnpinFoo<T>,)>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&'a mut (&'a mut NegUnpinFoo<T>,)>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&'a mut (&'a mut NegUnpinFoo<T>,)`
+   |
+LL |     &mut (x,): &'a pin mut (&'a mut NegUnpinFoo<T>,).pointer,
+   |                                                     ++++++++
+
+error[E0308]: mismatched types
+  --> $DIR/projection-unpin-checks.rs:114:5
+   |
+LL |     &mut (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |     ^^^^^^^^^  ------------------------------------- expected due to this
+   |     |
+   |     expected `Pin<&mut &mut (NegUnpinFoo<T>,)>`, found `&mut _`
+   |
+   = note:         expected struct `Pin<&'a mut &'a mut (NegUnpinFoo<T>,)>`
+           found mutable reference `&mut _`
+help: you might have meant to use field `pointer` whose type is `&'a mut &'a mut (NegUnpinFoo<T>,)`
+   |
+LL |     &mut (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,).pointer,
+   |                                                     ++++++++
+
+error[E0277]: the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied
+  --> $DIR/projection-unpin-checks.rs:126:5
+   |
+LL |     (x,): &'a pin mut &'a mut (NegUnpinFoo<T>,),
+   |     ^^^^ the trait bound `&'a mut (NegUnpinFoo<T>,): !Unpin` is not satisfied
+
+error: aborting due to 26 previous errors
+
+Some errors have detailed explanations: E0277, E0308.
+For more information about an error, try `rustc --explain E0277`.