---

yaml
---
r: 162419
b: refs/heads/try
c: 770378a
h: refs/heads/master
i:
  162417: f6761c9
  162415: 00f2d53
v: v3

Author: bors

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 9146a919b616e39e528e4d7100d16eef52f1f852
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: cafe2966770ff377aad6dd9fd808e68055587c58
-refs/heads/try: bc9de771d5f2ab71a0e3b0eb27a92c65e8ddd4b9
+refs/heads/try: 770378a313a573776b16237a46b75bafa49072c1
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/src/librustc/middle/traits/mod.rs

@@ -94,6 +94,9 @@ 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,
 }
 
 pub type Obligations<'tcx> = subst::VecPerParamSpace<Obligation<'tcx>>;

branches/try/src/librustc/middle/typeck/check/mod.rs

@@ -1775,12 +1775,13 @@ impl<'a, 'tcx> FnCtxt<'a, 'tcx> {
             }
             ty::UnsizeVtable(ref ty_trait, self_ty) => {
                 vtable::check_object_safety(self.tcx(), ty_trait, span);
+
                 // If the type is `Foo+'a`, ensures that the type
                 // being cast to `Foo+'a` implements `Foo`:
                 vtable::register_object_cast_obligations(self,
-                                                          span,
-                                                          ty_trait,
-                                                          self_ty);
+                                                         span,
+                                                         ty_trait,
+                                                         self_ty);
 
                 // If the type is `Foo+'a`, ensures that the type
                 // being cast to `Foo+'a` outlives `'a`:

branches/try/src/librustc/middle/typeck/check/vtable.rs

@@ -21,6 +21,7 @@ use middle::typeck::infer;
 use std::rc::Rc;
 use syntax::ast;
 use syntax::codemap::Span;
+use util::common::ErrorReported;
 use util::ppaux::{UserString, Repr, ty_to_string};
 
 pub fn check_object_cast<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
@@ -238,6 +239,20 @@ pub fn register_object_cast_obligations<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                                                   referent_ty: Ty<'tcx>)
                                                   -> Rc<ty::TraitRef<'tcx>>
 {
+    // We can only make objects from sized types.
+    let sized_obligation =
+        traits::obligation_for_builtin_bound(
+            fcx.tcx(),
+            traits::ObligationCause::new(span, traits::ObjectSized),
+            referent_ty,
+            ty::BoundSized);
+    match sized_obligation {
+        Ok(sized_obligation) => {
+            fcx.register_obligation(sized_obligation);
+        }
+        Err(ErrorReported) => { }
+    }
+
     // This is just for better error reporting. Kinda goofy. The object type stuff
     // needs some refactoring so there is a more convenient type to pass around.
     let object_trait_ty =
@@ -543,5 +558,9 @@ fn note_obligation_cause<'a, 'tcx>(fcx: &FnCtxt<'a, 'tcx>,
                        "only the last field of a struct or enum variant \
                        may have a dynamically sized type")
         }
+        traits::ObjectSized => {
+            span_note!(tcx.sess, obligation.cause.span,
+                       "only sized types can be made into objects");
+        }
     }
 }

branches/try/src/librustc/util/common.rs

@@ -20,7 +20,8 @@ use syntax::ast;
 use syntax::visit;
 use syntax::visit::Visitor;
 
-// An error has already been reported to the user, so no need to continue checking.
+// Useful type to use with `Result<>` indicate that an error has already
+// been reported to the user, so no need to continue checking.
 #[deriving(Clone,Show)]
 pub struct ErrorReported;
 

branches/try/src/libstd/macros.rs

@@ -557,17 +557,17 @@ pub mod builtin {
     /// A macro which expands to the column number on which it was invoked.
     ///
     /// The expanded expression has type `uint`, and the returned column is not
-    /// the invocation of the `col!()` macro itself, but rather the first macro
-    /// invocation leading up to the invocation of the `col!()` macro.
+    /// the invocation of the `column!()` macro itself, but rather the first macro
+    /// invocation leading up to the invocation of the `column!()` macro.
     ///
     /// # Example
     ///
     /// ```
-    /// let current_col = col!();
+    /// let current_col = column!();
     /// println!("defined on column: {}", current_col);
     /// ```
     #[macro_export]
-    macro_rules! col( () => ({ /* compiler built-in */ }) )
+    macro_rules! column( () => ({ /* compiler built-in */ }) )
 
     /// A macro which expands to the file name from which it was invoked.
     ///

branches/try/src/libsyntax/ext/base.rs

@@ -413,9 +413,9 @@ fn initial_syntax_expander_table(ecfg: &expand::ExpansionConfig) -> SyntaxEnv {
     syntax_expanders.insert(intern("line"),
                             builtin_normal_expander(
                                     ext::source_util::expand_line));
-    syntax_expanders.insert(intern("col"),
+    syntax_expanders.insert(intern("column"),
                             builtin_normal_expander(
-                                    ext::source_util::expand_col));
+                                    ext::source_util::expand_column));
     syntax_expanders.insert(intern("file"),
                             builtin_normal_expander(
                                     ext::source_util::expand_file));

branches/try/src/libsyntax/ext/source_util.rs

@@ -38,10 +38,10 @@ pub fn expand_line(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
     base::MacExpr::new(cx.expr_uint(topmost, loc.line))
 }
 
-/* col!(): expands to the current column number */
-pub fn expand_col(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
+/* column!(): expands to the current column number */
+pub fn expand_column(cx: &mut ExtCtxt, sp: Span, tts: &[ast::TokenTree])
                   -> Box<base::MacResult+'static> {
-    base::check_zero_tts(cx, sp, tts, "col!");
+    base::check_zero_tts(cx, sp, tts, "column!");
 
     let topmost = cx.original_span_in_file();
     let loc = cx.codemap().lookup_char_pos(topmost.lo);

branches/try/src/test/compile-fail/dst-object-from-unsized-type.rs

@@ -0,0 +1,30 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+// Test that we cannot create objects from unsized types.
+
+trait Foo for Sized? {}
+impl Foo for str {}
+
+fn test<Sized? T: Foo>(t: &T) {
+    let u: &Foo = t;
+    //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+
+    let v: &Foo = t as &Foo;
+    //~^ ERROR `core::kinds::Sized` is not implemented for the type `T`
+}
+
+fn main() {
+    let _: &[&Foo] = &["hi"];
+    //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+
+    let _: &Foo = "hi" as &Foo;
+    //~^ ERROR `core::kinds::Sized` is not implemented for the type `str`
+}

branches/try/src/test/compile-fail/issue-14366.rs

@@ -11,5 +11,5 @@
 fn main() {
     let _x = "test" as &::std::any::Any;
 //~^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str`
-//~^^ NOTE the trait `core::kinds::Sized` must be implemented for the cast to the object type
+//~^^ ERROR the trait `core::kinds::Sized` is not implemented for the type `str`
 }

branches/try/src/test/run-pass/syntax-extension-source-utils.rs

@@ -25,7 +25,7 @@ macro_rules! indirect_line( () => ( line!() ) )
 
 pub fn main() {
     assert_eq!(line!(), 27);
-    //assert!((col!() == 11));
+    //assert!((column!() == 11));
     assert_eq!(indirect_line!(), 29);
     assert!((file!().ends_with("syntax-extension-source-utils.rs")));
     assert_eq!(stringify!((2*3) + 5).to_string(), "( 2 * 3 ) + 5".to_string());