Forbid object types with incomplete projections, before coercions.

Author: eddyb

src/librustc_typeck/astconv.rs

@@ -59,6 +59,7 @@ use middle::ty::{self, RegionEscape, Ty};
 use rscope::{self, UnelidableRscope, RegionScope, ElidableRscope,
              ObjectLifetimeDefaultRscope, ShiftedRscope, BindingRscope};
 use util::common::{ErrorReported, FN_OUTPUT_NAME};
+use util::nodemap::FnvHashSet;
 use util::ppaux::{self, Repr, UserString};
 
 use std::iter::{repeat, AdditiveIterator};
@@ -1026,13 +1027,58 @@ fn trait_ref_to_object_type<'tcx>(this: &AstConv<'tcx>,
                                                      projection_bounds,
                                                      bounds);
 
-    let result = ty::mk_trait(this.tcx(), trait_ref, existential_bounds);
+    let result = make_object_type(this, span, trait_ref, existential_bounds);
     debug!("trait_ref_to_object_type: result={}",
            result.repr(this.tcx()));
 
     result
 }
 
+fn make_object_type<'tcx>(this: &AstConv<'tcx>,
+                          span: Span,
+                          principal: ty::PolyTraitRef<'tcx>,
+                          bounds: ty::ExistentialBounds<'tcx>)
+                          -> Ty<'tcx> {
+    let tcx = this.tcx();
+    let object = ty::TyTrait {
+        principal: principal,
+        bounds: bounds
+    };
+    let object_trait_ref =
+        object.principal_trait_ref_with_self_ty(tcx, tcx.types.err);
+
+    // ensure the super predicates and stop if we encountered an error
+    if this.ensure_super_predicates(span, object.principal_def_id()).is_err() {
+        return tcx.types.err;
+    }
+
+    let mut associated_types: FnvHashSet<(ast::DefId, ast::Name)> =
+        traits::supertraits(tcx, object_trait_ref)
+        .flat_map(|tr| {
+            let trait_def = ty::lookup_trait_def(tcx, tr.def_id());
+            trait_def.associated_type_names
+                .clone()
+                .into_iter()
+                .map(move |associated_type_name| (tr.def_id(), associated_type_name))
+        })
+        .collect();
+
+    for projection_bound in &object.bounds.projection_bounds {
+        let pair = (projection_bound.0.projection_ty.trait_ref.def_id,
+                    projection_bound.0.projection_ty.item_name);
+        associated_types.remove(&pair);
+    }
+
+    for (trait_def_id, name) in associated_types {
+        span_err!(tcx.sess, span, E0191,
+            "the value of the associated type `{}` (from the trait `{}`) must be specified",
+                    name.user_string(tcx),
+                    ty::item_path_str(tcx, trait_def_id));
+    }
+
+    ty::mk_trait(tcx, object.principal, object.bounds)
+}
+
 fn report_ambiguous_associated_type(tcx: &ty::ctxt,
                                     span: Span,
                                     type_str: &str,
@@ -1785,7 +1831,7 @@ fn conv_ty_poly_trait_ref<'tcx>(
                                                         projection_bounds,
                                                         partitioned_bounds);
 
-    ty::mk_trait(this.tcx(), main_trait_bound, bounds)
+    make_object_type(this, span, main_trait_bound, bounds)
 }
 
 pub fn conv_existential_bounds_from_partitioned_bounds<'tcx>(

src/librustc_typeck/check/vtable.rs

@@ -15,7 +15,6 @@ use middle::traits::report_fulfillment_errors;
 use middle::ty::{self, Ty, AsPredicate};
 use syntax::ast;
 use syntax::codemap::Span;
-use util::nodemap::FnvHashSet;
 use util::ppaux::{Repr, UserString};
 
 
@@ -134,46 +133,9 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
         fcx.register_predicate(projection_obligation);
     }
 
-    // Finally, check that there IS a projection predicate for every associated type.
-    check_object_type_binds_all_associated_types(fcx.tcx(),
-                                                 span,
-                                                 object_trait);
-
     object_trait_ref
 }
 
