review

Author: BoxyUwU

compiler/rustc_borrowck/src/type_check/mod.rs

@@ -173,22 +173,24 @@ pub(crate) fn type_check<'tcx>(
 
     let polonius_context = typeck.polonius_context;
 
-    let mut converter = constraint_conversion::ConstraintConversion::new(
-        typeck.infcx,
-        typeck.universal_regions,
-        typeck.region_bound_pairs,
-        typeck.known_type_outlives_obligations,
-        Locations::All(rustc_span::DUMMY_SP),
-        rustc_span::DUMMY_SP,
-        ConstraintCategory::Boring,
-        typeck.constraints,
-    );
-    typeck.infcx.destructure_solver_region_constraints_for_borrowck(
-        &mut converter,
-        typeck.known_type_outlives_obligations,
-        universal_region_relations.outlives.clone(),
-        infcx.tcx.def_span(infcx.root_def_id),
-    );
+    if infcx.tcx.assumptions_on_binders() {
+        let mut converter = constraint_conversion::ConstraintConversion::new(
+            typeck.infcx,
+            typeck.universal_regions,
+            typeck.region_bound_pairs,
+            typeck.known_type_outlives_obligations,
+            Locations::All(rustc_span::DUMMY_SP),
+            rustc_span::DUMMY_SP,
+            ConstraintCategory::Boring,
+            typeck.constraints,
+        );
+        typeck.infcx.destructure_solver_region_constraints_for_borrowck(
+            &mut converter,
+            typeck.known_type_outlives_obligations,
+            universal_region_relations.outlives.clone(),
+            infcx.tcx.def_span(infcx.root_def_id),
+        );
+    }
 
     // In case type check encountered an error region, we suppress unhelpful extra
     // errors in by clearing out all outlives bounds that we may end up checking.

compiler/rustc_infer/src/infer/context.rs

@@ -30,10 +30,6 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.typing_mode_raw()
     }
 
-    fn assumptions_on_binders(&self) -> bool {
-        self.tcx.sess.opts.unstable_opts.assumptions_on_binders
-    }
-
     fn universe(&self) -> ty::UniverseIndex {
         self.universe()
     }

compiler/rustc_infer/src/infer/mod.rs

@@ -124,7 +124,7 @@ 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.
+    /// Used by the next solver when `-Zassumptions-on-binders` is set.
     solver_region_constraint_storage: SolverRegionConstraintStorage<'tcx>,
 
     /// A set of constraints that regionck must validate.

compiler/rustc_infer/src/infer/outlives/obligations.rs

@@ -147,7 +147,7 @@ impl<'tcx> InferCtxt<'tcx> {
         sub_region: Region<'tcx>,
         cause: &ObligationCause<'tcx>,
     ) {
-        assert!(!self.tcx.sess.opts.unstable_opts.assumptions_on_binders);
+        assert!(!self.tcx.assumptions_on_binders());
 
         // `is_global` means the type has no params, infer, placeholder, or non-`'static`
         // free regions. If the type has none of these things, then we can skip registering
@@ -237,10 +237,7 @@ impl<'tcx> InferCtxt<'tcx> {
         mut conversion: impl TypeOutlivesDelegate<'tcx>,
         span: Span,
     ) {
-        if !self.tcx.sess.opts.unstable_opts.assumptions_on_binders {
-            return;
-        }
-
+        assert!(self.tcx.assumptions_on_binders());
         assert!(self.next_trait_solver());
 
         let origin = SubregionOrigin::SolverRegionConstraint(span);
@@ -277,8 +274,7 @@ impl<'tcx> InferCtxt<'tcx> {
                 }
                 // FIXME(-Zassumptions-on-binders): actually implement OR as an  OR
                 And(nested) | Or(nested) => constraints.extend(nested),
-                AliasTyOutlivesViaEnv(..) => unreachable!(),
-                PlaceholderTyOutlives(..) => unreachable!(),
+                AliasTyOutlivesViaEnv(..) | PlaceholderTyOutlives(..) => unreachable!(),
             }
         }
     }
