---

yaml
---
r: 79394
b: refs/heads/snap-stage3
c: be43625
h: refs/heads/master
v: v3

Author: emberian

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 124eb2119c78651cfaaa7a046a101fa2e20f83ca
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: d285ea791058f7db8bef828740aae95e69becc99
+refs/heads/snap-stage3: be43625082bf14f7ca49c9edc4b8a899fd73eddf
 refs/heads/try: ac820906c0e53eab79a98ee64f7231f57c3887b4
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/ndm: f3868061cd7988080c30d6d5bf352a5a5fe2460b

branches/snap-stage3/src/libextra/ebml.rs

@@ -410,7 +410,7 @@ pub mod reader {
         }
 
         fn read_bool(&mut self) -> bool {
-            doc_as_u8(self.next_doc(EsBool)) != 0
+            doc_as_u8(self.next_doc(EsBool)) as bool
         }
 
         fn read_f64(&mut self) -> f64 {

branches/snap-stage3/src/librustc/middle/trans/base.rs

@@ -2219,7 +2219,7 @@ pub fn trans_item(ccx: @mut CrateContext, item: &ast::item) {
               }
               let v = ccx.const_values.get_copy(&item.id);
               unsafe {
-                  if !(llvm::LLVMConstIntGetZExtValue(v) != 0) {
+                  if !(llvm::LLVMConstIntGetZExtValue(v) as bool) {
                       ccx.sess.span_fatal(expr.span, "static assertion failed");
                   }
               }

branches/snap-stage3/src/librustc/middle/typeck/check/mod.rs

@@ -2696,7 +2696,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                         }, t_e, None);
                     }
 
-                    let t1 = structurally_resolved_type(fcx, e.span, t_1);
                     let te = structurally_resolved_type(fcx, e.span, t_e);
                     let t_1_is_char = type_is_char(fcx, expr.span, t_1);
 
@@ -2711,9 +2710,6 @@ pub fn check_expr_with_unifier(fcx: @mut FnCtxt,
                                 fmt!("only `u8` can be cast as `char`, not `%s`", actual)
                             }, t_e, None);
                         }
