Handle binder predicates in new trait solver

Author: compiler-errors

compiler/rustc_hir_analysis/src/astconv/bounds.rs

@@ -83,9 +83,6 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                     let binder_predicates = self.tcx().mk_clauses_from_iter(
                         binder_predicates.into_iter().map(|(clause, _)| clause),
                     );
-                    if !binder_predicates.is_empty() {
-                        println!("binder_predicates = {binder_predicates:#?}");
-                    }
 
                     // Keep the type around in a dummy predicate, in case of no bounds.
                     // That way, `where Ty:` is not a complete noop (see #53696) and `Ty`
@@ -707,8 +704,7 @@ impl<'tcx> dyn AstConv<'tcx> + '_ {
                         ast_bounds.iter(),
                         bounds,
                         projection_ty.bound_vars(),
-                        // TODO: This is wrong, should take preds from binder
-                        ty::List::empty(),
+                        projection_ty.skip_binder_predicates(),
                         only_self_bounds,
                     );
                 }

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

@@ -108,6 +108,55 @@ impl<'tcx> InferCtxt<'tcx> {
         self.tcx.replace_bound_vars_uncached(binder, delegate)
     }
 
+    /// Replaces all bound variables (lifetimes, types, and constants) bound by
+    /// `binder` with placeholder variables in a new universe. This means that the
+    /// new placeholders can only be named by inference variables created after
+    /// this method has been called.
+    ///
+    /// This is the first step of checking subtyping when higher-ranked things are involved.
+    /// For more details visit the relevant sections of the [rustc dev guide].
+    ///
+    /// [rustc dev guide]: https://rustc-dev-guide.rust-lang.org/traits/hrtb.html
+    #[instrument(level = "debug", skip(self), ret)]
+    pub fn instantiate_binder_and_assumptions_with_placeholders<T>(
+        &self,
+        binder: ty::Binder<'tcx, T>,
+    ) -> (T, &'tcx ty::List<ty::Clause<'tcx>>)
+    where
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    {
+        if let Some(inner) = binder.no_bound_vars() {
+            return (inner, ty::List::empty());
+        }
+
+        let next_universe = self.create_next_universe();
+
+        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| {
+                ty::Const::new_placeholder(
+                    self.tcx,
+                    ty::PlaceholderConst { universe: next_universe, bound: bound_var },
+                    ty,
+                )
+            },
+        };
+
+        debug!(?next_universe);
+        self.tcx.replace_bound_vars_and_predicates_uncached(binder, delegate)
+    }
+
     /// See [RegionConstraintCollector::leak_check][1]. We only check placeholder
     /// leaking into `outer_universe`, i.e. placeholders which cannot be named by that
     /// universe.

compiler/rustc_infer/src/infer/mod.rs

@@ -1459,6 +1459,71 @@ impl<'tcx> InferCtxt<'tcx> {
         self.tcx.replace_bound_vars_uncached(value, delegate)
     }
 
+    pub fn instantiate_binder_and_predicates_with_fresh_vars<T>(
+        &self,
+        span: Span,
+        lbrct: LateBoundRegionConversionTime,
+        value: ty::Binder<'tcx, T>,
+    ) -> (T, &'tcx ty::List<ty::Clause<'tcx>>)
+    where
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    {
+        if let Some(inner) = value.no_bound_vars() {
+            return (inner, ty::List::empty());
+        }
+
+        struct ToFreshVars<'a, 'tcx> {
+            infcx: &'a InferCtxt<'tcx>,
+            span: Span,
+            lbrct: LateBoundRegionConversionTime,
+            map: FxHashMap<ty::BoundVar, ty::GenericArg<'tcx>>,
+        }
+
+        impl<'tcx> BoundVarReplacerDelegate<'tcx> for ToFreshVars<'_, 'tcx> {
+            fn replace_region(&mut self, br: ty::BoundRegion) -> ty::Region<'tcx> {
+                self.map
+                    .entry(br.var)
+                    .or_insert_with(|| {
+                        self.infcx
+                            .next_region_var(LateBoundRegion(self.span, br.kind, self.lbrct))
+                            .into()
+                    })
+                    .expect_region()
+            }
+            fn replace_ty(&mut self, bt: ty::BoundTy) -> Ty<'tcx> {
+                self.map
+                    .entry(bt.var)
+                    .or_insert_with(|| {
+                        self.infcx
+                            .next_ty_var(TypeVariableOrigin {
+                                kind: TypeVariableOriginKind::MiscVariable,
+                                span: self.span,
+                            })
+                            .into()
+                    })
+                    .expect_ty()
+            }
+            fn replace_const(&mut self, bv: ty::BoundVar, ty: Ty<'tcx>) -> ty::Const<'tcx> {
+                self.map
+                    .entry(bv)
+                    .or_insert_with(|| {
+                        self.infcx
+                            .next_const_var(
+                                ty,
+                                ConstVariableOrigin {
+                                    kind: ConstVariableOriginKind::MiscVariable,
+                                    span: self.span,
+                                },
+                            )
+                            .into()
+                    })
+                    .expect_const()
+            }
+        }
+        let delegate = ToFreshVars { infcx: self, span, lbrct, map: Default::default() };
+        self.tcx.replace_bound_vars_and_predicates_uncached(value, delegate)
+    }
+
     /// See the [`region_constraints::RegionConstraintCollector::verify_generic_bound`] method.
     pub fn verify_generic_bound(
         &self,

compiler/rustc_middle/src/ty/fold.rs

@@ -317,6 +317,15 @@ impl<'tcx> TyCtxt<'tcx> {
         self.replace_escaping_bound_vars_uncached(value.skip_binder(), delegate)
     }
 
+    pub fn replace_bound_vars_and_predicates_uncached<T: TypeFoldable<TyCtxt<'tcx>>>(
+        self,
+        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)
+    }
+
     /// Replaces any late-bound regions bound in `value` with
     /// free variants attached to `all_outlive_scope`.
     pub fn liberate_late_bound_regions<T>(

compiler/rustc_middle/src/ty/mod.rs

@@ -1737,6 +1737,17 @@ impl<'tcx> ParamEnv<'tcx> {
         ty::ParamEnv { packed: CopyTaggedPtr::new(caller_bounds, ParamTag { reveal }) }
     }
 
+    pub fn augment(
+        tcx: TyCtxt<'tcx>,
+        param_env: ty::ParamEnv<'tcx>,
+        more_caller_bounds: &'tcx List<Clause<'tcx>>,
+    ) -> Self {
+        ty::ParamEnv::new(
+            tcx.mk_clauses_from_iter(param_env.caller_bounds().iter().chain(more_caller_bounds)),
+            param_env.reveal(),
+        )
+    }
+
     pub fn with_user_facing(mut self) -> Self {
         self.packed.set_tag(ParamTag { reveal: Reveal::UserFacing, ..self.packed.tag() });
         self

compiler/rustc_middle/src/ty/sty.rs

@@ -1043,7 +1043,7 @@ where
 }
 
 impl<'tcx, T> Binder<'tcx, T> {
-    pub fn skip_binder_predicates(self) -> &'tcx List<ty::Clause<'tcx>> {
+    pub fn skip_binder_predicates(&self) -> &'tcx List<ty::Clause<'tcx>> {
         self.bound_predicates
     }
 

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -492,8 +492,13 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
                 }
             }
         } else {
-            let kind = self.infcx.instantiate_binder_with_placeholders(kind);
-            let goal = goal.with(self.tcx(), ty::Binder::dummy(kind));
+            let (kind, additional_assumptions) =
+                self.instantiate_binder_and_assumptions_with_placeholders(kind);
+            let goal = Goal::new(
+                self.tcx(),
+                ty::ParamEnv::augment(self.tcx(), goal.param_env, additional_assumptions),
+                ty::Binder::dummy(kind),
+            );
             self.add_goal(goal);
             self.evaluate_added_goals_and_make_canonical_response(Certainty::Yes)
         }
