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

@@ -28,7 +28,7 @@ use rustc_span::hygiene::DesugaringKind;
 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,36 @@ 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.peel_pin_refs()),
+                    }),
+                );
+            }
         }
 
         // (note_1): In most of the cases where (note_1) is referenced
@@ -553,30 +570,34 @@ 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
                 // and thus requires an `Unpin` bound.
                 if binding_mode == ByRef::Yes(Pinnedness::Not, Mutability::Mut) {
                     self.register_bound(
                         inner_ty,
-                        self.tcx.require_lang_item(hir::LangItem::Unpin, Some(pat.span)),
+                        self.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 +606,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.
@@ -684,6 +693,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)`.
@@ -1195,7 +1242,7 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             // Wrapping the type into `Pin` if the binding is like `ref pin const|mut x`
             ByRef::Yes(Pinnedness::Pinned, mutbl) => Ty::new_adt(
                 self.tcx,
-                self.tcx.adt_def(self.tcx.require_lang_item(hir::LangItem::Pin, Some(pat.span))),
+                self.tcx.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`.
@@ -2638,6 +2685,38 @@ 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 obligation_ctxt = ObligationCtxt::new(&self);
+            self.typeck_results.borrow().pat_walk_ref_pin_binding_of_non_unpin_type(inner, |ty| {
+                let ty = obligation_ctxt.normalize(&cause, self.param_env, ty).peel_pin_refs();
+                obligation_ctxt.register_bound(cause.clone(), self.param_env, ty, unpin);
+            });
+            obligation_ctxt.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 {
+                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,

compiler/rustc_middle/src/ty/typeck_results.rs

@@ -476,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

compiler/rustc_middle/src/ty/util.rs

@@ -1463,6 +1463,31 @@ impl<'tcx> Ty<'tcx> {
         ty
     }
 
+    /// Peel off all (maybe-pinned) reference types in this type until there are none left.
+    ///
+    /// This method is idempotent, i.e. `ty.peel_pinned_refs().peel_pinned_refs() == ty.peel_pinned_refs()`.
+    ///
+    /// # Examples
+    ///
+    /// - `u8` -> `u8`
+    /// - `&'a mut u8` -> `u8`
+    /// - `&'a pin mut u8` -> `u8`
+    /// - `&'a &'b u8` -> `u8`
+    /// - `&'a pin const &'b u8` -> `u8`
+    /// - `&'a *const &'b u8 -> *const &'b u8`
+    /// - `&'a pin const *const &'b u8 -> *const &'b u8`
+    pub fn peel_pin_refs(self) -> Ty<'tcx> {
+        let mut ty = self;
+        loop {
+            ty = match ty.kind() {
+                ty::Ref(_, inner_ty, _) => *inner_ty,
+                ty::Adt(adt, args) if adt.is_pin() => args.type_at(0),
+                _ => break,
+            };
+        }
+        ty
+    }
+
     // FIXME(compiler-errors): Think about removing this.
     #[inline]
     pub fn outer_exclusive_binder(self) -> ty::DebruijnIndex {

compiler/rustc_mir_build/src/builder/matches/mod.rs

@@ -18,9 +18,9 @@ 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_middle::{bug, span_bug};
 use rustc_span::{BytePos, Pos, Span, Symbol, sym};
 use tracing::{debug, instrument};
 
@@ -2811,7 +2811,7 @@ impl<'a, 'tcx> Builder<'a, 'tcx> {
         self.cfg.push_assign(block, source_info, pinned_temp, borrow);
         Rvalue::Aggregate(
             Box::new(AggregateKind::Adt(
-                self.tcx.require_lang_item(LangItem::Pin, Some(source_info.span)),
+                self.tcx.require_lang_item(LangItem::Pin, source_info.span),
                 FIRST_VARIANT,
                 self.tcx.mk_args(&[pinned_ty.into()]),
                 None,

compiler/rustc_pattern_analysis/src/rustc.rs

@@ -226,11 +226,6 @@ impl<'p, 'tcx: 'p> RustcPatCtxt<'p, 'tcx> {
                         // The only legal patterns of type `Box` (outside `std`) are `_` and box
                         // patterns. If we're here we can assume this is a box pattern.
                         reveal_and_alloc(cx, once(args.type_at(0)))
-                    } else if adt.is_pin()
-                        && let ty::Ref(_, rty, _) = args.type_at(0).kind()
-                        && self.tcx.features().pin_ergonomics()
-                    {
-                        reveal_and_alloc(cx, once(*rty))
                     } else {
                         let variant =
                             &adt.variant(RustcPatCtxt::variant_index_for_adt(&ctor, *adt));