Plumb inference obligations through select.rs and beyond

Author: soltanmm-google

src/librustc/middle/const_eval.rs

@@ -20,6 +20,7 @@ use middle::cstore::{self, CrateStore, InlinedItem};
 use middle::{infer, subst, traits};
 use middle::def::Def;
 use middle::subst::Subst;
+use middle::traits::SelectionOk;
 use middle::def_id::DefId;
 use middle::pat_util::def_to_path;
 use middle::ty::{self, Ty};
@@ -1241,15 +1242,22 @@ fn resolve_trait_associated_const<'a, 'tcx: 'a>(tcx: &'a ty::ctxt<'tcx>,
     let obligation = traits::Obligation::new(traits::ObligationCause::dummy(),
                                              trait_ref.to_poly_trait_predicate());
     let selection = match selcx.select(&obligation) {
-        Ok(Some(vtable)) => vtable,
+        Ok(SelectionOk { selection: Some(vtable), obligations }) => {
+            // FIXME these obligations should be propagated or selected on
+            assert!(obligations.is_empty());
+            vtable
+        },
         // Still ambiguous, so give up and let the caller decide whether this
         // expression is really needed yet. Some associated constant values
         // can't be evaluated until monomorphization is done in trans.
-        Ok(None) => {
-            return None
+        Ok(SelectionOk { selection: None, obligations }) => {
+            // FIXME these obligations should be propagated or selected on or... maybe they don't
+            // need to be?
+            assert!(obligations.is_empty());
+            return None;
         }
         Err(_) => {
-            return None
+            return None;
         }
     };
 

src/librustc/middle/traits/fulfill.rs

@@ -27,7 +27,7 @@ use super::ObligationCause;
 use super::PredicateObligation;
 use super::project;
 use super::report_overflow_error_cycle;
-use super::select::SelectionContext;
+use super::select::{SelectionContext, SelectionOk};
 use super::Unimplemented;
 use super::util::predicate_for_builtin_bound;
 
@@ -487,34 +487,40 @@ fn process_predicate1<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
 
             let trait_obligation = obligation.with(data.clone());
             match selcx.select(&trait_obligation) {
-                Ok(Some(vtable)) => {
+                Ok(SelectionOk { selection: Some(vtable), obligations: inferred_obligations }) => {
                     info!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
                           data, obligation.recursion_depth);
-                    Ok(Some(vtable.nested_obligations()))
+                    let mut nested_obligations = vtable.nested_obligations();
+                    nested_obligations.extend(inferred_obligations);
+                    Ok(Some(nested_obligations))
                 }
-                Ok(None) => {
+                Ok(SelectionOk { selection: None, obligations: inferred_obligations }) => {
                     info!("selecting trait `{:?}` at depth {} yielded Ok(None)",
                           data, obligation.recursion_depth);
 
-                    // This is a bit subtle: for the most part, the
-                    // only reason we can fail to make progress on
-                    // trait selection is because we don't have enough
-                    // information about the types in the trait. One
-                    // exception is that we sometimes haven't decided
-                    // what kind of closure a closure is. *But*, in
-                    // that case, it turns out, the type of the
-                    // closure will also change, because the closure
-                    // also includes references to its upvars as part
-                    // of its type, and those types are resolved at
-                    // the same time.
-                    pending_obligation.stalled_on =
-                        trait_ref_type_vars(selcx, data.to_poly_trait_ref());
-
-                    debug!("process_predicate: pending obligation {:?} now stalled on {:?}",
-                           selcx.infcx().resolve_type_vars_if_possible(obligation),
-                           pending_obligation.stalled_on);
-
-                    Ok(None)
+                    if inferred_obligations.is_empty() {
+                        // This is a bit subtle: for the most part, the
+                        // only reason we can fail to make progress on
+                        // trait selection is because we don't have enough
+                        // information about the types in the trait. One
+                        // exception is that we sometimes haven't decided
+                        // what kind of closure a closure is. *But*, in
+                        // that case, it turns out, the type of the
+                        // closure will also change, because the closure
+                        // also includes references to its upvars as part
+                        // of its type, and those types are resolved at
+                        // the same time.
+                        pending_obligation.stalled_on =
+                            trait_ref_type_vars(selcx, data.to_poly_trait_ref());
+
+                        debug!("process_predicate: pending obligation {:?} now stalled on {:?}",
+                               selcx.infcx().resolve_type_vars_if_possible(obligation),
+                               pending_obligation.stalled_on);
+
+                        Ok(None)
+                    } else {
+                        Ok(Some(inferred_obligations))
+                    }
                 }
                 Err(selection_err) => {
                     info!("selecting trait `{:?}` at depth {} yielded Err",

src/librustc/middle/traits/mod.rs

@@ -10,7 +10,6 @@
 
 //! Trait Resolution. See the Book for more.
 
-pub use self::SelectionError::*;
 pub use self::FulfillmentErrorCode::*;
 pub use self::Vtable::*;
 pub use self::ObligationCauseCode::*;
@@ -48,6 +47,8 @@ pub use self::object_safety::is_vtable_safe_method;
 pub use self::select::EvaluationCache;
 pub use self::select::SelectionContext;
 pub use self::select::SelectionCache;
+pub use self::select::{Selection, SelectionError, SelectionOk, SelectionResult};
+pub use self::select::{Unimplemented, OutputTypeParameterMismatch, TraitNotObjectSafe};
 pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
 pub use self::select::{MethodMatchedData}; // intentionally don't export variants
 pub use self::util::elaborate_predicates;
@@ -163,17 +164,6 @@ pub type Obligations<'tcx, O> = Vec<Obligation<'tcx, O>>;
 pub type PredicateObligations<'tcx> = Vec<PredicateObligation<'tcx>>;
 pub type TraitObligations<'tcx> = Vec<TraitObligation<'tcx>>;
 
-pub type Selection<'tcx> = Vtable<'tcx, PredicateObligation<'tcx>>;
-
-#[derive(Clone,Debug)]
-pub enum SelectionError<'tcx> {
-    Unimplemented,
-    OutputTypeParameterMismatch(ty::PolyTraitRef<'tcx>,
-                                ty::PolyTraitRef<'tcx>,
-                                ty::error::TypeError<'tcx>),
-    TraitNotObjectSafe(DefId),
-}
-
 pub struct FulfillmentError<'tcx> {
     pub obligation: PredicateObligation<'tcx>,
     pub code: FulfillmentErrorCode<'tcx>
@@ -186,15 +176,6 @@ pub enum FulfillmentErrorCode<'tcx> {
     CodeAmbiguity,
 }
 
-/// When performing resolution, it is typically the case that there
-/// can be one of three outcomes:
-///
-/// - `Ok(Some(r))`: success occurred with result `r`
-/// - `Ok(None)`: could not definitely determine anything, usually due
-///   to inconclusive type inference.
-/// - `Err(e)`: error `e` occurred
-pub type SelectionResult<'tcx, T> = Result<Option<T>, SelectionError<'tcx>>;
-
 /// Given the successful resolution of an obligation, the `Vtable`
 /// indicates where the vtable comes from. Note that while we call this
 /// a "vtable", it does not necessarily indicate dynamic dispatch at

src/librustc/middle/traits/project.rs

@@ -18,7 +18,7 @@ use super::Obligation;
 use super::ObligationCause;
 use super::PredicateObligation;
 use super::SelectionContext;
-use super::SelectionError;
+use super::{SelectionError, SelectionOk};
 use super::VtableClosureData;
 use super::VtableImplData;
 use super::util;
@@ -90,8 +90,8 @@ pub fn poly_project_and_unify_type<'cx,'tcx>(
     debug!("poly_project_and_unify_type(obligation={:?})",
            obligation);
 
-    let infcx = selcx.infcx();
-    infcx.commit_if_ok(|snapshot| {
+    selcx.commit_if_ok(|selcx, snapshot| {
+        let infcx = selcx.infcx();
         let (skol_predicate, skol_map) =
             infcx.skolemize_late_bound_regions(&obligation.predicate, snapshot);
 
@@ -657,24 +657,30 @@ fn assemble_candidates_from_predicates<'cx,'tcx,I>(
 {
     debug!("assemble_candidates_from_predicates(obligation={:?})",
            obligation);
-    let infcx = selcx.infcx();
     for predicate in env_predicates {
         debug!("assemble_candidates_from_predicates: predicate={:?}",
                predicate);
         match predicate {
             ty::Predicate::Projection(ref data) => {
                 let same_name = data.item_name() == obligation.predicate.item_name;
 
-                let is_match = same_name && infcx.probe(|_| {
+                let is_match = same_name && selcx.probe(|selcx, _| {
                     let origin = TypeOrigin::Misc(obligation.cause.span);
                     let data_poly_trait_ref =
                         data.to_poly_trait_ref();
                     let obligation_poly_trait_ref =
                         obligation_trait_ref.to_poly_trait_ref();
-                    infcx.sub_poly_trait_refs(false,
-                                              origin,
-                                              data_poly_trait_ref,
-                                              obligation_poly_trait_ref).is_ok()
+                    match selcx.infcx().sub_poly_trait_refs(false,
+                                                            origin,
+                                                            data_poly_trait_ref,
+                                                            obligation_poly_trait_ref)
+                    {
+                        Ok(InferOk { obligations, .. }) => {
+                            selcx.extend_inferred_obligations(obligations);
+                            true
+                        },
+                        Err(_) => false,
+                    }
                 });
 
                 debug!("assemble_candidates_from_predicates: candidate={:?} \
@@ -734,8 +740,12 @@ fn assemble_candidates_from_impls<'cx,'tcx>(
     let poly_trait_ref = obligation_trait_ref.to_poly_trait_ref();
     let trait_obligation = obligation.with(poly_trait_ref.to_poly_trait_predicate());
     let vtable = match selcx.select(&trait_obligation) {
-        Ok(Some(vtable)) => vtable,
-        Ok(None) => {
+        Ok(SelectionOk { selection: Some(vtable), obligations }) => {
+            selcx.extend_inferred_obligations(obligations);
+            vtable
+        },
+        Ok(SelectionOk { selection: None, obligations }) => {
+            selcx.extend_inferred_obligations(obligations);
             candidate_set.ambiguous = true;
             return Ok(());
         }