propagate other obligations that were left out

cc #32730 -- I left exactly one instance where I wasn't sure of the
right behavior.

diff --git a/src/librustc/infer/mod.rs b/src/librustc/infer/mod.rs
index a1bafe113e415cb90a30a0b2522c7df2b03ded98..4d8b31a33cdef59f12344fe95e94a4da1ce78376 100644 (file)
--- a/src/librustc/infer/mod.rs
+++ b/src/librustc/infer/mod.rs
@@ -1597,9 +1597,13 @@ pub fn can_equate<T>(&self, a: &T, b: &T) -> UnitResult<'tcx>
             // generic so we don't have to do anything quite this
             // terrible.
             let trace = TypeTrace::dummy(self.tcx);
-            self.equate(true, trace, a, b).map(|InferOk { obligations, .. }| {
-                // FIXME(#32730) propagate obligations
-                assert!(obligations.is_empty());
+            self.equate(true, trace, a, b).map(|InferOk { obligations: _, .. }| {
+                // We can intentionally ignore obligations here, since
+                // this is part of a simple test for general
+                // "equatability". However, it's not entirely clear
+                // that we *ought* to be, perhaps a better thing would
+                // be to use a mini-fulfillment context or something
+                // like that.
             })
         })
     }

diff --git a/src/librustc/traits/fulfill.rs b/src/librustc/traits/fulfill.rs
index d771be077ae3a403aeb830a216ea5a2d12f7f1fb..d49affa3e872c0172b7d245a6129ee5de377611c 100644 (file)
--- a/src/librustc/traits/fulfill.rs
+++ b/src/librustc/traits/fulfill.rs
@@ -184,6 +184,16 @@ pub fn register_predicate_obligation(&mut self,
         });
     }
 
