[WIP] -Zhigher-ranked-assumptions-v2

compiler/rustc_infer/src/infer/context.rs

@@ -22,6 +22,10 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.next_trait_solver
     }
 
+    fn higher_ranked_assumptions_v2(&self) -> bool {
+        self.tcx.sess.opts.unstable_opts.higher_ranked_assumptions_v2
+    }
+
     fn typing_mode(&self) -> ty::TypingMode<'tcx> {
         self.typing_mode()
     }
@@ -34,6 +38,12 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.create_next_universe()
     }
 
+    fn get_solve_region_constraint(
+        &self,
+    ) -> rustc_type_ir::region_constraint::RegionConstraint<TyCtxt<'tcx>> {
+        self.inner.borrow().solver_region_constraint_storage.get_constraint()
+    }
+
     fn universe_of_ty(&self, vid: ty::TyVid) -> Option<ty::UniverseIndex> {
         match self.try_resolve_ty_var(vid) {
             Err(universe) => Some(universe),
@@ -272,6 +282,18 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         );
     }
 
+    fn register_solver_region_constraint(
+        &self,
+        c: rustc_type_ir::region_constraint::RegionConstraint<TyCtxt<'tcx>>,
+    ) {
+        let mut inner = self.inner.borrow_mut();
+        use rustc_data_structures::undo_log::UndoLogs;
+
+        use crate::infer::UndoLog;
+        inner.undo_log.push(UndoLog::PushSolverRegionConstraint);
+        inner.solver_region_constraint_storage.push(c);
+    }
+
     fn register_ty_outlives(&self, ty: Ty<'tcx>, r: ty::Region<'tcx>, span: Span) {
         self.register_type_outlives_constraint(ty, r, &ObligationCause::dummy_with_span(span));
     }

compiler/rustc_infer/src/infer/mod.rs

@@ -123,6 +123,9 @@ pub struct InferCtxtInner<'tcx> {
     /// region constraints would've been added.
     region_constraint_storage: Option<RegionConstraintStorage<'tcx>>,
 
+    /// Used by the next solver when `-Zhigher-ranked-assumptions=v2` is set.
+    solver_region_constraint_storage: SolverRegionConstraintStorage<'tcx>,
+
     /// A set of constraints that regionck must validate.
     ///
     /// Each constraint has the form `T:'a`, meaning "some type `T` must
@@ -170,6 +173,7 @@ impl<'tcx> InferCtxtInner<'tcx> {
             float_unification_storage: Default::default(),
             float_origin_origin_storage: Default::default(),
             region_constraint_storage: Some(Default::default()),
+            solver_region_constraint_storage: SolverRegionConstraintStorage::new(),
             region_obligations: Default::default(),
             region_assumptions: Default::default(),
             hir_typeck_potentially_region_dependent_goals: Default::default(),
@@ -1721,3 +1725,46 @@ impl<'tcx> InferCtxt<'tcx> {
         }
     }
 }
+
+type SolverRegionConstraint<'tcx> =
+    rustc_type_ir::region_constraint::RegionConstraint<TyCtxt<'tcx>>;
+
+#[derive(Clone, Debug)]
+struct SolverRegionConstraintStorage<'tcx>(SolverRegionConstraint<'tcx>);
+
+impl<'tcx> SolverRegionConstraintStorage<'tcx> {
+    fn new() -> Self {
+        SolverRegionConstraintStorage(SolverRegionConstraint::And(Box::new([])))
+    }
+
+    fn get_constraint(&self) -> SolverRegionConstraint<'tcx> {
+        self.0.clone()
+    }
+
+    fn pop(&mut self) -> Option<SolverRegionConstraint<'tcx>> {
+        match &mut self.0 {
+            SolverRegionConstraint::And(and) => {
+                let mut and = core::mem::take(and).into_iter().collect::<Vec<_>>();
+                let popped = and.pop()?;
+                self.0 = SolverRegionConstraint::And(and.into_boxed_slice());
+                Some(popped)
+            }
+            _ => unreachable!(),
+        }
+    }
+
+    #[instrument(level = "debug")]
+    fn push(&mut self, constraint: SolverRegionConstraint<'tcx>) {
+        match &mut self.0 {
+            SolverRegionConstraint::And(and) => {
+                let and = core::mem::take(and)
+                    .into_iter()
+                    .chain([constraint])
+                    .collect::<Vec<_>>()
+                    .into_boxed_slice();
+                self.0 = SolverRegionConstraint::And(and);
+            }
+            _ => unreachable!(),
+        }
+    }
+}

compiler/rustc_infer/src/infer/snapshot/undo_log.rs

