Remove !Unpin related bounds

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, Upcast, UserArgs,
+    SizedTraitKind, Ty, TyCtxt, TypeFoldable, TypeVisitable, TypeVisitableExt, UserArgs,
     UserSelfTy,
 };
 use rustc_middle::{bug, span_bug};
@@ -464,29 +464,6 @@ 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, ObligationCtxt};
+use rustc_trait_selection::traits::{ObligationCause, ObligationCauseCode};
 use tracing::{debug, instrument, trace};
 use ty::VariantDef;
 use ty::adjustment::{PatAdjust, PatAdjustment};
@@ -403,38 +403,19 @@ 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 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)
-                        }
-                    }),
-                );
-            }
+        // 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,
+                }),
+            );
         }
 
         // (note_1): In most of the cases where (note_1) is referenced
@@ -583,9 +564,6 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
                         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.
@@ -2679,44 +2657,6 @@ 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,

compiler/rustc_trait_selection/src/traits/select/candidate_assembly.rs

@@ -52,35 +52,20 @@ 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());
@@ -1234,59 +1219,6 @@ 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(

compiler/rustc_trait_selection/src/traits/select/confirmation.rs

@@ -269,9 +269,6 @@ 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![])
@@ -297,7 +294,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
             cause,
             obligation.recursion_depth + 1,
             trait_def,
-            obligation.polarity(),
             types,
         )
     }
@@ -424,7 +420,6 @@ impl<'cx, 'tcx> SelectionContext<'cx, 'tcx> {
                 cause.clone(),
                 obligation.recursion_depth + 1,
                 obligation.predicate.def_id(),
-                obligation.polarity(),
                 constituents.types,
             );
 

compiler/rustc_trait_selection/src/traits/select/mod.rs

@@ -2232,52 +2232,6 @@ 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))
@@ -2428,7 +2382,6 @@ 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
@@ -2473,10 +2426,8 @@ impl<'tcx> SelectionContext<'_, 'tcx> {
                     ty::TraitRef::new_from_args(tcx, trait_def_id, err_args)
                 };
 
-                let trait_predicate = ty::TraitPredicate { trait_ref, polarity };
-
                 let obligation =
-                    Obligation::new(self.tcx(), cause.clone(), param_env, trait_predicate);
+                    Obligation::new(self.tcx(), cause.clone(), param_env, trait_ref);
                 obligations.push(obligation);
                 obligations
             })