Implement support for binders with clauses in new solver

Author: compiler-errors

Diff for: compiler/rustc_infer/src/infer/context.rs

@@ -113,6 +113,17 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         )
     }
 
+    fn instantiate_binder_with_infer_and_goals<T: TypeFoldable<TyCtxt<'tcx>> + Copy>(
+        &self,
+        value: ty::Binder<'tcx, T>,
+    ) -> (T, ty::Clauses<'tcx>) {
+        self.instantiate_binder_with_fresh_vars_and_goals(
+            DUMMY_SP,
+            BoundRegionConversionTime::HigherRankedType,
+            value,
+        )
+    }
+
     fn enter_forall<T: TypeFoldable<TyCtxt<'tcx>>, U>(
         &self,
         value: ty::Binder<'tcx, T>,
@@ -121,6 +132,15 @@ impl<'tcx> rustc_type_ir::InferCtxtLike for InferCtxt<'tcx> {
         self.enter_forall(value, f)
     }
 
+    fn enter_forall_with_assumptions<T: TypeFoldable<TyCtxt<'tcx>>, U>(
+        &self,
+        value: ty::Binder<'tcx, T>,
+        param_env: ty::ParamEnv<'tcx>,
+        f: impl FnOnce(T, ty::ParamEnv<'tcx>) -> U,
+    ) -> U {
+        self.enter_forall_with_assumptions(value, param_env, f)
+    }
+
     fn equate_ty_vids_raw(&self, a: rustc_type_ir::TyVid, b: rustc_type_ir::TyVid) {
         self.inner.borrow_mut().type_variables().equate(a, b);
     }

Diff for: compiler/rustc_infer/src/infer/mod.rs

@@ -1209,6 +1209,52 @@ impl<'tcx> InferCtxt<'tcx> {
         self.tcx.replace_bound_vars_uncached(value, delegate)
     }
 
