Remove all `i` suffixes

16 files changed, 195 insertions, 195 deletions

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index 7c71c733662..5ad3833a5ef 100644
--- a/src/libcoretest/any.rs
+++ b/src/libcoretest/any.rs
@@ -123,7 +123,7 @@ fn any_fixed_vec() {
 #[bench]
 fn bench_downcast_ref(b: &mut Bencher) {
     b.iter(|| {
-        let mut x = 0i;
+        let mut x = 0;
         let mut y = &mut x as &mut Any;
         test::black_box(&mut y);
         test::black_box(y.downcast_ref::<int>() == Some(&0));
diff --git a/src/libcoretest/cell.rs b/src/libcoretest/cell.rs
index 8bd2ed95ed5..5815dbc0acc 100644
--- a/src/libcoretest/cell.rs
+++ b/src/libcoretest/cell.rs
@@ -14,14 +14,14 @@ use std::mem::drop;
 
 #[test]
 fn smoketest_cell() {
-    let x = Cell::new(10i);
+    let x = Cell::new(10);
     assert!(x == Cell::new(10));
     assert!(x.get() == 10);
     x.set(20);
     assert!(x == Cell::new(20));
     assert!(x.get() == 20);
 
-    let y = Cell::new((30i, 40i));
+    let y = Cell::new((30, 40));
     assert!(y == Cell::new((30, 40)));
     assert!(y.get() == (30, 40));
 }
@@ -50,35 +50,35 @@ fn ref_and_refmut_have_sensible_show() {
 
 #[test]
 fn double_imm_borrow() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b1 = x.borrow();
     x.borrow();
 }
 
 #[test]
 fn no_mut_then_imm_borrow() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b1 = x.borrow_mut();
     assert!(x.try_borrow().is_none());
 }
 
 #[test]
 fn no_imm_then_borrow_mut() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b1 = x.borrow();
     assert!(x.try_borrow_mut().is_none());
 }
 
 #[test]
 fn no_double_borrow_mut() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b1 = x.borrow_mut();
     assert!(x.try_borrow_mut().is_none());
 }
 
 #[test]
 fn imm_release_borrow_mut() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     {
         let _b1 = x.borrow();
     }
@@ -87,7 +87,7 @@ fn imm_release_borrow_mut() {
 
 #[test]
 fn mut_release_borrow_mut() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     {
         let _b1 = x.borrow_mut();
     }
@@ -96,7 +96,7 @@ fn mut_release_borrow_mut() {
 
 #[test]
 fn double_borrow_single_release_no_borrow_mut() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b1 = x.borrow();
     {
         let _b2 = x.borrow();
@@ -107,7 +107,7 @@ fn double_borrow_single_release_no_borrow_mut() {
 #[test]
 #[should_fail]
 fn discard_doesnt_unborrow() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     let _b = x.borrow();
     let _ = _b;
     let _b = x.borrow_mut();
@@ -115,7 +115,7 @@ fn discard_doesnt_unborrow() {
 
 #[test]
 fn clone_ref_updates_flag() {
-    let x = RefCell::new(0i);
+    let x = RefCell::new(0);
     {
         let b1 = x.borrow();
         assert!(x.try_borrow_mut().is_none());
diff --git a/src/libcoretest/clone.rs b/src/libcoretest/clone.rs
index 67c30d945d4..5ab6ab27ba1 100644
--- a/src/libcoretest/clone.rs
+++ b/src/libcoretest/clone.rs
@@ -10,7 +10,7 @@
 
 #[test]
 fn test_borrowed_clone() {
-    let x = 5i;
+    let x = 5;
     let y: &int = &x;
     let z: &int = (&y).clone();
     assert_eq!(*z, 5);
@@ -18,8 +18,8 @@ fn test_borrowed_clone() {
 
 #[test]
 fn test_clone_from() {
-    let a = box 5i;
-    let mut b = box 10i;
+    let a = box 5;
+    let mut b = box 10;
     b.clone_from(&a);
     assert_eq!(*b, 5);
 }
diff --git a/src/libcoretest/cmp.rs b/src/libcoretest/cmp.rs
index 992c99f1f9f..6bc1f14cc5a 100644
--- a/src/libcoretest/cmp.rs
+++ b/src/libcoretest/cmp.rs
@@ -13,20 +13,20 @@ use core::cmp::Ordering::{Less, Greater, Equal};
 
 #[test]
 fn test_int_totalord() {
-    assert_eq!(5i.cmp(&10), Less);
-    assert_eq!(10i.cmp(&5), Greater);
-    assert_eq!(5i.cmp(&5), Equal);
-    assert_eq!((-5i).cmp(&12), Less);
-    assert_eq!(12i.cmp(&-5), Greater);
+    assert_eq!(5.cmp(&10), Less);
+    assert_eq!(10.cmp(&5), Greater);
+    assert_eq!(5.cmp(&5), Equal);
+    assert_eq!((-5).cmp(&12), Less);
+    assert_eq!(12.cmp(&-5), Greater);
 }
 
 #[test]
 fn test_mut_int_totalord() {
-    assert_eq!((&mut 5i).cmp(&&mut 10), Less);
-    assert_eq!((&mut 10i).cmp(&&mut 5), Greater);
-    assert_eq!((&mut 5i).cmp(&&mut 5), Equal);
-    assert_eq!((&mut -5i).cmp(&&mut 12), Less);
-    assert_eq!((&mut 12i).cmp(&&mut -5), Greater);
+    assert_eq!((&mut 5).cmp(&&mut 10), Less);
+    assert_eq!((&mut 10).cmp(&&mut 5), Greater);
+    assert_eq!((&mut 5).cmp(&&mut 5), Equal);
+    assert_eq!((&mut -5).cmp(&&mut 12), Less);
+    assert_eq!((&mut 12).cmp(&&mut -5), Greater);
 }
 
 #[test]
@@ -47,11 +47,11 @@ fn test_partial_min() {
     use core::f64::NAN;
     let data_integer = [
         // a, b, result
-        (0i, 0i, Some(0i)),
-        (1i, 0i, Some(0i)),
-        (0i, 1i, Some(0i)),
-        (-1i, 0i, Some(-1i)),
-        (0i, -1i, Some(-1i))
+        (0, 0, Some(0)),
+        (1, 0, Some(0)),
+        (0, 1, Some(0)),
+        (-1, 0, Some(-1)),
+        (0, -1, Some(-1))
     ];
 
     let data_float = [
@@ -80,11 +80,11 @@ fn test_partial_max() {
     use core::f64::NAN;
     let data_integer = [
         // a, b, result
-        (0i, 0i, Some(0i)),
-        (1i, 0i, Some(1i)),
-        (0i, 1i, Some(1i)),
-        (-1i, 0i, Some(0i)),
-        (0i, -1i, Some(0i))
+        (0, 0, Some(0)),
+        (1, 0, Some(1)),
+        (0, 1, Some(1)),
+        (-1, 0, Some(0)),
+        (0, -1, Some(0))
     ];
 
     let data_float = [
diff --git a/src/libcoretest/finally.rs b/src/libcoretest/finally.rs
index 6ec87203e00..22917b09ce9 100644
--- a/src/libcoretest/finally.rs
+++ b/src/libcoretest/finally.rs
@@ -15,7 +15,7 @@ use std::thread::Thread;
 
 #[test]
 fn test_success() {
-    let mut i = 0i;
+    let mut i = 0;
     try_finally(
         &mut i, (),
         |i, ()| {
@@ -32,7 +32,7 @@ fn test_success() {
 #[test]
 #[should_fail]
 fn test_fail() {
-    let mut i = 0i;
+    let mut i = 0;
     try_finally(
         &mut i, (),
         |i, ()| {
@@ -47,7 +47,7 @@ fn test_fail() {
 
 #[test]
 fn test_retval() {
-    let mut closure = |&mut:| 10i;
+    let mut closure = |&mut:| 10;
     let i = closure.finally(|| { });
     assert_eq!(i, 10);
 }
diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index d48820aee06..f83b03d845b 100644
--- a/src/libcoretest/hash/mod.rs
+++ b/src/libcoretest/hash/mod.rs
@@ -56,7 +56,7 @@ fn test_writer_hasher() {
     assert_eq!(hash(&5i16), 5);
     assert_eq!(hash(&5i32), 5);
     assert_eq!(hash(&5i64), 5);
-    assert_eq!(hash(&5i), 5);
+    assert_eq!(hash(&5), 5);
 
     assert_eq!(hash(&false), 0);
     assert_eq!(hash(&true), 1);
@@ -76,12 +76,12 @@ fn test_writer_hasher() {
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
 
     unsafe {
-        let ptr: *const int = mem::transmute(5i);
+        let ptr: *const int = mem::transmute(5);
         assert_eq!(hash(&ptr), 5);
     }
 
     unsafe {
-        let ptr: *mut int = mem::transmute(5i);
+        let ptr: *mut int = mem::transmute(5);
         assert_eq!(hash(&ptr), 5);
     }
 }
diff --git a/src/libcoretest/iter.rs b/src/libcoretest/iter.rs
index 8bcd4982fba..e6b0265576c 100644
--- a/src/libcoretest/iter.rs
+++ b/src/libcoretest/iter.rs
@@ -20,8 +20,8 @@ use test::Bencher;
 #[test]
 fn test_lt() {
     let empty: [int; 0] = [];
-    let xs = [1i,2,3];
-    let ys = [1i,2,0];
+    let xs = [1,2,3];
+    let ys = [1,2,0];
 
     assert!(!lt(xs.iter(), ys.iter()));
     assert!(!le(xs.iter(), ys.iter()));
@@ -64,15 +64,15 @@ fn test_lt() {
 
 #[test]
 fn test_multi_iter() {
-    let xs = [1i,2,3,4];
-    let ys = [4i,3,2,1];
+    let xs = [1,2,3,4];
+    let ys = [4,3,2,1];
     assert!(eq(xs.iter(), ys.iter().rev()));
     assert!(lt(xs.iter(), xs.iter().skip(2)));
 }
 
 #[test]
 fn test_counter_from_iter() {
-    let it = count(0i, 5).take(10);
+    let it = count(0, 5).take(10);
     let xs: Vec<int> = FromIterator::from_iter(it);
     assert!(xs == vec![0, 5, 10, 15, 20, 25, 30, 35, 40, 45]);
 }
@@ -304,7 +304,7 @@ fn test_cycle() {
 
 #[test]
 fn test_iterator_nth() {
-    let v: &[_] = &[0i, 1, 2, 3, 4];
+    let v: &[_] = &[0, 1, 2, 3, 4];
     for i in 0u..v.len() {
         assert_eq!(v.iter().nth(i).unwrap(), &v[i]);
     }
@@ -313,14 +313,14 @@ fn test_iterator_nth() {
 
 #[test]
 fn test_iterator_last() {
-    let v: &[_] = &[0i, 1, 2, 3, 4];
+    let v: &[_] = &[0, 1, 2, 3, 4];
     assert_eq!(v.iter().last().unwrap(), &4);
     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];
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().count(), 4);
     assert_eq!(v[..10].iter().count(), 10);
     assert_eq!(v[..0].iter().count(), 0);
@@ -328,7 +328,7 @@ fn test_iterator_len() {
 
 #[test]
 fn test_iterator_sum() {
-    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).sum(), 6);
     assert_eq!(v.iter().map(|&x| x).sum(), 55);
     assert_eq!(v[..0].iter().map(|&x| x).sum(), 0);
@@ -336,7 +336,7 @@ fn test_iterator_sum() {
 
 #[test]
 fn test_iterator_product() {
-    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).product(), 0);
     assert_eq!(v[1..5].iter().map(|&x| x).product(), 24);
     assert_eq!(v[..0].iter().map(|&x| x).product(), 1);
@@ -344,7 +344,7 @@ fn test_iterator_product() {
 
 #[test]
 fn test_iterator_max() {
-    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).max(), Some(3));
     assert_eq!(v.iter().map(|&x| x).max(), Some(10));
     assert_eq!(v[..0].iter().map(|&x| x).max(), None);
@@ -352,7 +352,7 @@ fn test_iterator_max() {
 
 #[test]
 fn test_iterator_min() {
-    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
     assert_eq!(v[..4].iter().map(|&x| x).min(), Some(0));
     assert_eq!(v.iter().map(|&x| x).min(), Some(0));
     assert_eq!(v[..0].iter().map(|&x| x).min(), None);
@@ -360,9 +360,9 @@ fn test_iterator_min() {
 
 #[test]
 fn test_iterator_size_hint() {
-    let c = count(0i, 1);
-    let v: &[_] = &[0i, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-    let v2 = &[10i, 11, 12];
+    let c = count(0, 1);
+    let v: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
+    let v2 = &[10, 11, 12];
     let vi = v.iter();
 
     assert_eq!(c.size_hint(), (uint::MAX, None));
@@ -375,10 +375,10 @@ fn test_iterator_size_hint() {
     assert_eq!(c.enumerate().size_hint(), (uint::MAX, None));
     assert_eq!(c.chain(vi.map(|&i| i)).size_hint(), (uint::MAX, None));
     assert_eq!(c.zip(vi).size_hint(), (10, Some(10)));
-    assert_eq!(c.scan(0i, |_,_| Some(0i)).size_hint(), (0, None));
+    assert_eq!(c.scan(0, |_,_| Some(0)).size_hint(), (0, None));
     assert_eq!(c.filter(|_| false).size_hint(), (0, None));
-    assert_eq!(c.map(|_| 0i).size_hint(), (uint::MAX, None));
-    assert_eq!(c.filter_map(|_| Some(0i)).size_hint(), (0, None));
+    assert_eq!(c.map(|_| 0).size_hint(), (uint::MAX, None));
+    assert_eq!(c.filter_map(|_| Some(0)).size_hint(), (0, None));
 
     assert_eq!(vi.take(5).size_hint(), (5, Some(5)));
     assert_eq!(vi.take(12).size_hint(), (10, Some(10)));
@@ -389,22 +389,22 @@ fn test_iterator_size_hint() {
     assert_eq!(vi.enumerate().size_hint(), (10, Some(10)));
     assert_eq!(vi.chain(v2.iter()).size_hint(), (13, Some(13)));
     assert_eq!(vi.zip(v2.iter()).size_hint(), (3, Some(3)));
-    assert_eq!(vi.scan(0i, |_,_| Some(0i)).size_hint(), (0, Some(10)));
+    assert_eq!(vi.scan(0, |_,_| Some(0)).size_hint(), (0, Some(10)));
     assert_eq!(vi.filter(|_| false).size_hint(), (0, Some(10)));
     assert_eq!(vi.map(|&i| i+1).size_hint(), (10, Some(10)));
-    assert_eq!(vi.filter_map(|_| Some(0i)).size_hint(), (0, Some(10)));
+    assert_eq!(vi.filter_map(|_| Some(0)).size_hint(), (0, Some(10)));
 }
 
 #[test]
 fn test_collect() {
-    let a = vec![1i, 2, 3, 4, 5];
+    let a = vec![1, 2, 3, 4, 5];
     let b: Vec<int> = a.iter().map(|&x| x).collect();
     assert!(a == b);
 }
 
 #[test]
 fn test_all() {
-    let v: Box<[int]> = box [1i, 2, 3, 4, 5];
+    let v: Box<[int]> = box [1, 2, 3, 4, 5];
     assert!(v.iter().all(|&x| x < 10));
     assert!(!v.iter().all(|&x| x % 2 == 0));
     assert!(!v.iter().all(|&x| x > 100));
@@ -413,7 +413,7 @@ fn test_all() {
 
 #[test]
 fn test_any() {
-    let v: Box<[int]> = box [1i, 2, 3, 4, 5];
+    let v: Box<[int]> = box [1, 2, 3, 4, 5];
     assert!(v.iter().any(|&x| x < 10));
     assert!(v.iter().any(|&x| x % 2 == 0));
     assert!(!v.iter().any(|&x| x > 100));
@@ -422,7 +422,7 @@ fn test_any() {
 
 #[test]
 fn test_find() {
-    let v: &[int] = &[1i, 3, 9, 27, 103, 14, 11];
+    let v: &[int] = &[1, 3, 9, 27, 103, 14, 11];
     assert_eq!(*v.iter().find(|&&x| x & 1 == 0).unwrap(), 14);
     assert_eq!(*v.iter().find(|&&x| x % 3 == 0).unwrap(), 3);
     assert!(v.iter().find(|&&x| x % 12 == 0).is_none());
@@ -430,7 +430,7 @@ fn test_find() {
 
 #[test]
 fn test_position() {
-    let v = &[1i, 3, 9, 27, 103, 14, 11];
+    let v = &[1, 3, 9, 27, 103, 14, 11];
     assert_eq!(v.iter().position(|x| *x & 1 == 0).unwrap(), 5);
     assert_eq!(v.iter().position(|x| *x % 3 == 0).unwrap(), 1);
     assert!(v.iter().position(|x| *x % 12 == 0).is_none());
@@ -438,7 +438,7 @@ fn test_position() {
 
 #[test]
 fn test_count() {
-    let xs = &[1i, 2, 2, 1, 5, 9, 0, 2];
+    let xs = &[1, 2, 2, 1, 5, 9, 0, 2];
     assert_eq!(xs.iter().filter(|x| **x == 2).count(), 3);
     assert_eq!(xs.iter().filter(|x| **x == 5).count(), 1);
     assert_eq!(xs.iter().filter(|x| **x == 95).count(), 0);
@@ -446,19 +446,19 @@ fn test_count() {
 
 #[test]
 fn test_max_by() {
-    let xs: &[int] = &[-3i, 0, 1, 5, -10];
+    let xs: &[int] = &[-3, 0, 1, 5, -10];
     assert_eq!(*xs.iter().max_by(|x| x.abs()).unwrap(), -10);
 }
 
 #[test]
 fn test_min_by() {
-    let xs: &[int] = &[-3i, 0, 1, 5, -10];
+    let xs: &[int] = &[-3, 0, 1, 5, -10];
     assert_eq!(*xs.iter().min_by(|x| x.abs()).unwrap(), 0);
 }
 
 #[test]
 fn test_by_ref() {
-    let mut xs = 0i..10;
+    let mut xs = 0..10;
     // sum the first five values
     let partial_sum = xs.by_ref().take(5).fold(0, |a, b| a + b);
     assert_eq!(partial_sum, 10);
@@ -467,7 +467,7 @@ fn test_by_ref() {
 
 #[test]
 fn test_rev() {
-    let xs = [2i, 4, 6, 8, 10, 12, 14, 16];
+    let xs = [2, 4, 6, 8, 10, 12, 14, 16];
     let mut it = xs.iter();
     it.next();
     it.next();
@@ -494,7 +494,7 @@ fn test_cloned() {
 
 #[test]
 fn test_double_ended_map() {
-    let xs = [1i, 2, 3, 4, 5, 6];
+    let xs = [1, 2, 3, 4, 5, 6];
     let mut it = xs.iter().map(|&x| x * -1);
     assert_eq!(it.next(), Some(-1));
     assert_eq!(it.next(), Some(-2));
@@ -507,7 +507,7 @@ fn test_double_ended_map() {
 
 #[test]
 fn test_double_ended_enumerate() {
-    let xs = [1i, 2, 3, 4, 5, 6];
+    let xs = [1, 2, 3, 4, 5, 6];
     let mut it = xs.iter().map(|&x| x).enumerate();
     assert_eq!(it.next(), Some((0, 1)));
     assert_eq!(it.next(), Some((1, 2)));
@@ -520,8 +520,8 @@ fn test_double_ended_enumerate() {
 
 #[test]
 fn test_double_ended_zip() {
-    let xs = [1i, 2, 3, 4, 5, 6];
-    let ys = [1i, 2, 3, 7];
+    let xs = [1, 2, 3, 4, 5, 6];
+    let ys = [1, 2, 3, 7];
     let a = xs.iter().map(|&x| x);
     let b = ys.iter().map(|&x| x);
     let mut it = a.zip(b);
@@ -534,7 +534,7 @@ fn test_double_ended_zip() {
 
 #[test]
 fn test_double_ended_filter() {
-    let xs = [1i, 2, 3, 4, 5, 6];
+    let xs = [1, 2, 3, 4, 5, 6];
     let mut it = xs.iter().filter(|&x| *x & 1 == 0);
     assert_eq!(it.next_back().unwrap(), &6);
     assert_eq!(it.next_back().unwrap(), &4);
@@ -544,7 +544,7 @@ fn test_double_ended_filter() {
 
 #[test]
 fn test_double_ended_filter_map() {
-    let xs = [1i, 2, 3, 4, 5, 6];
+    let xs = [1, 2, 3, 4, 5, 6];
     let mut it = xs.iter().filter_map(|&x| if x & 1 == 0 { Some(x * 2) } else { None });
     assert_eq!(it.next_back().unwrap(), 12);
     assert_eq!(it.next_back().unwrap(), 8);
@@ -554,8 +554,8 @@ fn test_double_ended_filter_map() {
 
 #[test]
 fn test_double_ended_chain() {
-    let xs = [1i, 2, 3, 4, 5];
-    let ys = [7i, 9, 11];
+    let xs = [1, 2, 3, 4, 5];
+    let ys = [7, 9, 11];
     let mut it = xs.iter().chain(ys.iter()).rev();
     assert_eq!(it.next().unwrap(), &11);
     assert_eq!(it.next().unwrap(), &9);
@@ -572,7 +572,7 @@ fn test_double_ended_chain() {
 fn test_rposition() {
     fn f(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'b' }
     fn g(xy: &(int, char)) -> bool { let (_x, y) = *xy; y == 'd' }
-    let v = [(0i, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
+    let v = [(0, 'a'), (1, 'b'), (2, 'c'), (3, 'b')];
 
     assert_eq!(v.iter().rposition(f), Some(3u));
     assert!(v.iter().rposition(g).is_none());
@@ -581,9 +581,9 @@ fn test_rposition() {
 #[test]
 #[should_fail]
 fn test_rposition_panic() {
-    let v = [(box 0i, box 0i), (box 0i, box 0i),
-             (box 0i, box 0i), (box 0i, box 0i)];
-    let mut i = 0i;
+    let v = [(box 0, box 0), (box 0, box 0),
+             (box 0, box 0), (box 0, box 0)];
+    let mut i = 0;
     v.iter().rposition(|_elt| {
         if i == 2 {
             panic!()
@@ -635,8 +635,8 @@ fn test_double_ended_flat_map() {
 
 #[test]
 fn test_random_access_chain() {
-    let xs = [1i, 2, 3, 4, 5];
-    let ys = [7i, 9, 11];
+    let xs = [1, 2, 3, 4, 5];
+    let ys = [7, 9, 11];
     let mut it = xs.iter().chain(ys.iter());
     assert_eq!(it.idx(0).unwrap(), &1);
     assert_eq!(it.idx(5).unwrap(), &7);
@@ -656,13 +656,13 @@ fn test_random_access_chain() {
 
 #[test]
 fn test_random_access_enumerate() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
     check_randacc_iter(xs.iter().enumerate(), xs.len());
 }
 
 #[test]
 fn test_random_access_rev() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
     check_randacc_iter(xs.iter().rev(), xs.len());
     let mut it = xs.iter().rev();
     it.next();
@@ -673,14 +673,14 @@ fn test_random_access_rev() {
 
 #[test]
 fn test_random_access_zip() {
-    let xs = [1i, 2, 3, 4, 5];
-    let ys = [7i, 9, 11];
+    let xs = [1, 2, 3, 4, 5];
+    let ys = [7, 9, 11];
     check_randacc_iter(xs.iter().zip(ys.iter()), cmp::min(xs.len(), ys.len()));
 }
 
 #[test]
 fn test_random_access_take() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
     let empty: &[int] = &[];
     check_randacc_iter(xs.iter().take(3), 3);
     check_randacc_iter(xs.iter().take(20), xs.len());
@@ -690,7 +690,7 @@ fn test_random_access_take() {
 
 #[test]
 fn test_random_access_skip() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
     let empty: &[int] = &[];
     check_randacc_iter(xs.iter().skip(2), xs.len() - 2);
     check_randacc_iter(empty.iter().skip(2), 0);
@@ -698,7 +698,7 @@ fn test_random_access_skip() {
 
 #[test]
 fn test_random_access_inspect() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
 
     // test .map and .inspect that don't implement Clone
     let mut it = xs.iter().inspect(|_| {});
@@ -711,7 +711,7 @@ fn test_random_access_inspect() {
 
 #[test]
 fn test_random_access_map() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
 
     let mut it = xs.iter().map(|x| *x);
     assert_eq!(xs.len(), it.indexable());
@@ -722,7 +722,7 @@ fn test_random_access_map() {
 
 #[test]
 fn test_random_access_cycle() {
-    let xs = [1i, 2, 3, 4, 5];
+    let xs = [1, 2, 3, 4, 5];
     let empty: &[int] = &[];
     check_randacc_iter(xs.iter().cycle().take(27), 27);
     check_randacc_iter(empty.iter().cycle(), 0);
@@ -730,8 +730,8 @@ fn test_random_access_cycle() {
 
 #[test]
 fn test_double_ended_range() {
-    assert!((11i..14).rev().collect::<Vec<int>>() == vec![13i, 12, 11]);
-    for _ in (10i..0).rev() {
+    assert!((11..14).rev().collect::<Vec<int>>() == vec![13, 12, 11]);
+    for _ in (10..0).rev() {
         panic!("unreachable");
     }
 
@@ -743,73 +743,73 @@ fn test_double_ended_range() {
 
 #[test]
 fn test_range() {
-    assert!((0i..5).collect::<Vec<int>>() == vec![0i, 1, 2, 3, 4]);
-    assert!((-10i..-1).collect::<Vec<int>>() ==
+    assert!((0..5).collect::<Vec<int>>() == vec![0, 1, 2, 3, 4]);
+    assert!((-10..-1).collect::<Vec<int>>() ==
                vec![-10, -9, -8, -7, -6, -5, -4, -3, -2]);
-    assert!((0i..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
-    assert_eq!((200i..-5).count(), 0);
-    assert_eq!((200i..-5).rev().count(), 0);
-    assert_eq!((200i..200).count(), 0);
-    assert_eq!((200i..200).rev().count(), 0);
+    assert!((0..5).rev().collect::<Vec<int>>() == vec![4, 3, 2, 1, 0]);
+    assert_eq!((200..-5).count(), 0);
+    assert_eq!((200..-5).rev().count(), 0);
+    assert_eq!((200..200).count(), 0);
+    assert_eq!((200..200).rev().count(), 0);
 
-    assert_eq!((0i..100).size_hint(), (100, Some(100)));
+    assert_eq!((0..100).size_hint(), (100, Some(100)));
     // this test is only meaningful when sizeof uint < sizeof u64
     assert_eq!((uint::MAX - 1..uint::MAX).size_hint(), (1, Some(1)));
-    assert_eq!((-10i..-1).size_hint(), (9, Some(9)));
+    assert_eq!((-10..-1).size_hint(), (9, Some(9)));
 }
 
 #[test]
 fn test_range_inclusive() {
-    assert!(range_inclusive(0i, 5).collect::<Vec<int>>() ==
-            vec![0i, 1, 2, 3, 4, 5]);
-    assert!(range_inclusive(0i, 5).rev().collect::<Vec<int>>() ==
-            vec![5i, 4, 3, 2, 1, 0]);
-    assert_eq!(range_inclusive(200i, -5).count(), 0);
-    assert_eq!(range_inclusive(200i, -5).rev().count(), 0);
-    assert!(range_inclusive(200i, 200).collect::<Vec<int>>() == vec![200]);
-    assert!(range_inclusive(200i, 200).rev().collect::<Vec<int>>() == vec![200]);
+    assert!(range_inclusive(0, 5).collect::<Vec<int>>() ==
+            vec![0, 1, 2, 3, 4, 5]);
+    assert!(range_inclusive(0, 5).rev().collect::<Vec<int>>() ==
+            vec![5, 4, 3, 2, 1, 0]);
+    assert_eq!(range_inclusive(200, -5).count(), 0);
+    assert_eq!(range_inclusive(200, -5).rev().count(), 0);
+    assert!(range_inclusive(200, 200).collect::<Vec<int>>() == vec![200]);
+    assert!(range_inclusive(200, 200).rev().collect::<Vec<int>>() == vec![200]);
 }
 
 #[test]
 fn test_range_step() {
-    assert!(range_step(0i, 20, 5).collect::<Vec<int>>() ==
+    assert!(range_step(0, 20, 5).collect::<Vec<int>>() ==
             vec![0, 5, 10, 15]);
-    assert!(range_step(20i, 0, -5).collect::<Vec<int>>() ==
+    assert!(range_step(20, 0, -5).collect::<Vec<int>>() ==
             vec![20, 15, 10, 5]);
-    assert!(range_step(20i, 0, -6).collect::<Vec<int>>() ==
+    assert!(range_step(20, 0, -6).collect::<Vec<int>>() ==
             vec![20, 14, 8, 2]);
     assert!(range_step(200u8, 255, 50).collect::<Vec<u8>>() ==
             vec![200u8, 250]);
-    assert!(range_step(200i, -5, 1).collect::<Vec<int>>() == vec![]);
-    assert!(range_step(200i, 200, 1).collect::<Vec<int>>() == vec![]);
+    assert!(range_step(200, -5, 1).collect::<Vec<int>>() == vec![]);
+    assert!(range_step(200, 200, 1).collect::<Vec<int>>() == vec![]);
 }
 
 #[test]
 fn test_range_step_inclusive() {
-    assert!(range_step_inclusive(0i, 20, 5).collect::<Vec<int>>() ==
+    assert!(range_step_inclusive(0, 20, 5).collect::<Vec<int>>() ==
             vec![0, 5, 10, 15, 20]);
-    assert!(range_step_inclusive(20i, 0, -5).collect::<Vec<int>>() ==
+    assert!(range_step_inclusive(20, 0, -5).collect::<Vec<int>>() ==
             vec![20, 15, 10, 5, 0]);
-    assert!(range_step_inclusive(20i, 0, -6).collect::<Vec<int>>() ==
+    assert!(range_step_inclusive(20, 0, -6).collect::<Vec<int>>() ==
             vec![20, 14, 8, 2]);
     assert!(range_step_inclusive(200u8, 255, 50).collect::<Vec<u8>>() ==
             vec![200u8, 250]);
-    assert!(range_step_inclusive(200i, -5, 1).collect::<Vec<int>>() ==
+    assert!(range_step_inclusive(200, -5, 1).collect::<Vec<int>>() ==
             vec![]);
-    assert!(range_step_inclusive(200i, 200, 1).collect::<Vec<int>>() ==
+    assert!(range_step_inclusive(200, 200, 1).collect::<Vec<int>>() ==
             vec![200]);
 }
 
 #[test]
 fn test_reverse() {
-    let mut ys = [1i, 2, 3, 4, 5];
+    let mut ys = [1, 2, 3, 4, 5];
     ys.iter_mut().reverse_in_place();
     assert!(ys == [5, 4, 3, 2, 1]);
 }
 
 #[test]
 fn test_peekable_is_empty() {
-    let a = [1i];
+    let a = [1];
     let mut it = a.iter().peekable();
     assert!( !it.is_empty() );
     it.next();
@@ -821,16 +821,16 @@ fn test_min_max() {
     let v: [int; 0] = [];
     assert_eq!(v.iter().min_max(), NoElements);
 
-    let v = [1i];
+    let v = [1];
     assert!(v.iter().min_max() == OneElement(&1));
 
-    let v = [1i, 2, 3, 4, 5];
+    let v = [1, 2, 3, 4, 5];
     assert!(v.iter().min_max() == MinMax(&1, &5));
 
-    let v = [1i, 2, 3, 4, 5, 6];
+    let v = [1, 2, 3, 4, 5, 6];
     assert!(v.iter().min_max() == MinMax(&1, &6));
 
-    let v = [1i, 1, 1, 1];
+    let v = [1, 1, 1, 1];
     assert!(v.iter().min_max() == MinMax(&1, &1));
 }
 
@@ -839,10 +839,10 @@ fn test_min_max_result() {
     let r: MinMaxResult<int> = NoElements;
     assert_eq!(r.into_option(), None);
 
-    let r = OneElement(1i);
+    let r = OneElement(1);
     assert_eq!(r.into_option(), Some((1,1)));
 
-    let r = MinMax(1i,2);
+    let r = MinMax(1,2);
     assert_eq!(r.into_option(), Some((1,2)));
 }
 
diff --git a/src/libcoretest/mem.rs b/src/libcoretest/mem.rs
index 3dc209e6fcb..fd9dc696bdf 100644
--- a/src/libcoretest/mem.rs
+++ b/src/libcoretest/mem.rs
@@ -70,8 +70,8 @@ fn align_of_val_basic() {
 
 #[test]
 fn test_swap() {
-    let mut x = 31337i;
-    let mut y = 42i;
+    let mut x = 31337;
+    let mut y = 42;
     swap(&mut x, &mut y);
     assert_eq!(x, 42);
     assert_eq!(y, 31337);
@@ -87,7 +87,7 @@ fn test_replace() {
 
 #[test]
 fn test_transmute_copy() {
-    assert_eq!(1u, unsafe { transmute_copy(&1i) });
+    assert_eq!(1u, unsafe { transmute_copy(&1) });
 }
 
 #[test]
@@ -95,7 +95,7 @@ fn test_transmute() {
     trait Foo {}
     impl Foo for int {}
 
-    let a = box 100i as Box<Foo>;
+    let a = box 100 as Box<Foo>;
     unsafe {
         let x: ::core::raw::TraitObject = transmute(a);
         assert!(*(x.data as *const int) == 100);
@@ -146,7 +146,7 @@ fn trait_static_method_call(b: &mut Bencher) {
 
 #[bench]
 fn match_option_some(b: &mut Bencher) {
-    let x = Some(10i);
+    let x = Some(10);
     b.iter(|| {
         match x {
             Some(y) => y,
@@ -157,11 +157,11 @@ fn match_option_some(b: &mut Bencher) {
 
 #[bench]
 fn match_vec_pattern(b: &mut Bencher) {
-    let x = [1i,2,3,4,5,6];
+    let x = [1,2,3,4,5,6];
     b.iter(|| {
         match x {
-            [1,2,3,..] => 10i,
-            _ => 11i,
+            [1,2,3,..] => 10,
+            _ => 11,
         }
     });
 }
diff --git a/src/libcoretest/nonzero.rs b/src/libcoretest/nonzero.rs
index ab2f6da1cf7..be4c83d23e8 100644
--- a/src/libcoretest/nonzero.rs
+++ b/src/libcoretest/nonzero.rs
@@ -16,7 +16,7 @@ use std::mem::size_of;
 #[test]
 fn test_create_nonzero_instance() {
     let _a = unsafe {
-        NonZero::new(21i)
+        NonZero::new(21)
     };
 }
 
@@ -28,14 +28,14 @@ fn test_size_nonzero_in_option() {
 #[test]
 fn test_match_on_nonzero_option() {
     let a = Some(unsafe {
-        NonZero::new(42i)
+        NonZero::new(42)
     });
     match a {
         Some(val) => assert_eq!(*val, 42),
         None => panic!("unexpected None while matching on Some(NonZero(_))")
     }
 
-    match unsafe { Some(NonZero::new(43i)) } {
+    match unsafe { Some(NonZero::new(43)) } {
         Some(val) => assert_eq!(*val, 43),
         None => panic!("unexpected None while matching on Some(NonZero(_))")
     }
@@ -52,9 +52,9 @@ fn test_match_option_empty_vec() {
 
 #[test]
 fn test_match_option_vec() {
-    let a = Some(vec![1i, 2, 3, 4]);
+    let a = Some(vec![1, 2, 3, 4]);
     match a {
-        Some(v) => assert_eq!(v, vec![1i, 2, 3, 4]),
+        Some(v) => assert_eq!(v, vec![1, 2, 3, 4]),
         None => panic!("unexpected None while matching on Some(vec![1, 2, 3, 4])")
     }
 }
@@ -63,9 +63,9 @@ fn test_match_option_vec() {
 fn test_match_option_rc() {
     use std::rc::Rc;
 
-    let five = Rc::new(5i);
+    let five = Rc::new(5);
     match Some(five) {
-        Some(r) => assert_eq!(*r, 5i),
+        Some(r) => assert_eq!(*r, 5),
         None => panic!("unexpected None while matching on Some(Rc::new(5))")
     }
 }
@@ -74,9 +74,9 @@ fn test_match_option_rc() {
 fn test_match_option_arc() {
     use std::sync::Arc;
 
-    let five = Arc::new(5i);
+    let five = Arc::new(5);
     match Some(five) {
-        Some(a) => assert_eq!(*a, 5i),
+        Some(a) => assert_eq!(*a, 5),
         None => panic!("unexpected None while matching on Some(Arc::new(5))")
     }
 }
diff --git a/src/libcoretest/num/int_macros.rs b/src/libcoretest/num/int_macros.rs
index b98432e26b2..f89733e766b 100644
--- a/src/libcoretest/num/int_macros.rs
+++ b/src/libcoretest/num/int_macros.rs
@@ -151,8 +151,8 @@ mod tests {
 
     #[test]
     fn test_signed_checked_div() {
-        assert!(10i.checked_div(2) == Some(5));
-        assert!(5i.checked_div(0) == None);
+        assert!(10.checked_div(2) == Some(5));
+        assert!(5.checked_div(0) == None);
         assert!(int::MIN.checked_div(-1) == None);
     }
 
diff --git a/src/libcoretest/num/mod.rs b/src/libcoretest/num/mod.rs
index e0623bade5c..0b013359f7e 100644
--- a/src/libcoretest/num/mod.rs
+++ b/src/libcoretest/num/mod.rs
@@ -40,11 +40,11 @@ pub fn test_num<T>(ten: T, two: T) where
      + Rem<Output=T> + Debug
      + Copy
 {
-    assert_eq!(ten.add(two),  cast(12i).unwrap());
-    assert_eq!(ten.sub(two),  cast(8i).unwrap());
-    assert_eq!(ten.mul(two),  cast(20i).unwrap());
-    assert_eq!(ten.div(two),  cast(5i).unwrap());
-    assert_eq!(ten.rem(two),  cast(0i).unwrap());
+    assert_eq!(ten.add(two),  cast(12).unwrap());
+    assert_eq!(ten.sub(two),  cast(8).unwrap());
+    assert_eq!(ten.mul(two),  cast(20).unwrap());
+    assert_eq!(ten.div(two),  cast(5).unwrap());
+    assert_eq!(ten.rem(two),  cast(0).unwrap());
 
     assert_eq!(ten.add(two),  ten + two);
     assert_eq!(ten.sub(two),  ten - two);
diff --git a/src/libcoretest/option.rs b/src/libcoretest/option.rs
index bb9d1524786..b32ae68b5d3 100644
--- a/src/libcoretest/option.rs
+++ b/src/libcoretest/option.rs
@@ -16,7 +16,7 @@ use core::clone::Clone;
 #[test]
 fn test_get_ptr() {
     unsafe {
-        let x = box 0i;
+        let x = box 0;
         let addr_x: *const int = mem::transmute(&*x);
         let opt = Some(x);
         let y = opt.unwrap();
@@ -59,7 +59,7 @@ fn test_get_resource() {
         }
     }
 
-    let i = Rc::new(RefCell::new(0i));
+    let i = Rc::new(RefCell::new(0));
     {
         let x = r(i.clone());
         let opt = Some(x);
@@ -71,7 +71,7 @@ fn test_get_resource() {
 #[test]
 fn test_option_dance() {
     let x = Some(());
-    let mut y = Some(5i);
+    let mut y = Some(5);
     let mut y2 = 0;
     for _x in x.iter() {
         y2 = y.take().unwrap();
@@ -89,12 +89,12 @@ fn test_option_too_much_dance() {
 
 #[test]
 fn test_and() {
-    let x: Option<int> = Some(1i);
-    assert_eq!(x.and(Some(2i)), Some(2));
+    let x: Option<int> = Some(1);
+    assert_eq!(x.and(Some(2)), Some(2));
     assert_eq!(x.and(None::<int>), None);
 
     let x: Option<int> = None;
-    assert_eq!(x.and(Some(2i)), None);
+    assert_eq!(x.and(Some(2)), None);
     assert_eq!(x.and(None::<int>), None);
 }
 
@@ -133,7 +133,7 @@ fn test_or_else() {
 
 #[test]
 fn test_unwrap() {
-    assert_eq!(Some(1i).unwrap(), 1);
+    assert_eq!(Some(1).unwrap(), 1);
     let s = Some("hello".to_string()).unwrap();
     assert_eq!(s, "hello");
 }
@@ -172,7 +172,7 @@ fn test_unwrap_or_else() {
 
 #[test]
 fn test_iter() {
-    let val = 5i;
+    let val = 5;
 
     let x = Some(val);
     let mut it = x.iter();
@@ -185,8 +185,8 @@ fn test_iter() {
 
 #[test]
 fn test_mut_iter() {
-    let val = 5i;
-    let new_val = 11i;
+    let val = 5;
+    let new_val = 11;
 
     let mut x = Some(val);
     {
@@ -223,13 +223,13 @@ fn test_ord() {
 /* FIXME(#20575)
 #[test]
 fn test_collect() {
-    let v: Option<Vec<int>> = (0i..0).map(|_| Some(0i)).collect();
+    let v: Option<Vec<int>> = (0..0).map(|_| Some(0i)).collect();
     assert!(v == Some(vec![]));
 
-    let v: Option<Vec<int>> = (0i..3).map(|x| Some(x)).collect();
+    let v: Option<Vec<int>> = (0..3).map(|x| Some(x)).collect();
     assert!(v == Some(vec![0, 1, 2]));
 
-    let v: Option<Vec<int>> = (0i..3).map(|x| {
+    let v: Option<Vec<int>> = (0..3).map(|x| {
         if x > 1 { None } else { Some(x) }
     }).collect();
     assert!(v == None);
diff --git a/src/libcoretest/ptr.rs b/src/libcoretest/ptr.rs
index 875affe0ac7..7f0b97c53d4 100644
--- a/src/libcoretest/ptr.rs
+++ b/src/libcoretest/ptr.rs
@@ -84,7 +84,7 @@ fn test_as_ref() {
         assert_eq!(q.as_ref().unwrap(), &2);
 
         // Lifetime inference
-        let u = 2i;
+        let u = 2;
         {
             let p: *const int = &u as *const _;
             assert_eq!(p.as_ref().unwrap(), &2);
@@ -102,7 +102,7 @@ fn test_as_mut() {
         assert!(q.as_mut().unwrap() == &mut 2);
 
         // Lifetime inference
-        let mut u = 2i;
+        let mut u = 2;
         {
             let p: *mut int = &mut u as *mut _;
             assert!(p.as_mut().unwrap() == &mut 2);
@@ -113,7 +113,7 @@ fn test_as_mut() {
 #[test]
 fn test_ptr_addition() {
     unsafe {
-        let xs = repeat(5i).take(16).collect::<Vec<_>>();
+        let xs = repeat(5).take(16).collect::<Vec<_>>();
         let mut ptr = xs.as_ptr();
         let end = ptr.offset(16);
 
@@ -131,7 +131,7 @@ fn test_ptr_addition() {
             m_ptr = m_ptr.offset(1);
         }
 
-        assert!(xs_mut == repeat(10i).take(16).collect::<Vec<_>>());
+        assert!(xs_mut == repeat(10).take(16).collect::<Vec<_>>());
     }
 }
 
diff --git a/src/libcoretest/result.rs b/src/libcoretest/result.rs
index d36228fa3d7..ab7b5101e72 100644
--- a/src/libcoretest/result.rs
+++ b/src/libcoretest/result.rs
@@ -13,11 +13,11 @@ pub fn op2() -> Result<int, &'static str> { Err("sadface") }
 
 #[test]
 pub fn test_and() {
-    assert_eq!(op1().and(Ok(667i)).unwrap(), 667);
+    assert_eq!(op1().and(Ok(667)).unwrap(), 667);
     assert_eq!(op1().and(Err::<i32, &'static str>("bad")).unwrap_err(),
                "bad");
 
-    assert_eq!(op2().and(Ok(667i)).unwrap_err(), "sadface");
+    assert_eq!(op2().and(Ok(667)).unwrap_err(), "sadface");
     assert_eq!(op2().and(Err::<i32,&'static str>("bad")).unwrap_err(),
                "sadface");
 }
@@ -68,20 +68,20 @@ pub fn test_impl_map_err() {
 /* FIXME(#20575)
 #[test]
 fn test_collect() {
-    let v: Result<Vec<int>, ()> = (0i..0).map(|_| Ok::<int, ()>(0)).collect();
+    let v: Result<Vec<int>, ()> = (0..0).map(|_| Ok::<int, ()>(0)).collect();
     assert!(v == Ok(vec![]));
 
-    let v: Result<Vec<int>, ()> = (0i..3).map(|x| Ok::<int, ()>(x)).collect();
+    let v: Result<Vec<int>, ()> = (0..3).map(|x| Ok::<int, ()>(x)).collect();
     assert!(v == Ok(vec![0, 1, 2]));
 
-    let v: Result<Vec<int>, int> = (0i..3).map(|x| {
+    let v: Result<Vec<int>, int> = (0..3).map(|x| {
         if x > 1 { Err(x) } else { Ok(x) }
     }).collect();
     assert!(v == Err(2));
 
     // test that it does not take more elements than it needs
     let mut functions: [Box<Fn() -> Result<(), int>>; 3] =
-        [box || Ok(()), box || Err(1i), box || panic!()];
+        [box || Ok(()), box || Err(1), box || panic!()];
 
     let v: Result<Vec<()>, int> = functions.iter_mut().map(|f| (*f)()).collect();
     assert!(v == Err(1));
@@ -101,7 +101,7 @@ pub fn test_fmt_default() {
 
 #[test]
 pub fn test_unwrap_or() {
-    let ok: Result<int, &'static str> = Ok(100i);
+    let ok: Result<int, &'static str> = Ok(100);
     let ok_err: Result<int, &'static str> = Err("Err");
 
     assert_eq!(ok.unwrap_or(50), 100);
@@ -112,7 +112,7 @@ pub fn test_unwrap_or() {
 pub fn test_unwrap_or_else() {
     fn handler(msg: &'static str) -> int {
         if msg == "I got this." {
-            50i
+            50
         } else {
             panic!("BadBad")
         }
@@ -130,7 +130,7 @@ pub fn test_unwrap_or_else() {
 pub fn test_unwrap_or_else_panic() {
     fn handler(msg: &'static str) -> int {
         if msg == "I got this." {
-            50i
+            50
         } else {
             panic!("BadBad")
         }
diff --git a/src/libcoretest/slice.rs b/src/libcoretest/slice.rs
index 6fae384763f..6d5cc38ef0a 100644
--- a/src/libcoretest/slice.rs
+++ b/src/libcoretest/slice.rs
@@ -12,25 +12,25 @@ use core::result::Result::{Ok, Err};
 
 #[test]
 fn binary_search_not_found() {
-    let b = [1i, 2, 4, 6, 8, 9];
+    let b = [1, 2, 4, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&6)) == Ok(3));
-    let b = [1i, 2, 4, 6, 8, 9];
+    let b = [1, 2, 4, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&5)) == Err(3));
-    let b = [1i, 2, 4, 6, 7, 8, 9];
+    let b = [1, 2, 4, 6, 7, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&6)) == Ok(3));
-    let b = [1i, 2, 4, 6, 7, 8, 9];
+    let b = [1, 2, 4, 6, 7, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&5)) == Err(3));
-    let b = [1i, 2, 4, 6, 8, 9];
+    let b = [1, 2, 4, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&8)) == Ok(4));
-    let b = [1i, 2, 4, 6, 8, 9];
+    let b = [1, 2, 4, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&7)) == Err(4));
-    let b = [1i, 2, 4, 6, 7, 8, 9];
+    let b = [1, 2, 4, 6, 7, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&8)) == Ok(5));
-    let b = [1i, 2, 4, 5, 6, 8, 9];
+    let b = [1, 2, 4, 5, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&7)) == Err(5));
-    let b = [1i, 2, 4, 5, 6, 8, 9];
+    let b = [1, 2, 4, 5, 6, 8, 9];
     assert!(b.binary_search_by(|v| v.cmp(&0)) == Err(0));
-    let b = [1i, 2, 4, 5, 6, 8];
+    let b = [1, 2, 4, 5, 6, 8];
     assert!(b.binary_search_by(|v| v.cmp(&9)) == Err(6));
 }
 
diff --git a/src/libcoretest/tuple.rs b/src/libcoretest/tuple.rs
index e524d8de056..57844f5995f 100644
--- a/src/libcoretest/tuple.rs
+++ b/src/libcoretest/tuple.rs
@@ -12,7 +12,7 @@ use std::cmp::Ordering::{Equal, Less, Greater};
 
 #[test]
 fn test_clone() {
-    let a = (1i, "2");
+    let a = (1, "2");
     let b = a.clone();
     assert_eq!(a, b);
 }
@@ -59,10 +59,10 @@ fn test_tuple_cmp() {
 
 #[test]
 fn test_show() {
-    let s = format!("{:?}", (1i,));
+    let s = format!("{:?}", (1,));
     assert_eq!(s, "(1,)");
-    let s = format!("{:?}", (1i, true));
+    let s = format!("{:?}", (1, true));
     assert_eq!(s, "(1, true)");
-    let s = format!("{:?}", (1i, "hi", true));
+    let s = format!("{:?}", (1, "hi", true));
     assert_eq!(s, "(1, \"hi\", true)");
 }