Plumb inference obligations through selection

src/librustc/traits/fulfill.rs

@@ -28,6 +28,7 @@ use super::PredicateObligation;
 use super::project;
 use super::report_overflow_error_cycle;
 use super::select::SelectionContext;
+use super::SelectionOk;
 use super::Unimplemented;
 use super::util::predicate_for_builtin_bound;
 
@@ -541,10 +542,11 @@ 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(Some(SelectionOk{ selection: vtable, mut obligations })) => {
                     debug!("selecting trait `{:?}` at depth {} yielded Ok(Some)",
                           data, obligation.recursion_depth);
-                    Ok(Some(vtable.nested_obligations()))
+                    obligations.extend(vtable.nested_obligations());
+                    Ok(Some(obligations))
                 }
                 Ok(None) => {
                     debug!("selecting trait `{:?}` at depth {} yielded Ok(None)",

src/librustc/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::*;
@@ -47,6 +46,8 @@ pub use self::object_safety::is_vtable_safe_method;
 pub use self::select::{EvaluationCache, SelectionContext, SelectionCache};
 pub use self::select::{MethodMatchResult, MethodMatched, MethodAmbiguous, MethodDidNotMatch};
 pub use self::select::{MethodMatchedData}; // intentionally don't export variants
+pub use self::select::{Selection, SelectionOk, SelectionError, SelectionResult};
+pub use self::select::{Unimplemented, OutputTypeParameterMismatch, TraitNotObjectSafe};
 pub use self::specialize::{Overlap, specialization_graph, specializes, translate_substs};
 pub use self::util::elaborate_predicates;
 pub use self::util::get_vtable_index_of_object_method;
@@ -162,17 +163,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>
@@ -185,15 +175,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/traits/project.rs

@@ -19,6 +19,7 @@ use super::ObligationCause;
 use super::PredicateObligation;
 use super::SelectionContext;
 use super::SelectionError;
+use super::SelectionOk;
 use super::VtableClosureData;
 use super::VtableImplData;
 use super::util;
@@ -899,7 +900,11 @@ 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(Some(SelectionOk { selection: vtable, obligations })) => {
+            // FIXME(#32730) propagate obligations (or... not... this *is* an 'assembly_*')
+            assert!(obligations.is_empty());
+            vtable
+        },
         Ok(None) => {
             candidate_set.ambiguous = true;
             return Ok(());