@@ -787,13 +792,35 @@ impl<'tcx> EvalCtxt<'_, 'tcx> {
         )
     }
 
+    pub(super) fn instantiate_binder_and_predicates_with_infer<
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    >(
+        &self,
+        value: ty::Binder<'tcx, T>,
+    ) -> (T, &'tcx ty::List<ty::Clause<'tcx>>) {
+        self.infcx.instantiate_binder_and_predicates_with_fresh_vars(
+            DUMMY_SP,
+            LateBoundRegionConversionTime::HigherRankedType,
+            value,
+        )
+    }
+
     pub(super) fn instantiate_binder_with_placeholders<T: TypeFoldable<TyCtxt<'tcx>> + Copy>(
         &self,
         value: ty::Binder<'tcx, T>,
     ) -> T {
         self.infcx.instantiate_binder_with_placeholders(value)
     }
 
+    pub(super) fn instantiate_binder_and_assumptions_with_placeholders<
+        T: TypeFoldable<TyCtxt<'tcx>> + Copy,
+    >(
+        &self,
+        value: ty::Binder<'tcx, T>,
+    ) -> (T, &'tcx ty::List<ty::Clause<'tcx>>) {
+        self.infcx.instantiate_binder_and_assumptions_with_placeholders(value)
+    }
+
     pub(super) fn resolve_vars_if_possible<T>(&self, value: T) -> T
     where
         T: TypeFoldable<TyCtxt<'tcx>>,

compiler/rustc_trait_selection/src/solve/project_goals.rs

@@ -114,8 +114,8 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
             if projection_pred.projection_def_id() == goal.predicate.def_id() {
                 let tcx = ecx.tcx();
                 ecx.probe_candidate("assumption").enter(|ecx| {
-                    let assumption_projection_pred =
-                        ecx.instantiate_binder_with_infer(projection_pred);
+                    let (assumption_projection_pred, additional_goals) =
+                        ecx.instantiate_binder_and_predicates_with_infer(projection_pred);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.projection_ty,
@@ -130,7 +130,7 @@ impl<'tcx> assembly::GoalKind<'tcx> for ProjectionPredicate<'tcx> {
                             .instantiate_own(tcx, goal.predicate.projection_ty.args)
                             .map(|(pred, _)| goal.with(tcx, pred)),
                     );
-
+                    ecx.add_goals(additional_goals.iter().map(|pred| goal.with(tcx, pred)));
                     then(ecx)
                 })
             } else {

compiler/rustc_trait_selection/src/solve/trait_goals.rs

@@ -97,12 +97,15 @@ impl<'tcx> assembly::GoalKind<'tcx> for TraitPredicate<'tcx> {
             {
                 // FIXME: Constness
                 ecx.probe_candidate("assumption").enter(|ecx| {
-                    let assumption_trait_pred = ecx.instantiate_binder_with_infer(trait_clause);
+                    let (assumption_trait_pred, additional_goals) =
+                        ecx.instantiate_binder_and_predicates_with_infer(trait_clause);
                     ecx.eq(
                         goal.param_env,
                         goal.predicate.trait_ref,
                         assumption_trait_pred.trait_ref,
                     )?;
+                    let tcx = ecx.tcx();
+                    ecx.add_goals(additional_goals.iter().map(|pred| goal.with(tcx, pred)));
                     then(ecx)
                 })
             } else {