+    pub fn instantiate_binder_with_fresh_vars_and_goals<T>(
+        &self,
+        span: Span,
+        lbrct: BoundRegionConversionTime,
+        binder: ty::Binder<'tcx, T>,
+    ) -> (T, ty::Clauses<'tcx>)
+    where
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    {
+        if !binder.as_ref().skip_binder_with_clauses().has_escaping_bound_vars() {
+            return binder.skip_binder_with_clauses();
+        }
+
+        let bound_vars = binder.bound_vars();
+        let mut args = Vec::with_capacity(bound_vars.len());
+
+        for bound_var_kind in bound_vars {
+            let arg: ty::GenericArg<'_> = match bound_var_kind {
+                ty::BoundVariableKind::Ty(_) => self.next_ty_var(span).into(),
+                ty::BoundVariableKind::Region(br) => {
+                    self.next_region_var(BoundRegion(span, br, lbrct)).into()
+                }
+                ty::BoundVariableKind::Const => self.next_const_var(span).into(),
+            };
+            args.push(arg);
+        }
+
+        struct ToFreshVars<'tcx> {
+            args: Vec<ty::GenericArg<'tcx>>,
+        }
+
+        impl<'tcx> BoundVarReplacerDelegate<'tcx> for ToFreshVars<'tcx> {
+            fn replace_region(&mut self, br: ty::BoundRegion) -> ty::Region<'tcx> {
+                self.args[br.var.index()].expect_region()
+            }
+            fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> {
+                self.args[bt.var.index()].expect_ty()
+            }
+            fn replace_const(&mut self, bv: ty::BoundVar) -> ty::Const<'tcx> {
+                self.args[bv.index()].expect_const()
+            }
+        }
+        let delegate = ToFreshVars { args };
+        self.tcx.replace_bound_vars_uncached_with_clauses(binder, delegate)
+    }
+
     /// See the [`region_constraints::RegionConstraintCollector::verify_generic_bound`] method.
     pub(crate) fn verify_generic_bound(
         &self,

Diff for: compiler/rustc_infer/src/infer/relate/higher_ranked.rs

@@ -57,6 +57,49 @@ impl<'tcx> InferCtxt<'tcx> {
         self.tcx.replace_bound_vars_uncached(binder, delegate)
     }
 
+    pub fn enter_forall_with_assumptions_and_leak_universe<T>(
+        &self,
+        binder: ty::Binder<'tcx, T>,
+        param_env: ty::ParamEnv<'tcx>,
+    ) -> (T, ty::ParamEnv<'tcx>)
+    where
+        T: TypeFoldable<TyCtxt<'tcx>>,
+    {
+        if !binder.as_ref().skip_binder_with_clauses().has_escaping_bound_vars() {
+            let (value, assumptions) = binder.skip_binder_with_clauses();
+            return (value, param_env.extend(self.tcx, assumptions));
+        }
+
+        let next_universe = self.create_next_universe();
+
+        // TODO: Deduplicate this with above.
+        let delegate = FnMutDelegate {
+            regions: &mut |br: ty::BoundRegion| {
+                ty::Region::new_placeholder(
+                    self.tcx,
+                    ty::PlaceholderRegion { universe: next_universe, bound: br },
+                )
+            },
+            types: &mut |bound_ty: ty::BoundTy| {
+                Ty::new_placeholder(
+                    self.tcx,
+                    ty::PlaceholderType { universe: next_universe, bound: bound_ty },
+                )
+            },
+            consts: &mut |bound_var: ty::BoundVar| {
+                ty::Const::new_placeholder(
+                    self.tcx,
+                    ty::PlaceholderConst { universe: next_universe, bound: bound_var },
+                )
+            },
+        };
+
+        debug!(?next_universe);
+        let (value, assumptions) =
+            self.tcx.replace_bound_vars_uncached_with_clauses(binder, delegate);
+        (value, param_env.extend(self.tcx, assumptions))
+    }
+
     /// Replaces all bound variables (lifetimes, types, and constants) bound by
     /// `binder` with placeholder variables in a new universe and then calls the
     /// closure `f` with the instantiated value. The new placeholders can only be
@@ -82,6 +125,26 @@ impl<'tcx> InferCtxt<'tcx> {
         f(value)
     }
 
+    #[instrument(level = "debug", skip(self, f))]
+    pub fn enter_forall_with_assumptions<T, U>(
+        &self,
+        forall: ty::Binder<'tcx, T>,
+        param_env: ty::ParamEnv<'tcx>,
+        f: impl FnOnce(T, ty::ParamEnv<'tcx>) -> U,
+    ) -> U
+    where
+        T: TypeFoldable<TyCtxt<'tcx>>,
+    {
+        // FIXME: currently we do nothing to prevent placeholders with the new universe being
+        // used after exiting `f`. For example region subtyping can result in outlives constraints
+        // that name placeholders created in this function. Nested goals from type relations can
+        // also contain placeholders created by this function.
+        let (value, param_env) =
+            self.enter_forall_with_assumptions_and_leak_universe(forall, param_env);
+        debug!(?value);
+        f(value, param_env)
+    }
+
     /// See [RegionConstraintCollector::leak_check][1]. We only check placeholder
     /// leaking into `outer_universe`, i.e. placeholders which cannot be named by that
     /// universe.

Diff for: compiler/rustc_middle/src/ty/fold.rs

@@ -258,6 +258,14 @@ impl<'tcx> TyCtxt<'tcx> {
         self.replace_escaping_bound_vars_uncached(value.skip_binder(), delegate)
     }
 
+    pub fn replace_bound_vars_uncached_with_clauses<T: TypeFoldable<TyCtxt<'tcx>>>(
+        self,
+        value: Binder<'tcx, T>,
+        delegate: impl BoundVarReplacerDelegate<'tcx>,
+    ) -> (T, ty::Clauses<'tcx>) {
+        self.replace_escaping_bound_vars_uncached(value.skip_binder_with_clauses(), delegate)
+    }
+
     /// Replaces any late-bound regions bound in `value` with
     /// free variants attached to `all_outlive_scope`.
     pub fn liberate_late_bound_regions<T>(

Diff for: compiler/rustc_middle/src/ty/mod.rs

@@ -998,6 +998,20 @@ impl<'tcx> ParamEnv<'tcx> {
     pub fn and<T: TypeVisitable<TyCtxt<'tcx>>>(self, value: T) -> ParamEnvAnd<'tcx, T> {
         ParamEnvAnd { param_env: self, value }
     }
+
+    /// TODO:
+    pub fn extend(self, tcx: TyCtxt<'tcx>, assumptions: ty::Clauses<'tcx>) -> Self {
+        if assumptions.is_empty() {
+            self
+        } else if self.caller_bounds.is_empty() {
+            ParamEnv { caller_bounds: assumptions }
+        } else {
+            ParamEnv {
+                caller_bounds: tcx
+                    .mk_clauses_from_iter(self.caller_bounds.iter().chain(assumptions)),
+            }
+        }
+    }
 }
 
 #[derive(Copy, Clone, Debug, PartialEq, Eq, Hash, TypeFoldable, TypeVisitable)]

Diff for: compiler/rustc_next_trait_solver/src/solve/effect_goals.rs

@@ -55,12 +55,18 @@ where
                 }
 
                 ecx.probe_trait_candidate(source).enter(|ecx| {
-                    let assumption_trait_pred = ecx.instantiate_binder_with_infer(host_clause);
+                    let (assumption_trait_pred, goals) =
+                        ecx.instantiate_binder_with_infer_and_goals(host_clause);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.trait_ref,
                         assumption_trait_pred.trait_ref,
                     )?;
+                    let cx = ecx.cx();
+                    ecx.add_goals(
+                        GoalSource::Misc,
+                        goals.iter().map(|clause| goal.with(cx, clause)),
+                    );
                     then(ecx)
                 })
             } else {

Diff for: compiler/rustc_next_trait_solver/src/solve/eval_ctxt/mod.rs

@@ -582,8 +582,8 @@ where
                 }
             }
         } else {
-            self.enter_forall(kind, |ecx, kind| {
-                let goal = goal.with(ecx.cx(), ty::Binder::dummy(kind));
+            self.enter_forall_with_assumptions(kind, goal.param_env, |ecx, kind, param_env| {
+                let goal = Goal::new(ecx.cx(), param_env, ty::Binder::dummy(kind));
                 ecx.add_goal(GoalSource::InstantiateHigherRanked, goal);
                 ecx.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
             })
@@ -1007,6 +1007,13 @@ where
         self.delegate.instantiate_binder_with_infer(value)
     }
 
+    pub(super) fn instantiate_binder_with_infer_and_goals<T: TypeFoldable<I> + Copy>(
+        &self,
+        value: ty::Binder<I, T>,
+    ) -> (T, I::Clauses) {
+        self.delegate.instantiate_binder_with_infer_and_goals(value)
+    }
+
     /// `enter_forall`, but takes `&mut self` and passes it back through the
     /// callback since it can't be aliased during the call.
     pub(super) fn enter_forall<T: TypeFoldable<I>, U>(
@@ -1017,6 +1024,18 @@ where
         self.delegate.enter_forall(value, |value| f(self, value))
     }
 
+    /// UwU
+    pub(super) fn enter_forall_with_assumptions<T: TypeFoldable<I>, U>(
+        &mut self,
+        value: ty::Binder<I, T>,
+        param_env: I::ParamEnv,
+        f: impl FnOnce(&mut Self, T, I::ParamEnv) -> U,
+    ) -> U {
+        self.delegate.enter_forall_with_assumptions(value, param_env, |value, param_env| {
+            f(self, value, param_env)
+        })
+    }
+
     pub(super) fn resolve_vars_if_possible<T>(&self, value: T) -> T
     where
         T: TypeFoldable<I>,

Diff for: compiler/rustc_next_trait_solver/src/solve/normalizes_to/mod.rs

@@ -121,13 +121,17 @@ where
                     return Err(NoSolution);
                 }
                 ecx.probe_trait_candidate(source).enter(|ecx| {
-                    let assumption_projection_pred =
-                        ecx.instantiate_binder_with_infer(projection_pred);
+                    let (assumption_projection_pred, goals) =
+                        ecx.instantiate_binder_with_infer_and_goals(projection_pred);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.alias,
                         assumption_projection_pred.projection_term,
                     )?;
+                    ecx.add_goals(
+                        GoalSource::Misc,
+                        goals.iter().map(|clause| goal.with(cx, clause)),
+                    );
 
                     ecx.instantiate_normalizes_to_term(goal, assumption_projection_pred.term);
 

Diff for: compiler/rustc_next_trait_solver/src/solve/trait_goals.rs

@@ -143,12 +143,18 @@ where
                 }
 
                 ecx.probe_trait_candidate(source).enter(|ecx| {
-                    let assumption_trait_pred = ecx.instantiate_binder_with_infer(trait_clause);
+                    let (assumption_trait_pred, goals) =
+                        ecx.instantiate_binder_with_infer_and_goals(trait_clause);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.trait_ref,
                         assumption_trait_pred.trait_ref,
                     )?;
+                    let cx = ecx.cx();
+                    ecx.add_goals(
+                        GoalSource::Misc,
+                        goals.iter().map(|clause| goal.with(cx, clause)),
+                    );
                     then(ecx)
                 })
             } else {

Diff for: compiler/rustc_type_ir/src/infer_ctxt.rs

@@ -155,12 +155,24 @@ pub trait InferCtxtLike: Sized {
         value: ty::Binder<Self::Interner, T>,
     ) -> T;
 
+    fn instantiate_binder_with_infer_and_goals<T: TypeFoldable<Self::Interner> + Copy>(
+        &self,
+        value: ty::Binder<Self::Interner, T>,
+    ) -> (T, <Self::Interner as Interner>::Clauses);
+
     fn enter_forall<T: TypeFoldable<Self::Interner>, U>(
         &self,
         value: ty::Binder<Self::Interner, T>,
         f: impl FnOnce(T) -> U,
     ) -> U;
 
+    fn enter_forall_with_assumptions<T: TypeFoldable<Self::Interner>, U>(
+        &self,
+        value: ty::Binder<Self::Interner, T>,
+        param_env: <Self::Interner as Interner>::ParamEnv,
+        f: impl FnOnce(T, <Self::Interner as Interner>::ParamEnv) -> U,
+    ) -> U;
+
     fn equate_ty_vids_raw(&self, a: ty::TyVid, b: ty::TyVid);
     fn equate_int_vids_raw(&self, a: ty::IntVid, b: ty::IntVid);
     fn equate_float_vids_raw(&self, a: ty::FloatVid, b: ty::FloatVid);

Diff for: compiler/rustc_type_ir/src/visit.rs

@@ -132,6 +132,12 @@ pub trait TypeVisitor<I: Interner>: Sized {
 ///////////////////////////////////////////////////////////////////////////
 // Traversal implementations.
 
+impl<I: Interner, T: TypeVisitable<I>> TypeVisitable<I> for &T {
+    fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
+        (**self).visit_with(visitor)
+    }
+}
+
 impl<I: Interner, T: TypeVisitable<I>, U: TypeVisitable<I>> TypeVisitable<I> for (T, U) {
     fn visit_with<V: TypeVisitor<I>>(&self, visitor: &mut V) -> V::Result {
         try_visit!(self.0.visit_with(visitor));