---

yaml
---
r: 65239
b: refs/heads/master
c: dc970c1
h: refs/heads/master
i:
  65237: 8773815
  65235: da45b6e
  65231: b43eaf7
v: v3

Author: erickt

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: 1965d7295775b93d56f6daea96a6d2f6e8f242da
+refs/heads/master: dc970c13f476ef086066a47829185ac83645c61f
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 18e3db7392d2d0697b7e27d6d986139960144d85
 refs/heads/try: 7b78b52e602bb3ea8174f9b2006bff3315f03ef9

trunk/src/libstd/cast.rs

@@ -11,7 +11,6 @@
 //! Unsafe casting functions
 
 use sys;
-use unstable;
 use unstable::intrinsics;
 
 /// Casts the value at `src` to U. The two types must have the same length.

trunk/src/libstd/hash.rs

@@ -488,7 +488,7 @@ mod tests {
             assert!(f == i && f == v);
 
             buf += ~[t as u8];
-            stream_inc.input(~[t as u8]);
+            stream_inc.input([t as u8]);
 
             t += 1;
         }

trunk/src/libstd/io.rs

@@ -1839,7 +1839,7 @@ mod tests {
         {
             let out: @io::Writer =
                 result::get(
-                    &io::file_writer(tmpfile, ~[io::Create, io::Truncate]));
+                    &io::file_writer(tmpfile, [io::Create, io::Truncate]));
             out.write_str(frood);
         }
         let inp: @io::Reader = result::get(&io::file_reader(tmpfile));
