More work

Author: compiler-errors

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -126,8 +126,13 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                             }
                             _ => bug!(),
                         };
-                        let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2))
-                            .to_predicate(self.tcx());
+                        // This predicate may have escaping bound vars,
+                        // e.g. if we have `for<'a: 'a> ..`.
+                        let pred = ty::Binder::bind_with_vars(
+                            ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2)),
+                            ty::List::empty(),
+                        )
+                        .to_predicate(self.tcx());
                         (pred, span)
                     }))
                 }
@@ -715,7 +720,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         ast_bounds.iter(),
                         bounds,
                         projection_ty.bound_vars(),
-                        projection_ty.skip_binder_predicates(),
+                        projection_ty.skip_binder_with_predicates().1,
                         only_self_bounds,
                     );
                 }

compiler/rustc_hir_typeck/src/method/probe.rs

@@ -851,7 +851,8 @@ impl<'a, 'tcx> ProbeContext<'a, 'tcx> {
         });
 
         self.elaborate_bounds(bounds, |this, poly_trait_ref, item| {
-            let trait_ref = this.instantiate_binder_with_fresh_vars(
+            // FIXME(non_lifetime_binders): We could check these predicates hold.
+            let (trait_ref, _) = this.instantiate_binder_and_predicates_with_fresh_vars(
                 this.span,
                 infer::LateBoundRegionConversionTime::FnCall,
                 poly_trait_ref,

compiler/rustc_infer/src/infer/higher_ranked/mod.rs

@@ -7,6 +7,7 @@ use crate::infer::CombinedSnapshot;
 use rustc_middle::ty::fold::FnMutDelegate;
 use rustc_middle::ty::relate::{Relate, RelateResult, TypeRelation};
 use rustc_middle::ty::{self, Binder, Ty, TyCtxt, TypeFoldable};
+use rustc_span::DUMMY_SP;
 
 impl<'a, 'tcx> CombineFields<'a, 'tcx> {
     /// Checks whether `for<..> sub <: for<..> sup` holds.
@@ -74,7 +75,12 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
-        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+        if !binder.skip_binder_with_predicates().1.is_empty() {
+            self.tcx.sess.delay_span_bug(
+                DUMMY_SP,
+                "binder instantiated with placeholders ignoring predicates",
+            );
+        }
 
         if let Some(inner) = binder.no_bound_vars() {
             return inner;

compiler/rustc_infer/src/infer/mod.rs

@@ -7,6 +7,7 @@ pub use self::SubregionOrigin::*;
 pub use self::ValuePairs::*;
 pub use combine::ObligationEmittingRelation;
 use rustc_data_structures::undo_log::UndoLogs;
+use rustc_span::DUMMY_SP;
 
 use self::opaque_types::OpaqueTypeStorage;
 pub(crate) use self::undo_log::{InferCtxtUndoLogs, Snapshot, UndoLog};
@@ -1446,7 +1447,11 @@ impl<'tcx> InferCtxt<'tcx> {
     where
         T: TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
-        assert_eq!(value.skip_binder_predicates(), ty::List::empty());
+        if !value.skip_binder_with_predicates().1.is_empty() {
+            self.tcx
+                .sess
+                .delay_span_bug(DUMMY_SP, "binder instantiated with infer ignoring predicates");
+        }
 
         if let Some(inner) = value.no_bound_vars() {
             return inner;

compiler/rustc_infer/src/infer/nll_relate/mod.rs

@@ -263,7 +263,7 @@ where
     where
         T: ty::TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
-        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+        assert_eq!(binder.skip_binder_with_predicates().1, ty::List::empty());
 
         if let Some(inner) = binder.no_bound_vars() {
             return inner;
@@ -313,7 +313,7 @@ where
     where
         T: ty::TypeFoldable<TyCtxt<'tcx>> + Copy,
     {
-        assert_eq!(binder.skip_binder_predicates(), ty::List::empty());
+        assert_eq!(binder.skip_binder_with_predicates().1, ty::List::empty());
 
         if let Some(inner) = binder.no_bound_vars() {
             return inner;

compiler/rustc_lint/src/opaque_hidden_inferred_bound.rs

@@ -77,7 +77,9 @@ impl<'tcx> LateLintPass<'tcx> for OpaqueHiddenInferredBound {
         for (pred, pred_span) in
             cx.tcx.explicit_item_bounds(def_id).instantiate_identity_iter_copied()
         {
-            let predicate = infcx.instantiate_binder_with_placeholders(pred.kind());
+            // FIXME(non_lifetime_binders): We could assume the predicates in this binder.
+            let (predicate, _) =
+                infcx.instantiate_binder_and_assumptions_with_placeholders(pred.kind());
             let ty::ClauseKind::Projection(proj) = predicate else {
                 continue;
             };

compiler/rustc_middle/src/ty/context.rs

@@ -1290,6 +1290,7 @@ nop_lift! {predicate; Predicate<'a> => Predicate<'tcx>}
 nop_lift! {predicate; Clause<'a> => Clause<'tcx>}
 
 nop_list_lift! {type_lists; Ty<'a> => Ty<'tcx>}
+nop_list_lift! {clauses; Clause<'a> => Clause<'tcx>}
 nop_list_lift! {poly_existential_predicates; PolyExistentialPredicate<'a> => PolyExistentialPredicate<'tcx>}
 nop_list_lift! {bound_variable_kinds; ty::BoundVariableKind => ty::BoundVariableKind}
 

compiler/rustc_middle/src/ty/fold.rs

@@ -322,8 +322,7 @@ impl<'tcx> TyCtxt<'tcx> {
         value: Binder<'tcx, T>,
         delegate: impl BoundVarReplacerDelegate<'tcx>,
     ) -> (T, &'tcx ty::List<ty::Clause<'tcx>>) {
-        let preds = value.skip_binder_predicates();
-        self.replace_escaping_bound_vars_uncached((value.skip_binder(), preds), delegate)
+        self.replace_escaping_bound_vars_uncached(value.skip_binder_with_predicates(), delegate)
     }
 
     /// Replaces any late-bound regions bound in `value` with

compiler/rustc_middle/src/ty/mod.rs

@@ -823,7 +823,7 @@ impl<'tcx> Clause<'tcx> {
         // 1) Self: Bar1<'a, '^0.0> -> Self: Bar1<'a, '^0.1>
         let (shifted_pred, shifted_bound_clauses) = tcx.shift_bound_var_indices(
             trait_bound_vars.len(),
-            (bound_pred.skip_binder(), bound_pred.skip_binder_predicates()),
+            bound_pred.skip_binder_with_predicates(),
         );
         // 2) Self: Bar1<'a, '^0.1> -> T: Bar1<'^0.0, '^0.1>
         let new = EarlyBinder::bind(shifted_pred).instantiate(tcx, trait_ref.skip_binder().args);
@@ -832,7 +832,7 @@ impl<'tcx> Clause<'tcx> {
             tcx.mk_bound_variable_kinds_from_iter(trait_bound_vars.iter().chain(pred_bound_vars));
 
         let binder_predicates = tcx.mk_clauses_from_iter(
-            trait_ref.skip_binder_predicates().into_iter().chain(shifted_bound_clauses),
+            trait_ref.skip_binder_with_predicates().1.into_iter().chain(shifted_bound_clauses),
         );
 
         // FIXME: Is it really perf sensitive to use reuse_or_mk_predicate here?

compiler/rustc_middle/src/ty/structural_impls.rs

@@ -585,7 +585,9 @@ impl<'tcx, T: TypeFoldable<TyCtxt<'tcx>>> TypeSuperFoldable<TyCtxt<'tcx>> for ty
         self,
         folder: &mut F,
     ) -> Result<Self, F::Error> {
-        self.try_map_bound(|ty| ty.try_fold_with(folder))
+        let bound_vars = self.bound_vars();
+        let (value, bound_predicates) = self.skip_binder_with_predicates().try_fold_with(folder)?;
+        Ok(ty::Binder::bind_with_vars_and_predicates(value, bound_vars, bound_predicates))
     }
 }
 
@@ -596,7 +598,9 @@ impl<'tcx, T: TypeVisitable<TyCtxt<'tcx>>> TypeSuperVisitable<TyCtxt<'tcx>>
         &self,
         visitor: &mut V,
     ) -> ControlFlow<V::BreakTy> {
-        self.as_ref().skip_binder().visit_with(visitor)
+        let (val, predicates) = self.as_ref().skip_binder_with_predicates();
+        val.visit_with(visitor)?;
+        predicates.visit_with(visitor)
     }
 }