---

yaml
---
r: 152618
b: refs/heads/try2
c: feceb12
h: refs/heads/master
v: v3

Author: nathantypanski

[refs]

@@ -5,7 +5,7 @@ refs/heads/snap-stage3: 78a7676898d9f80ab540c6df5d4c9ce35bb50463
 refs/heads/try: 519addf6277dbafccbb4159db4b710c37eaa2ec5
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b
-refs/heads/try2: d6736a1440d42f6af967a8a20ab8d73522112b72
+refs/heads/try2: feceb1276e3f7848fb6bee0a130065f6b1c56daf
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596
 refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503

branches/try2/src/doc/rust.md

@@ -234,7 +234,7 @@ rule. A literal is a form of constant expression, so is evaluated (primarily)
 at compile time.
 
 ~~~~ {.ebnf .gram}
-literal : string_lit | char_lit | byte_string_lit | byte_lit | num_lit ;
+literal : string_lit | char_lit | num_lit ;
 ~~~~
 
 #### Character and string literals
@@ -244,17 +244,17 @@ char_lit : '\x27' char_body '\x27' ;
 string_lit : '"' string_body * '"' | 'r' raw_string ;
 
 char_body : non_single_quote
-          | '\x5c' [ '\x27' | common_escape | unicode_escape ] ;
+          | '\x5c' [ '\x27' | common_escape ] ;
 
 string_body : non_double_quote
-            | '\x5c' [ '\x22' | common_escape | unicode_escape ] ;
+            | '\x5c' [ '\x22' | common_escape ] ;
 raw_string : '"' raw_string_body '"' | '#' raw_string '#' ;
 
 common_escape : '\x5c'
               | 'n' | 'r' | 't' | '0'
               | 'x' hex_digit 2
-unicode_escape : 'u' hex_digit 4
-               | 'U' hex_digit 8 ;
+              | 'u' hex_digit 4
+              | 'U' hex_digit 8 ;
 
 hex_digit : 'a' | 'b' | 'c' | 'd' | 'e' | 'f'
           | 'A' | 'B' | 'C' | 'D' | 'E' | 'F'
@@ -294,7 +294,7 @@ the following forms:
     escaped in order to denote *itself*.
 
 Raw string literals do not process any escapes. They start with the character
-`U+0072` (`r`), followed by zero or more of the character `U+0023` (`#`) and a
+`U+0072` (`r`), followed zero or more of the character `U+0023` (`#`) and a
 `U+0022` (double-quote) character. The _raw string body_ is not defined in the
 EBNF grammar above: it can contain any sequence of Unicode characters and is
 terminated only by another `U+0022` (double-quote) character, followed by the
@@ -319,65 +319,6 @@ r##"foo #"# bar"##;                // foo #"# bar
 "\\x52"; r"\x52";                  // \x52
 ~~~~
 