@@ -1850,31 +1850,31 @@ mod tests {
 
     #[test]
     fn test_readchars_empty() {
-        do io::with_str_reader(~"") |inp| {
+        do io::with_str_reader("") |inp| {
             let res : ~[char] = inp.read_chars(128);
             assert_eq!(res.len(), 0);
         }
     }
 
     #[test]
     fn test_read_line_utf8() {
-        do io::with_str_reader(~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
+        do io::with_str_reader("生锈的汤匙切肉汤hello生锈的汤匙切肉汤") |inp| {
             let line = inp.read_line();
             assert_eq!(line, ~"生锈的汤匙切肉汤hello生锈的汤匙切肉汤");
         }
     }
 
     #[test]
     fn test_read_lines() {
-        do io::with_str_reader(~"a\nb\nc\n") |inp| {
+        do io::with_str_reader("a\nb\nc\n") |inp| {
             assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
         }
 
-        do io::with_str_reader(~"a\nb\nc") |inp| {
+        do io::with_str_reader("a\nb\nc") |inp| {
             assert_eq!(inp.read_lines(), ~[~"a", ~"b", ~"c"]);
         }
 
-        do io::with_str_reader(~"") |inp| {
+        do io::with_str_reader("") |inp| {
             assert!(inp.read_lines().is_empty());
         }
     }
@@ -1909,15 +1909,15 @@ mod tests {
 
     #[test]
     fn test_readchar() {
-        do io::with_str_reader(~"生") |inp| {
+        do io::with_str_reader("生") |inp| {
             let res : char = inp.read_char();
             assert_eq!(res as int, 29983);
         }
     }
 
     #[test]
     fn test_readchar_empty() {
-        do io::with_str_reader(~"") |inp| {
+        do io::with_str_reader("") |inp| {
             let res : char = inp.read_char();
             assert_eq!(res as int, -1);
         }
@@ -1966,7 +1966,7 @@ mod tests {
 
     #[test]
     fn file_writer_bad_name() {
-        match io::file_writer(&Path("?/?"), ~[]) {
+        match io::file_writer(&Path("?/?"), []) {
           result::Err(copy e) => {
             assert!(str::starts_with(e, "error opening"));
           }
@@ -1987,15 +1987,15 @@ mod tests {
     #[test]
     fn bytes_buffer_overwrite() {
         let wr = BytesWriter();
-        wr.write(~[0u8, 1u8, 2u8, 3u8]);
+        wr.write([0u8, 1u8, 2u8, 3u8]);
         assert!(*wr.bytes == ~[0u8, 1u8, 2u8, 3u8]);
         wr.seek(-2, SeekCur);
-        wr.write(~[4u8, 5u8, 6u8, 7u8]);
+        wr.write([4u8, 5u8, 6u8, 7u8]);
         assert!(*wr.bytes == ~[0u8, 1u8, 4u8, 5u8, 6u8, 7u8]);
         wr.seek(-2, SeekEnd);
-        wr.write(~[8u8]);
+        wr.write([8u8]);
         wr.seek(1, SeekSet);
-        wr.write(~[9u8]);
+        wr.write([9u8]);
         assert!(*wr.bytes == ~[0u8, 9u8, 4u8, 5u8, 8u8, 7u8]);
     }
 
@@ -2085,7 +2085,7 @@ mod tests {
         }
     }
 
-#[test]
+    #[test]
     fn test_read_write_f32() {
         let path = Path("tmp/lib-io-test-read-write-f32.tmp");
         let f:f32 = 8.1250;

trunk/src/libstd/num/f32.rs

@@ -951,7 +951,6 @@ impl num::FromStrRadix for f32 {
 mod tests {
     use f32::*;
     use num::*;
-    use super::*;
     use prelude::*;
 
     #[test]

trunk/src/libstd/num/f64.rs

@@ -993,7 +993,6 @@ impl num::FromStrRadix for f64 {
 mod tests {
     use f64::*;
     use num::*;
-    use super::*;
     use prelude::*;
 
     #[test]

trunk/src/libstd/num/float.rs

@@ -1251,101 +1251,101 @@ mod tests {
 
     #[test]
     pub fn test_from_str() {
-        assert_eq!(from_str(~"3"), Some(3.));
-        assert_eq!(from_str(~"3.14"), Some(3.14));
-        assert_eq!(from_str(~"+3.14"), Some(3.14));
-        assert_eq!(from_str(~"-3.14"), Some(-3.14));
-        assert_eq!(from_str(~"2.5E10"), Some(25000000000.));
-        assert_eq!(from_str(~"2.5e10"), Some(25000000000.));
-        assert_eq!(from_str(~"25000000000.E-10"), Some(2.5));
-        assert_eq!(from_str(~"."), Some(0.));
-        assert_eq!(from_str(~".e1"), Some(0.));
-        assert_eq!(from_str(~".e-1"), Some(0.));
-        assert_eq!(from_str(~"5."), Some(5.));
-        assert_eq!(from_str(~".5"), Some(0.5));
-        assert_eq!(from_str(~"0.5"), Some(0.5));
-        assert_eq!(from_str(~"-.5"), Some(-0.5));
-        assert_eq!(from_str(~"-5"), Some(-5.));
-        assert_eq!(from_str(~"inf"), Some(infinity));
-        assert_eq!(from_str(~"+inf"), Some(infinity));
-        assert_eq!(from_str(~"-inf"), Some(neg_infinity));
+        assert_eq!(from_str("3"), Some(3.));
+        assert_eq!(from_str("3.14"), Some(3.14));
+        assert_eq!(from_str("+3.14"), Some(3.14));
+        assert_eq!(from_str("-3.14"), Some(-3.14));
+        assert_eq!(from_str("2.5E10"), Some(25000000000.));
+        assert_eq!(from_str("2.5e10"), Some(25000000000.));
+        assert_eq!(from_str("25000000000.E-10"), Some(2.5));
+        assert_eq!(from_str("."), Some(0.));
+        assert_eq!(from_str(".e1"), Some(0.));
+        assert_eq!(from_str(".e-1"), Some(0.));
+        assert_eq!(from_str("5."), Some(5.));
+        assert_eq!(from_str(".5"), Some(0.5));
+        assert_eq!(from_str("0.5"), Some(0.5));
+        assert_eq!(from_str("-.5"), Some(-0.5));
+        assert_eq!(from_str("-5"), Some(-5.));
+        assert_eq!(from_str("inf"), Some(infinity));
+        assert_eq!(from_str("+inf"), Some(infinity));
+        assert_eq!(from_str("-inf"), Some(neg_infinity));
         // note: NaN != NaN, hence this slightly complex test
-        match from_str(~"NaN") {
+        match from_str("NaN") {
             Some(f) => assert!(f.is_NaN()),
             None => fail!()
         }
         // note: -0 == 0, hence these slightly more complex tests
-        match from_str(~"-0") {
+        match from_str("-0") {
             Some(v) if v.is_zero() => assert!(v.is_negative()),
             _ => fail!()
         }
-        match from_str(~"0") {
+        match from_str("0") {
             Some(v) if v.is_zero() => assert!(v.is_positive()),
             _ => fail!()
         }
 
-        assert!(from_str(~"").is_none());
-        assert!(from_str(~"x").is_none());
-        assert!(from_str(~" ").is_none());
-        assert!(from_str(~"   ").is_none());
-        assert!(from_str(~"e").is_none());
-        assert!(from_str(~"E").is_none());
-        assert!(from_str(~"E1").is_none());
-        assert!(from_str(~"1e1e1").is_none());
-        assert!(from_str(~"1e1.1").is_none());
-        assert!(from_str(~"1e1-1").is_none());
+        assert!(from_str("").is_none());
+        assert!(from_str("x").is_none());
+        assert!(from_str(" ").is_none());
+        assert!(from_str("   ").is_none());
+        assert!(from_str("e").is_none());
+        assert!(from_str("E").is_none());
+        assert!(from_str("E1").is_none());
+        assert!(from_str("1e1e1").is_none());
+        assert!(from_str("1e1.1").is_none());
+        assert!(from_str("1e1-1").is_none());
     }
 
     #[test]
     pub fn test_from_str_hex() {
-        assert_eq!(from_str_hex(~"a4"), Some(164.));
-        assert_eq!(from_str_hex(~"a4.fe"), Some(164.9921875));
-        assert_eq!(from_str_hex(~"-a4.fe"), Some(-164.9921875));
-        assert_eq!(from_str_hex(~"+a4.fe"), Some(164.9921875));
-        assert_eq!(from_str_hex(~"ff0P4"), Some(0xff00 as float));
-        assert_eq!(from_str_hex(~"ff0p4"), Some(0xff00 as float));
-        assert_eq!(from_str_hex(~"ff0p-4"), Some(0xff as float));
-        assert_eq!(from_str_hex(~"."), Some(0.));
-        assert_eq!(from_str_hex(~".p1"), Some(0.));
-        assert_eq!(from_str_hex(~".p-1"), Some(0.));
-        assert_eq!(from_str_hex(~"f."), Some(15.));
-        assert_eq!(from_str_hex(~".f"), Some(0.9375));
-        assert_eq!(from_str_hex(~"0.f"), Some(0.9375));
-        assert_eq!(from_str_hex(~"-.f"), Some(-0.9375));
-        assert_eq!(from_str_hex(~"-f"), Some(-15.));
-        assert_eq!(from_str_hex(~"inf"), Some(infinity));
-        assert_eq!(from_str_hex(~"+inf"), Some(infinity));
-        assert_eq!(from_str_hex(~"-inf"), Some(neg_infinity));
+        assert_eq!(from_str_hex("a4"), Some(164.));
+        assert_eq!(from_str_hex("a4.fe"), Some(164.9921875));
+        assert_eq!(from_str_hex("-a4.fe"), Some(-164.9921875));
+        assert_eq!(from_str_hex("+a4.fe"), Some(164.9921875));
+        assert_eq!(from_str_hex("ff0P4"), Some(0xff00 as float));
+        assert_eq!(from_str_hex("ff0p4"), Some(0xff00 as float));
+        assert_eq!(from_str_hex("ff0p-4"), Some(0xff as float));
+        assert_eq!(from_str_hex("."), Some(0.));
+        assert_eq!(from_str_hex(".p1"), Some(0.));
+        assert_eq!(from_str_hex(".p-1"), Some(0.));
+        assert_eq!(from_str_hex("f."), Some(15.));
+        assert_eq!(from_str_hex(".f"), Some(0.9375));
+        assert_eq!(from_str_hex("0.f"), Some(0.9375));
+        assert_eq!(from_str_hex("-.f"), Some(-0.9375));
+        assert_eq!(from_str_hex("-f"), Some(-15.));
+        assert_eq!(from_str_hex("inf"), Some(infinity));
+        assert_eq!(from_str_hex("+inf"), Some(infinity));
+        assert_eq!(from_str_hex("-inf"), Some(neg_infinity));
         // note: NaN != NaN, hence this slightly complex test
-        match from_str_hex(~"NaN") {
+        match from_str_hex("NaN") {
             Some(f) => assert!(f.is_NaN()),
             None => fail!()
         }
         // note: -0 == 0, hence these slightly more complex tests
-        match from_str_hex(~"-0") {
+        match from_str_hex("-0") {
             Some(v) if v.is_zero() => assert!(v.is_negative()),
             _ => fail!()
         }
-        match from_str_hex(~"0") {
+        match from_str_hex("0") {
             Some(v) if v.is_zero() => assert!(v.is_positive()),
             _ => fail!()
         }
-        assert_eq!(from_str_hex(~"e"), Some(14.));
-        assert_eq!(from_str_hex(~"E"), Some(14.));
-        assert_eq!(from_str_hex(~"E1"), Some(225.));
-        assert_eq!(from_str_hex(~"1e1e1"), Some(123361.));
-        assert_eq!(from_str_hex(~"1e1.1"), Some(481.0625));
-
-        assert!(from_str_hex(~"").is_none());
-        assert!(from_str_hex(~"x").is_none());
-        assert!(from_str_hex(~" ").is_none());
-        assert!(from_str_hex(~"   ").is_none());
-        assert!(from_str_hex(~"p").is_none());
-        assert!(from_str_hex(~"P").is_none());
-        assert!(from_str_hex(~"P1").is_none());
-        assert!(from_str_hex(~"1p1p1").is_none());
-        assert!(from_str_hex(~"1p1.1").is_none());
-        assert!(from_str_hex(~"1p1-1").is_none());
+        assert_eq!(from_str_hex("e"), Some(14.));
+        assert_eq!(from_str_hex("E"), Some(14.));
+        assert_eq!(from_str_hex("E1"), Some(225.));
+        assert_eq!(from_str_hex("1e1e1"), Some(123361.));
+        assert_eq!(from_str_hex("1e1.1"), Some(481.0625));
+
+        assert!(from_str_hex("").is_none());
+        assert!(from_str_hex("x").is_none());
+        assert!(from_str_hex(" ").is_none());
+        assert!(from_str_hex("   ").is_none());
+        assert!(from_str_hex("p").is_none());
+        assert!(from_str_hex("P").is_none());
+        assert!(from_str_hex("P1").is_none());
+        assert!(from_str_hex("1p1p1").is_none());
+        assert!(from_str_hex("1p1.1").is_none());
+        assert!(from_str_hex("1p1-1").is_none());
     }
 
     #[test]
@@ -1375,8 +1375,8 @@ mod tests {
 
     #[test]
     pub fn test_from_str_radix() {
-        assert_eq!(from_str_radix(~"10", 36u), Some(36.));
-        assert_eq!(from_str_radix(~"1000.001", 2u), Some(8.125));
+        assert_eq!(from_str_radix("10", 36u), Some(36.));
+        assert_eq!(from_str_radix("1000.001", 2u), Some(8.125));
     }
 
     #[test]