-                    } else if ty::get(t1).sty == ty::ty_bool {
-                        fcx.tcx().sess.span_err(expr.span,
-                                                "cannot cast as `bool`, compare with zero instead");
                     } else if type_is_region_ptr(fcx, expr.span, t_e) &&
                         type_is_unsafe_ptr(fcx, expr.span, t_1) {
 

branches/snap-stage3/src/libstd/from_str.rs

@@ -19,3 +19,7 @@ pub trait FromStr {
     /// string is ill-formatted, the None is returned.
     fn from_str(s: &str) -> Option<Self>;
 }
+
+pub fn from_str<A: FromStr>(s: &str) -> Option<A> {
+    FromStr::from_str(s)
+}

branches/snap-stage3/src/libstd/prelude.rs

@@ -41,6 +41,7 @@ pub use result::{Result, Ok, Err};
 // Reexported functions
 pub use io::{print, println};
 pub use iterator::range;
+pub use from_str::from_str;
 
 // Reexported types and traits
 pub use c_str::ToCStr;

branches/snap-stage3/src/libstd/str.rs

@@ -799,8 +799,6 @@ pub fn is_utf8(v: &[u8]) -> bool {
             //        first  C2 80        last DF BF
             // 3-byte encoding is for codepoints  \u0800 to  \uffff
             //        first  E0 A0 80     last EF BF BF
-            //   excluding surrogates codepoints  \ud800 to  \udfff
-            //               ED A0 80 to       ED BF BF
             // 4-byte encoding is for codepoints \u10000 to \u10ffff
             //        first  F0 90 80 80  last F4 8F BF BF
             //
@@ -814,6 +812,8 @@ pub fn is_utf8(v: &[u8]) -> bool {
             // UTF8-4      = %xF0 %x90-BF 2( UTF8-tail ) / %xF1-F3 3( UTF8-tail ) /
             //               %xF4 %x80-8F 2( UTF8-tail )
             // UTF8-tail   = %x80-BF
+            // --
+            // This code allows surrogate pairs: \uD800 to \uDFFF -> ED A0 80 to ED BF BF
             match w {
                 2 => if unsafe_get(v, i + 1) & 192u8 != TAG_CONT_U8 {
                     return false
@@ -822,9 +822,7 @@ pub fn is_utf8(v: &[u8]) -> bool {
                             unsafe_get(v, i + 1),
                             unsafe_get(v, i + 2) & 192u8) {
                     (0xE0        , 0xA0 .. 0xBF, TAG_CONT_U8) => (),
-                    (0xE1 .. 0xEC, 0x80 .. 0xBF, TAG_CONT_U8) => (),
-                    (0xED        , 0x80 .. 0x9F, TAG_CONT_U8) => (),
-                    (0xEE .. 0xEF, 0x80 .. 0xBF, TAG_CONT_U8) => (),
+                    (0xE1 .. 0xEF, 0x80 .. 0xBF, TAG_CONT_U8) => (),
                     _ => return false,
                 },
                 _ => match (v_i,
@@ -3014,7 +3012,6 @@ mod tests {
 
     #[test]
     fn test_is_utf8() {
-        // deny overlong encodings
         assert!(!is_utf8([0xc0, 0x80]));
         assert!(!is_utf8([0xc0, 0xae]));
         assert!(!is_utf8([0xe0, 0x80, 0x80]));
@@ -3023,15 +3020,9 @@ mod tests {
         assert!(!is_utf8([0xf0, 0x82, 0x82, 0xac]));
         assert!(!is_utf8([0xf4, 0x90, 0x80, 0x80]));
 
-        // deny surrogates
-        assert!(!is_utf8([0xED, 0xA0, 0x80]));
-        assert!(!is_utf8([0xED, 0xBF, 0xBF]));
-
         assert!(is_utf8([0xC2, 0x80]));
         assert!(is_utf8([0xDF, 0xBF]));
         assert!(is_utf8([0xE0, 0xA0, 0x80]));
-        assert!(is_utf8([0xED, 0x9F, 0xBF]));
-        assert!(is_utf8([0xEE, 0x80, 0x80]));
         assert!(is_utf8([0xEF, 0xBF, 0xBF]));
         assert!(is_utf8([0xF0, 0x90, 0x80, 0x80]));
         assert!(is_utf8([0xF4, 0x8F, 0xBF, 0xBF]));

branches/snap-stage3/src/test/compile-fail/cast-as-bool.rs

@@ -18,5 +18,6 @@ pub fn main() {
     assert_eq!(i as u8, 'Q' as u8);
     assert_eq!(i as u8 as i8, 'Q' as u8 as i8);
     assert_eq!(0x51u8 as char, 'Q');
+    assert_eq!(true, 1 as bool);
     assert_eq!(0 as u32, false as u32);
 }

branches/snap-stage3/src/test/run-pass/cast.rs

@@ -26,6 +26,7 @@ pub fn main() {
   info!(1 as int);
   info!(1 as uint);
   info!(1 as float);
+  info!(1 as bool);
   info!(1 as *libc::FILE);
   info!(1 as i8);
   info!(1 as i16);
@@ -41,6 +42,7 @@ pub fn main() {
   info!(1u as int);
   info!(1u as uint);
   info!(1u as float);
+  info!(1u as bool);
   info!(1u as *libc::FILE);
   info!(1u as i8);
   info!(1u as i16);
@@ -56,6 +58,7 @@ pub fn main() {
   info!(1i8 as int);
   info!(1i8 as uint);
   info!(1i8 as float);
+  info!(1i8 as bool);
   info!(1i8 as *libc::FILE);
   info!(1i8 as i8);
   info!(1i8 as i16);
@@ -71,6 +74,7 @@ pub fn main() {
   info!(1u8 as int);
   info!(1u8 as uint);
   info!(1u8 as float);
+  info!(1u8 as bool);
   info!(1u8 as *libc::FILE);
   info!(1u8 as i8);
   info!(1u8 as i16);
@@ -86,6 +90,7 @@ pub fn main() {
   info!(1i16 as int);
   info!(1i16 as uint);
   info!(1i16 as float);
+  info!(1i16 as bool);
   info!(1i16 as *libc::FILE);
   info!(1i16 as i8);
   info!(1i16 as i16);
@@ -101,6 +106,7 @@ pub fn main() {
   info!(1u16 as int);
   info!(1u16 as uint);
   info!(1u16 as float);
+  info!(1u16 as bool);
   info!(1u16 as *libc::FILE);
   info!(1u16 as i8);
   info!(1u16 as i16);
@@ -116,6 +122,7 @@ pub fn main() {
   info!(1i32 as int);
   info!(1i32 as uint);
   info!(1i32 as float);
+  info!(1i32 as bool);
   info!(1i32 as *libc::FILE);
   info!(1i32 as i8);
   info!(1i32 as i16);
@@ -131,6 +138,7 @@ pub fn main() {
   info!(1u32 as int);
   info!(1u32 as uint);
   info!(1u32 as float);
+  info!(1u32 as bool);
   info!(1u32 as *libc::FILE);
   info!(1u32 as i8);
   info!(1u32 as i16);
@@ -146,6 +154,7 @@ pub fn main() {
   info!(1i64 as int);
   info!(1i64 as uint);
   info!(1i64 as float);
+  info!(1i64 as bool);
   info!(1i64 as *libc::FILE);
   info!(1i64 as i8);
   info!(1i64 as i16);
@@ -161,6 +170,7 @@ pub fn main() {
   info!(1u64 as int);
   info!(1u64 as uint);
   info!(1u64 as float);
+  info!(1u64 as bool);
   info!(1u64 as *libc::FILE);
   info!(1u64 as i8);
   info!(1u64 as i16);
@@ -176,6 +186,7 @@ pub fn main() {
   info!(1u64 as int);
   info!(1u64 as uint);
   info!(1u64 as float);
+  info!(1u64 as bool);
   info!(1u64 as *libc::FILE);
   info!(1u64 as i8);
   info!(1u64 as i16);
@@ -191,6 +202,7 @@ pub fn main() {
   info!(true as int);
   info!(true as uint);
   info!(true as float);
+  info!(true as bool);
   info!(true as *libc::FILE);
   info!(true as i8);
   info!(true as i16);
@@ -206,6 +218,7 @@ pub fn main() {
   info!(1. as int);
   info!(1. as uint);
   info!(1. as float);
+  info!(1. as bool);
   info!(1. as i8);
   info!(1. as i16);
   info!(1. as i32);
@@ -220,6 +233,7 @@ pub fn main() {
   info!(1f32 as int);
   info!(1f32 as uint);
   info!(1f32 as float);
+  info!(1f32 as bool);
   info!(1f32 as i8);
   info!(1f32 as i16);
   info!(1f32 as i32);
@@ -234,6 +248,7 @@ pub fn main() {
   info!(1f64 as int);
   info!(1f64 as uint);
   info!(1f64 as float);
+  info!(1f64 as bool);
   info!(1f64 as i8);
   info!(1f64 as i16);
   info!(1f64 as i32);