---

yaml
---
r: 104137
b: refs/heads/try
c: 4f72c01
h: refs/heads/master
i:
  104135: 74d3d2e
v: v3

Author: zr40

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: 62f1d68439dcfd509eaca29887afa97f22938373
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
-refs/heads/try: 58eeb07c2a128cbba403d6204c2f291af4ddf938
+refs/heads/try: 4f72c018cec120d596ece1b5f2a2e7d59f1ef520
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
 refs/heads/try2: 147ecfdd8221e4a4d4e090486829a06da1e0ca3c

branches/try/src/doc/complement-cheatsheet.md

@@ -36,42 +36,12 @@ let y: ~str = x.to_str_radix(16);
 Use [`FromStrRadix`](http://static.rust-lang.org/doc/master/std/num/trait.FromStrRadix.html), and its helper function, [`from_str_radix`](http://static.rust-lang.org/doc/master/std/num/fn.from_str_radix.html).
 
 ~~~
-use std::num;
+use std::num::from_str_radix;
 
-let x: Option<i64> = num::from_str_radix("deadbeef", 16);
+let x: Option<i64> = from_str_radix("deadbeef", 16);
 let y: i64 = x.unwrap();
 ~~~
 
-**Vector of Bytes to String**
-
-To return a Borrowed String Slice (&str) use the str helper function [`from_utf8`](http://static.rust-lang.org/doc/master/std/str/fn.from_utf8.html).
-
-~~~
-use std::str;
-
-let bytes = ~[104u8,105u8];
-let x: Option<&str> = str::from_utf8(bytes);
-let y: &str = x.unwrap();
-~~~
-
-To return an Owned String (~str) use the str helper function [`from_utf8_owned`](http://static.rust-lang.org/doc/master/std/str/fn.from_utf8_owned.html).
-
-~~~
-use std::str;
-
-let x: Option<~str> = str::from_utf8_owned(~[104u8,105u8]);
-let y: ~str = x.unwrap();
-~~~~
-
-To return a [`MaybeOwned`](http://static.rust-lang.org/doc/master/std/str/enum.MaybeOwned.html) use the str helper function [`from_utf8_lossy`](http://static.rust-lang.org/doc/master/std/str/fn.from_utf8_owned.html).  This function also replaces non-valid utf-8 sequences with U+FFFD replacement character.
-
-~~~
-use std::str;
-
-let x = bytes!(72u8,"ello ",0xF0,0x90,0x80,"World!");
-let y = str::from_utf8_lossy(x);
-~~~~
-
 # File operations
 
 ## How do I read from a file?

branches/try/src/doc/tutorial.md

@@ -293,7 +293,7 @@ braced block gives the whole block the value of that last expression.
 
 Put another way, the semicolon in Rust *ignores the value of an expression*.
 Thus, if the branches of the `if` had looked like `{ 4; }`, the above example
-would simply assign `()` (nil or void) to `price`. But without the semicolon, each
+would simply assign `()` (unit or void) to `price`. But without the semicolon, each
 branch has a different value, and `price` gets the value of the branch that
 was taken.
 
@@ -352,7 +352,7 @@ before the opening and after the closing quote, and can contain any sequence of
 characters except their closing delimiter.  More on strings
 [later](#vectors-and-strings).
 
-The nil type, written `()`, has a single value, also written `()`.
+The unit type, written `()`, has a single value, also written `()`.
 
 ## Operators
 
@@ -852,7 +852,7 @@ fn line(a: int, b: int, x: int) -> int {
 It's better Rust style to write a return value this way instead of
 writing an explicit `return`. The utility of `return` comes in when
 returning early from a function. Functions that do not return a value
-are said to return nil, `()`, and both the return type and the return
+are said to return unit, `()`, and both the return type and the return
 value may be omitted from the definition. The following two functions
 are equivalent.
 

branches/try/src/libfourcc/lib.rs

@@ -26,10 +26,10 @@ To load the extension and use it:
 extern mod fourcc;
 
 fn main() {
-    let val = fourcc!("\xC0\xFF\xEE!");
-    assert_eq!(val, 0xC0FFEE21u32);
-    let little_val = fourcc!("foo ", little);
-    assert_eq!(little_val, 0x21EEFFC0u32);
+    let val = fourcc!("\xC0\xFF\xEE!")
+    // val is 0xC0FFEE21
+    let big_val = fourcc!("foo ", big);
+    // big_val is 0x21EEFFC0
 }
  ```
 
@@ -60,6 +60,7 @@ use syntax::parse::token;
 use syntax::parse::token::InternedString;
 
 #[macro_registrar]
+#[cfg(not(test))]
 pub fn macro_registrar(register: |Name, SyntaxExtension|) {
     register(token::intern("fourcc"),
         NormalTT(~BasicMacroExpander {
@@ -154,6 +155,6 @@ fn target_endian_little(cx: &ExtCtxt, sp: Span) -> bool {
     contains(cx.cfg(), meta)
 }
 
-// FIXME (10872): This is required to prevent an LLVM assert on Windows
+// Fixes LLVM assert on Windows
 #[test]
 fn dummy_test() { }

branches/try/src/librustc/metadata/tydecode.rs

@@ -372,6 +372,7 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
       'F' => {
         return ty::mk_bare_fn(st.tcx, parse_bare_fn_ty(st, |x,y| conv(x,y)));
       }
+      'Y' => return ty::mk_type(st.tcx),
       '#' => {
         let pos = parse_hex(st);
         assert_eq!(next(st), ':');

branches/try/src/librustc/metadata/tyencode.rs

@@ -328,6 +328,7 @@ fn enc_sty(w: &mut MemWriter, cx: @ctxt, st: &ty::sty) {
         ty::ty_self(did) => {
             mywrite!(w, "s{}|", (cx.ds)(did));
         }
+        ty::ty_type => mywrite!(w, "Y"),
         ty::ty_struct(def, ref substs) => {
             mywrite!(w, "a[{}|", (cx.ds)(def));
             enc_substs(w, cx, substs);

branches/try/src/librustc/middle/trans/base.rs

@@ -598,8 +598,19 @@ pub fn compare_scalar_types<'a>(
         ty::ty_int(_) => rslt(cx, f(signed_int)),
         ty::ty_uint(_) => rslt(cx, f(unsigned_int)),
         ty::ty_float(_) => rslt(cx, f(floating_point)),
+        ty::ty_type => {
+            rslt(
+                controlflow::trans_fail(
+                    cx, None,
+                    InternedString::new("attempt to compare values of type \
+                                         type")),
+                C_nil())
+        }
+        _ => {
             // Should never get here, because t is scalar.
-        _ => cx.sess().bug("non-scalar type passed to compare_scalar_types")
+            cx.sess().bug("non-scalar type passed to \
+                           compare_scalar_types")
+        }
     }
 }
 

branches/try/src/librustc/middle/trans/closure.rs

@@ -152,12 +152,8 @@ pub fn mk_closure_tys(tcx: ty::ctxt,
     return cdata_ty;
 }
 
-fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
-    let ptr = ty::mk_imm_ptr(tcx, ty::mk_i8());
-    ty::mk_tup(tcx, ~[ty::mk_uint(), ty::mk_nil_ptr(tcx), ptr, ptr, t])
-}
-
-fn allocate_cbox<'a>(bcx: &'a Block<'a>,
+pub fn allocate_cbox<'a>(
+                     bcx: &'a Block<'a>,
                      sigil: ast::Sigil,
                      cdata_ty: ty::t)
                      -> Result<'a> {

branches/try/src/librustc/middle/trans/common.rs

@@ -520,6 +520,19 @@ pub fn val_ty(v: ValueRef) -> Type {
     }
 }
 
+// Let T be the content of a box @T.  tuplify_box_ty(t) returns the
+// representation of @T as a tuple (i.e., the ty::t version of what T_box()
+// returns).
+pub fn tuplify_box_ty(tcx: ty::ctxt, t: ty::t) -> ty::t {
+    let ptr = ty::mk_ptr(
+        tcx,
+        ty::mt {ty: ty::mk_i8(), mutbl: ast::MutImmutable}
+    );
+    return ty::mk_tup(tcx, ~[ty::mk_uint(), ty::mk_type(tcx),
+                         ptr, ptr,
+                         t]);
+}
+
 // LLVM constant constructors.
 pub fn C_null(t: Type) -> ValueRef {
     unsafe {

branches/try/src/librustc/middle/trans/reflect.rs

@@ -368,7 +368,8 @@ impl<'a> Reflector<'a> {
               let extra = ~[self.c_uint(p.idx)];
               self.visit("param", extra)
           }
-          ty::ty_self(..) => self.leaf("self")
+          ty::ty_self(..) => self.leaf("self"),
+          ty::ty_type => self.leaf("type")
         }
     }
 

branches/try/src/librustc/middle/trans/type_of.rs

@@ -119,7 +119,8 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
         ty::ty_box(..) |
         ty::ty_uniq(..) |
         ty::ty_ptr(..) |
-        ty::ty_rptr(..) => Type::i8p(),
+        ty::ty_rptr(..) |
+        ty::ty_type => Type::i8p(),
 
         ty::ty_str(ty::vstore_slice(..)) |
         ty::ty_vec(_, ty::vstore_slice(..)) => {
@@ -262,6 +263,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
           Type::struct_([fn_ty, Type::i8p()], false)
       }
       ty::ty_trait(..) => Type::opaque_trait(),
+      ty::ty_type => cx.tydesc_type.ptr_to(),
       ty::ty_tup(..) => {
           let repr = adt::represent_type(cx, t);
           adt::type_of(cx, repr)

branches/try/src/librustc/middle/ty.rs

@@ -756,6 +756,7 @@ pub enum sty {
             // on non-useful type error messages)
 
     // "Fake" types, used for trans purposes
+    ty_type, // type_desc*
     ty_unboxed_vec(mt),
 }
 
@@ -1180,7 +1181,7 @@ pub fn mk_t(cx: ctxt, st: sty) -> t {
         flags |= get(mt.ty).flags;
       }
       &ty_nil | &ty_bool | &ty_char | &ty_int(_) | &ty_float(_) | &ty_uint(_) |
-      &ty_str(_) => {}
+      &ty_str(_) | &ty_type => {}
       // You might think that we could just return ty_err for
       // any type containing ty_err as a component, and get
       // rid of the has_ty_err flag -- likewise for ty_bot (with
@@ -1443,6 +1444,8 @@ pub fn mk_param(cx: ctxt, n: uint, k: DefId) -> t {
     mk_t(cx, ty_param(param_ty { idx: n, def_id: k }))
 }
 
+pub fn mk_type(cx: ctxt) -> t { mk_t(cx, ty_type) }
+
 pub fn walk_ty(ty: t, f: |t|) {
     maybe_walk_ty(ty, |t| { f(t); true });
 }
@@ -1453,7 +1456,7 @@ pub fn maybe_walk_ty(ty: t, f: |t| -> bool) {
     }
     match get(ty).sty {
         ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) | ty_uint(_) | ty_float(_) |
-        ty_str(_) | ty_self(_) |
+        ty_str(_) | ty_type | ty_self(_) |
         ty_infer(_) | ty_param(_) | ty_err => {}
         ty_box(ty) | ty_uniq(ty) => maybe_walk_ty(ty, f),
         ty_vec(ref tm, _) | ty_unboxed_vec(ref tm) | ty_ptr(ref tm) |
@@ -1727,7 +1730,7 @@ pub fn type_is_unique(ty: t) -> bool {
 pub fn type_is_scalar(ty: t) -> bool {
     match get(ty).sty {
       ty_nil | ty_bool | ty_char | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) |
+      ty_infer(IntVar(_)) | ty_infer(FloatVar(_)) | ty_type |
       ty_bare_fn(..) | ty_ptr(_) => true,
       _ => false
     }
@@ -2213,6 +2216,8 @@ pub fn type_contents(cx: ctxt, ty: t) -> TypeContents {
             }
             ty_unboxed_vec(mt) => TC::InteriorUnsized | tc_mt(cx, mt, cache),
 
+            ty_type => TC::None,
+
             ty_err => {
                 cx.sess.bug("asked to compute contents of error type");
             }
@@ -2396,6 +2401,7 @@ pub fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
             ty_err |
             ty_param(_) |
             ty_self(_) |
+            ty_type |
             ty_vec(_, _) |
             ty_unboxed_vec(_) => {
                 false
@@ -2622,7 +2628,7 @@ pub fn type_is_pod(cx: ctxt, ty: t) -> bool {
     match get(ty).sty {
       // Scalar types
       ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) | ty_float(_) | ty_uint(_) |
-      ty_ptr(_) | ty_bare_fn(_) => result = true,
+      ty_type | ty_ptr(_) | ty_bare_fn(_) => result = true,
       // Boxed types
       ty_box(_) | ty_uniq(_) | ty_closure(_) |
       ty_str(vstore_uniq) |
@@ -3550,7 +3556,7 @@ pub fn occurs_check(tcx: ctxt, sp: Span, vid: TyVid, rt: t) {
 pub fn ty_sort_str(cx: ctxt, t: t) -> ~str {
     match get(t).sty {
         ty_nil | ty_bot | ty_bool | ty_char | ty_int(_) |
-        ty_uint(_) | ty_float(_) | ty_str(_) => {
+        ty_uint(_) | ty_float(_) | ty_str(_) | ty_type => {
             ::util::ppaux::ty_to_str(cx, t)
         }
 
@@ -5114,8 +5120,9 @@ pub fn hash_crate_independent(tcx: ctxt, t: t, local_hash: ~str) -> u64 {
             }
             ty_infer(_) => unreachable!(),
             ty_err => hash.input([23]),
+            ty_type => hash.input([24]),
             ty_unboxed_vec(m) => {
-                hash.input([24]);
+                hash.input([25]);
                 mt(&mut hash, m);
             }
         }

branches/try/src/librustc/middle/ty_fold.rs

@@ -187,7 +187,8 @@ pub fn super_fold_sty<T:TypeFolder>(this: &mut T,
             ty::ty_str(this.fold_vstore(vst))
         }
         ty::ty_nil | ty::ty_bot | ty::ty_bool | ty::ty_char |
-        ty::ty_int(_) | ty::ty_uint(_) | ty::ty_float(_) |
+        ty::ty_int(_) | ty::ty_uint(_) |
+        ty::ty_float(_) | ty::ty_type |
         ty::ty_err | ty::ty_infer(_) |
         ty::ty_param(..) | ty::ty_self(_) => {
             (*sty).clone()

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

@@ -788,7 +788,7 @@ impl<'a> LookupContext<'a> {
 
             ty_err => None,
 
-            ty_unboxed_vec(_) | ty_infer(TyVar(_)) => {
+            ty_unboxed_vec(_) | ty_type | ty_infer(TyVar(_)) => {
                 self.bug(format!("unexpected type: {}",
                               self.ty_to_str(self_ty)));
             }

branches/try/src/librustc/middle/typeck/coherence.rs

@@ -23,7 +23,7 @@ use middle::ty::{substs, t, ty_bool, ty_char, ty_bot, ty_box, ty_enum, ty_err};
 use middle::ty::{ty_str, ty_vec, ty_float, ty_infer, ty_int, ty_nil};
 use middle::ty::{ty_param, ty_param_bounds_and_ty, ty_ptr};
 use middle::ty::{ty_rptr, ty_self, ty_struct, ty_trait, ty_tup};
-use middle::ty::{ty_uint, ty_uniq, ty_bare_fn, ty_closure};
+use middle::ty::{ty_type, ty_uint, ty_uniq, ty_bare_fn, ty_closure};
 use middle::ty::{ty_unboxed_vec, type_is_ty_var};
 use middle::subst::Subst;
 use middle::ty;
@@ -82,7 +82,7 @@ fn get_base_type(inference_context: &InferCtxt,
 
         ty_nil | ty_bot | ty_bool | ty_char | ty_int(..) | ty_uint(..) | ty_float(..) |
         ty_str(..) | ty_vec(..) | ty_bare_fn(..) | ty_closure(..) | ty_tup(..) |
-        ty_infer(..) | ty_param(..) | ty_self(..) |
+        ty_infer(..) | ty_param(..) | ty_self(..) | ty_type |
         ty_unboxed_vec(..) | ty_err | ty_box(_) |
         ty_uniq(_) | ty_ptr(_) | ty_rptr(_, _) => {
             debug!("(getting base type) no base type; found {:?}",

branches/try/src/librustc/middle/typeck/variance.rs

@@ -715,7 +715,8 @@ impl<'a> ConstraintContext<'a> {
                 self.add_constraints_from_sig(sig, variance);
             }
 
-            ty::ty_infer(..) | ty::ty_err | ty::ty_unboxed_vec(..) => {
+            ty::ty_infer(..) | ty::ty_err |
+            ty::ty_type | ty::ty_unboxed_vec(..) => {
                 self.tcx().sess.bug(
                     format!("unexpected type encountered in \
                             variance inference: {}",

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

@@ -18,7 +18,7 @@ use middle::ty::{ReFree, ReScope, ReInfer, ReStatic, Region,
                  ReEmpty};
 use middle::ty::{ty_bool, ty_char, ty_bot, ty_box, ty_struct, ty_enum};
 use middle::ty::{ty_err, ty_str, ty_vec, ty_float, ty_bare_fn, ty_closure};
-use middle::ty::{ty_nil, ty_param, ty_ptr, ty_rptr, ty_self, ty_tup};
+use middle::ty::{ty_nil, ty_param, ty_ptr, ty_rptr, ty_self, ty_tup, ty_type};
 use middle::ty::{ty_uniq, ty_trait, ty_int, ty_uint, ty_unboxed_vec, ty_infer};
 use middle::ty;
 use middle::typeck;
@@ -454,6 +454,7 @@ pub fn ty_to_str(cx: ctxt, typ: t) -> ~str {
         region_ptr_to_str(cx, r) + mt_to_str(cx, tm)
       }
       ty_unboxed_vec(ref tm) => { format!("unboxed_vec<{}>", mt_to_str(cx, tm)) }
+      ty_type => ~"type",
       ty_tup(ref elems) => {
         let strs = elems.map(|elem| ty_to_str(cx, *elem));
         ~"(" + strs.connect(",") + ")"