-#### Byte and byte string literals
-
-~~~~ {.ebnf .gram}
-byte_lit : 'b' '\x27' byte_body '\x27' ;
-byte_string_lit : 'b' '"' string_body * '"' | 'b' 'r' raw_byte_string ;
-
-byte_body : ascii_non_single_quote
-          | '\x5c' [ '\x27' | common_escape ] ;
-
-byte_string_body : ascii_non_double_quote
-            | '\x5c' [ '\x22' | common_escape ] ;
-raw_byte_string : '"' raw_byte_string_body '"' | '#' raw_byte_string '#' ;
-
-~~~~
-
-A _byte literal_ is a single ASCII character (in the `U+0000` to `U+007F` range)
-enclosed within two `U+0027` (single-quote) characters,
-with the exception of `U+0027` itself,
-which must be _escaped_ by a preceding U+005C character (`\`),
-or a single _escape_.
-It is equivalent to a `u8` unsigned 8-bit integer _number literal_.
-
-A _byte string literal_ is a sequence of ASCII characters and _escapes_
-enclosed within two `U+0022` (double-quote) characters,
-with the exception of `U+0022` itself,
-which must be _escaped_ by a preceding `U+005C` character (`\`),
-or a _raw byte string literal_.
-It is equivalent to a `&'static [u8]` borrowed vectior unsigned 8-bit integers.
-
-Some additional _escapes_ are available in either byte or non-raw byte string
-literals. An escape starts with a `U+005C` (`\`) and continues with one of
-the following forms:
-
-  * An _byte escape_ escape starts with `U+0078` (`x`) and is
-    followed by exactly two _hex digits_. It denotes the byte
-    equal to the provided hex value.
-  * A _whitespace escape_ is one of the characters `U+006E` (`n`), `U+0072`
-    (`r`), or `U+0074` (`t`), denoting the bytes values `0x0A` (ASCII LF),
-    `0x0D` (ASCII CR) or `0x09` (ASCII HT) respectively.
-  * The _backslash escape_ is the character `U+005C` (`\`) which must be
-    escaped in order to denote its ASCII encoding `0x5C`.
-
-Raw byte string literals do not process any escapes.
-They start with the character `U+0072` (`r`),
-followed by `U+0062` (`b`),
-followed by zero or more of the character `U+0023` (`#`),
-and a `U+0022` (double-quote) character.
-The _raw string body_ is not defined in the EBNF grammar above:
-it can contain any sequence of ASCII characters and is
-terminated only by another `U+0022` (double-quote) character, followed by the
-same number of `U+0023` (`#`) characters that preceded the opening `U+0022`
-(double-quote) character.
-A raw byte string literal can not contain any non-ASCII byte.
-
-All characters contained in the raw string body represent their ASCII encoding,
-the characters `U+0022` (double-quote) (except when followed by at least as
-many `U+0023` (`#`) characters as were used to start the raw string literal) or
-`U+005C` (`\`) do not have any special meaning.
-
 #### Number literals
 
 ~~~~ {.ebnf .gram}

branches/try2/src/libcore/option.rs

@@ -574,13 +574,17 @@ impl<A> ExactSize<A> for Item<A> {}
 /// Here is an example which increments every integer in a vector,
 /// checking for overflow:
 ///
-///     fn inc_conditionally(x: uint) -> Option<uint> {
-///         if x == uint::MAX { return None; }
-///         else { return Some(x+1u); }
-///     }
-///     let v = [1u, 2, 3];
-///     let res = collect(v.iter().map(|&x| inc_conditionally(x)));
-///     assert!(res == Some(~[2u, 3, 4]));
+/// ```rust
+/// use std::option;
+/// use std::uint;
+///
+/// let v = vec!(1u, 2u);
+/// let res: Option<Vec<uint>> = option::collect(v.iter().map(|x: &uint|
+///     if *x == uint::MAX { None }
+///     else { Some(x + 1) }
+/// ));
+/// assert!(res == Some(vec!(2u, 3u)));
+/// ```
 #[inline]
 pub fn collect<T, Iter: Iterator<Option<T>>, V: FromIterator<T>>(iter: Iter) -> Option<V> {
     // FIXME(#11084): This should be twice as fast once this bug is closed.

branches/try2/src/libcore/result.rs

@@ -572,13 +572,17 @@ impl<T: Show, E> Result<T, E> {
 /// Here is an example which increments every integer in a vector,
 /// checking for overflow:
 ///
-///     fn inc_conditionally(x: uint) -> Result<uint, &'static str> {
-///         if x == uint::MAX { return Err("overflow"); }
-///         else { return Ok(x+1u); }
-///     }
-///     let v = [1u, 2, 3];
-///     let res = collect(v.iter().map(|&x| inc_conditionally(x)));
-///     assert!(res == Ok(~[2u, 3, 4]));
+/// ```rust
+/// use std::result;
+/// use std::uint;
+///
+/// let v = vec!(1u, 2u);
+/// let res: Result<Vec<uint>, &'static str> = result::collect(v.iter().map(|x: &uint|
+///     if *x == uint::MAX { Err("Overflow!") }
+///     else { Ok(x + 1) }
+/// ));
+/// assert!(res == Ok(vec!(2u, 3u)));
+/// ```
 #[inline]
 pub fn collect<T, E, Iter: Iterator<Result<T, E>>, V: FromIterator<T>>(iter: Iter) -> Result<V, E> {
     // FIXME(#11084): This should be twice as fast once this bug is closed.

branches/try2/src/libcore/str.rs

@@ -560,8 +560,6 @@ Section: Comparing strings
 
 // share the implementation of the lang-item vs. non-lang-item
 // eq_slice.
-/// NOTE: This function is (ab)used in rustc::middle::trans::_match
-/// to compare &[u8] byte slices that are not necessarily valid UTF-8.
 #[inline]
 fn eq_slice_(a: &str, b: &str) -> bool {
     #[allow(ctypes)]
@@ -574,8 +572,6 @@ fn eq_slice_(a: &str, b: &str) -> bool {
 }
 
 /// Bytewise slice equality
-/// NOTE: This function is (ab)used in rustc::middle::trans::_match
-/// to compare &[u8] byte slices that are not necessarily valid UTF-8.
 #[cfg(not(test))]
 #[lang="str_eq"]
 #[inline]

branches/try2/src/libregex_macros/lib.rs

@@ -182,7 +182,7 @@ fn exec<'t>(which: ::regex::native::MatchKind, input: &'t str,
         #[allow(unused_variable)]
         fn run(&mut self, start: uint, end: uint) -> Vec<Option<uint>> {
             let mut matched = false;
-            let prefix_bytes: &[u8] = $prefix_bytes;
+            let prefix_bytes: &[u8] = &$prefix_bytes;
             let mut clist = &mut Threads::new(self.which);
             let mut nlist = &mut Threads::new(self.which);
 

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

@@ -346,9 +346,10 @@ fn parse_ty(st: &mut PState, conv: conv_did) -> ty::t {
         assert_eq!(next(st), '[');
         let def = parse_def(st, NominalType, |x,y| conv(x,y));
         let substs = parse_substs(st, |x,y| conv(x,y));
+        let store = parse_trait_store(st, |x,y| conv(x,y));
         let bounds = parse_bounds(st, |x,y| conv(x,y));
         assert_eq!(next(st), ']');
-        return ty::mk_trait(st.tcx, def, substs, bounds.builtin_bounds);
+        return ty::mk_trait(st.tcx, def, substs, store, bounds.builtin_bounds);
       }
       'p' => {
         let did = parse_def(st, TypeParameter, |x,y| conv(x,y));

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

@@ -232,10 +232,12 @@ fn enc_sty(w: &mut MemWriter, cx: &ctxt, st: &ty::sty) {
         ty::ty_trait(box ty::TyTrait {
                 def_id,
                 ref substs,
+                store,
                 bounds
             }) => {
             mywrite!(w, "x[{}|", (cx.ds)(def_id));
             enc_substs(w, cx, substs);
+            enc_trait_store(w, cx, store);
             let bounds = ty::ParamBounds {builtin_bounds: bounds,
                                           trait_bounds: Vec::new()};
             enc_bounds(w, cx, &bounds);

branches/try2/src/librustc/middle/const_eval.rs

@@ -506,7 +506,6 @@ pub fn lit_to_const(lit: &Lit) -> const_val {
         LitBinary(ref data) => {
             const_binary(Rc::new(data.iter().map(|x| *x).collect()))
         }
-        LitByte(n) => const_uint(n as u64),
         LitChar(n) => const_uint(n as u64),
         LitInt(n, _) => const_int(n),
         LitUint(n, _) => const_uint(n),
@@ -529,7 +528,6 @@ pub fn compare_const_vals(a: &const_val, b: &const_val) -> Option<int> {
         (&const_float(a), &const_float(b)) => compare_vals(a, b),
         (&const_str(ref a), &const_str(ref b)) => compare_vals(a, b),
         (&const_bool(a), &const_bool(b)) => compare_vals(a, b),
-        (&const_binary(ref a), &const_binary(ref b)) => compare_vals(a, b),
         _ => None
     }
 }

branches/try2/src/librustc/middle/kind.rs

@@ -361,12 +361,9 @@ fn check_bounds_on_type_parameters(cx: &mut Context, e: &Expr) {
 fn check_trait_cast(cx: &mut Context, source_ty: ty::t, target_ty: ty::t, span: Span) {
     check_cast_for_escaping_regions(cx, source_ty, target_ty, span);
     match ty::get(target_ty).sty {
-        ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ ty, .. }) => match ty::get(ty).sty {
-            ty::ty_trait(box ty::TyTrait { bounds, .. }) => {
-                check_trait_cast_bounds(cx, span, source_ty, bounds);
-            }
-            _ => {}
-        },
+        ty::ty_trait(box ty::TyTrait { bounds, .. }) => {
+            check_trait_cast_bounds(cx, span, source_ty, bounds);
+        }
         _ => {}
     }
 }
@@ -533,8 +530,9 @@ pub fn check_cast_for_escaping_regions(
 {
     // Determine what type we are casting to; if it is not a trait, then no
     // worries.
-    if !ty::type_is_trait(target_ty) {
-        return;
+    match ty::get(target_ty).sty {
+        ty::ty_trait(..) => {}
+        _ => { return; }
     }
 
     // Collect up the regions that appear in the target type.  We want to

branches/try2/src/librustc/middle/lint.rs

@@ -805,7 +805,6 @@ fn check_type_limits(cx: &Context, e: &ast::Expr) {
                     } else { t };
                     let (min, max) = uint_ty_range(uint_type);
                     let lit_val: u64 = match lit.node {
-                        ast::LitByte(_v) => return,  // _v is u8, within range by definition
                         ast::LitInt(v, _) => v as u64,
                         ast::LitUint(v, _) => v,
                         ast::LitIntUnsuffixed(v) => v as u64,
@@ -981,6 +980,9 @@ fn check_heap_type(cx: &Context, span: Span, ty: ty::t) {
                     n_box += 1;
                 }
                 ty::ty_uniq(_) |
+                ty::ty_trait(box ty::TyTrait {
+                    store: ty::UniqTraitStore, ..
+                }) |
                 ty::ty_closure(box ty::ClosureTy {
                     store: ty::UniqTraitStore,
                     ..

branches/try2/src/librustc/middle/mem_categorization.rs

@@ -174,6 +174,7 @@ pub enum deref_kind {
 pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
     match ty::get(t).sty {
         ty::ty_uniq(_) |
+        ty::ty_trait(box ty::TyTrait { store: ty::UniqTraitStore, .. }) |
         ty::ty_closure(box ty::ClosureTy {store: ty::UniqTraitStore, ..}) => {
             Some(deref_ptr(OwnedPtr))
         }
@@ -182,6 +183,13 @@ pub fn opt_deref_kind(t: ty::t) -> Option<deref_kind> {
             let kind = ty::BorrowKind::from_mutbl(mt.mutbl);
             Some(deref_ptr(BorrowedPtr(kind, r)))
         }
+        ty::ty_trait(box ty::TyTrait {
+                store: ty::RegionTraitStore(r, mutbl),
+                ..
+            }) => {
+            let kind = ty::BorrowKind::from_mutbl(mutbl);
+            Some(deref_ptr(BorrowedPtr(kind, r)))
+        }
 
         ty::ty_closure(box ty::ClosureTy {
                 store: ty::RegionTraitStore(r, _),

branches/try2/src/librustc/middle/trans/_match.rs

@@ -1273,24 +1273,13 @@ fn compare_values<'a>(
                     val: bool_to_i1(result.bcx, result.val)
                 }
             }
-            _ => cx.sess().bug("only strings supported in compare_values"),
+            _ => cx.sess().bug("only scalars and strings supported in compare_values"),
         },
         ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
             ty::ty_str => compare_str(cx, lhs, rhs, rhs_t),
-            ty::ty_vec(mt, _) => match ty::get(mt.ty).sty {
-                ty::ty_uint(ast::TyU8) => {
-                    // NOTE: cast &[u8] to &str and abuse the str_eq lang item,
-                    // which calls memcmp().
-                    let t = ty::mk_str_slice(cx.tcx(), ty::ReStatic, ast::MutImmutable);
-                    let lhs = BitCast(cx, lhs, type_of::type_of(cx.ccx(), t).ptr_to());
-                    let rhs = BitCast(cx, rhs, type_of::type_of(cx.ccx(), t).ptr_to());
-                    compare_str(cx, lhs, rhs, rhs_t)
-                },
-                _ => cx.sess().bug("only byte strings supported in compare_values"),
-            },
-            _ => cx.sess().bug("on string and byte strings supported in compare_values"),
+            _ => cx.sess().bug("only scalars and strings supported in compare_values"),
         },
-        _ => cx.sess().bug("only scalars, byte strings, and strings supported in compare_values"),
+        _ => cx.sess().bug("only scalars and strings supported in compare_values"),
     }
 }
 

branches/try2/src/librustc/middle/trans/adt.rs

@@ -292,11 +292,12 @@ impl Case {
     fn find_ptr(&self) -> Option<uint> {
         self.tys.iter().position(|&ty| {
             match ty::get(ty).sty {
-                ty::ty_uniq(ty) | ty::ty_rptr(_, ty::mt{ty, ..}) => match ty::get(ty).sty {
-                    ty::ty_vec(_, None) | ty::ty_str| ty::ty_trait(..) => false,
+                ty::ty_rptr(_, mt) => match ty::get(mt.ty).sty {
+                    ty::ty_vec(_, None) | ty::ty_str => false,
                     _ => true,
                 },
-                ty::ty_box(..) | ty::ty_bare_fn(..) => true,
+                ty::ty_uniq(..) | ty::ty_box(..) |
+                ty::ty_bare_fn(..) => true,
                 // Is that everything?  Would closures or slices qualify?
                 _ => false
             }

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

@@ -1794,9 +1794,6 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t) -> Vec<(uint, u6
         match ty::get(ret_ty).sty {
             // `~` pointer return values never alias because ownership
             // is transferred
-            ty::ty_uniq(it)  if match ty::get(it).sty {
-                ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
-            } => {}
             ty::ty_uniq(_) => {
                 attrs.push((lib::llvm::ReturnIndex as uint, lib::llvm::NoAliasAttribute as u64));
             }
@@ -1806,9 +1803,9 @@ pub fn get_fn_llvm_attributes(ccx: &CrateContext, fn_ty: ty::t) -> Vec<(uint, u6
         // We can also mark the return value as `nonnull` in certain cases
         match ty::get(ret_ty).sty {
             // These are not really pointers but pairs, (pointer, len)
-            ty::ty_uniq(it) |
+            ty::ty_rptr(_, ty::mt { ty: it, .. }) |
             ty::ty_rptr(_, ty::mt { ty: it, .. }) if match ty::get(it).sty {
-                ty::ty_str | ty::ty_vec(..) | ty::ty_trait(..) => true, _ => false
+                ty::ty_str | ty::ty_vec(..) => true, _ => false
             } => {}
             ty::ty_uniq(_) | ty::ty_rptr(_, _) => {
                 attrs.push((lib::llvm::ReturnIndex as uint, lib::llvm::NonNullAttribute as u64));

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

@@ -67,7 +67,7 @@ pub fn type_is_immediate(ccx: &CrateContext, ty: ty::t) -> bool {
         ty::type_is_unique(ty) || ty::type_is_region_ptr(ty) ||
         type_is_newtype_immediate(ccx, ty) || ty::type_is_bot(ty) ||
         ty::type_is_simd(tcx, ty);
-    if simple && !ty::type_is_trait(ty) {
+    if simple {
         return true;
     }
     match ty::get(ty).sty {

branches/try2/src/librustc/middle/trans/consts.rs

@@ -43,7 +43,6 @@ pub fn const_lit(cx: &CrateContext, e: &ast::Expr, lit: ast::Lit)
     -> ValueRef {
     let _icx = push_ctxt("trans_lit");
     match lit.node {
-        ast::LitByte(b) => C_integral(Type::uint_from_ty(cx, ast::TyU8), b as u64, false),
         ast::LitChar(i) => C_integral(Type::char(cx), i as u64, false),
         ast::LitInt(i, t) => C_integral(Type::int_from_ty(cx, t), i as u64, true),
         ast::LitUint(u, t) => C_integral(Type::uint_from_ty(cx, t), u, false),
@@ -144,9 +143,7 @@ fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
             let dv = match ty::get(t).sty {
                 ty::ty_ptr(mt) | ty::ty_rptr(_, mt) => {
                     match ty::get(mt.ty).sty {
-                        ty::ty_vec(_, None) | ty::ty_str | ty::ty_trait(..) => {
-                            cx.sess().bug("unexpected unsized type")
-                        }
+                        ty::ty_vec(_, None) | ty::ty_str => cx.sess().bug("unexpected slice"),
                         _ => const_deref_ptr(cx, v),
                     }
                 }