Make projected types select out of the trait bounds.

Author: nikomatsakis

src/librustc/middle/check_static.rs

@@ -31,7 +31,6 @@ use middle::infer;
 use middle::traits;
 use middle::mem_categorization as mc;
 use middle::expr_use_visitor as euv;
-use util::common::ErrorReported;
 use util::nodemap::NodeSet;
 
 use syntax::ast;
@@ -120,19 +119,14 @@ impl<'a, 'tcx> CheckStaticVisitor<'a, 'tcx> {
         let ty = ty::node_id_to_type(self.tcx, e.id);
         let infcx = infer::new_infer_ctxt(self.tcx);
         let mut fulfill_cx = traits::FulfillmentContext::new();
-        match traits::poly_trait_ref_for_builtin_bound(self.tcx, ty::BoundSync, ty) {
-            Ok(trait_ref) => {
-                let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic);
-                fulfill_cx.register_trait_ref(self.tcx, trait_ref, cause);
-                let env = ty::empty_parameter_environment();
-                match fulfill_cx.select_all_or_error(&infcx, &env, self.tcx) {
-                    Ok(()) => { },
-                    Err(ref errors) => {
-                      traits::report_fulfillment_errors(&infcx, errors);
-                    }
-                }
+        let cause = traits::ObligationCause::new(e.span, e.id, traits::SharedStatic);
+        fulfill_cx.register_builtin_bound(&infcx, ty, ty::BoundSync, cause);
+        let env = ty::empty_parameter_environment();
+        match fulfill_cx.select_all_or_error(&infcx, &env, self.tcx) {
+            Ok(()) => { },
+            Err(ref errors) => {
+                traits::report_fulfillment_errors(&infcx, errors);
             }
-            Err(ErrorReported) => { }
         }
     }
 }

src/librustc/middle/subst.rs

@@ -412,6 +412,10 @@ impl<T> VecPerParamSpace<T> {
         self.content.as_slice()
     }
 
+    pub fn to_vec(self) -> Vec<T> {
+        self.content
+    }
+
     pub fn all_vecs<P>(&self, mut pred: P) -> bool where
         P: FnMut(&[T]) -> bool,
     {

src/librustc/middle/traits/fulfill.rs

@@ -119,43 +119,43 @@ impl<'tcx> FulfillmentContext<'tcx> {
                 ty: ty_var
             });
         let obligation = Obligation::new(cause, projection.as_predicate());
-        self.register_predicate(infcx.tcx, obligation);
+        self.register_predicate(infcx, obligation);
         ty_var
     }
 
