Introduce a built-in Unsize trait and use it for unsizing in coercions.

Author: eddyb

src/libcore/marker.rs

@@ -53,6 +53,14 @@ pub trait Sized : MarkerTrait {
     // Empty.
 }
 
+/// Types that can be "unsized" to a dynamically sized type.
+#[unstable(feature = "core")]
+#[cfg(not(stage0))] // SNAP c64d671
+#[lang="unsize"]
+pub trait Unsize<T> : PhantomFn<Self, T> {
+    // Empty.
+}
+
 /// Types that can be copied by simply copying bits (i.e. `memcpy`).
 ///
 /// By default, variable bindings have 'move semantics.' In other

src/librustc/diagnostics.rs

@@ -68,6 +68,7 @@ register_diagnostics! {
     E0019,
     E0020,
     E0022,
+    E0038,
     E0109,
     E0110,
     E0133,

src/librustc/middle/lang_items.rs

@@ -259,6 +259,7 @@ lets_do_this! {
 
     SendTraitLangItem,               "send",                    send_trait;
     SizedTraitLangItem,              "sized",                   sized_trait;
+    UnsizeTraitLangItem,             "unsize",                  unsize_trait;
     CopyTraitLangItem,               "copy",                    copy_trait;
     SyncTraitLangItem,               "sync",                    sync_trait;
 

src/librustc/middle/traits/error_reporting.rs

@@ -15,8 +15,12 @@ use super::{
     Obligation,
     ObligationCauseCode,
     OutputTypeParameterMismatch,
+    TraitNotObjectSafe,
     PredicateObligation,
     SelectionError,
+    ObjectSafetyViolation,
+    MethodViolationCode,
+    object_safety_violations,
 };
 
 use fmt_macros::{Parser, Piece, Position};
@@ -246,6 +250,55 @@ pub fn report_selection_error<'a, 'tcx>(infcx: &InferCtxt<'a, 'tcx>,
                     note_obligation_cause(infcx, obligation);
             }
         }
+
+        TraitNotObjectSafe(ref trait_ref) => {
+            span_err!(infcx.tcx.sess, obligation.cause.span, E0038,
+                "cannot convert to a trait object because trait `{}` is not object-safe",
+                ty::item_path_str(infcx.tcx, trait_ref.def_id()));
+
+                for violation in object_safety_violations(infcx.tcx, trait_ref.clone()) {
+                    match violation {
+                        ObjectSafetyViolation::SizedSelf => {
+                            infcx.tcx.sess.span_note(
+                                obligation.cause.span,
+                                "the trait cannot require that `Self : Sized`");
+                        }
+
+                        ObjectSafetyViolation::SupertraitSelf => {
+                            infcx.tcx.sess.span_note(
+                                obligation.cause.span,
+                                "the trait cannot use `Self` as a type parameter \
+                                in the supertrait listing");
+                        }
+
+                        ObjectSafetyViolation::Method(method,
+                                MethodViolationCode::StaticMethod) => {
+                            infcx.tcx.sess.span_note(
+                                obligation.cause.span,
+                                &format!("method `{}` has no receiver",
+                                        method.name.user_string(infcx.tcx)));
+                        }
+
+                        ObjectSafetyViolation::Method(method,
+                                MethodViolationCode::ReferencesSelf) => {
+                            infcx.tcx.sess.span_note(
+                                obligation.cause.span,
+                                &format!("method `{}` references the `Self` type \
+                                        in its arguments or return type",
+                                        method.name.user_string(infcx.tcx)));
+                        }
+
+                        ObjectSafetyViolation::Method(method,
+                                MethodViolationCode::Generic) => {
+                            infcx.tcx.sess.span_note(
+                                obligation.cause.span,
+                                &format!("method `{}` has generic type parameters",
+                                        method.name.user_string(infcx.tcx)));
+                        }
+                    }
+                }
+
+        }
     }
 }
 
@@ -397,10 +450,6 @@ fn note_obligation_cause_code<'a, 'tcx, T>(infcx: &InferCtxt<'a, 'tcx>,
                        "only the last field of a struct or enum variant \
                        may have a dynamically sized type")
         }
-        ObligationCauseCode::ObjectSized => {
-            span_note!(tcx.sess, cause_span,
-                       "only sized types can be made into objects");
-        }
         ObligationCauseCode::SharedStatic => {
             span_note!(tcx.sess, cause_span,
                        "shared static variables must have a type that implements `Sync`");

src/librustc/middle/traits/mod.rs

@@ -27,6 +27,7 @@ use util::ppaux::Repr;
 
 pub use self::error_reporting::report_fulfillment_errors;
 pub use self::error_reporting::report_overflow_error;
+pub use self::error_reporting::report_selection_error;
 pub use self::error_reporting::suggest_new_overflow_limit;
 pub use self::coherence::orphan_check;
 pub use self::coherence::overlapping_impls;
@@ -46,6 +47,7 @@ pub use self::select::{MethodMatchedData}; // intentionally don't export variant
 pub use self::util::elaborate_predicates;
 pub use self::util::get_vtable_index_of_object_method;
 pub use self::util::trait_ref_for_builtin_bound;
+pub use self::util::predicate_for_trait_def;
 pub use self::util::supertraits;
 pub use self::util::Supertraits;
 pub use self::util::transitive_bounds;
@@ -117,9 +119,6 @@ pub enum ObligationCauseCode<'tcx> {
     // Types of fields (other than the last) in a struct must be sized.
     FieldSized,
 
-    // Only Sized types can be made into objects
-    ObjectSized,
-
     // static items must have `Sync` type
     SharedStatic,
 
@@ -155,6 +154,7 @@ pub enum SelectionError<'tcx> {
     OutputTypeParameterMismatch(ty::PolyTraitRef<'tcx>,
                                 ty::PolyTraitRef<'tcx>,
                                 ty::type_err<'tcx>),
+    TraitNotObjectSafe(ty::PolyTraitRef<'tcx>),
 }
 
 pub struct FulfillmentError<'tcx> {
@@ -531,7 +531,9 @@ impl<'tcx, N> Vtable<'tcx, N> {
         }
     }
 
-    pub fn map_nested<M, F>(&self, op: F) -> Vtable<'tcx, M> where F: FnMut(&N) -> M {
+    pub fn map_nested<M, F>(&self, op: F) -> Vtable<'tcx, M> where
+        F: FnMut(&N) -> M,
+    {
         match *self {
             VtableImpl(ref i) => VtableImpl(i.map_nested(op)),
             VtableDefaultImpl(ref t) => VtableDefaultImpl(t.map_nested(op)),