use new solver for coherence

Author: compiler-errors

compiler/rustc_infer/src/infer/at.rs

@@ -85,6 +85,7 @@ impl<'tcx> InferCtxt<'tcx> {
             universe: self.universe.clone(),
             intercrate: self.intercrate,
             inside_canonicalization_ctxt: Cell::new(self.inside_canonicalization_ctxt()),
+            use_new_solver: self.use_new_solver,
         }
     }
 }

compiler/rustc_infer/src/infer/combine.rs

@@ -121,12 +121,12 @@ impl<'tcx> InferCtxt<'tcx> {
             | (
                 ty::Infer(ty::TyVar(_) | ty::FreshTy(_) | ty::FreshIntTy(_) | ty::FreshFloatTy(_)),
                 ty::Alias(AliasKind::Projection, _),
-            ) if self.tcx.trait_solver_next() => {
+            ) if self.use_new_solver => {
                 bug!()
             }
 
             (_, ty::Alias(AliasKind::Projection, _)) | (ty::Alias(AliasKind::Projection, _), _)
-                if self.tcx.trait_solver_next() =>
+                if self.use_new_solver =>
             {
                 relation.register_type_relate_obligation(a, b);
                 Ok(a)
@@ -242,15 +242,37 @@ impl<'tcx> InferCtxt<'tcx> {
                 // FIXME(#59490): Need to remove the leak check to accommodate
                 // escaping bound variables here.
                 if !a.has_escaping_bound_vars() && !b.has_escaping_bound_vars() {
-                    relation.register_const_equate_obligation(a, b);
+                    let (a, b) = if relation.a_is_expected() { (a, b) } else { (b, a) };
+
+                    // FIXME(deferred_projection_equality): What do here...
+                    relation.register_predicates([ty::Binder::dummy(if self.use_new_solver {
+                        ty::PredicateKind::AliasRelate(
+                            a.into(),
+                            b.into(),
+                            ty::AliasRelationDirection::Equate,
+                        )
+                    } else {
+                        ty::PredicateKind::ConstEquate(a, b)
+                    })]);
                 }
                 return Ok(b);
             }
             (_, ty::ConstKind::Unevaluated(..)) if self.tcx.lazy_normalization() => {
                 // FIXME(#59490): Need to remove the leak check to accommodate
                 // escaping bound variables here.
                 if !a.has_escaping_bound_vars() && !b.has_escaping_bound_vars() {
-                    relation.register_const_equate_obligation(a, b);
+                    let (a, b) = if relation.a_is_expected() { (a, b) } else { (b, a) };
+
+                    // FIXME(deferred_projection_equality): What do here...
+                    relation.register_predicates([ty::Binder::dummy(if self.use_new_solver {
+                        ty::PredicateKind::AliasRelate(
+                            a.into(),
+                            b.into(),
+                            ty::AliasRelationDirection::Equate,
+                        )
+                    } else {
+                        ty::PredicateKind::ConstEquate(a, b)
+                    })]);
                 }
                 return Ok(a);
             }
@@ -835,19 +857,6 @@ pub trait ObligationEmittingRelation<'tcx>: TypeRelation<'tcx> {
     /// be used if control over the obligation causes is required.
     fn register_predicates(&mut self, obligations: impl IntoIterator<Item: ToPredicate<'tcx>>);
 
-    /// Register an obligation that both constants must be equal to each other.
-    ///
-    /// If they aren't equal then the relation doesn't hold.
-    fn register_const_equate_obligation(&mut self, a: ty::Const<'tcx>, b: ty::Const<'tcx>) {
-        let (a, b) = if self.a_is_expected() { (a, b) } else { (b, a) };
-
-        self.register_predicates([ty::Binder::dummy(if self.tcx().trait_solver_next() {
-            ty::PredicateKind::AliasRelate(a.into(), b.into(), ty::AliasRelationDirection::Equate)
-        } else {
-            ty::PredicateKind::ConstEquate(a, b)
-        })]);
-    }
-
     /// Register an obligation that both types must be related to each other according to
     /// the [`ty::AliasRelationDirection`] given by [`ObligationEmittingRelation::alias_relate_direction`]
     fn register_type_relate_obligation(&mut self, a: Ty<'tcx>, b: Ty<'tcx>) {

compiler/rustc_infer/src/infer/mod.rs

@@ -347,6 +347,8 @@ pub struct InferCtxt<'tcx> {
     /// that we only collect region information for `BorrowckInferCtxt::reg_var_to_origin`
     /// inside non-canonicalization contexts.
     inside_canonicalization_ctxt: Cell<bool>,
+
+    pub use_new_solver: bool,
 }
 
 /// See the `error_reporting` module for more details.
@@ -561,6 +563,8 @@ pub struct InferCtxtBuilder<'tcx> {
     considering_regions: bool,
     /// Whether we are in coherence mode.
     intercrate: bool,
+    /// Whether to use the new trait solver for calls to `predicate_may_hold`, etc.
+    use_new_solver: bool,
 }
 
 pub trait TyCtxtInferExt<'tcx> {
@@ -574,6 +578,7 @@ impl<'tcx> TyCtxtInferExt<'tcx> for TyCtxt<'tcx> {
             defining_use_anchor: DefiningAnchor::Error,
             considering_regions: true,
             intercrate: false,
+            use_new_solver: self.trait_solver_next(),
         }
     }
 }
@@ -590,6 +595,11 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
         self
     }
 