-    pub fn register_builtin_bound(&mut self,
-                                  tcx: &ty::ctxt<'tcx>,
-                                  ty: Ty<'tcx>,
-                                  builtin_bound: ty::BuiltinBound,
-                                  cause: ObligationCause<'tcx>)
+    pub fn register_builtin_bound<'a>(&mut self,
+                                      infcx: &InferCtxt<'a,'tcx>,
+                                      ty: Ty<'tcx>,
+                                      builtin_bound: ty::BuiltinBound,
+                                      cause: ObligationCause<'tcx>)
     {
-        match predicate_for_builtin_bound(tcx, cause, builtin_bound, 0, ty) {
+        match predicate_for_builtin_bound(infcx.tcx, cause, builtin_bound, 0, ty) {
             Ok(predicate) => {
-                self.register_predicate(tcx, predicate);
+                self.register_predicate(infcx, predicate);
             }
             Err(ErrorReported) => { }
         }
     }
 
-    pub fn register_region_obligation(&mut self,
-                                      tcx: &ty::ctxt<'tcx>,
-                                      t_a: Ty<'tcx>,
-                                      r_b: ty::Region,
-                                      cause: ObligationCause<'tcx>)
+    pub fn register_region_obligation<'a>(&mut self,
+                                          infcx: &InferCtxt<'a,'tcx>,
+                                          t_a: Ty<'tcx>,
+                                          r_b: ty::Region,
+                                          cause: ObligationCause<'tcx>)
     {
-        register_region_obligation(tcx, t_a, r_b, cause, &mut self.region_obligations);
+        register_region_obligation(infcx.tcx, t_a, r_b, cause, &mut self.region_obligations);
     }
 
     pub fn register_predicate<'a>(&mut self,
-                                  tcx: &ty::ctxt<'tcx>,
+                                  infcx: &InferCtxt<'a,'tcx>,
                                   obligation: PredicateObligation<'tcx>)
     {
         if !self.duplicate_set.insert(obligation.predicate.clone()) {
-            debug!("register_predicate({}) -- already seen, skip", obligation.repr(tcx));
+            debug!("register_predicate({}) -- already seen, skip", obligation.repr(infcx.tcx));
             return;
         }
 
-        debug!("register_predicate({})", obligation.repr(tcx));
+        debug!("register_predicate({})", obligation.repr(infcx.tcx));
         self.predicates.push(obligation);
     }
 
@@ -230,7 +230,6 @@ impl<'tcx> FulfillmentContext<'tcx> {
                self.predicates.len(),
                only_new_obligations);
 
-        let tcx = selcx.tcx();
         let mut errors = Vec::new();
 
         loop {
@@ -279,7 +278,7 @@ impl<'tcx> FulfillmentContext<'tcx> {
             // Now go through all the successful ones,
             // registering any nested obligations for the future.
             for new_obligation in new_obligations.into_iter() {
-                self.register_predicate(tcx, new_obligation);
+                self.register_predicate(selcx.infcx(), new_obligation);
             }
         }
 
@@ -469,17 +468,22 @@ fn process_predicate<'a,'tcx>(selcx: &mut SelectionContext<'a,'tcx>,
                             CodeProjectionError(e)));
                     true
                 }
-                Err(project::ProjectionError::TraitSelectionError(e)) => {
-                    // Extract just the `T : Trait` from `<T as
-                    // Trait>::Name == U`, so that when we report an
-                    // error to the user, it says something like "`T :
-                    // Trait` not satisfied".5D
+                Err(project::ProjectionError::TraitSelectionError(_)) => {
+                    // There was an error matching `T : Trait` (which
+                    // is a pre-requisite for `<T as Trait>::Name`
+                    // being valid).  We could just report the error
+                    // now, but that tends to lead to double error
+                    // reports for the user (one for the obligation `T
+                    // : Trait`, typically incurred somewhere else,
+                    // and one from here). Instead, we'll create the
+                    // `T : Trait` obligation and add THAT as a
+                    // requirement. This will (eventually) trigger the
+                    // same error, but it will also wind up flagged as
+                    // a duplicate if another requirement that `T :
+                    // Trait` arises from somewhere else.
                     let trait_predicate = data.to_poly_trait_ref();
                     let trait_obligation = obligation.with(trait_predicate.as_predicate());
-                    errors.push(
-                        FulfillmentError::new(
-                            trait_obligation,
-                            CodeSelectionError(e)));
+                    new_obligations.push(trait_obligation);
                     true
                 }
             }

src/librustc/middle/traits/mod.rs

@@ -37,7 +37,6 @@ pub use self::util::elaborate_predicates;
 pub use self::util::trait_ref_for_builtin_bound;
 pub use self::util::supertraits;
 pub use self::util::Supertraits;
-pub use self::util::search_trait_and_supertraits_from_bound;
 pub use self::util::transitive_bounds;
 
 mod coherence;
@@ -189,10 +188,10 @@ pub type SelectionResult<'tcx, T> = Result<Option<T>, SelectionError<'tcx>>;
 ///
 ///    // Case B: Vtable must be provided by caller. This applies when
 ///    // type is a type parameter.
-///    param.clone();    // VtableParam(Oblig_1)
+///    param.clone();    // VtableParam
 ///
 ///    // Case C: A mix of cases A and B.
-///    mixed.clone();    // Vtable(Impl_1, [VtableParam(Oblig_1)])
+///    mixed.clone();    // Vtable(Impl_1, [VtableParam])
 /// }
 /// ```
 ///
@@ -206,7 +205,7 @@ pub enum Vtable<'tcx, N> {
 
     /// Successful resolution to an obligation provided by the caller
     /// for some type parameter.
-    VtableParam(VtableParamData<'tcx>),
+    VtableParam,
 
     /// Successful resolution for a builtin trait.
     VtableBuiltin(VtableBuiltinData<N>),
@@ -243,15 +242,6 @@ pub struct VtableBuiltinData<N> {
     pub nested: subst::VecPerParamSpace<N>
 }
 
-/// A vtable provided as a parameter by the caller. For example, in a
-/// function like `fn foo<T:Eq>(...)`, if the `eq()` method is invoked
-/// on an instance of `T`, the vtable would be of type `VtableParam`.
-#[deriving(PartialEq,Eq,Clone)]
-pub struct VtableParamData<'tcx> {
-    // In the above example, this would `Eq`
-    pub bound: ty::PolyTraitRef<'tcx>,
-}
-
 /// True if neither the trait nor self type is local. Note that `impl_def_id` must refer to an impl
 /// of a trait, not an inherent impl.
 pub fn is_orphan_impl(tcx: &ty::ctxt,
@@ -302,7 +292,7 @@ pub fn type_known_to_meet_builtin_bound<'a,'tcx>(infcx: &InferCtxt<'a,'tcx>,
     // (there shouldn't really be any anyhow).
     let cause = ObligationCause::misc(DUMMY_SP, ast::DUMMY_NODE_ID);
 
-    fulfill_cx.register_builtin_bound(infcx.tcx, ty, bound, cause);
+    fulfill_cx.register_builtin_bound(infcx, ty, bound, cause);
 
     // Note: we only assume something is `Copy` if we can
     // *definitively* show that it implements `Copy`. Otherwise,
@@ -361,7 +351,7 @@ impl<'tcx, N> Vtable<'tcx, N> {
             VtableImpl(ref i) => i.iter_nested(),
             VtableFnPointer(..) => (&[]).iter(),
             VtableUnboxedClosure(..) => (&[]).iter(),
-            VtableParam(_) => (&[]).iter(),
+            VtableParam => (&[]).iter(),
             VtableBuiltin(ref i) => i.iter_nested(),
         }
     }
@@ -371,7 +361,7 @@ impl<'tcx, N> Vtable<'tcx, N> {
             VtableImpl(ref i) => VtableImpl(i.map_nested(op)),
             VtableFnPointer(ref sig) => VtableFnPointer((*sig).clone()),
             VtableUnboxedClosure(d, ref s) => VtableUnboxedClosure(d, s.clone()),
-            VtableParam(ref p) => VtableParam((*p).clone()),
+            VtableParam => VtableParam,
             VtableBuiltin(ref b) => VtableBuiltin(b.map_nested(op)),
         }
     }
@@ -383,7 +373,7 @@ impl<'tcx, N> Vtable<'tcx, N> {
             VtableImpl(i) => VtableImpl(i.map_move_nested(op)),
             VtableFnPointer(sig) => VtableFnPointer(sig),
             VtableUnboxedClosure(d, s) => VtableUnboxedClosure(d, s),
-            VtableParam(p) => VtableParam(p),
+            VtableParam => VtableParam,
             VtableBuiltin(no) => VtableBuiltin(no.map_move_nested(op)),
         }
     }

src/librustc/middle/traits/project.rs

@@ -128,10 +128,12 @@ pub fn project_type<'cx,'tcx>(
                                                   &mut candidates);
 
     if candidates.vec.is_empty() {
-        // TODO This `if` is not necessarily wrong, but it needs an
-        // explanation, and it should probably be accompanied by a
-        // similar rule in `select.rs`. Currently it's *needed*
-        // because the impl-trait-for-trait branch has not landed.
+        // FIXME(#20297) -- In `select.rs` there is similar logic that
+        // gives precedence to where-clauses, but it's a bit more
+        // fine-grained. I was lazy here and just always give
+        // precedence to where-clauses or other such sources over
+        // actually dredging through impls. This logic probably should
+        // be tightened up.
 
         let () = try!(assemble_candidates_from_impls(selcx,
                                                      obligation,