auto merge of #6774 : alexcrichton/rust/silence-warnings, r=graydon

Also as a bonus this fixes #6767

8 files changed, 90 insertions, 90 deletions

diff --git a/src/libstd/at_vec.rs b/src/libstd/at_vec.rs
index 44c55563ac5..7a41c278fa3 100644
--- a/src/libstd/at_vec.rs
+++ b/src/libstd/at_vec.rs
@@ -300,7 +300,7 @@ mod test {
 
     #[test]
     fn append_test() {
-        assert_eq!(@[1,2,3] + @[4,5,6], @[1,2,3,4,5,6]);
+        assert_eq!(@[1,2,3] + [4,5,6], @[1,2,3,4,5,6]);
     }
 
     #[test]
diff --git a/src/libstd/hash.rs b/src/libstd/hash.rs
index f46c8ab7ecc..7eb2054a35d 100644
--- a/src/libstd/hash.rs
+++ b/src/libstd/hash.rs
@@ -487,7 +487,7 @@ mod tests {
 
             assert!(f == i && f == v);
 
-            buf += ~[t as u8];
+            buf += [t as u8];
             stream_inc.input([t as u8]);
 
             t += 1;
diff --git a/src/libstd/logging.rs b/src/libstd/logging.rs
index be71714a048..693d7863297 100644
--- a/src/libstd/logging.rs
+++ b/src/libstd/logging.rs
@@ -12,10 +12,7 @@
 
 use option::*;
 use either::*;
-use rt;
 use rt::logging::{Logger, StdErrLogger};
-use cast;
-use str;
 
 /// Turns on logging to stdout globally
 pub fn console_on() {
@@ -40,10 +37,13 @@ pub fn console_off() {
 #[cfg(not(test))]
 #[lang="log_type"]
 pub fn log_type<T>(level: u32, object: &T) {
+    use cast;
     use container::Container;
     use io;
     use libc;
     use repr;
+    use rt;
+    use str;
     use vec;
 
     let bytes = do io::with_bytes_writer |writer| {
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 6fde30fdb50..27e872003ec 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -757,45 +757,45 @@ mod tests {
 
     #[test]
     fn test_from_str() {
-        assert_eq!(from_str(~"0"), Some(0 as $T));
-        assert_eq!(from_str(~"3"), Some(3 as $T));
-        assert_eq!(from_str(~"10"), Some(10 as $T));
-        assert_eq!(i32::from_str(~"123456789"), Some(123456789 as i32));
-        assert_eq!(from_str(~"00100"), Some(100 as $T));
+        assert_eq!(from_str("0"), Some(0 as $T));
+        assert_eq!(from_str("3"), Some(3 as $T));
+        assert_eq!(from_str("10"), Some(10 as $T));
+        assert_eq!(i32::from_str("123456789"), Some(123456789 as i32));
+        assert_eq!(from_str("00100"), Some(100 as $T));
 
-        assert_eq!(from_str(~"-1"), Some(-1 as $T));
-        assert_eq!(from_str(~"-3"), Some(-3 as $T));
-        assert_eq!(from_str(~"-10"), Some(-10 as $T));
-        assert_eq!(i32::from_str(~"-123456789"), Some(-123456789 as i32));
-        assert_eq!(from_str(~"-00100"), Some(-100 as $T));
+        assert_eq!(from_str("-1"), Some(-1 as $T));
+        assert_eq!(from_str("-3"), Some(-3 as $T));
+        assert_eq!(from_str("-10"), Some(-10 as $T));
+        assert_eq!(i32::from_str("-123456789"), Some(-123456789 as i32));
+        assert_eq!(from_str("-00100"), Some(-100 as $T));
 
-        assert!(from_str(~" ").is_none());
-        assert!(from_str(~"x").is_none());
+        assert!(from_str(" ").is_none());
+        assert!(from_str("x").is_none());
     }
 
     #[test]
     fn test_parse_bytes() {
         use str::to_bytes;
-        assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"1001"), 2u), Some(9 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83 as $T));
-        assert_eq!(i32::parse_bytes(to_bytes(~"123"), 16u), Some(291 as i32));
-        assert_eq!(i32::parse_bytes(to_bytes(~"ffff"), 16u), Some(65535 as i32));
-        assert_eq!(i32::parse_bytes(to_bytes(~"FFFF"), 16u), Some(65535 as i32));
-        assert_eq!(parse_bytes(to_bytes(~"z"), 36u), Some(35 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"Z"), 36u), Some(35 as $T));
-
-        assert_eq!(parse_bytes(to_bytes(~"-123"), 10u), Some(-123 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"-1001"), 2u), Some(-9 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"-123"), 8u), Some(-83 as $T));
-        assert_eq!(i32::parse_bytes(to_bytes(~"-123"), 16u), Some(-291 as i32));
-        assert_eq!(i32::parse_bytes(to_bytes(~"-ffff"), 16u), Some(-65535 as i32));
-        assert_eq!(i32::parse_bytes(to_bytes(~"-FFFF"), 16u), Some(-65535 as i32));
-        assert_eq!(parse_bytes(to_bytes(~"-z"), 36u), Some(-35 as $T));
-        assert_eq!(parse_bytes(to_bytes(~"-Z"), 36u), Some(-35 as $T));
-
-        assert!(parse_bytes(to_bytes(~"Z"), 35u).is_none());
-        assert!(parse_bytes(to_bytes(~"-9"), 2u).is_none());
+        assert_eq!(parse_bytes(to_bytes("123"), 10u), Some(123 as $T));
+        assert_eq!(parse_bytes(to_bytes("1001"), 2u), Some(9 as $T));
+        assert_eq!(parse_bytes(to_bytes("123"), 8u), Some(83 as $T));
+        assert_eq!(i32::parse_bytes(to_bytes("123"), 16u), Some(291 as i32));
+        assert_eq!(i32::parse_bytes(to_bytes("ffff"), 16u), Some(65535 as i32));
+        assert_eq!(i32::parse_bytes(to_bytes("FFFF"), 16u), Some(65535 as i32));
+        assert_eq!(parse_bytes(to_bytes("z"), 36u), Some(35 as $T));
+        assert_eq!(parse_bytes(to_bytes("Z"), 36u), Some(35 as $T));
+
+        assert_eq!(parse_bytes(to_bytes("-123"), 10u), Some(-123 as $T));
+        assert_eq!(parse_bytes(to_bytes("-1001"), 2u), Some(-9 as $T));
+        assert_eq!(parse_bytes(to_bytes("-123"), 8u), Some(-83 as $T));
+        assert_eq!(i32::parse_bytes(to_bytes("-123"), 16u), Some(-291 as i32));
+        assert_eq!(i32::parse_bytes(to_bytes("-ffff"), 16u), Some(-65535 as i32));
+        assert_eq!(i32::parse_bytes(to_bytes("-FFFF"), 16u), Some(-65535 as i32));
+        assert_eq!(parse_bytes(to_bytes("-z"), 36u), Some(-35 as $T));
+        assert_eq!(parse_bytes(to_bytes("-Z"), 36u), Some(-35 as $T));
+
+        assert!(parse_bytes(to_bytes("Z"), 35u).is_none());
+        assert!(parse_bytes(to_bytes("-9"), 2u).is_none());
     }
 
     #[test]
@@ -838,36 +838,36 @@ mod tests {
     #[test]
     fn test_int_from_str_overflow() {
         let mut i8_val: i8 = 127_i8;
-        assert_eq!(i8::from_str(~"127"), Some(i8_val));
-        assert!(i8::from_str(~"128").is_none());
+        assert_eq!(i8::from_str("127"), Some(i8_val));
+        assert!(i8::from_str("128").is_none());
 
         i8_val += 1 as i8;
-        assert_eq!(i8::from_str(~"-128"), Some(i8_val));
-        assert!(i8::from_str(~"-129").is_none());
+        assert_eq!(i8::from_str("-128"), Some(i8_val));
+        assert!(i8::from_str("-129").is_none());
 
         let mut i16_val: i16 = 32_767_i16;
-        assert_eq!(i16::from_str(~"32767"), Some(i16_val));
-        assert!(i16::from_str(~"32768").is_none());
+        assert_eq!(i16::from_str("32767"), Some(i16_val));
+        assert!(i16::from_str("32768").is_none());
 
         i16_val += 1 as i16;
-        assert_eq!(i16::from_str(~"-32768"), Some(i16_val));
-        assert!(i16::from_str(~"-32769").is_none());
+        assert_eq!(i16::from_str("-32768"), Some(i16_val));
+        assert!(i16::from_str("-32769").is_none());
 
         let mut i32_val: i32 = 2_147_483_647_i32;
-        assert_eq!(i32::from_str(~"2147483647"), Some(i32_val));
-        assert!(i32::from_str(~"2147483648").is_none());
+        assert_eq!(i32::from_str("2147483647"), Some(i32_val));
+        assert!(i32::from_str("2147483648").is_none());
 
         i32_val += 1 as i32;
-        assert_eq!(i32::from_str(~"-2147483648"), Some(i32_val));
-        assert!(i32::from_str(~"-2147483649").is_none());
+        assert_eq!(i32::from_str("-2147483648"), Some(i32_val));
+        assert!(i32::from_str("-2147483649").is_none());
 
         let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
-        assert_eq!(i64::from_str(~"9223372036854775807"), Some(i64_val));
-        assert!(i64::from_str(~"9223372036854775808").is_none());
+        assert_eq!(i64::from_str("9223372036854775807"), Some(i64_val));
+        assert!(i64::from_str("9223372036854775808").is_none());
 
         i64_val += 1 as i64;
-        assert_eq!(i64::from_str(~"-9223372036854775808"), Some(i64_val));
-        assert!(i64::from_str(~"-9223372036854775809").is_none());
+        assert_eq!(i64::from_str("-9223372036854775808"), Some(i64_val));
+        assert!(i64::from_str("-9223372036854775809").is_none());
     }
 
     #[test]
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index 3448314c436..e6267bfe9e1 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -496,29 +496,29 @@ mod tests {
 
     #[test]
     pub fn test_from_str() {
-        assert_eq!(from_str(~"0"), Some(0u as $T));
-        assert_eq!(from_str(~"3"), Some(3u as $T));
-        assert_eq!(from_str(~"10"), Some(10u as $T));
-        assert_eq!(u32::from_str(~"123456789"), Some(123456789 as u32));
-        assert_eq!(from_str(~"00100"), Some(100u as $T));
+        assert_eq!(from_str("0"), Some(0u as $T));
+        assert_eq!(from_str("3"), Some(3u as $T));
+        assert_eq!(from_str("10"), Some(10u as $T));
+        assert_eq!(u32::from_str("123456789"), Some(123456789 as u32));
+        assert_eq!(from_str("00100"), Some(100u as $T));
 
-        assert!(from_str(~"").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("x").is_none());
     }
 
     #[test]
     pub fn test_parse_bytes() {
         use str::to_bytes;
-        assert_eq!(parse_bytes(to_bytes(~"123"), 10u), Some(123u as $T));
-        assert_eq!(parse_bytes(to_bytes(~"1001"), 2u), Some(9u as $T));
-        assert_eq!(parse_bytes(to_bytes(~"123"), 8u), Some(83u as $T));
-        assert_eq!(u16::parse_bytes(to_bytes(~"123"), 16u), Some(291u as u16));
-        assert_eq!(u16::parse_bytes(to_bytes(~"ffff"), 16u), Some(65535u as u16));
-        assert_eq!(parse_bytes(to_bytes(~"z"), 36u), Some(35u as $T));
+        assert_eq!(parse_bytes(to_bytes("123"), 10u), Some(123u as $T));
+        assert_eq!(parse_bytes(to_bytes("1001"), 2u), Some(9u as $T));
+        assert_eq!(parse_bytes(to_bytes("123"), 8u), Some(83u as $T));
+        assert_eq!(u16::parse_bytes(to_bytes("123"), 16u), Some(291u as u16));
+        assert_eq!(u16::parse_bytes(to_bytes("ffff"), 16u), Some(65535u as u16));
+        assert_eq!(parse_bytes(to_bytes("z"), 36u), Some(35u as $T));
 
-        assert!(parse_bytes(to_bytes(~"Z"), 10u).is_none());
-        assert!(parse_bytes(to_bytes(~"_"), 2u).is_none());
+        assert!(parse_bytes(to_bytes("Z"), 10u).is_none());
+        assert!(parse_bytes(to_bytes("_"), 2u).is_none());
     }
 
     #[test]
@@ -551,36 +551,36 @@ mod tests {
     #[test]
     fn test_uint_from_str_overflow() {
         let mut u8_val: u8 = 255_u8;
-        assert_eq!(u8::from_str(~"255"), Some(u8_val));
-        assert!(u8::from_str(~"256").is_none());
+        assert_eq!(u8::from_str("255"), Some(u8_val));
+        assert!(u8::from_str("256").is_none());
 
         u8_val += 1 as u8;
-        assert_eq!(u8::from_str(~"0"), Some(u8_val));
-        assert!(u8::from_str(~"-1").is_none());
+        assert_eq!(u8::from_str("0"), Some(u8_val));
+        assert!(u8::from_str("-1").is_none());
 
         let mut u16_val: u16 = 65_535_u16;
-        assert_eq!(u16::from_str(~"65535"), Some(u16_val));
-        assert!(u16::from_str(~"65536").is_none());
+        assert_eq!(u16::from_str("65535"), Some(u16_val));
+        assert!(u16::from_str("65536").is_none());
 
         u16_val += 1 as u16;
-        assert_eq!(u16::from_str(~"0"), Some(u16_val));
-        assert!(u16::from_str(~"-1").is_none());
+        assert_eq!(u16::from_str("0"), Some(u16_val));
+        assert!(u16::from_str("-1").is_none());
 
         let mut u32_val: u32 = 4_294_967_295_u32;
-        assert_eq!(u32::from_str(~"4294967295"), Some(u32_val));
-        assert!(u32::from_str(~"4294967296").is_none());
+        assert_eq!(u32::from_str("4294967295"), Some(u32_val));
+        assert!(u32::from_str("4294967296").is_none());
 
         u32_val += 1 as u32;
-        assert_eq!(u32::from_str(~"0"), Some(u32_val));
-        assert!(u32::from_str(~"-1").is_none());
+        assert_eq!(u32::from_str("0"), Some(u32_val));
+        assert!(u32::from_str("-1").is_none());
 
         let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
-        assert_eq!(u64::from_str(~"18446744073709551615"), Some(u64_val));
-        assert!(u64::from_str(~"18446744073709551616").is_none());
+        assert_eq!(u64::from_str("18446744073709551615"), Some(u64_val));
+        assert!(u64::from_str("18446744073709551616").is_none());
 
         u64_val += 1 as u64;
-        assert_eq!(u64::from_str(~"0"), Some(u64_val));
-        assert!(u64::from_str(~"-1").is_none());
+        assert_eq!(u64::from_str("0"), Some(u64_val));
+        assert!(u64::from_str("-1").is_none());
     }
 
     #[test]
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 49e3c17be1b..15c68efc7cc 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -1481,7 +1481,7 @@ mod tests {
     fn test_getenv_big() {
         let mut s = ~"";
         let mut i = 0;
-        while i < 100 { s += ~"aaaaaaaaaa"; i += 1; }
+        while i < 100 { s += "aaaaaaaaaa"; i += 1; }
         let n = make_rand_name();
         setenv(n, s);
         debug!(copy s);
@@ -1658,7 +1658,7 @@ mod tests {
           };
           assert!((ostream as uint != 0u));
           let s = ~"hello";
-          let mut buf = str::to_bytes(s) + ~[0 as u8];
+          let mut buf = str::to_bytes(s) + [0 as u8];
           do vec::as_mut_buf(buf) |b, _len| {
               assert!((libc::fwrite(b as *c_void, 1u as size_t,
                                    (str::len(s) + 1u) as size_t, ostream)
diff --git a/src/libstd/ptr.rs b/src/libstd/ptr.rs
index 309129b7f13..38d7095a366 100644
--- a/src/libstd/ptr.rs
+++ b/src/libstd/ptr.rs
@@ -11,8 +11,8 @@
 //! Unsafe pointer utility functions
 
 use cast;
-use libc;
-use libc::{c_void, size_t};
+#[cfg(stage0)] use libc;
+#[cfg(stage0)] use libc::{c_void, size_t};
 use option::{Option, Some, None};
 use sys;
 
diff --git a/src/libstd/str.rs b/src/libstd/str.rs
index 449c7848f56..349a848e2c7 100644
--- a/src/libstd/str.rs
+++ b/src/libstd/str.rs
@@ -3147,7 +3147,7 @@ mod tests {
         }
         t([~"you", ~"know", ~"I'm", ~"no", ~"good"],
           " ", "you know I'm no good");
-        let v: &[~str] = ~[];
+        let v: &[~str] = [];
         t(v, " ", "");
         t([~"hi"], " ", "hi");
     }