auto merge of #20677 : alexcrichton/rust/rollup, r=alexcrichton

11 files changed, 72 insertions, 51 deletions

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index 9b0471bfad9..c0be3a28794 100644
--- a/src/libcoretest/any.rs
+++ b/src/libcoretest/any.rs
@@ -56,12 +56,12 @@ fn any_downcast_ref() {
 
     match a.downcast_ref::<uint>() {
         Some(&5) => {}
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match a.downcast_ref::<Test>() {
         None => {}
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 }
 
@@ -79,7 +79,7 @@ fn any_downcast_mut() {
             assert_eq!(*x, 5u);
             *x = 612;
         }
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match b_r.downcast_mut::<uint>() {
@@ -87,27 +87,27 @@ fn any_downcast_mut() {
             assert_eq!(*x, 7u);
             *x = 413;
         }
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match a_r.downcast_mut::<Test>() {
         None => (),
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match b_r.downcast_mut::<Test>() {
         None => (),
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match a_r.downcast_mut::<uint>() {
         Some(&612) => {}
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 
     match b_r.downcast_mut::<uint>() {
         Some(&413) => {}
-        x => panic!("Unexpected value {}", x)
+        x => panic!("Unexpected value {:?}", x)
     }
 }
 
diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs
index 54da6264bb0..86f34ecd15e 100644
--- a/src/libcoretest/cell.rs
+++ b/src/libcoretest/cell.rs
@@ -29,10 +29,10 @@ fn smoketest_cell() {
 #[test]
 fn cell_has_sensible_show() {
     let x = Cell::new("foo bar");
-    assert!(format!("{}", x).contains(x.get()));
+    assert!(format!("{:?}", x).contains(x.get()));
 
     x.set("baz qux");
-    assert!(format!("{}", x).contains(x.get()));
+    assert!(format!("{:?}", x).contains(x.get()));
 }
 
 #[test]
@@ -40,11 +40,11 @@ fn ref_and_refmut_have_sensible_show() {
     let refcell = RefCell::new("foo");
 
     let refcell_refmut = refcell.borrow_mut();
-    assert!(format!("{}", refcell_refmut).contains("foo"));
+    assert!(format!("{:?}", refcell_refmut).contains("foo"));
     drop(refcell_refmut);
 
     let refcell_ref = refcell.borrow();
-    assert!(format!("{}", refcell_ref).contains("foo"));
+    assert!(format!("{:?}", refcell_ref).contains("foo"));
     drop(refcell_ref);
 }
 
diff --git a/src/libcoretest/char.rs b/src/libcoretest/char.rs
index b581cdbd710..f901e800176 100644
--- a/src/libcoretest/char.rs
+++ b/src/libcoretest/char.rs
@@ -167,7 +167,7 @@ fn test_encode_utf8() {
     fn check(input: char, expect: &[u8]) {
         let mut buf = [0u8; 4];
         let n = input.encode_utf8(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf[..n], expect);
+        assert_eq!(buf.index(&(0..n)), expect);
     }
 
     check('x', &[0x78]);
@@ -181,7 +181,7 @@ fn test_encode_utf16() {
     fn check(input: char, expect: &[u16]) {
         let mut buf = [0u16; 2];
         let n = input.encode_utf16(buf.as_mut_slice()).unwrap_or(0);
-        assert_eq!(buf[..n], expect);
+        assert_eq!(buf.index(&(0..n)), expect);
     }
 
     check('x', &[0x0078]);
diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs
index 1e28933becd..c259e4cbb68 100644
--- a/src/libcoretest/fmt/num.rs
+++ b/src/libcoretest/fmt/num.rs
@@ -26,6 +26,11 @@ fn test_format_int() {
     assert!(format!("{}", -1i16) == "-1");
     assert!(format!("{}", -1i32) == "-1");
     assert!(format!("{}", -1i64) == "-1");
+    assert!(format!("{:?}", 1i) == "1i");
+    assert!(format!("{:?}", 1i8) == "1i8");
+    assert!(format!("{:?}", 1i16) == "1i16");
+    assert!(format!("{:?}", 1i32) == "1i32");
+    assert!(format!("{:?}", 1i64) == "1i64");
     assert!(format!("{:b}", 1i) == "1");
     assert!(format!("{:b}", 1i8) == "1");
     assert!(format!("{:b}", 1i16) == "1");
@@ -52,6 +57,11 @@ fn test_format_int() {
     assert!(format!("{}", 1u16) == "1");
     assert!(format!("{}", 1u32) == "1");
     assert!(format!("{}", 1u64) == "1");
+    assert!(format!("{:?}", 1u) == "1u");
+    assert!(format!("{:?}", 1u8) == "1u8");
+    assert!(format!("{:?}", 1u16) == "1u16");
+    assert!(format!("{:?}", 1u32) == "1u32");
+    assert!(format!("{:?}", 1u64) == "1u64");
     assert!(format!("{:b}", 1u) == "1");
     assert!(format!("{:b}", 1u8) == "1");
     assert!(format!("{:b}", 1u16) == "1");
@@ -84,12 +94,14 @@ fn test_format_int() {
 #[test]
 fn test_format_int_zero() {
     assert!(format!("{}", 0i) == "0");
+    assert!(format!("{:?}", 0i) == "0i");
     assert!(format!("{:b}", 0i) == "0");
     assert!(format!("{:o}", 0i) == "0");
     assert!(format!("{:x}", 0i) == "0");
     assert!(format!("{:X}", 0i) == "0");
 
     assert!(format!("{}", 0u) == "0");
+    assert!(format!("{:?}", 0u) == "0u");
     assert!(format!("{:b}", 0u) == "0");
     assert!(format!("{:o}", 0u) == "0");
     assert!(format!("{:x}", 0u) == "0");
@@ -184,6 +196,12 @@ mod uint {
     }
 
     #[bench]
+    fn format_show(b: &mut Bencher) {
+        let mut rng = weak_rng();
+        b.iter(|| { format!("{:?}", rng.gen::<uint>()); })
+    }
+
+    #[bench]
     fn format_base_36(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| { format!("{}", radix(rng.gen::<uint>(), 36)); })
@@ -220,6 +238,12 @@ mod int {
     }
 
     #[bench]
+    fn format_show(b: &mut Bencher) {
+        let mut rng = weak_rng();
+        b.iter(|| { format!("{:?}", rng.gen::<int>()); })
+    }
+
+    #[bench]
     fn format_base_36(b: &mut Bencher) {
         let mut rng = weak_rng();
         b.iter(|| { format!("{}", radix(rng.gen::<int>(), 36)); })
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index a4bafe754ff..63bf9ec3314 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -7,7 +7,7 @@
 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
-use core::kinds::Sized;
+use core::marker::Sized;
 use std::mem;
 
 use core::slice::SliceExt;
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 73db72d0313..61266a92649 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -14,7 +14,6 @@ use core::iter::MinMaxResult::*;
 use core::num::SignedInt;
 use core::uint;
 use core::cmp;
-use core::ops::Slice;
 
 use test::Bencher;
 
@@ -230,7 +229,7 @@ fn test_inspect() {
                .collect::<Vec<uint>>();
 
     assert_eq!(n, xs.len());
-    assert_eq!(xs[], ys[]);
+    assert_eq!(&xs[], &ys[]);
 }
 
 #[test]
@@ -281,21 +280,21 @@ fn test_iterator_nth() {
 fn test_iterator_last() {
     let v: &[_] = &[0i, 1, 2, 3, 4];
     assert_eq!(v.iter().last().unwrap(), &4);
-    assert_eq!(v[0..1].iter().last().unwrap(), &0);
+    assert_eq!(v[..1].iter().last().unwrap(), &0);
 }
 
 #[test]
 fn test_iterator_len() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().count(), 4);
-    assert_eq!(v[0..10].iter().count(), 10);
+    assert_eq!(v[..4].iter().count(), 4);
+    assert_eq!(v[..10].iter().count(), 10);
     assert_eq!(v[0..0].iter().count(), 0);
 }
 
 #[test]
 fn test_iterator_sum() {
     let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
-    assert_eq!(v[0..4].iter().map(|&x| x).sum(), 6);
+    assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
     assert_eq!(v.iter().map(|&x| x).sum(), 55);
     assert_eq!(v[0..0].iter().map(|&x| x).sum(), 0);
 }
@@ -374,7 +373,7 @@ fn test_all() {
     assert!(v.iter().all(|&x| x < 10));
     assert!(!v.iter().all(|&x| x % 2 == 0));
     assert!(!v.iter().all(|&x| x > 100));
-    assert!(v.slice_or_fail(&0, &0).iter().all(|_| panic!()));
+    assert!(v[0..0].iter().all(|_| panic!()));
 }
 
 #[test]
@@ -383,7 +382,7 @@ fn test_any() {
     assert!(v.iter().any(|&x| x < 10));
     assert!(v.iter().any(|&x| x % 2 == 0));
     assert!(!v.iter().any(|&x| x > 100));
-    assert!(!v.slice_or_fail(&0, &0).iter().any(|_| panic!()));
+    assert!(!v[0..0].iter().any(|_| panic!()));
 }
 
 #[test]
@@ -586,7 +585,7 @@ fn check_randacc_iter<A, T>(a: T, len: uint) where
 fn test_double_ended_flat_map() {
     let u = [0u,1];
     let v = [5u,6,7,8];
-    let mut it = u.iter().flat_map(|x| v[*x..v.len()].iter());
+    let mut it = u.iter().flat_map(|x| v[(*x)..v.len()].iter());
     assert_eq!(it.next_back().unwrap(), &8);
     assert_eq!(it.next().unwrap(),      &5);
     assert_eq!(it.next_back().unwrap(), &7);
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index f86c85f8216..8186a4f0904 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -12,10 +12,9 @@ use core::cmp::PartialEq;
 use core::fmt::Show;
 use core::num::{NumCast, cast};
 use core::ops::{Add, Sub, Mul, Div, Rem};
-use core::kinds::Copy;
+use core::marker::Copy;
 
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
 mod int_macros;
 
 mod i8;
@@ -24,8 +23,7 @@ mod i32;
 mod i64;
 mod int;
 
-#[cfg_attr(stage0, macro_escape)]
-#[cfg_attr(not(stage0), macro_use)]
+#[macro_use]
 mod uint_macros;
 
 mod u8;
diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
index 4a459992098..1169f910238 100644
--- a/src/libcoretest/option.rs
+++ b/src/libcoretest/option.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use core::option::*;
-use core::kinds::marker;
+use core::marker;
 use core::mem;
 use core::clone::Clone;
 
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index 52ea14dd05d..b9403598ec2 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -95,10 +95,10 @@ pub fn test_fmt_default() {
     let ok: Result<int, &'static str> = Ok(100);
     let err: Result<int, &'static str> = Err("Err");
 
-    let s = format!("{}", ok);
-    assert_eq!(s, "Ok(100)");
-    let s = format!("{}", err);
-    assert_eq!(s, "Err(Err)");
+    let s = format!("{:?}", ok);
+    assert_eq!(s, "Ok(100i)");
+    let s = format!("{:?}", err);
+    assert_eq!(s, "Err(\"Err\")");
 }
 
 #[test]
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
index 9ef7d603059..b714b6a4e41 100644
--- a/src/libcoretest/slice.rs
+++ b/src/libcoretest/slice.rs
@@ -43,35 +43,35 @@ fn iterator_to_slice() {
 
             {
                 let mut iter = data.iter();
-                assert_eq!(iter[], other_data[]);
+                assert_eq!(&iter[], &other_data[]);
 
                 iter.next();
-                assert_eq!(iter[], other_data[1..]);
+                assert_eq!(&iter[], &other_data[1..]);
 
                 iter.next_back();
-                assert_eq!(iter[], other_data[1..2]);
+                assert_eq!(&iter[], &other_data[1..2]);
 
                 let s = iter.as_slice();
                 iter.next();
-                assert_eq!(s, other_data[1..2]);
+                assert_eq!(s, &other_data[1..2]);
             }
             {
                 let mut iter = data.iter_mut();
-                assert_eq!(iter[], other_data[]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&FullRange));
                 // mutability:
-                assert!(iter[mut] == other_data);
+                assert!(&mut iter[] == other_data);
 
                 iter.next();
-                assert_eq!(iter[], other_data[1..]);
-                assert!(iter[mut] == other_data[mut 1..]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..)));
+                assert!(&mut iter[] == &mut other_data[1..]);
 
                 iter.next_back();
 
-                assert_eq!(iter[], other_data[1..2]);
-                assert!(iter[mut] == other_data[mut 1..2]);
+                assert_eq!(iter.index(&FullRange), other_data.index(&(1..2)));
+                assert!(&mut iter[] == &mut other_data[1..2]);
 
                 let s = iter.into_slice();
-                assert!(s == other_data[mut 1..2]);
+                assert!(s == &mut other_data[1..2]);
             }
         }}
     }
diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs
index c3bc38a6614..62eb9f4ad34 100644
--- a/src/libcoretest/tuple.rs
+++ b/src/libcoretest/tuple.rs
@@ -59,10 +59,10 @@ fn test_tuple_cmp() {
 
 #[test]
 fn test_show() {
-    let s = format!("{}", (1i,));
-    assert_eq!(s, "(1,)");
-    let s = format!("{}", (1i, true));
-    assert_eq!(s, "(1, true)");
-    let s = format!("{}", (1i, "hi", true));
-    assert_eq!(s, "(1, hi, true)");
+    let s = format!("{:?}", (1i,));
+    assert_eq!(s, "(1i,)");
+    let s = format!("{:?}", (1i, true));
+    assert_eq!(s, "(1i, true)");
+    let s = format!("{:?}", (1i, "hi", true));
+    assert_eq!(s, "(1i, \"hi\", true)");
 }