require T: !Unpin for &pin mut T to be projected to &pin mut T.U where U: ?Unpin

Author: frank-king

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};
@@ -464,6 +464,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));

compiler/rustc_hir_typeck/src/pat.rs

@@ -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};
@@ -403,19 +403,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 | PatAdjust::PinDeref => 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
@@ -553,13 +572,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                 && let &ty::Ref(_, inner_ty, inner_mutability) = pinned_ty.kind() =>
             {
                 debug!("scrutinee ty {expected:?} is a pinned reference, inserting pin deref");
-                // Preserve the pinned type. We'll need it later during THIR lowering.
-                self.typeck_results
-                    .borrow_mut()
-                    .pat_adjustments_mut()
-                    .entry(pat.hir_id)
-                    .or_default()
-                    .push(PatAdjustment { kind: PatAdjust::PinDeref, source: expected });
 
                 let binding_mode = adjust_binding_mode(Pinnedness::Pinned, inner_mutability);
                 // If the pinnedness is `Not`, it means the pattern is unpinned
@@ -569,14 +581,25 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         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 };
-                // Recurse with the new expected type.
-                // using `break` instead of `return` in case where any shared codes are added
-                // after the `match pat.kind {}`.
-                self.check_pat_inner(pat, opt_path_res, adjust_mode, inner_ty, new_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/`.
@@ -585,35 +608,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.
@@ -692,6 +703,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)`.
@@ -2630,6 +2679,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,
@@ -2656,7 +2743,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
@@ -2675,9 +2764,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

compiler/rustc_middle/src/ty/sty.rs

@@ -1356,6 +1356,16 @@ impl<'tcx> Ty<'tcx> {
         }
     }
 
+    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()

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -493,6 +493,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

compiler/rustc_pattern_analysis/src/constructor.rs

@@ -981,7 +981,7 @@ pub enum ConstructorSet<Cx: PatCx> {
     /// This type has the following list of constructors. If `variants` is empty and
     /// `non_exhaustive` is false, don't use this; use `NoConstructors` instead.
     Variants { variants: IndexVec<Cx::VariantIdx, VariantVisibility>, non_exhaustive: bool },
-    /// The type is `&T`
+    /// The type is `&T`.
     Ref,
     /// The type is a union.
     Union,