-fn check_object_type_binds_all_associated_types<'tcx>(tcx: &ty::ctxt<'tcx>,
-                                                      span: Span,
-                                                      object_trait: &ty::TyTrait<'tcx>)
-{
-    let object_trait_ref =
-        object_trait.principal_trait_ref_with_self_ty(tcx, tcx.types.err);
-
-    let mut associated_types: FnvHashSet<(ast::DefId, ast::Name)> =
-        traits::supertraits(tcx, object_trait_ref.clone())
-        .flat_map(|tr| {
-            let trait_def = ty::lookup_trait_def(tcx, tr.def_id());
-            trait_def.associated_type_names
-                .clone()
-                .into_iter()
-                .map(move |associated_type_name| (tr.def_id(), associated_type_name))
-        })
-        .collect();
-
-    for projection_bound in &object_trait.bounds.projection_bounds {
-        let pair = (projection_bound.0.projection_ty.trait_ref.def_id,
-                    projection_bound.0.projection_ty.item_name);
-        associated_types.remove(&pair);
-    }
-
-    for (trait_def_id, name) in associated_types {
-        span_err!(tcx.sess, span, E0191,
-            "the value of the associated type `{}` (from the trait `{}`) must be specified",
-                    name.user_string(tcx),
-                    ty::item_path_str(tcx, trait_def_id));
-    }
-}
-
 pub fn select_all_fcx_obligations_and_apply_defaults(fcx: &FnCtxt) {
     debug!("select_all_fcx_obligations_and_apply_defaults");
 

src/test/compile-fail/associated-type-projection-from-multiple-supertraits.rs

@@ -34,6 +34,8 @@ fn dent<C:BoxCar>(c: C, color: C::Color) {
 
 fn dent_object<COLOR>(c: BoxCar<Color=COLOR>) {
     //~^ ERROR ambiguous associated type
+    //~| ERROR the associated type `Color` (from the trait `Box`) must be specified
+    //~| ERROR the associated type `Color` (from the trait `Vehicle`) must be specified
 }
 
 fn paint<C:BoxCar>(c: C, d: C::Color) {

src/test/compile-fail/issue-18819.rs

@@ -20,7 +20,7 @@ impl Foo for X {
     type Item = bool;
 }
 
-fn print_x(_: &Foo, extra: &str) {
+fn print_x(_: &Foo<Item=bool>, extra: &str) {
     println!("{}", extra);
 }
 

src/test/run-pass/issue-19121.rs renamed to src/test/compile-fail/issue-19482.rs

@@ -1,4 +1,4 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // Test that a partially specified trait object with unspecified associated
-// type does not ICE.
+// type does not type-check.
 
 // pretty-expanded FIXME #23616
 
@@ -20,7 +20,6 @@ trait Foo {
 }
 
 fn bar(x: &Foo) {}
-// FIXME(#19482) -- `Foo` should specify `A`, but this is not
-// currently enforced except at object creation
+//~^ ERROR the associated type `A` (from the trait `Foo`) must be specified
 
 pub fn main() {}

src/test/compile-fail/retslot-cast.rs

@@ -11,7 +11,8 @@
 #![feature(rustc_attrs)]
 #![allow(warnings)]
 
-pub fn fail(x: Option<& (Iterator+Send)>) -> Option<&Iterator> {
+pub fn fail(x: Option<&(Iterator<Item=()>+Send)>)
+            -> Option<&Iterator<Item=()>> {
     // This call used to trigger an LLVM assertion because the return
     // slot had type "Option<&Iterator>"* instead of
     // "Option<&(Iterator+Send)>"* -- but this now yields a
@@ -23,7 +24,8 @@ pub fn fail(x: Option<& (Iterator+Send)>) -> Option<&Iterator> {
     inner(x) //~ ERROR mismatched types
 }
 
-pub fn inner(x: Option<& (Iterator+Send)>) -> Option<&(Iterator+Send)> {
+pub fn inner(x: Option<&(Iterator<Item=()>+Send)>)
+             -> Option<&(Iterator<Item=()>+Send)> {
     x
 }
 

src/test/compile-fail/unboxed-closure-sugar-not-used-on-fn.rs

@@ -11,7 +11,7 @@
 
 // Test that the `Fn` traits require `()` form without a feature gate.
 
-fn bar1(x: &Fn<()>) {
+fn bar1(x: &Fn<(), Output=()>) {
     //~^ ERROR angle-bracket notation is not stable when used with the `Fn` family
 }