+    pub fn register_predicate_obligations(&mut self,
+                                          infcx: &InferCtxt<'a, 'gcx, 'tcx>,
+                                          obligations: Vec<PredicateObligation<'tcx>>)
+    {
+        for obligation in obligations {
+            self.register_predicate_obligation(infcx, obligation);
+        }
+    }
+
+
     pub fn region_obligations(&self,
                               body_id: ast::NodeId)
                               -> &[RegionObligation<'tcx>]

diff --git a/src/librustc/traits/specialize/mod.rs b/src/librustc/traits/specialize/mod.rs
index 92b7c736d42fda8e676ad48cbaa0554ab83d4938..5f02688be34bcbd2e13a8bdcfb3ef270be539556 100644 (file)
--- a/src/librustc/traits/specialize/mod.rs
+++ b/src/librustc/traits/specialize/mod.rs
@@ -218,7 +218,7 @@ fn fulfill_implication<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
                                        -> Result<&'tcx Substs<'tcx>, ()> {
     let selcx = &mut SelectionContext::new(&infcx);
     let target_substs = infcx.fresh_substs_for_item(DUMMY_SP, target_impl);
-    let (target_trait_ref, obligations) = impl_trait_ref_and_oblig(selcx,
+    let (target_trait_ref, mut obligations) = impl_trait_ref_and_oblig(selcx,
                                                                    target_impl,
                                                                    target_substs);
 
@@ -227,9 +227,8 @@ fn fulfill_implication<'a, 'gcx, 'tcx>(infcx: &InferCtxt<'a, 'gcx, 'tcx>,
                               &ObligationCause::dummy(),
                               source_trait_ref,
                               target_trait_ref) {
-        Ok(InferOk { obligations, .. }) => {
-            // FIXME(#32730) propagate obligations
-            assert!(obligations.is_empty())
+        Ok(InferOk { obligations: o, .. }) => {
+            obligations.extend(o);
         }
         Err(_) => {
             debug!("fulfill_implication: {:?} does not unify with {:?}",

diff --git a/src/librustc_driver/test.rs b/src/librustc_driver/test.rs
index 44e291a44c7779e4ba1ae72b27514ee610647bfb..7447fba3038eaeb151e0c4cacb1fe1aed0c95e72 100644 (file)
--- a/src/librustc_driver/test.rs
+++ b/src/librustc_driver/test.rs
@@ -376,7 +376,7 @@ pub fn glb(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) -> InferResult<'tcx, Ty<'tcx>> {
     pub fn check_sub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) {
         match self.sub(t1, t2) {
             Ok(InferOk { obligations, .. }) => {
-                // FIXME(#32730) once obligations are being propagated, assert the right thing.
+                // None of these tests should require nested obligations:
                 assert!(obligations.is_empty());
             }
             Err(ref e) => {
@@ -400,7 +400,7 @@ pub fn check_not_sub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>) {
     pub fn check_lub(&self, t1: Ty<'tcx>, t2: Ty<'tcx>, t_lub: Ty<'tcx>) {
         match self.lub(t1, t2) {
             Ok(InferOk { obligations, value: t }) => {
-                // FIXME(#32730) once obligations are being propagated, assert the right thing.
+                // None of these tests should require nested obligations:
                 assert!(obligations.is_empty());
 
                 self.assert_eq(t, t_lub);
@@ -415,7 +415,7 @@ pub fn check_glb(&self, t1: Ty<'tcx>, t2: Ty<'tcx>, t_glb: Ty<'tcx>) {
         match self.glb(t1, t2) {
             Err(e) => panic!("unexpected error computing LUB: {:?}", e),
             Ok(InferOk { obligations, value: t }) => {
-                // FIXME(#32730) once obligations are being propagated, assert the right thing.
+                // None of these tests should require nested obligations:
                 assert!(obligations.is_empty());
 
                 self.assert_eq(t, t_glb);

diff --git a/src/librustc_typeck/check/compare_method.rs b/src/librustc_typeck/check/compare_method.rs
index 8a6853461a5e847d15c465fe14f494a6edead243..ae70049cc5bdc1a253dfd0d43819833fd053958a 100644 (file)
--- a/src/librustc_typeck/check/compare_method.rs
+++ b/src/librustc_typeck/check/compare_method.rs
@@ -294,10 +294,9 @@ fn compare_predicate_entailment<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
         debug!("compare_impl_method: trait_fty={:?}", trait_fty);
 
         let sub_result = infcx.sub_types(false, &cause, impl_fty, trait_fty)
-            .map(|InferOk { obligations, .. }| {
-                // FIXME(#32730) propagate obligations
-                assert!(obligations.is_empty());
-            });
+                              .map(|InferOk { obligations, .. }| {
+                                  inh.register_predicates(obligations);
+                              });
 
         if let Err(terr) = sub_result {
             debug!("sub_types failed: impl ty {:?}, trait ty {:?}",

diff --git a/src/librustc_typeck/check/dropck.rs b/src/librustc_typeck/check/dropck.rs
index 9f41373dab1b74ec2cd3b0ae858567818a17cceb..b71ff58ccec3305923fcf0085b165b9d607267e0 100644 (file)
--- a/src/librustc_typeck/check/dropck.rs
+++ b/src/librustc_typeck/check/dropck.rs
@@ -82,7 +82,7 @@ fn ensure_drop_params_and_item_params_correspond<'a, 'tcx>(
     // check that the impl type can be made to match the trait type.
 
     let impl_param_env = ty::ParameterEnvironment::for_item(tcx, self_type_node_id);
-    tcx.infer_ctxt(impl_param_env, Reveal::UserFacing).enter(|infcx| {
+    tcx.infer_ctxt(impl_param_env, Reveal::UserFacing).enter(|ref infcx| {
         let tcx = infcx.tcx;
         let mut fulfillment_cx = traits::FulfillmentContext::new();
 
@@ -97,8 +97,7 @@ fn ensure_drop_params_and_item_params_correspond<'a, 'tcx>(
         let cause = &ObligationCause::misc(drop_impl_span, drop_impl_node_id);
         match infcx.eq_types(true, cause, named_type, fresh_impl_self_ty) {
             Ok(InferOk { obligations, .. }) => {
-                // FIXME(#32730) propagate obligations
-                assert!(obligations.is_empty());
+                fulfillment_cx.register_predicate_obligations(infcx, obligations);
             }
             Err(_) => {
                 let item_span = tcx.hir.span(self_type_node_id);

diff --git a/src/librustc_typeck/lib.rs b/src/librustc_typeck/lib.rs
index e9a606dc0ab1dfe10f9130f264869935d397c4dc..0754b52cf280a24a225d8549b7d20bbca85298a9 100644 (file)
--- a/src/librustc_typeck/lib.rs
+++ b/src/librustc_typeck/lib.rs
@@ -109,7 +109,7 @@
 use rustc::ty::subst::Substs;
 use rustc::ty::{self, Ty, TyCtxt};
 use rustc::ty::maps::Providers;
-use rustc::traits::{ObligationCause, ObligationCauseCode, Reveal};
+use rustc::traits::{FulfillmentContext, ObligationCause, ObligationCauseCode, Reveal};
 use session::config;
 use util::common::time;
 
@@ -153,15 +153,22 @@ fn require_same_types<'a, 'tcx>(tcx: TyCtxt<'a, 'tcx, 'tcx>,
                                 expected: Ty<'tcx>,
                                 actual: Ty<'tcx>)
                                 -> bool {
-    tcx.infer_ctxt((), Reveal::UserFacing).enter(|infcx| {
+    tcx.infer_ctxt((), Reveal::UserFacing).enter(|ref infcx| {
+        let mut fulfill_cx = FulfillmentContext::new();
         match infcx.eq_types(false, &cause, expected, actual) {
             Ok(InferOk { obligations, .. }) => {
-                // FIXME(#32730) propagate obligations
-                assert!(obligations.is_empty());
-                true
+                fulfill_cx.register_predicate_obligations(infcx, obligations);
             }
             Err(err) => {
                 infcx.report_mismatched_types(cause, expected, actual, err).emit();
+                return false;
+            }
+        }
+
+        match fulfill_cx.select_all_or_error(infcx) {
+            Ok(()) => true,
+            Err(errors) => {
+                infcx.report_fulfillment_errors(&errors);
                 false
             }
         }