+    pub fn with_new_solver(mut self) -> Self {
+        self.use_new_solver = true;
+        self
+    }
+
     pub fn intercrate(mut self, intercrate: bool) -> Self {
         self.intercrate = intercrate;
         self
@@ -621,7 +631,13 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
     }
 
     pub fn build(&mut self) -> InferCtxt<'tcx> {
-        let InferCtxtBuilder { tcx, defining_use_anchor, considering_regions, intercrate } = *self;
+        let InferCtxtBuilder {
+            tcx,
+            defining_use_anchor,
+            considering_regions,
+            intercrate,
+            use_new_solver,
+        } = *self;
         InferCtxt {
             tcx,
             defining_use_anchor,
@@ -639,6 +655,7 @@ impl<'tcx> InferCtxtBuilder<'tcx> {
             universe: Cell::new(ty::UniverseIndex::ROOT),
             intercrate,
             inside_canonicalization_ctxt: Cell::new(false),
+            use_new_solver,
         }
     }
 }

compiler/rustc_infer/src/infer/projection.rs

@@ -21,7 +21,7 @@ impl<'tcx> InferCtxt<'tcx> {
         recursion_depth: usize,
         obligations: &mut Vec<PredicateObligation<'tcx>>,
     ) -> Ty<'tcx> {
-        if self.tcx.trait_solver_next() {
+        if self.use_new_solver {
             // FIXME(-Ztrait-solver=next): Instead of branching here,
             // completely change the normalization routine with the new solver.
             //

compiler/rustc_trait_selection/src/solve/eval_ctxt.rs

@@ -173,6 +173,7 @@ impl<'a, 'tcx> EvalCtxt<'a, 'tcx> {
             };
             let (ref infcx, goal, var_values) = tcx
                 .infer_ctxt()
+                .with_new_solver()
                 .intercrate(intercrate)
                 .build_with_canonical(DUMMY_SP, &canonical_goal);
             let mut ecx = EvalCtxt {

compiler/rustc_trait_selection/src/solve/fulfill.rs

@@ -72,6 +72,8 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentCtxt<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
+        assert!(infcx.use_new_solver);
+
         let mut errors = Vec::new();
         for i in 0.. {
             if !infcx.tcx.recursion_limit().value_within_limit(i) {

compiler/rustc_trait_selection/src/traits/chalk_fulfill.rs

@@ -58,6 +58,8 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
+        assert!(!infcx.use_new_solver);
+
         if !self.usable_in_snapshot {
             assert!(!infcx.is_in_snapshot());
         }

compiler/rustc_trait_selection/src/traits/coherence.rs

@@ -98,6 +98,7 @@ pub fn overlapping_impls(
 
     let infcx = tcx
         .infer_ctxt()
+        .with_new_solver()
         .with_opaque_type_inference(DefiningAnchor::Bubble)
         .intercrate(true)
         .build();
@@ -113,6 +114,7 @@ pub fn overlapping_impls(
     // diagnostics. (These take time and can lead to false errors.)
     let infcx = tcx
         .infer_ctxt()
+        .with_new_solver()
         .with_opaque_type_inference(DefiningAnchor::Bubble)
         .intercrate(true)
         .build();
@@ -299,7 +301,7 @@ fn negative_impl(tcx: TyCtxt<'_>, impl1_def_id: DefId, impl2_def_id: DefId) -> b
     debug!("negative_impl(impl1_def_id={:?}, impl2_def_id={:?})", impl1_def_id, impl2_def_id);
 
     // Create an infcx, taking the predicates of impl1 as assumptions:
-    let infcx = tcx.infer_ctxt().build();
+    let infcx = tcx.infer_ctxt().with_new_solver().build();
     // create a parameter environment corresponding to a (placeholder) instantiation of impl1
     let impl_env = tcx.param_env(impl1_def_id);
     let subject1 = match traits::fully_normalize(

compiler/rustc_trait_selection/src/traits/engine.rs

@@ -58,11 +58,21 @@ pub struct ObligationCtxt<'a, 'tcx> {
 
 impl<'a, 'tcx> ObligationCtxt<'a, 'tcx> {
     pub fn new(infcx: &'a InferCtxt<'tcx>) -> Self {
-        Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new(infcx.tcx)) }
+        let engine = if infcx.use_new_solver {
+            Box::new(crate::solve::FulfillmentCtxt::new())
+        } else {
+            <dyn TraitEngine<'_>>::new(infcx.tcx)
+        };
+        Self { infcx, engine: RefCell::new(engine) }
     }
 
     pub fn new_in_snapshot(infcx: &'a InferCtxt<'tcx>) -> Self {
-        Self { infcx, engine: RefCell::new(<dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)) }
+        let engine = if infcx.use_new_solver {
+            Box::new(crate::solve::FulfillmentCtxt::new())
+        } else {
+            <dyn TraitEngine<'_>>::new_in_snapshot(infcx.tcx)
+        };
+        Self { infcx, engine: RefCell::new(engine) }
     }
 
     pub fn register_obligation(&self, obligation: PredicateObligation<'tcx>) {

compiler/rustc_trait_selection/src/traits/fulfill.rs

@@ -145,6 +145,7 @@ impl<'tcx> TraitEngine<'tcx> for FulfillmentContext<'tcx> {
     }
 
     fn select_where_possible(&mut self, infcx: &InferCtxt<'tcx>) -> Vec<FulfillmentError<'tcx>> {
+        assert!(!infcx.use_new_solver);
         let selcx = SelectionContext::new(infcx);
         self.select(selcx)
     }