change the enter_canonical_trait_query method to give a fulfill cx

Author: nikomatsakis

src/librustc/infer/canonical/query_result.rs

@@ -56,7 +56,7 @@ impl<'cx, 'gcx, 'tcx> InferCtxtBuilder<'cx, 'gcx, 'tcx> {
     pub fn enter_canonical_trait_query<K, R>(
         &'tcx mut self,
         canonical_key: &Canonical<'tcx, K>,
-        op: impl FnOnce(&InferCtxt<'_, 'gcx, 'tcx>, K) -> Fallible<InferOk<'tcx, R>>,
+        op: impl FnOnce(&InferCtxt<'_, 'gcx, 'tcx>, &mut FulfillmentContext<'tcx>, K) -> Fallible<R>,
     ) -> Fallible<CanonicalizedQueryResult<'gcx, R>>
     where
         K: TypeFoldable<'tcx>,
@@ -65,9 +65,8 @@ impl<'cx, 'gcx, 'tcx> InferCtxtBuilder<'cx, 'gcx, 'tcx> {
         self.enter(|ref infcx| {
             let (key, canonical_inference_vars) =
                 infcx.instantiate_canonical_with_fresh_inference_vars(DUMMY_SP, &canonical_key);
-            let InferOk { value, obligations } = op(infcx, key)?;
             let fulfill_cx = &mut FulfillmentContext::new();
-            fulfill_cx.register_predicate_obligations(infcx, obligations);
+            let value = op(infcx, fulfill_cx, key)?;
             infcx.make_canonicalized_query_result(canonical_inference_vars, value, fulfill_cx)
         })
     }

src/librustc/infer/mod.rs

@@ -27,7 +27,7 @@ use ty::{self, Ty, TyCtxt, GenericParamDefKind};
 use ty::error::{ExpectedFound, TypeError, UnconstrainedNumeric};
 use ty::fold::TypeFoldable;
 use ty::relate::RelateResult;
-use traits::{self, ObligationCause, PredicateObligations};
+use traits::{self, ObligationCause, PredicateObligations, TraitEngine};
 use rustc_data_structures::unify as ut;
 use std::cell::{Cell, RefCell, Ref, RefMut};
 use std::collections::BTreeMap;
@@ -485,6 +485,19 @@ impl<'tcx, T> InferOk<'tcx, T> {
     pub fn unit(self) -> InferOk<'tcx, ()> {
         InferOk { value: (), obligations: self.obligations }
     }
+
+    /// Extract `value`, registering any obligations into `fulfill_cx`
+    pub fn into_value_registering_obligations(
+        self,
+        infcx: &InferCtxt<'_, '_, 'tcx>,
+        fulfill_cx: &mut impl TraitEngine<'tcx>,
+    ) -> T {
+        let InferOk { value, obligations } = self;
+        for obligation in obligations {
+            fulfill_cx.register_predicate_obligation(infcx, obligation);
+        }
+        value
+    }
 }
 
 impl<'tcx> InferOk<'tcx, ()> {

src/librustc/infer/outlives/bounds.rs

@@ -11,7 +11,7 @@
 use infer::InferCtxt;
 use syntax::ast;
 use syntax::codemap::Span;
-use traits::{FulfillmentContext, TraitEngine};
+use traits::{FulfillmentContext, TraitEngine, TraitEngineExt};
 use ty::{self, Ty, TypeFoldable};
 use ty::outlives::Component;
 use ty::wf;

src/librustc/traits/engine.rs

@@ -16,56 +16,64 @@ use super::{FulfillmentContext, FulfillmentError};
 use super::{ObligationCause, PredicateObligation};
 
 pub trait TraitEngine<'tcx>: 'tcx {
-    fn normalize_projection_type<'a, 'gcx>(
+    fn normalize_projection_type(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         projection_ty: ty::ProjectionTy<'tcx>,
         cause: ObligationCause<'tcx>,
     ) -> Ty<'tcx>;
 
-    fn register_bound<'a, 'gcx>(
+    fn register_bound(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
         param_env: ty::ParamEnv<'tcx>,
         ty: Ty<'tcx>,
         def_id: DefId,
         cause: ObligationCause<'tcx>,
     );
 
-    fn register_predicate_obligation<'a, 'gcx>(
+    fn register_predicate_obligation(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
         obligation: PredicateObligation<'tcx>,
     );
 
-    fn select_all_or_error<'a, 'gcx>(
+    fn select_all_or_error(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
     ) -> Result<(), Vec<FulfillmentError<'tcx>>>;
 
-    fn select_where_possible<'a, 'gcx>(
+    fn select_where_possible(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
     ) -> Result<(), Vec<FulfillmentError<'tcx>>>;
 
     fn pending_obligations(&self) -> Vec<PredicateObligation<'tcx>>;
 }
 
-impl<'a, 'gcx, 'tcx> dyn TraitEngine<'tcx> {
-    pub fn new(_tcx: TyCtxt<'_, '_, 'tcx>) -> Box<Self> {
-        Box::new(FulfillmentContext::new())
-    }
+pub trait TraitEngineExt<'tcx> {
+    fn register_predicate_obligations(
+        &mut self,
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+        obligations: impl IntoIterator<Item = PredicateObligation<'tcx>>,
+    );
+}
 
-    pub fn register_predicate_obligations<I>(
+impl<T: ?Sized + TraitEngine<'tcx>> TraitEngineExt<'tcx> for T {
+    fn register_predicate_obligations(
         &mut self,
-        infcx: &InferCtxt<'a, 'gcx, 'tcx>,
-        obligations: I,
-    ) where
-        I: IntoIterator<Item = PredicateObligation<'tcx>>,
-    {
+        infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+        obligations: impl IntoIterator<Item = PredicateObligation<'tcx>>,
+    ) {
         for obligation in obligations {
             self.register_predicate_obligation(infcx, obligation);
         }
     }
 }
+
+impl dyn TraitEngine<'tcx> {
+    pub fn new(_tcx: TyCtxt<'_, '_, 'tcx>) -> Box<Self> {
+        Box::new(FulfillmentContext::new())
+    }
+}

src/librustc/traits/fulfill.rs

@@ -21,7 +21,7 @@ use middle::const_val::{ConstEvalErr, ErrKind};
 use super::CodeAmbiguity;
 use super::CodeProjectionError;
 use super::CodeSelectionError;
-use super::engine::TraitEngine;
+use super::engine::{TraitEngine, TraitEngineExt};
 use super::{FulfillmentError, FulfillmentErrorCode};
 use super::{ObligationCause, PredicateObligation, Obligation};
 use super::project;
@@ -86,16 +86,6 @@ impl<'a, 'gcx, 'tcx> FulfillmentContext<'tcx> {
         }
     }
 
-    pub fn register_predicate_obligations<I>(&mut self,
-                                             infcx: &InferCtxt<'a, 'gcx, 'tcx>,
-                                             obligations: I)
-        where I: IntoIterator<Item = PredicateObligation<'tcx>>
-    {
-        for obligation in obligations {
-            self.register_predicate_obligation(infcx, obligation);
-        }
-    }
-
     /// Attempts to select obligations using `selcx`. If `only_new_obligations` is true, then it
     /// only attempts to select obligations that haven't been seen before.
     fn select(&mut self, selcx: &mut SelectionContext<'a, 'gcx, 'tcx>)

src/librustc/traits/mod.rs

@@ -47,7 +47,7 @@ pub use self::select::{EvaluationCache, SelectionContext, SelectionCache};
 pub use self::select::{EvaluationResult, IntercrateAmbiguityCause, OverflowError};
 pub use self::specialize::{OverlapError, specialization_graph, translate_substs};
 pub use self::specialize::{SpecializesCache, find_associated_item};
-pub use self::engine::TraitEngine;
+pub use self::engine::{TraitEngine, TraitEngineExt};
 pub use self::util::elaborate_predicates;
 pub use self::util::supertraits;
 pub use self::util::Supertraits;

src/librustc/traits/query/type_op/custom.rs

@@ -16,7 +16,7 @@ use infer::canonical::query_result;
 use infer::canonical::QueryRegionConstraint;
 use std::rc::Rc;
 use syntax::codemap::DUMMY_SP;
-use traits::{ObligationCause, TraitEngine};
+use traits::{ObligationCause, TraitEngine, TraitEngineExt};
 
 pub struct CustomTypeOp<F, G> {
     closure: F,

src/librustc_traits/dropck_outlives.rs

@@ -12,7 +12,7 @@ use rustc::hir::def_id::DefId;
 use rustc::infer::canonical::{Canonical, QueryResult};
 use rustc::traits::query::dropck_outlives::{DropckOutlivesResult, DtorckConstraint};
 use rustc::traits::query::{CanonicalTyGoal, NoSolution};
-use rustc::traits::{FulfillmentContext, Normalized, ObligationCause};
+use rustc::traits::{FulfillmentContext, Normalized, ObligationCause, TraitEngineExt};
 use rustc::ty::query::Providers;
 use rustc::ty::subst::{Subst, Substs};
 use rustc::ty::{self, ParamEnvAnd, Ty, TyCtxt};

src/librustc_traits/normalize_projection_ty.rs

@@ -9,9 +9,8 @@
 // except according to those terms.
 
 use rustc::infer::canonical::{Canonical, QueryResult};
-use rustc::infer::InferOk;
 use rustc::traits::query::{normalize::NormalizationResult, CanonicalProjectionGoal, NoSolution};
-use rustc::traits::{self, ObligationCause, SelectionContext};
+use rustc::traits::{self, ObligationCause, SelectionContext, TraitEngineExt};
 use rustc::ty::query::Providers;
 use rustc::ty::{ParamEnvAnd, TyCtxt};
 use rustc_data_structures::sync::Lrc;
@@ -39,6 +38,7 @@ fn normalize_projection_ty<'tcx>(
     tcx.infer_ctxt().enter_canonical_trait_query(
         &goal,
         |infcx,
+         fulfill_cx,
          ParamEnvAnd {
              param_env,
              value: goal,
@@ -54,11 +54,9 @@ fn normalize_projection_ty<'tcx>(
                 0,
                 &mut obligations,
             );
-            Ok(InferOk {
-                value: NormalizationResult {
-                    normalized_ty: answer,
-                },
-                obligations,
+            fulfill_cx.register_predicate_obligations(infcx, obligations);
+            Ok(NormalizationResult {
+                normalized_ty: answer,
             })
         },
     )

src/librustc_traits/type_op.rs

@@ -9,15 +9,15 @@
 // except according to those terms.
 
 use rustc::infer::canonical::{Canonical, QueryResult};
-use rustc::infer::{InferCtxt, InferOk};
+use rustc::infer::InferCtxt;
 use rustc::traits::query::type_op::eq::Eq;
 use rustc::traits::query::type_op::normalize::Normalize;
 use rustc::traits::query::type_op::prove_predicate::ProvePredicate;
 use rustc::traits::query::type_op::subtype::Subtype;
 use rustc::traits::query::{Fallible, NoSolution};
-use rustc::traits::{Obligation, Normalized, ObligationCause};
+use rustc::traits::{FulfillmentContext, Normalized, Obligation, ObligationCause, TraitEngine, TraitEngineExt};
 use rustc::ty::query::Providers;
-use rustc::ty::{ParamEnvAnd, FnSig, Lift, PolyFnSig, Predicate, Ty, TyCtxt, TypeFoldable};
+use rustc::ty::{FnSig, Lift, ParamEnvAnd, PolyFnSig, Predicate, Ty, TyCtxt, TypeFoldable};
 use rustc_data_structures::sync::Lrc;
 use std::fmt;
 
@@ -39,24 +39,29 @@ fn type_op_eq<'tcx>(
     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Eq<'tcx>>>,
 ) -> Result<Lrc<Canonical<'tcx, QueryResult<'tcx, ()>>>, NoSolution> {
     tcx.infer_ctxt()
-        .enter_canonical_trait_query(&canonicalized, |infcx, key| {
+        .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
             let (param_env, Eq { a, b }) = key.into_parts();
-            Ok(infcx.at(&ObligationCause::dummy(), param_env).eq(a, b)?)
+            Ok(infcx
+                .at(&ObligationCause::dummy(), param_env)
+                .eq(a, b)?
+                .into_value_registering_obligations(infcx, fulfill_cx))
         })
 }
 
 fn type_op_normalize<T>(
     infcx: &InferCtxt<'_, 'gcx, 'tcx>,
+    fulfill_cx: &mut FulfillmentContext<'tcx>,
     key: ParamEnvAnd<'tcx, Normalize<T>>,
-) -> Fallible<InferOk<'tcx, T>>
+) -> Fallible<T>
 where
     T: fmt::Debug + TypeFoldable<'tcx> + Lift<'gcx>,
 {
     let (param_env, Normalize { value }) = key.into_parts();
     let Normalized { value, obligations } = infcx
         .at(&ObligationCause::dummy(), param_env)
         .normalize(&value)?;
-    Ok(InferOk { value, obligations }) // ugh we should merge these two structs
+    fulfill_cx.register_predicate_obligations(infcx, obligations);
+    Ok(value)
 }
 
 fn type_op_normalize_ty(
@@ -95,30 +100,27 @@ fn type_op_subtype<'tcx>(
     tcx: TyCtxt<'_, 'tcx, 'tcx>,
     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, Subtype<'tcx>>>,
 ) -> Result<Lrc<Canonical<'tcx, QueryResult<'tcx, ()>>>, NoSolution> {
-    tcx.infer_ctxt().enter_canonical_trait_query(
-        &canonicalized, |infcx, key| {
+    tcx.infer_ctxt()
+        .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
             let (param_env, Subtype { sub, sup }) = key.into_parts();
             Ok(infcx
                 .at(&ObligationCause::dummy(), param_env)
-                .sup(sup, sub)?)
-        },
-    )
+                .sup(sup, sub)?
+                .into_value_registering_obligations(infcx, fulfill_cx))
+        })
 }
 
 fn type_op_prove_predicate<'tcx>(
     tcx: TyCtxt<'_, 'tcx, 'tcx>,
     canonicalized: Canonical<'tcx, ParamEnvAnd<'tcx, ProvePredicate<'tcx>>>,
 ) -> Result<Lrc<Canonical<'tcx, QueryResult<'tcx, ()>>>, NoSolution> {
     tcx.infer_ctxt()
-        .enter_canonical_trait_query(&canonicalized, |_infcx, key| {
+        .enter_canonical_trait_query(&canonicalized, |infcx, fulfill_cx, key| {
             let (param_env, ProvePredicate { predicate }) = key.into_parts();
-            Ok(InferOk {
-                value: (),
-                obligations: vec![Obligation::new(
-                    ObligationCause::dummy(),
-                    param_env,
-                    predicate,
-                )],
-            })
+            fulfill_cx.register_predicate_obligation(
+                infcx,
+                Obligation::new(ObligationCause::dummy(), param_env, predicate),
+            );
+            Ok(())
         })
 }