@@ -28,6 +28,7 @@ pub(crate) enum UndoLog<'tcx> {
     RegionUnificationTable(sv::UndoLog<ut::Delegate<RegionVidKey<'tcx>>>),
     ProjectionCache(traits::UndoLog<'tcx>),
     PushTypeOutlivesConstraint,
+    PushSolverRegionConstraint,
     PushRegionAssumption,
     PushHirTypeckPotentiallyRegionDependentGoal,
 }
@@ -77,6 +78,14 @@ impl<'tcx> Rollback<UndoLog<'tcx>> for InferCtxtInner<'tcx> {
                 self.region_constraint_storage.as_mut().unwrap().unification_table.reverse(undo)
             }
             UndoLog::ProjectionCache(undo) => self.projection_cache.reverse(undo),
+            UndoLog::PushSolverRegionConstraint => {
+                let popped = self.solver_region_constraint_storage.pop();
+                assert_matches!(
+                    popped,
+                    Some(_),
+                    "pushed solver region constraint but could not pop it"
+                );
+            }
             UndoLog::PushTypeOutlivesConstraint => {
                 let popped = self.region_obligations.pop();
                 assert_matches!(popped, Some(_), "pushed region constraint but could not pop it");

compiler/rustc_middle/src/traits/solve.rs

@@ -48,6 +48,10 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
         }
 
         Ok(FallibleTypeFolder::cx(folder).mk_external_constraints(ExternalConstraintsData {
+            solver_region_constraint: self
+                .solver_region_constraint
+                .clone()
+                .try_fold_with(folder)?,
             region_constraints: self.region_constraints.clone().try_fold_with(folder)?,
             opaque_types: self
                 .opaque_types
@@ -70,6 +74,7 @@ impl<'tcx> TypeFoldable<TyCtxt<'tcx>> for ExternalConstraints<'tcx> {
         }
 
         TypeFolder::cx(folder).mk_external_constraints(ExternalConstraintsData {
+            solver_region_constraint: self.solver_region_constraint.clone().fold_with(folder),
             region_constraints: self.region_constraints.clone().fold_with(folder),
             opaque_types: self.opaque_types.iter().map(|opaque| opaque.fold_with(folder)).collect(),
             normalization_nested_goals: self.normalization_nested_goals.clone().fold_with(folder),

compiler/rustc_next_trait_solver/src/canonical/mod.rs

@@ -113,9 +113,14 @@ where
 
     unify_query_var_values(delegate, param_env, &original_values, var_values, span);
 
-    let ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals } =
-        &*external_constraints;
+    let ExternalConstraintsData {
+        solver_region_constraint,
+        region_constraints,
+        opaque_types,
+        normalization_nested_goals,
+    } = &*external_constraints;
 
+    delegate.register_solver_region_constraint(solver_region_constraint.clone());
     register_region_constraints(delegate, region_constraints, span);
     register_new_opaque_types(delegate, opaque_types, span);
 

compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -1,18 +1,22 @@
 use std::mem;
 use std::ops::ControlFlow;
 
+use rustc_data_structures::transitive_relation::TransitiveRelationBuilder;
 #[cfg(feature = "nightly")]
 use rustc_macros::HashStable_NoContext;
-use rustc_type_ir::data_structures::{HashMap, HashSet};
+use rustc_type_ir::ClauseKind::*;
+use rustc_type_ir::data_structures::{HashMap, HashSet, IndexMap};
 use rustc_type_ir::inherent::*;
+use rustc_type_ir::outlives::Component;
+use rustc_type_ir::region_constraint::RegionConstraint;
 use rustc_type_ir::relate::Relate;
 use rustc_type_ir::relate::solver_relating::RelateExt;
 use rustc_type_ir::search_graph::{CandidateHeadUsages, PathKind};
 use rustc_type_ir::solve::OpaqueTypesJank;
 use rustc_type_ir::{
-    self as ty, CanonicalVarValues, InferCtxtLike, Interner, TypeFoldable, TypeFolder,
-    TypeSuperFoldable, TypeSuperVisitable, TypeVisitable, TypeVisitableExt, TypeVisitor,
-    TypingMode,
+    self as ty, AliasTy, Binder, CanonicalVarValues, InferCtxtLike, Interner, OutlivesPredicate,
+    TypeFoldable, TypeFolder, TypeSuperFoldable, TypeSuperVisitable, TypeVisitable,
+    TypeVisitableExt, TypeVisitor, TypingMode, UniverseIndex,
 };
 use tracing::{debug, instrument, trace};
 
@@ -1092,6 +1096,14 @@ where
         args
     }
 
+    pub(super) fn higher_ranked_assumptions_v2(&self) -> bool {
+        self.delegate.higher_ranked_assumptions_v2()
+    }
+
+    pub(super) fn register_solver_region_constraint(&self, c: RegionConstraint<I>) {
+        self.delegate.register_solver_region_constraint(c);
+    }
+
     pub(super) fn register_ty_outlives(&self, ty: I::Ty, lt: I::Region) {
         self.delegate.register_ty_outlives(ty, lt, self.origin_span);
     }
@@ -1287,8 +1299,11 @@ where
             return Ok(self.make_ambiguous_response_no_constraints(cause, opaque_types_jank));
         }
 
-        let external_constraints =
-            self.compute_external_query_constraints(certainty, normalization_nested_goals);
+        let external_constraints = self.compute_external_query_constraints(
+            certainty,
+            normalization_nested_goals,
+            RegionConstraint::new_true(),
+        );
         let (var_values, mut external_constraints) =
             eager_resolve_vars(self.delegate, (self.var_values, external_constraints));
 
@@ -1340,6 +1355,7 @@ where
         &self,
         certainty: Certainty,
         normalization_nested_goals: NestedNormalizationGoals<I>,
+        solver_region_constraint: RegionConstraint<I>,
     ) -> ExternalConstraintsData<I> {
         // We only return region constraints once the certainty is `Yes`. This
         // is necessary as we may drop nested goals on ambiguity, which may result
@@ -1363,7 +1379,12 @@ where
             .delegate
             .clone_opaque_types_added_since(self.initial_opaque_types_storage_num_entries);
 
-        ExternalConstraintsData { region_constraints, opaque_types, normalization_nested_goals }
+        ExternalConstraintsData {
+            solver_region_constraint,
+            region_constraints,
+            opaque_types,
+            normalization_nested_goals,
+        }
     }
 }
 

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -59,18 +59,21 @@ fn has_no_inference_or_external_constraints<I: Interner>(
     response: ty::Canonical<I, Response<I>>,
 ) -> bool {
     let ExternalConstraintsData {
+        ref solver_region_constraint,
         ref region_constraints,
         ref opaque_types,
         ref normalization_nested_goals,
     } = *response.value.external_constraints;
     response.value.var_values.is_identity()
+        && solver_region_constraint.is_true()
         && region_constraints.is_empty()
         && opaque_types.is_empty()
         && normalization_nested_goals.is_empty()
 }
 
 fn has_only_region_constraints<I: Interner>(response: ty::Canonical<I, Response<I>>) -> bool {
     let ExternalConstraintsData {
+        solver_region_constraint: _,
         region_constraints: _,
         ref opaque_types,
         ref normalization_nested_goals,

compiler/rustc_session/src/options.rs

@@ -2355,6 +2355,8 @@ options! {
     help: bool = (false, parse_no_value, [UNTRACKED], "Print unstable compiler options"),
     higher_ranked_assumptions: bool = (false, parse_bool, [TRACKED],
         "allow deducing higher-ranked outlives assumptions from coroutines when proving auto traits"),
+    higher_ranked_assumptions_v2: bool = (false, parse_bool, [TRACKED],
+        "allow deducing higher-ranked outlives assumptions from all binders (`for<'a>`)"),
     hint_mostly_unused: bool = (false, parse_bool, [TRACKED],
         "hint that most of this crate will go unused, to minimize work for uncalled functions"),
     human_readable_cgu_names: bool = (false, parse_bool, [TRACKED],

compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -234,6 +234,14 @@ pub trait InferCtxtLike: Sized {
     fn universe(&self) -> ty::UniverseIndex;
     fn create_next_universe(&self) -> ty::UniverseIndex;
 
+    fn higher_ranked_assumptions_v2(&self) -> bool {
+        false
+    }
+
+    fn get_solve_region_constraint(
+        &self,
+    ) -> crate::region_constraint::RegionConstraint<Self::Interner>;
+
     fn universe_of_ty(&self, ty: ty::TyVid) -> Option<ty::UniverseIndex>;
     fn universe_of_lt(&self, lt: ty::RegionVid) -> Option<ty::UniverseIndex>;
     fn universe_of_ct(&self, ct: ty::ConstVid) -> Option<ty::UniverseIndex>;
@@ -333,6 +341,11 @@ pub trait InferCtxtLike: Sized {
         span: <Self::Interner as Interner>::Span,
     );
 
+    fn register_solver_region_constraint(
+        &self,
+        c: crate::region_constraint::RegionConstraint<Self::Interner>,
+    );
+
     fn register_ty_outlives(
         &self,
         ty: <Self::Interner as Interner>::Ty,

compiler/rustc_type_ir/src/lib.rs

@@ -28,6 +28,7 @@ pub mod ir_print;
 pub mod lang_items;
 pub mod lift;
 pub mod outlives;
+pub mod region_constraint;
 pub mod relate;
 pub mod search_graph;
 pub mod solve;