@@ -305,7 +301,9 @@ impl<'tcx> InferCtxt<'tcx> {
     ) -> Result<(), (PolyTypeOutlivesPredicate<'tcx>, SubregionOrigin<'tcx>)> {
         assert!(!self.in_snapshot(), "cannot process registered region obligations in a snapshot");
 
-        self.destructure_solver_region_constraints_for_regionck(outlives_env, span);
+        if self.tcx.assumptions_on_binders() {
+            self.destructure_solver_region_constraints_for_regionck(outlives_env, span);
+        }
 
         // Must loop since the process of normalizing may itself register region obligations.
         for iteration in 0.. {

compiler/rustc_middle/src/ty/context.rs

@@ -2652,6 +2652,10 @@ impl<'tcx> TyCtxt<'tcx> {
         self.next_trait_solver_globally() || self.sess.opts.unstable_opts.typing_mode_borrowck
     }
 
+    pub fn assumptions_on_binders(self) -> bool {
+        self.sess.opts.unstable_opts.assumptions_on_binders
+    }
+
     pub fn is_impl_trait_in_trait(self, def_id: DefId) -> bool {
         self.opt_rpitit_info(def_id).is_some()
     }

compiler/rustc_middle/src/ty/context/impl_interner.rs

@@ -328,7 +328,7 @@ impl<'tcx> Interner for TyCtxt<'tcx> {
     }
 
     fn assumptions_on_binders(self) -> bool {
-        self.sess.opts.unstable_opts.assumptions_on_binders
+        self.assumptions_on_binders()
     }
 
     fn coroutine_hidden_types(

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

@@ -1342,7 +1342,7 @@ where
     ) -> U {
         self.delegate.enter_forall(value, |value| {
             let u = self.delegate.universe();
-            let assumptions = if self.assumptions_on_binders() {
+            let assumptions = if self.cx().assumptions_on_binders() {
                 self.region_assumptions_for_placeholders_in_universe(value.clone(), u, param_env)
             } else {
                 None
@@ -1379,10 +1379,6 @@ where
         args
     }
 
-    pub(super) fn assumptions_on_binders(&self) -> bool {
-        self.delegate.assumptions_on_binders()
-    }
-
     pub(super) fn register_solver_region_constraint(&self, c: RegionConstraint<I>) {
         self.delegate.register_solver_region_constraint(c);
     }
@@ -1578,7 +1574,7 @@ where
             previous call to `try_evaluate_added_goals!`"
         );
 
-        let goals_certainty = match self.delegate.assumptions_on_binders() {
+        let goals_certainty = match self.delegate.cx().assumptions_on_binders() {
             true => {
                 let certainty = self.eagerly_handle_placeholders()?;
                 certainty.and(goals_certainty)
@@ -1707,15 +1703,18 @@ where
         // region constraints from an ambiguous nested goal. This is tested in both
         // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-5-ambig.rs` and
         // `tests/ui/higher-ranked/leak-check/leak-check-in-selection-6-ambig-unify.rs`.
-        let region_constraints = match self.assumptions_on_binders() {
-            true if let Certainty::Yes = certainty => {
-                ExternalRegionConstraints::NextGen(self.delegate.get_solver_region_constraint())
-            }
-            true => ExternalRegionConstraints::NextGen(RegionConstraint::new_true()),
-            false if let Certainty::Yes = certainty => {
-                ExternalRegionConstraints::Old(self.delegate.make_deduplicated_region_constraints())
-            }
-            false => ExternalRegionConstraints::Old(vec![]),
+        let region_constraints = if self.cx().assumptions_on_binders() {
+            ExternalRegionConstraints::NextGen(if let Certainty::Yes = certainty {
+                self.delegate.get_solver_region_constraint()
+            } else {
+                RegionConstraint::new_true()
+            })
+        } else {
+            ExternalRegionConstraints::Old(if let Certainty::Yes = certainty {
+                self.delegate.make_deduplicated_region_constraints()
+            } else {
+                vec![]
+            })
         };
 
         // We only return *newly defined* opaque types from canonical queries.

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

@@ -35,6 +35,8 @@ where
         u: UniverseIndex,
         param_env: I::ParamEnv,
     ) -> Option<Assumptions<I>> {
+        assert!(self.cx().assumptions_on_binders());
+
         struct RawAssumptions<'a, 'b, D: SolverDelegate<Interner = I>, I: Interner> {
             ecx: &'a mut EvalCtxt<'b, D, I>,
             param_env: I::ParamEnv,
@@ -46,6 +48,8 @@ where
             I: Interner,
             D: SolverDelegate<Interner = I>,
         {
+            type Result = ();
+
             fn visit_ty(&mut self, t: I::Ty) {
                 self.out.extend(
                     self.ecx

compiler/rustc_next_trait_solver/src/solve/mod.rs

@@ -92,7 +92,7 @@ where
     ) -> QueryResultOrRerunNonErased<I> {
         let ty::OutlivesPredicate(ty, lt) = goal.predicate;
 
-        if self.assumptions_on_binders() {
+        if self.cx().assumptions_on_binders() {
             // FIXME(-Zassumptions-on-binders): we need to normalize `ty`
             let constraint = self.destructure_type_outlives(ty, lt);
             self.register_solver_region_constraint(constraint);
@@ -110,7 +110,7 @@ where
     ) -> QueryResultOrRerunNonErased<I> {
         let ty::OutlivesPredicate(a, b) = goal.predicate;
 
-        if self.assumptions_on_binders() {
+        if self.cx().assumptions_on_binders() {
             let constraint =
                 rustc_type_ir::region_constraint::RegionConstraint::RegionOutlives(a, b);
             self.register_solver_region_constraint(constraint);

compiler/rustc_trait_selection/src/solve/delegate.rs

@@ -74,7 +74,10 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
         span: Span,
     ) -> Option<Certainty> {
         // FIXME(-Zassumptions-on-binders): actually handle fast path
-        let assumptions_on_binders = self.tcx.sess.opts.unstable_opts.assumptions_on_binders;
+        if self.tcx.assumptions_on_binders() {
+            return None;
+        }
+
         let pred = goal.predicate.kind();
         match pred.skip_binder() {
             ty::PredicateKind::Clause(ty::ClauseKind::Trait(trait_pred)) => {
@@ -124,9 +127,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
             ty::PredicateKind::DynCompatible(def_id) if self.0.tcx.is_dyn_compatible(def_id) => {
                 Some(Certainty::Yes)
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(outlives))
-                if !assumptions_on_binders =>
-            {
+            ty::PredicateKind::Clause(ty::ClauseKind::RegionOutlives(outlives)) => {
                 if outlives.has_escaping_bound_vars() {
                     return None;
                 }
@@ -139,9 +140,7 @@ impl<'tcx> rustc_next_trait_solver::delegate::SolverDelegate for SolverDelegate<
                 );
                 Some(Certainty::Yes)
             }
-            ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(outlives))
-                if !assumptions_on_binders =>
-            {
+            ty::PredicateKind::Clause(ty::ClauseKind::TypeOutlives(outlives)) => {
                 if outlives.has_escaping_bound_vars() {
                     return None;
                 }