More work

Author: compiler-errors

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -126,8 +126,17 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                             }
                             _ => bug!(),
                         };
-                        let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2))
-                            .to_predicate(self.tcx());
+                        let pred = ty::ClauseKind::RegionOutlives(ty::OutlivesPredicate(r1, r2));
+                        // This predicate may have escaping bound vars, e.g. if
+                        // we have `for<'a: 'a> ..`. Since outlives predicates
+                        // don't implicitly have a binder added for them in
+                        // resolve_bound_vars, we need to explicitly shift the
+                        // vars in once here.
+                        let pred = ty::Binder::bind_with_vars(
+                            ty::fold::shift_vars(self.tcx(), pred, 1),
+                            ty::List::empty(),
+                        )
+                        .to_predicate(self.tcx());
                         (pred, span)
                     }))
                 }
@@ -641,7 +650,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/check.rs

@@ -67,7 +67,7 @@ pub(super) fn check_fn<'a, 'tcx>(
                 fcx.require_type_is_sized(yield_ty, span, traits::SizedYieldType);
                 yield_ty
             }
-            // HACK(-Ztrait-solver=next): In the *old* trait solver, we must eagerly
+            // HACK(-Znext-solver): In the *old* trait solver, we must eagerly
             // guide inference on the yield type so that we can handle `AsyncIterator`
             // in this block in projection correctly. In the new trait solver, it is
             // not a problem.

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::BoundRegionConversionTime::FnCall,
                 poly_trait_ref,

compiler/rustc_infer/src/infer/mod.rs

@@ -1470,7 +1470,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
+                .span_delayed_bug(DUMMY_SP, "binder instantiated with infer ignoring predicates");
+        }
 
         if let Some(inner) = value.no_bound_vars() {
             return inner;

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

@@ -7,6 +7,7 @@ use crate::infer::{HigherRankedType, InferCtxt};
 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.span_delayed_bug(
+                DUMMY_SP,
+                "binder instantiated with placeholders ignoring predicates",
+            );
+        }
 
         if let Some(inner) = binder.no_bound_vars() {
             return inner;

compiler/rustc_infer/src/infer/relate/nll.rs

@@ -266,7 +266,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;
@@ -316,7 +316,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/fold.rs

@@ -320,8 +320,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

@@ -749,7 +749,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);
@@ -758,7 +758,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

@@ -509,7 +509,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))
     }
 }
 
@@ -520,7 +522,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)
     }
 }