Remove all `i` suffixes

407 files changed, 1010 insertions, 1010 deletions

diff --git a/src/test/auxiliary/issue-11224.rs b/src/test/auxiliary/issue-11224.rs
index d66cfe9bf63..560844332a1 100644
--- a/src/test/auxiliary/issue-11224.rs
+++ b/src/test/auxiliary/issue-11224.rs
@@ -21,6 +21,6 @@ mod inner {
 }
 
 pub fn foo() {
-    let a = &1i as &inner::Trait;
+    let a = &1 as &inner::Trait;
     a.f();
 }
diff --git a/src/test/auxiliary/issue-8044.rs b/src/test/auxiliary/issue-8044.rs
index 7096146a43a..7bfd2e79641 100644
--- a/src/test/auxiliary/issue-8044.rs
+++ b/src/test/auxiliary/issue-8044.rs
@@ -21,5 +21,5 @@ pub fn leaf<V>(value: V) -> TreeItem<V> {
 }
 
 fn main() {
-    BTree::<int> { node: leaf(1i) };
+    BTree::<int> { node: leaf(1) };
 }
diff --git a/src/test/auxiliary/issue-9906.rs b/src/test/auxiliary/issue-9906.rs
index c0cb501735d..1e746bf39db 100644
--- a/src/test/auxiliary/issue-9906.rs
+++ b/src/test/auxiliary/issue-9906.rs
@@ -22,6 +22,6 @@ mod other {
     }
 
     pub fn foo(){
-        1i+1;
+        1+1;
     }
 }
diff --git a/src/test/auxiliary/macro_crate_test.rs b/src/test/auxiliary/macro_crate_test.rs
index e3e91e05f55..d545a42ae19 100644
--- a/src/test/auxiliary/macro_crate_test.rs
+++ b/src/test/auxiliary/macro_crate_test.rs
@@ -25,9 +25,9 @@ use syntax::ptr::P;
 use rustc::plugin::Registry;
 
 #[macro_export]
-macro_rules! exported_macro { () => (2i) }
+macro_rules! exported_macro { () => (2) }
 
-macro_rules! unexported_macro { () => (3i) }
+macro_rules! unexported_macro { () => (3) }
 
 #[plugin_registrar]
 pub fn plugin_registrar(reg: &mut Registry) {
@@ -47,7 +47,7 @@ fn expand_make_a_1(cx: &mut ExtCtxt, sp: Span, tts: &[TokenTree])
     if !tts.is_empty() {
         cx.span_fatal(sp, "make_a_1 takes no arguments");
     }
-    MacExpr::new(quote_expr!(cx, 1i))
+    MacExpr::new(quote_expr!(cx, 1))
 }
 
 // See Issue #15750
diff --git a/src/test/bench/core-std.rs b/src/test/bench/core-std.rs
index 6d12d84f652..388868eee70 100644
--- a/src/test/bench/core-std.rs
+++ b/src/test/bench/core-std.rs
@@ -62,7 +62,7 @@ fn maybe_run_test<F>(argv: &[String], name: String, test: F) where F: FnOnce() {
 }
 
 fn shift_push() {
-    let mut v1 = repeat(1i).take(30000).collect::<Vec<_>>();
+    let mut v1 = repeat(1).take(30000).collect::<Vec<_>>();
     let mut v2 = Vec::new();
 
     while v1.len() > 0 {
diff --git a/src/test/bench/shootout-meteor.rs b/src/test/bench/shootout-meteor.rs
index e6ef58cba35..11c471c40c5 100644
--- a/src/test/bench/shootout-meteor.rs
+++ b/src/test/bench/shootout-meteor.rs
@@ -150,16 +150,16 @@ fn mask(dy: int, dx: int, id: uint, p: &Vec<(int, int)>) -> Option<u64> {
 // (i/5, i%5).
 fn make_masks() -> Vec<Vec<Vec<u64> > > {
     let pieces = vec!(
-        vec!((0i,0i),(0,1),(0,2),(0,3),(1,3)),
-        vec!((0i,0i),(0,2),(0,3),(1,0),(1,1)),
-        vec!((0i,0i),(0,1),(0,2),(1,2),(2,1)),
-        vec!((0i,0i),(0,1),(0,2),(1,1),(2,1)),
-        vec!((0i,0i),(0,2),(1,0),(1,1),(2,1)),
-        vec!((0i,0i),(0,1),(0,2),(1,1),(1,2)),
-        vec!((0i,0i),(0,1),(1,1),(1,2),(2,1)),
-        vec!((0i,0i),(0,1),(0,2),(1,0),(1,2)),
-        vec!((0i,0i),(0,1),(0,2),(1,2),(1,3)),
-        vec!((0i,0i),(0,1),(0,2),(0,3),(1,2)));
+        vec!((0,0),(0,1),(0,2),(0,3),(1,3)),
+        vec!((0,0),(0,2),(0,3),(1,0),(1,1)),
+        vec!((0,0),(0,1),(0,2),(1,2),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,1),(2,1)),
+        vec!((0,0),(0,2),(1,0),(1,1),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,1),(1,2)),
+        vec!((0,0),(0,1),(1,1),(1,2),(2,1)),
+        vec!((0,0),(0,1),(0,2),(1,0),(1,2)),
+        vec!((0,0),(0,1),(0,2),(1,2),(1,3)),
+        vec!((0,0),(0,1),(0,2),(0,3),(1,2)));
 
     // To break the central symmetry of the problem, every
     // transformation must be taken except for one piece (piece 3
@@ -169,7 +169,7 @@ fn make_masks() -> Vec<Vec<Vec<u64> > > {
         .map(|(id, p)| transform(p, id != 3))
         .collect();
 
-    (0i..50).map(|yx| {
+    (0..50).map(|yx| {
         transforms.iter().enumerate().map(|(id, t)| {
             t.iter().filter_map(|p| mask(yx / 5, yx % 5, id, p)).collect()
         }).collect()
diff --git a/src/test/bench/shootout-pfib.rs b/src/test/bench/shootout-pfib.rs
index 2f68262b608..dd3ae1699a9 100644
--- a/src/test/bench/shootout-pfib.rs
+++ b/src/test/bench/shootout-pfib.rs
@@ -66,9 +66,9 @@ fn parse_opts(argv: Vec<String> ) -> Config {
 }
 
 fn stress_task(id: int) {
-    let mut i = 0i;
+    let mut i = 0;
     loop {
-        let n = 15i;
+        let n = 15;
         assert_eq!(fib(n), fib(n));
         i += 1;
         println!("{}: Completed {} iterations", id, i);
diff --git a/src/test/debuginfo/basic-types-metadata.rs b/src/test/debuginfo/basic-types-metadata.rs
index 5e2497043da..3b016f287fb 100644
--- a/src/test/debuginfo/basic-types-metadata.rs
+++ b/src/test/debuginfo/basic-types-metadata.rs
@@ -67,7 +67,7 @@ fn main() {
     let f32: f32 = 2.5;
     let f64: f64 = 3.5;
     _zzz(); // #break
-    if 1i == 1 { _yyy(); }
+    if 1 == 1 { _yyy(); }
 }
 
 fn _zzz() {()}
diff --git a/src/test/debuginfo/box.rs b/src/test/debuginfo/box.rs
index 0439e3dc34d..6db3dce4668 100644
--- a/src/test/debuginfo/box.rs
+++ b/src/test/debuginfo/box.rs
@@ -36,8 +36,8 @@
 #![omit_gdb_pretty_printer_section]
 
 fn main() {
-    let a = box 1i;
-    let b = box() (2i, 3.5f64);
+    let a = box 1;
+    let b = box() (2, 3.5f64);
 
     zzz(); // #break
 }
diff --git a/src/test/debuginfo/closure-in-generic-function.rs b/src/test/debuginfo/closure-in-generic-function.rs
index f8b12569400..59428a2c06f 100644
--- a/src/test/debuginfo/closure-in-generic-function.rs
+++ b/src/test/debuginfo/closure-in-generic-function.rs
@@ -60,8 +60,8 @@ fn some_generic_fun<T1, T2>(a: T1, b: T2) -> (T2, T1) {
 }
 
 fn main() {
-    some_generic_fun(0.5f64, 10i);
-    some_generic_fun(&29i, box 110i);
+    some_generic_fun(0.5f64, 10);
+    some_generic_fun(&29, box 110);
 }
 
 fn zzz() { () }
diff --git a/src/test/debuginfo/destructured-for-loop-variable.rs b/src/test/debuginfo/destructured-for-loop-variable.rs
index 38f8f859d39..08062ce8966 100644
--- a/src/test/debuginfo/destructured-for-loop-variable.rs
+++ b/src/test/debuginfo/destructured-for-loop-variable.rs
@@ -202,7 +202,7 @@ fn main() {
         zzz(); // #break
     }
 
-    for i in 1234..1235i {
+    for i in 1234..1235 {
         zzz(); // #break
     }
 
diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs
index 1fd598e18c1..22cc779aeca 100644
--- a/src/test/debuginfo/destructured-local.rs
+++ b/src/test/debuginfo/destructured-local.rs
@@ -278,7 +278,7 @@ fn main() {
     let Struct { a: k, b: l } = Struct { a: 12, b: 13 };
 
     // ignored tuple element
-    let (m, _, n) = (14i, 15i, 16i);
+    let (m, _, n) = (14, 15, 16);
 
     // ignored struct field
     let Struct { b: o, .. } = Struct { a: 17, b: 18 };
@@ -291,25 +291,25 @@ fn main() {
 
     // complex nesting
     let ((u, v), ((w, (x, Struct { a: y, b: z})), Struct { a: ae, b: oe }), ue) =
-        ((25i, 26i), ((27i, (28i, Struct { a: 29, b: 30})), Struct { a: 31, b: 32 }), 33i);
+        ((25, 26), ((27, (28, Struct { a: 29, b: 30})), Struct { a: 31, b: 32 }), 33);
 
     // reference
-    let &aa = &(34i, 35i);
+    let &aa = &(34, 35);
 
     // reference
-    let &bb = &(36i, 37i);
+    let &bb = &(36, 37);
 
     // contained reference
-    let (&cc, _) = (&38i, 39i);
+    let (&cc, _) = (&38, 39);
 
     // unique pointer
-    let box dd = box() (40i, 41i, 42i);
+    let box dd = box() (40, 41, 42);
 
     // ref binding
-    let ref ee = (43i, 44i, 45i);
+    let ref ee = (43, 44, 45);
 
     // ref binding in tuple
-    let (ref ff, gg) = (46i, (47i, 48i));
+    let (ref ff, gg) = (46, (47, 48));
 
     // ref binding in struct
     let Struct { b: ref hh, .. } = Struct { a: 49, b: 50 };
diff --git a/src/test/debuginfo/function-arg-initialization.rs b/src/test/debuginfo/function-arg-initialization.rs
index 38875c7656e..f9a2b2fef34 100644
--- a/src/test/debuginfo/function-arg-initialization.rs
+++ b/src/test/debuginfo/function-arg-initialization.rs
@@ -245,7 +245,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) {
 }
 
 fn binding(a: i64, b: u64, c: f64) {
-    let x = 0i; // #break
+    let x = 0; // #break
     ::std::old_io::print("")
 }
 
diff --git a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
index 4692318b98f..8d456f33432 100644
--- a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
+++ b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
@@ -270,7 +270,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) {
 
 #[no_stack_check]
 fn binding(a: i64, b: u64, c: f64) {
-    let x = 0i;
+    let x = 0;
     ::std::old_io::print("");
 }
 
diff --git a/src/test/debuginfo/function-prologue-stepping-regular.rs b/src/test/debuginfo/function-prologue-stepping-regular.rs
index 799352911f6..14433fbcd23 100644
--- a/src/test/debuginfo/function-prologue-stepping-regular.rs
+++ b/src/test/debuginfo/function-prologue-stepping-regular.rs
@@ -148,7 +148,7 @@ fn non_immediate_args(a: BigStruct, b: BigStruct) {
 }
 
 fn binding(a: i64, b: u64, c: f64) {
-    let x = 0i;
+    let x = 0;
 }
 
 fn assignment(mut a: u64, b: u64, c: f64) {
diff --git a/src/test/debuginfo/generic-function.rs b/src/test/debuginfo/generic-function.rs
index b2fdb708db5..b9a09867a00 100644
--- a/src/test/debuginfo/generic-function.rs
+++ b/src/test/debuginfo/generic-function.rs
@@ -86,9 +86,9 @@ fn dup_tup<T0: Clone, T1: Clone>(t0: &T0, t1: &T1) -> ((T0, T1), (T1, T0)) {
 
 fn main() {
 
-    let _ = dup_tup(&1i, &2.5f64);
+    let _ = dup_tup(&1, &2.5f64);
     let _ = dup_tup(&3.5f64, &4_u16);
-    let _ = dup_tup(&5i, &Struct { a: 6, b: 7.5 });
+    let _ = dup_tup(&5, &Struct { a: 6, b: 7.5 });
 }
 
 fn zzz() {()}
diff --git a/src/test/debuginfo/generic-functions-nested.rs b/src/test/debuginfo/generic-functions-nested.rs
index 0f3fd556f18..9f6d8a45a99 100644
--- a/src/test/debuginfo/generic-functions-nested.rs
+++ b/src/test/debuginfo/generic-functions-nested.rs
@@ -74,7 +74,7 @@
 #![omit_gdb_pretty_printer_section]
 
 fn outer<TA: Clone>(a: TA) {
-    inner(a.clone(), 1i);
+    inner(a.clone(), 1);
     inner(a.clone(), 2.5f64);
 
     fn inner<TX, TY>(x: TX, y: TY) {
@@ -83,7 +83,7 @@ fn outer<TA: Clone>(a: TA) {
 }
 
 fn main() {
-    outer(-1i);
+    outer(-1);
     outer(-2.5f64);
 }
 
diff --git a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
index bf755d379a6..61843a20d05 100644
--- a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
+++ b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
@@ -61,8 +61,8 @@ impl Enum {
 }
 
 fn main() {
-    Struct::static_method(1i, 2i);
-    Enum::static_method(-3i, 4.5f64, 5i);
+    Struct::static_method(1, 2);
+    Enum::static_method(-3, 4.5f64, 5);
 }
 
 fn zzz() {()}
diff --git a/src/test/debuginfo/generic-struct-style-enum.rs b/src/test/debuginfo/generic-struct-style-enum.rs
index 992e7417913..2faafbd7634 100644
--- a/src/test/debuginfo/generic-struct-style-enum.rs
+++ b/src/test/debuginfo/generic-struct-style-enum.rs
@@ -76,7 +76,7 @@ fn main() {
     // 0b01011001 = 89
     let case3: Regular<u16, i32, u64>  = Case3 { a: 0, b: 6438275382588823897 };
 
-    let univariant = TheOnlyCase { a: -1i };
+    let univariant = TheOnlyCase { a: -1 };
 
     zzz(); // #break
 }
diff --git a/src/test/debuginfo/generic-struct.rs b/src/test/debuginfo/generic-struct.rs
index a81230599fa..0eb65f2d80f 100644
--- a/src/test/debuginfo/generic-struct.rs
+++ b/src/test/debuginfo/generic-struct.rs
@@ -51,12 +51,12 @@ struct AGenericStruct<TKey, TValue> {
 
 fn main() {
 
-    let int_int = AGenericStruct { key: 0i, value: 1i };
-    let int_float = AGenericStruct { key: 2i, value: 3.5f64 };
-    let float_int = AGenericStruct { key: 4.5f64, value: 5i };
+    let int_int = AGenericStruct { key: 0, value: 1 };
+    let int_float = AGenericStruct { key: 2, value: 3.5f64 };
+    let float_int = AGenericStruct { key: 4.5f64, value: 5 };
     let float_int_float = AGenericStruct {
         key: 6.5f64,
-        value: AGenericStruct { key: 7i, value: 8.5f64 },
+        value: AGenericStruct { key: 7, value: 8.5f64 },
     };
 
     zzz(); // #break
diff --git a/src/test/debuginfo/lexical-scope-in-for-loop.rs b/src/test/debuginfo/lexical-scope-in-for-loop.rs
index 3309ae13c9d..1fa54e47163 100644
--- a/src/test/debuginfo/lexical-scope-in-for-loop.rs
+++ b/src/test/debuginfo/lexical-scope-in-for-loop.rs
@@ -90,15 +90,15 @@
 
 fn main() {
 
-    let range = [1i, 2, 3];
+    let range = [1, 2, 3];
 
-    let x = 1000000i; // wan meeeljen doollaars!
+    let x = 1000000; // wan meeeljen doollaars!
 
     for &x in range.iter() {
         zzz(); // #break
         sentinel();
 
-        let x = -1i * x;
+        let x = -1 * x;
 
         zzz(); // #break
         sentinel();
diff --git a/src/test/debuginfo/lexical-scope-in-if.rs b/src/test/debuginfo/lexical-scope-in-if.rs
index bc3a6945243..c885bfce216 100644
--- a/src/test/debuginfo/lexical-scope-in-if.rs
+++ b/src/test/debuginfo/lexical-scope-in-if.rs
@@ -138,8 +138,8 @@
 
 fn main() {
 
-    let x = 999i;
-    let y = -1i;
+    let x = 999;
+    let y = -1;
 
     zzz(); // #break
     sentinel();
@@ -148,13 +148,13 @@ fn main() {
         zzz(); // #break
         sentinel();
 
-        let x = 1001i;
+        let x = 1001;
 
         zzz(); // #break
         sentinel();
 
-        let x = 1002i;
-        let y = 1003i;
+        let x = 1002;
+        let y = 1003;
         zzz(); // #break
         sentinel();
     } else {
@@ -170,8 +170,8 @@ fn main() {
         zzz(); // #break
         sentinel();
 
-        let x = 1004i;
-        let y = 1005i;
+        let x = 1004;
+        let y = 1005;
         zzz(); // #break
         sentinel();
     }
diff --git a/src/test/debuginfo/lexical-scope-in-match.rs b/src/test/debuginfo/lexical-scope-in-match.rs
index 37976ab3996..c596253560e 100644
--- a/src/test/debuginfo/lexical-scope-in-match.rs
+++ b/src/test/debuginfo/lexical-scope-in-match.rs
@@ -135,13 +135,13 @@ struct Struct {
 
 fn main() {
 
-    let shadowed = 231i;
-    let not_shadowed = 232i;
+    let shadowed = 231;
+    let not_shadowed = 232;
 
     zzz(); // #break
     sentinel();
 
-    match (233i, 234i) {
+    match (233, 234) {
         (shadowed, local_to_arm) => {
 
             zzz(); // #break
@@ -149,7 +149,7 @@ fn main() {
         }
     }
 
-    match (235i, 236i) {
+    match (235, 236) {
         // with literal
         (235, shadowed) => {
 
@@ -186,7 +186,7 @@ fn main() {
         _ => {}
     }
 
-    match (243i, 244i) {
+    match (243, 244) {
         (shadowed, ref local_to_arm) => {
 
             zzz(); // #break
diff --git a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
index 107c5cb9782..5e04c81cefd 100644
--- a/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-parameterless-closure.rs
@@ -19,6 +19,6 @@
 // Nothing to do here really, just make sure it compiles. See issue #8513.
 fn main() {
     let _ = |&:|();
-    let _ = (1u..3).map(|_| 5i);
+    let _ = (1u..3).map(|_| 5);
 }
 
diff --git a/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs b/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs
index b295c6f37a7..6826bca695b 100644
--- a/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs
+++ b/src/test/debuginfo/lexical-scope-in-unconditional-loop.rs
@@ -136,7 +136,7 @@
 
 fn main() {
 
-    let mut x = 0i;
+    let mut x = 0;
 
     loop {
         if x >= 2 {
@@ -160,7 +160,7 @@ fn main() {
             zzz(); // #break
             sentinel();
 
-            let x = -987i;
+            let x = -987;
 
             zzz(); // #break
             sentinel();
diff --git a/src/test/debuginfo/lexical-scope-in-while.rs b/src/test/debuginfo/lexical-scope-in-while.rs
index c7a36ef9b82..40280b469f7 100644
--- a/src/test/debuginfo/lexical-scope-in-while.rs
+++ b/src/test/debuginfo/lexical-scope-in-while.rs
@@ -136,7 +136,7 @@
 
 fn main() {
 
-    let mut x = 0i;
+    let mut x = 0;
 
     while x < 2 {
         zzz(); // #break
@@ -156,7 +156,7 @@ fn main() {
             zzz(); // #break
             sentinel();
 
-            let x = -987i;
+            let x = -987;
 
             zzz(); // #break
             sentinel();
diff --git a/src/test/debuginfo/lexical-scope-with-macro.rs b/src/test/debuginfo/lexical-scope-with-macro.rs
index 2aa31969a46..da941979fb6 100644
--- a/src/test/debuginfo/lexical-scope-with-macro.rs
+++ b/src/test/debuginfo/lexical-scope-with-macro.rs
@@ -123,7 +123,7 @@ macro_rules! no_new_scope {
 
 macro_rules! new_scope {
     () => ({
-        let a = 890242i;
+        let a = 890242;
         zzz(); // #break
         sentinel();
     })
@@ -151,8 +151,8 @@ macro_rules! dup_expr {
 
 fn main() {
 
-    let a = trivial!(10i);
-    let b = no_new_scope!(33i);
+    let a = trivial!(10);
+    let b = no_new_scope!(33);
 
     zzz(); // #break
     sentinel();
@@ -162,12 +162,12 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    shadow_within_macro!(100i);
+    shadow_within_macro!(100);
 
     zzz(); // #break
     sentinel();
 
-    let c = dup_expr!(10i * 20);
+    let c = dup_expr!(10 * 20);
 
     zzz(); // #break
     sentinel();
diff --git a/src/test/debuginfo/lexical-scopes-in-block-expression.rs b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
index 2f8b11ac283..118d096d31b 100644
--- a/src/test/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
@@ -364,8 +364,8 @@ fn a_function(x: int) -> int {
 
 fn main() {
 
-    let val = -1i;
-    let ten = 10i;
+    let val = -1;
+    let ten = 10;
 
     // surrounded by struct expression
     let point = Point {
@@ -417,7 +417,7 @@ fn main() {
         sentinel();
 
         val
-    }, 0i);
+    }, 0);
 
     zzz(); // #break
     sentinel();
@@ -492,7 +492,7 @@ fn main() {
     sentinel();
 
     // index expression
-    let a_vector = [10i; 20];
+    let a_vector = [10; 20];
     let _ = a_vector[{
         zzz(); // #break
         sentinel();
diff --git a/src/test/debuginfo/limited-debuginfo.rs b/src/test/debuginfo/limited-debuginfo.rs
index e1aec83714d..c8fe76fdbe5 100644
--- a/src/test/debuginfo/limited-debuginfo.rs
+++ b/src/test/debuginfo/limited-debuginfo.rs
@@ -47,7 +47,7 @@ fn zzz() {()}
 
 fn some_function(a: int, b: int) {
     let some_variable = Struct { a: 11, b: 22 };
-    let some_other_variable = 23i;
+    let some_other_variable = 23;
 
     for x in 0..1 {
         zzz(); // #break
diff --git a/src/test/debuginfo/multiple-functions-equal-var-names.rs b/src/test/debuginfo/multiple-functions-equal-var-names.rs
index cb21c13426a..0b2f8ef8181 100644
--- a/src/test/debuginfo/multiple-functions-equal-var-names.rs
+++ b/src/test/debuginfo/multiple-functions-equal-var-names.rs
@@ -48,18 +48,18 @@
 #![omit_gdb_pretty_printer_section]
 
 fn function_one() {
-    let abc = 10101i;
+    let abc = 10101;
     zzz(); // #break
 }
 
 fn function_two() {
-    let abc = 20202i;
+    let abc = 20202;
     zzz(); // #break
 }
 
 
 fn function_three() {
-    let abc = 30303i;
+    let abc = 30303;
     zzz(); // #break
 }
 
diff --git a/src/test/debuginfo/multiple-functions.rs b/src/test/debuginfo/multiple-functions.rs
index ef7c4ce2045..00698ae1dfb 100644
--- a/src/test/debuginfo/multiple-functions.rs
+++ b/src/test/debuginfo/multiple-functions.rs
@@ -48,18 +48,18 @@
 #![omit_gdb_pretty_printer_section]
 
 fn function_one() {
-    let a = 10101i;
+    let a = 10101;
     zzz(); // #break
 }
 
 fn function_two() {
-    let b = 20202i;
+    let b = 20202;
     zzz(); // #break
 }
 
 
 fn function_three() {
-    let c = 30303i;
+    let c = 30303;
     zzz(); // #break
 }
 
diff --git a/src/test/debuginfo/name-shadowing-and-scope-nesting.rs b/src/test/debuginfo/name-shadowing-and-scope-nesting.rs
index d248c7e9819..8c1a5376dba 100644
--- a/src/test/debuginfo/name-shadowing-and-scope-nesting.rs
+++ b/src/test/debuginfo/name-shadowing-and-scope-nesting.rs
@@ -103,20 +103,20 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let x = 10i;
+    let x = 10;
 
     zzz(); // #break
     sentinel();
 
     let x = 10.5f64;
-    let y = 20i;
+    let y = 20;
 
     zzz(); // #break
     sentinel();
 
     {
         let x = true;
-        let y = 2220i;
+        let y = 2220;
 
         zzz(); // #break
         sentinel();
diff --git a/src/test/debuginfo/shadowed-argument.rs b/src/test/debuginfo/shadowed-argument.rs
index c5c3664b07a..5b36d32e49f 100644
--- a/src/test/debuginfo/shadowed-argument.rs
+++ b/src/test/debuginfo/shadowed-argument.rs
@@ -65,13 +65,13 @@ fn a_function(x: bool, y: bool) {
     zzz(); // #break
     sentinel();
 
-    let x = 10i;
+    let x = 10;
 
     zzz(); // #break
     sentinel();
 
     let x = 10.5f64;
-    let y = 20i;
+    let y = 20;
 
     zzz(); // #break
     sentinel();
diff --git a/src/test/debuginfo/shadowed-variable.rs b/src/test/debuginfo/shadowed-variable.rs
index f384b756da6..66fd656eaac 100644
--- a/src/test/debuginfo/shadowed-variable.rs
+++ b/src/test/debuginfo/shadowed-variable.rs
@@ -67,13 +67,13 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let x = 10i;
+    let x = 10;
 
     zzz(); // #break
     sentinel();
 
     let x = 10.5f64;
-    let y = 20i;
+    let y = 20;
 
     zzz(); // #break
     sentinel();
diff --git a/src/test/debuginfo/simple-lexical-scope.rs b/src/test/debuginfo/simple-lexical-scope.rs
index 5981c18494d..31441db20f1 100644
--- a/src/test/debuginfo/simple-lexical-scope.rs
+++ b/src/test/debuginfo/simple-lexical-scope.rs
@@ -91,7 +91,7 @@ fn main() {
         zzz(); // #break
         sentinel();
 
-        let x = 10i;
+        let x = 10;
 
         zzz(); // #break
         sentinel();
diff --git a/src/test/debuginfo/type-names.rs b/src/test/debuginfo/type-names.rs
index 156e5f12ad5..24b6df4e8f1 100644
--- a/src/test/debuginfo/type-names.rs
+++ b/src/test/debuginfo/type-names.rs
@@ -288,15 +288,15 @@ fn main() {
     let slice2 = vec2.as_slice();
 
     // Trait Objects
-    let box_trait = (box 0i) as Box<Trait1>;
-    let ref_trait = &0i as &Trait1;
-    let mut mut_int1 = 0i;
+    let box_trait = (box 0) as Box<Trait1>;
+    let ref_trait = &0 as &Trait1;
+    let mut mut_int1 = 0;
     let mut_ref_trait = (&mut mut_int1) as &mut Trait1;
 
-    let generic_box_trait = (box 0i) as Box<Trait2<i32, Mod1::Struct2>>;
-    let generic_ref_trait  = (&0i) as &Trait2<Struct1, Struct1>;
+    let generic_box_trait = (box 0) as Box<Trait2<i32, Mod1::Struct2>>;
+    let generic_ref_trait  = (&0) as &Trait2<Struct1, Struct1>;
 
-    let mut generic_mut_ref_trait_impl = 0i;
+    let mut generic_mut_ref_trait_impl = 0;
     let generic_mut_ref_trait = (&mut generic_mut_ref_trait_impl) as
         &mut Trait2<Mod1::Mod2::Struct3, GenericStruct<usize, isize>>;
 
diff --git a/src/test/debuginfo/vec.rs b/src/test/debuginfo/vec.rs
index 92a490206b6..9ee18c0d77b 100644
--- a/src/test/debuginfo/vec.rs
+++ b/src/test/debuginfo/vec.rs
@@ -34,7 +34,7 @@
 static mut VECT: [i32; 3] = [1, 2, 3];
 
 fn main() {
-    let a = [1i, 2, 3];
+    let a = [1, 2, 3];
 
     unsafe {
         VECT[0] = 4;
diff --git a/src/test/pretty/block-disambig.rs b/src/test/pretty/block-disambig.rs
index 1e286c236a5..c9cb72d8af7 100644
--- a/src/test/pretty/block-disambig.rs
+++ b/src/test/pretty/block-disambig.rs
@@ -15,9 +15,9 @@
 
 use std::cell::Cell;
 
-fn test1() { let val = &0i; { } *val; }
+fn test1() { let val = &0; { } *val; }
 
-fn test2() -> int { let val = &0i; { } *val }
+fn test2() -> int { let val = &0; { } *val }
 
 #[derive(Copy)]
 struct S { eax: int }
@@ -35,13 +35,13 @@ fn test5() -> (int, int) { { } (0, 1) }
 fn test6() -> bool { { } (true || false) && true }
 
 fn test7() -> uint {
-    let regs = &0i;
+    let regs = &0;
     match true { true => { } _ => { } }
     (*regs < 2) as uint
 }
 
 fn test8() -> int {
-    let val = &0i;
+    let val = &0;
     match true {
         true => { }
         _    => { }
@@ -54,12 +54,12 @@ fn test8() -> int {
 }
 
 fn test9() {
-    let regs = &Cell::new(0i);
+    let regs = &Cell::new(0);
     match true { true => { } _ => { } } regs.set(regs.get() + 1);
 }
 
 fn test10() -> int {
-    let regs = vec!(0i);
+    let regs = vec!(0);
     match true { true => { } _ => { } }
     regs[0]
 }
diff --git a/src/test/pretty/issue-929.rs b/src/test/pretty/issue-929.rs
index 377f4669ffc..75a6b919342 100644
--- a/src/test/pretty/issue-929.rs
+++ b/src/test/pretty/issue-929.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f() { if (1i == panic!()) { } else { } }
+fn f() { if (1 == panic!()) { } else { } }
 
 fn main() { }
diff --git a/src/test/pretty/match-block-expr.rs b/src/test/pretty/match-block-expr.rs
index 44771a29bb4..7751f155da4 100644
--- a/src/test/pretty/match-block-expr.rs
+++ b/src/test/pretty/match-block-expr.rs
@@ -11,6 +11,6 @@
 // pp-exact
 
 fn main() {
-    let x = match { 5i } { 1 => 5i, 2 => 6, _ => 7, };
+    let x = match { 5 } { 1 => 5, 2 => 6, _ => 7, };
     assert_eq!(x , 7);
 }
diff --git a/src/test/pretty/match-naked-expr-medium.rs b/src/test/pretty/match-naked-expr-medium.rs
index d2f8157ef62..39af19dbf6f 100644
--- a/src/test/pretty/match-naked-expr-medium.rs
+++ b/src/test/pretty/match-naked-expr-medium.rs
@@ -11,7 +11,7 @@
 // pp-exact
 
 fn main() {
-    let x = Some(3i);
+    let x = Some(3);
     let _y =
         match x {
             Some(_) =>
diff --git a/src/test/pretty/match-naked-expr.rs b/src/test/pretty/match-naked-expr.rs
index 6b4f579f9c5..02bbf667d96 100644
--- a/src/test/pretty/match-naked-expr.rs
+++ b/src/test/pretty/match-naked-expr.rs
@@ -11,7 +11,7 @@
 // pp-exact
 
 fn main() {
-    let x = Some(3i);
+    let x = Some(3);
     let _y =
         match x {
             Some(_) => "some(_)".to_string(),
diff --git a/src/test/pretty/path-type-bounds.rs b/src/test/pretty/path-type-bounds.rs
index 382394b1407..e27a3365a41 100644
--- a/src/test/pretty/path-type-bounds.rs
+++ b/src/test/pretty/path-type-bounds.rs
@@ -19,6 +19,6 @@ fn foo<'a>(x: Box<Tr+ Sync + 'a>) -> Box<Tr+ Sync + 'a> { x }
 fn main() {
     let x: Box<Tr+ Sync>;
 
-    Box::new(1i) as Box<Tr+ Sync>;
+    Box::new(1) as Box<Tr+ Sync>;
 }
 
diff --git a/src/test/pretty/unary-op-disambig.rs b/src/test/pretty/unary-op-disambig.rs
index 850904fe53e..1592e010aaf 100644
--- a/src/test/pretty/unary-op-disambig.rs
+++ b/src/test/pretty/unary-op-disambig.rs
@@ -18,10 +18,10 @@ fn block_nosemi() -> int { ({ 0 }) - 1 }
 
 fn if_semi() -> int { if true { f() } else { f() }; -1 }
 
-fn if_nosemi() -> int { (if true { 0i } else { 0i }) - 1 }
+fn if_nosemi() -> int { (if true { 0 } else { 0 }) - 1 }
 
 fn alt_semi() -> int { match true { true => { f() } _ => { } }; -1 }
 
 fn alt_no_semi() -> int { (match true { true => { 0 } _ => { 1 } }) - 1 }
 
-fn stmt() { { f() }; -1i; }
+fn stmt() { { f() }; -1; }
diff --git a/src/test/pretty/vec-comments.pp b/src/test/pretty/vec-comments.pp
index 401c63efbc4..dc2dae1044d 100644
--- a/src/test/pretty/vec-comments.pp
+++ b/src/test/pretty/vec-comments.pp
@@ -15,25 +15,25 @@ fn main() {
     let _v1 =
         [
          // Comment
-         0i,
+         0,
          // Comment
-         1i,
+         1,
          // Comment
-         2i];
+         2];
     let _v2 =
-        [0i, // Comment
-         1i, // Comment
-         2i]; // Comment
+        [0, // Comment
+         1, // Comment
+         2]; // Comment
     let _v3 =
         [
          /* Comment */
-         0i,
+         0,
          /* Comment */
-         1i,
+         1,
          /* Comment */
-         2i];
+         2];
     let _v4 =
-        [0i, /* Comment */
-         1i, /* Comment */
-         2i]; /* Comment */
+        [0, /* Comment */
+         1, /* Comment */
+         2]; /* Comment */
 }
diff --git a/src/test/pretty/vec-comments.rs b/src/test/pretty/vec-comments.rs
index 401c63efbc4..dc2dae1044d 100644
--- a/src/test/pretty/vec-comments.rs
+++ b/src/test/pretty/vec-comments.rs
@@ -15,25 +15,25 @@ fn main() {
     let _v1 =
         [
          // Comment
-         0i,
+         0,
          // Comment
-         1i,
+         1,
          // Comment
-         2i];
+         2];
     let _v2 =
-        [0i, // Comment
-         1i, // Comment
-         2i]; // Comment
+        [0, // Comment
+         1, // Comment
+         2]; // Comment
     let _v3 =
         [
          /* Comment */
-         0i,
+         0,
          /* Comment */
-         1i,
+         1,
          /* Comment */
-         2i];
+         2];
     let _v4 =
-        [0i, /* Comment */
-         1i, /* Comment */
-         2i]; /* Comment */
+        [0, /* Comment */
+         1, /* Comment */
+         2]; /* Comment */
 }
diff --git a/src/test/run-fail/assert-eq-macro-panic.rs b/src/test/run-fail/assert-eq-macro-panic.rs
index 69ed025070b..fd6d69efb4f 100644
--- a/src/test/run-fail/assert-eq-macro-panic.rs
+++ b/src/test/run-fail/assert-eq-macro-panic.rs
@@ -11,5 +11,5 @@
 // error-pattern:assertion failed: `(left == right) && (right == left)` (left: `14`, right: `15`)
 
 fn main() {
-    assert_eq!(14i,15i);
+    assert_eq!(14,15);
 }
diff --git a/src/test/run-fail/assert-macro-fmt.rs b/src/test/run-fail/assert-macro-fmt.rs
index 223c60d6ae4..78239a2217e 100644
--- a/src/test/run-fail/assert-macro-fmt.rs
+++ b/src/test/run-fail/assert-macro-fmt.rs
@@ -11,5 +11,5 @@
 // error-pattern:panicked at 'test-assert-fmt 42 rust'
 
 fn main() {
-    assert!(false, "test-assert-fmt {} {}", 42i, "rust");
+    assert!(false, "test-assert-fmt {} {}", 42, "rust");
 }
diff --git a/src/test/run-fail/bounds-check-no-overflow.rs b/src/test/run-fail/bounds-check-no-overflow.rs
index df9050e2186..be4ad0781f2 100644
--- a/src/test/run-fail/bounds-check-no-overflow.rs
+++ b/src/test/run-fail/bounds-check-no-overflow.rs
@@ -14,6 +14,6 @@ use std::uint;
 use std::mem::size_of;
 
 fn main() {
-    let xs = [1i, 2, 3];
+    let xs = [1, 2, 3];
     xs[uint::MAX / size_of::<int>() + 1];
 }
diff --git a/src/test/run-fail/divide-by-zero.rs b/src/test/run-fail/divide-by-zero.rs
index c58d30f2729..de69b7b9fa6 100644
--- a/src/test/run-fail/divide-by-zero.rs
+++ b/src/test/run-fail/divide-by-zero.rs
@@ -10,6 +10,6 @@
 
 // error-pattern:attempted to divide by zero
 fn main() {
-    let y = 0i;
-    let _z = 1i / y;
+    let y = 0;
+    let _z = 1 / y;
 }
diff --git a/src/test/run-fail/dst-raw-slice.rs b/src/test/run-fail/dst-raw-slice.rs
index 39bf899a023..77cec8b6327 100644
--- a/src/test/run-fail/dst-raw-slice.rs
+++ b/src/test/run-fail/dst-raw-slice.rs
@@ -12,7 +12,7 @@
 // error-pattern:index out of bounds
 
 fn main() {
-    let a: *const [_] = &[1i, 2, 3];
+    let a: *const [_] = &[1, 2, 3];
     unsafe {
         let _b = (*a)[3];
     }
diff --git a/src/test/run-fail/explicit-panic-msg.rs b/src/test/run-fail/explicit-panic-msg.rs
index ae6e72bdd4f..c9c04e5f2da 100644
--- a/src/test/run-fail/explicit-panic-msg.rs
+++ b/src/test/run-fail/explicit-panic-msg.rs
@@ -13,7 +13,7 @@
 
 // error-pattern:wooooo
 fn main() {
-    let mut a = 1i;
-    if 1i == 1 { a = 2; }
+    let mut a = 1;
+    if 1 == 1 { a = 2; }
     panic!(format!("woooo{}", "o"));
 }
diff --git a/src/test/run-fail/expr-if-panic.rs b/src/test/run-fail/expr-if-panic.rs
index f04c94a3bf4..b6791271a11 100644
--- a/src/test/run-fail/expr-if-panic.rs
+++ b/src/test/run-fail/expr-if-panic.rs
@@ -10,4 +10,4 @@
 
 // error-pattern:explicit panic
 
-fn main() { let _x = if false { 0i } else if true { panic!() } else { 10i }; }
+fn main() { let _x = if false { 0 } else if true { panic!() } else { 10 }; }
diff --git a/src/test/run-fail/expr-match-panic.rs b/src/test/run-fail/expr-match-panic.rs
index d5c005b7029..3a6bd59b3ac 100644
--- a/src/test/run-fail/expr-match-panic.rs
+++ b/src/test/run-fail/expr-match-panic.rs
@@ -10,4 +10,4 @@
 
 // error-pattern:explicit panic
 
-fn main() { let _x = match true { false => { 0i } true => { panic!() } }; }
+fn main() { let _x = match true { false => { 0 } true => { panic!() } }; }
diff --git a/src/test/run-fail/issue-12920.rs b/src/test/run-fail/issue-12920.rs
index 8dbfc06152a..cbc92c640d2 100644
--- a/src/test/run-fail/issue-12920.rs
+++ b/src/test/run-fail/issue-12920.rs
@@ -11,5 +11,5 @@
 // error-pattern:explicit panic
 
 pub fn main() {
-    panic!(); println!("{}", 1i);
+    panic!(); println!("{}", 1);
 }
diff --git a/src/test/run-fail/issue-3029.rs b/src/test/run-fail/issue-3029.rs
index 0846ba2e71a..4d048fe0fcf 100644
--- a/src/test/run-fail/issue-3029.rs
+++ b/src/test/run-fail/issue-3029.rs
@@ -16,7 +16,7 @@
 // error-pattern:so long
 fn main() {
     let mut x = Vec::new();
-    let y = vec!(3i);
+    let y = vec!(3);
     panic!("so long");
     x.extend(y.into_iter());
 }
diff --git a/src/test/run-fail/mod-zero.rs b/src/test/run-fail/mod-zero.rs
index 54415051708..76d4de7ecb0 100644
--- a/src/test/run-fail/mod-zero.rs
+++ b/src/test/run-fail/mod-zero.rs
@@ -10,6 +10,6 @@
 
 // error-pattern:attempted remainder with a divisor of zero
 fn main() {
-    let y = 0i;
-    let _z = 1i % y;
+    let y = 0;
+    let _z = 1 % y;
 }
diff --git a/src/test/run-fail/panic-macro-any.rs b/src/test/run-fail/panic-macro-any.rs
index 231c57390b3..ce6a5d46cc7 100644
--- a/src/test/run-fail/panic-macro-any.rs
+++ b/src/test/run-fail/panic-macro-any.rs
@@ -14,5 +14,5 @@
 #![feature(box_syntax)]
 
 fn main() {
-    panic!(box 413i as Box<::std::any::Any+Send>);
+    panic!(box 413 as Box<::std::any::Any+Send>);
 }
diff --git a/src/test/run-fail/panic-macro-fmt.rs b/src/test/run-fail/panic-macro-fmt.rs
index ac50f02cf33..50ad99c6747 100644
--- a/src/test/run-fail/panic-macro-fmt.rs
+++ b/src/test/run-fail/panic-macro-fmt.rs
@@ -11,5 +11,5 @@
 // error-pattern:panicked at 'test-fail-fmt 42 rust'
 
 fn main() {
-    panic!("test-fail-fmt {} {}", 42i, "rust");
+    panic!("test-fail-fmt {} {}", 42, "rust");
 }
diff --git a/src/test/run-fail/panic-task-name-none.rs b/src/test/run-fail/panic-task-name-none.rs
index 9beee3b1843..816ee84a841 100644
--- a/src/test/run-fail/panic-task-name-none.rs
+++ b/src/test/run-fail/panic-task-name-none.rs
@@ -15,7 +15,7 @@ use std::thread::Thread;
 fn main() {
     let r: Result<int,_> = Thread::scoped(move|| {
         panic!("test");
-        1i
+        1
     }).join();
     assert!(r.is_ok());
 }
diff --git a/src/test/run-fail/panic-task-name-owned.rs b/src/test/run-fail/panic-task-name-owned.rs
index 714cec6fb3d..d48d282c9eb 100644
--- a/src/test/run-fail/panic-task-name-owned.rs
+++ b/src/test/run-fail/panic-task-name-owned.rs
@@ -15,7 +15,7 @@ use std::thread::Builder;
 fn main() {
     let r: Result<int,_> = Builder::new().name("owned name".to_string()).scoped(move|| {
         panic!("test");
-        1i
+        1
     }).join();
     assert!(r.is_ok());
 }
diff --git a/src/test/run-fail/unwind-interleaved.rs b/src/test/run-fail/unwind-interleaved.rs
index 5012ded28b5..91a33329a4f 100644
--- a/src/test/run-fail/unwind-interleaved.rs
+++ b/src/test/run-fail/unwind-interleaved.rs
@@ -15,8 +15,8 @@ fn a() { }
 fn b() { panic!(); }
 
 fn main() {
-    let _x = vec!(0i);
+    let _x = vec!(0);
     a();
-    let _y = vec!(0i);
+    let _y = vec!(0);
     b();
 }
diff --git a/src/test/run-fail/unwind-unique.rs b/src/test/run-fail/unwind-unique.rs
index f39ded8f98e..e1176b1bcdb 100644
--- a/src/test/run-fail/unwind-unique.rs
+++ b/src/test/run-fail/unwind-unique.rs
@@ -18,6 +18,6 @@ fn failfn() {
 }
 
 fn main() {
-    box 0i;
+    box 0;
     failfn();
 }
diff --git a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
index f9dffdf8928..f7c581172e2 100644
--- a/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
+++ b/src/test/run-make/cannot-read-embedded-idents/create_and_compile.rs
@@ -23,7 +23,7 @@ fn main() {
     let main_file = tmpdir.join("broken.rs");
     let _ = File::create(&main_file).unwrap()
         .write_str("pub fn main() {
-                   let \x00name_0,ctxt_0\x00 = 3i;
+                   let \x00name_0,ctxt_0\x00 = 3;
                    println!(\"{}\", \x00name_0,ctxt_0\x00);
         }");
 
diff --git a/src/test/run-make/static-unwinding/main.rs b/src/test/run-make/static-unwinding/main.rs
index bd88cb19aa7..6d10a247143 100644
--- a/src/test/run-make/static-unwinding/main.rs
+++ b/src/test/run-make/static-unwinding/main.rs
@@ -25,7 +25,7 @@ fn main() {
     Thread::scoped(move|| {
         let _a = A;
         lib::callback(|| panic!());
-        1i
+        1
     }).join().err().unwrap();
 
     unsafe {
diff --git a/src/test/run-pass-fulldeps/issue-16992.rs b/src/test/run-pass-fulldeps/issue-16992.rs
index 563b8394963..9e3ad8ee283 100644
--- a/src/test/run-pass-fulldeps/issue-16992.rs
+++ b/src/test/run-pass-fulldeps/issue-16992.rs
@@ -19,8 +19,8 @@ use syntax::ext::base::ExtCtxt;
 
 #[allow(dead_code)]
 fn foobar(cx: &mut ExtCtxt) {
-    quote_expr!(cx, 1i);
-    quote_expr!(cx, 2i);
+    quote_expr!(cx, 1);
+    quote_expr!(cx, 2);
 }
 
 fn main() { }
diff --git a/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs b/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs
index a8762234ad9..497afae6189 100644
--- a/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs
+++ b/src/test/run-pass-fulldeps/macro-crate-does-hygiene-work.rs
@@ -20,9 +20,9 @@
 extern crate macro_crate_test;
 
 fn main() {
-    let x = 3i;
+    let x = 3;
     assert_eq!(3, identity!(x));
     assert_eq!(6, identity!(x+x));
-    let x = 4i;
+    let x = 4;
     assert_eq!(4, identity!(x));
 }
diff --git a/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs b/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs
index 2d5bbd43e82..848ea738ed7 100644
--- a/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs
+++ b/src/test/run-pass-fulldeps/quote-unused-sp-no-warning.rs
@@ -19,7 +19,7 @@ extern crate syntax;
 use syntax::ext::base::ExtCtxt;
 
 fn test(cx: &mut ExtCtxt) {
-    let foo = 10i;
+    let foo = 10;
     let _e = quote_expr!(cx, $foo);
 }
 
diff --git a/src/test/run-pass/assert-eq-macro-success.rs b/src/test/run-pass/assert-eq-macro-success.rs
index 8771ed7a742..e55a2d39cbf 100644
--- a/src/test/run-pass/assert-eq-macro-success.rs
+++ b/src/test/run-pass/assert-eq-macro-success.rs
@@ -15,7 +15,7 @@
 struct Point { x : int }
 
 pub fn main() {
-    assert_eq!(14i,14i);
+    assert_eq!(14,14);
     assert_eq!("abc".to_string(),"abc".to_string());
     assert_eq!(box Point{x:34},box Point{x:34});
     assert_eq!(&Point{x:34},&Point{x:34});
diff --git a/src/test/run-pass/associated-types-binding-in-where-clause.rs b/src/test/run-pass/associated-types-binding-in-where-clause.rs
index caf7d31a5fd..2f9a0b328b5 100644
--- a/src/test/run-pass/associated-types-binding-in-where-clause.rs
+++ b/src/test/run-pass/associated-types-binding-in-where-clause.rs
@@ -37,7 +37,7 @@ fn foo_uint<I: Foo<A=uint>>(x: I) -> uint {
 }
 
 pub fn main() {
-    let a = 42i;
+    let a = 42;
     foo_uint(a);
 
     let a = 'a';
diff --git a/src/test/run-pass/associated-types-bound.rs b/src/test/run-pass/associated-types-bound.rs
index c34a19e1d82..9f97d69ce3f 100644
--- a/src/test/run-pass/associated-types-bound.rs
+++ b/src/test/run-pass/associated-types-bound.rs
@@ -8,44 +8,44 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Test equality constraints on associated types in a where clause.
+// Test equality constrai32s on associated types in a where clause.
 
-pub trait ToInt {
-    fn to_int(&self) -> int;
+pub trait ToI32 {
+    fn to_i32(&self) -> i32;
 }
 
-impl ToInt for int {
-    fn to_int(&self) -> int { *self }
+impl ToI32 for i32 {
+    fn to_i32(&self) -> i32 { *self }
 }
 
-impl ToInt for uint {
-    fn to_int(&self) -> int { *self as int }
+impl ToI32 for u32 {
+    fn to_i32(&self) -> i32 { *self as i32 }
 }
 
-pub trait GetToInt
+pub trait GetToI32
 {
-    type R : ToInt;
+    type R : ToI32;
 
-    fn get(&self) -> <Self as GetToInt>::R;
+    fn get(&self) -> <Self as GetToI32>::R;
 }
 
-impl GetToInt for int {
-    type R = int;
-    fn get(&self) -> int { *self }
+impl GetToI32 for i32 {
+    type R = i32;
+    fn get(&self) -> i32 { *self }
 }
 
-impl GetToInt for uint {
-    type R = uint;
-    fn get(&self) -> uint { *self }
+impl GetToI32 for u32 {
+    type R = u32;
+    fn get(&self) -> u32 { *self }
 }
 
-fn foo<G>(g: G) -> int
-    where G : GetToInt
+fn foo<G>(g: G) -> i32
+    where G : GetToI32
 {
-    ToInt::to_int(&g.get())
+    ToI32::to_i32(&g.get())
 }
 
 pub fn main() {
-    assert_eq!(foo(22i), 22i);
-    assert_eq!(foo(22u), 22i);
+    assert_eq!(foo(22i32), 22);
+    assert_eq!(foo(22u32), 22);
 }
diff --git a/src/test/run-pass/associated-types-cc.rs b/src/test/run-pass/associated-types-cc.rs
index 58aa351ba9c..948192f4fc0 100644
--- a/src/test/run-pass/associated-types-cc.rs
+++ b/src/test/run-pass/associated-types-cc.rs
@@ -22,5 +22,5 @@ fn foo<B:Bar>(b: B) -> <B as Bar>::T {
 }
 
 fn main() {
-    println!("{}", foo(3i));
+    println!("{}", foo(3));
 }
diff --git a/src/test/run-pass/associated-types-nested-projections.rs b/src/test/run-pass/associated-types-nested-projections.rs
index a907b9fcde5..e3227613159 100644
--- a/src/test/run-pass/associated-types-nested-projections.rs
+++ b/src/test/run-pass/associated-types-nested-projections.rs
@@ -45,6 +45,6 @@ fn bar<T, I, X>(x: X) where
 }
 
 fn main() {
-    foo(&[0i, 1, 2]);
-    bar(&[0i, 1, 2]);
+    foo(&[0, 1, 2]);
+    bar(&[0, 1, 2]);
 }
diff --git a/src/test/run-pass/associated-types-ref-in-struct-literal.rs b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
index b51d44a0c24..022c8f4cd01 100644
--- a/src/test/run-pass/associated-types-ref-in-struct-literal.rs
+++ b/src/test/run-pass/associated-types-ref-in-struct-literal.rs
@@ -24,6 +24,6 @@ struct Thing<F: Foo> {
 }
 
 fn main() {
-    let thing = Thing{a: 1i, b: 2i};
+    let thing = Thing{a: 1, b: 2};
     assert_eq!(thing.a + 1, thing.b);
 }
diff --git a/src/test/run-pass/associated-types-return.rs b/src/test/run-pass/associated-types-return.rs
index b9b6d14f8a0..72290921854 100644
--- a/src/test/run-pass/associated-types-return.rs
+++ b/src/test/run-pass/associated-types-return.rs
@@ -42,11 +42,11 @@ fn foo2<I: Foo>(x: I) -> <I as Foo>::A {
 }
 
 pub fn main() {
-    let a = 42i;
+    let a = 42;
     assert!(foo2(a) == 42u);
 
     let a = Bar;
-    assert!(foo2(a) == 43i);
+    assert!(foo2(a) == 43);
 
     let a = 'a';
     foo1(a);
diff --git a/src/test/run-pass/associated-types-sugar-path.rs b/src/test/run-pass/associated-types-sugar-path.rs
index 880554b61b2..ea1df6658fd 100644
--- a/src/test/run-pass/associated-types-sugar-path.rs
+++ b/src/test/run-pass/associated-types-sugar-path.rs
@@ -40,5 +40,5 @@ impl<T: Foo> C for B<T> {
 }
 
 pub fn main() {
-    let z: uint = bar(2i, 4u);
+    let z: uint = bar(2, 4u);
 }
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index 0e2f6ef056e..cd4c66cb321 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -15,6 +15,6 @@ struct Triple { x: int, y: int, z: int }
 fn f<T,U>(x: T, y: U) -> Pair<T, U> { return Pair {a: x, b: y}; }
 
 pub fn main() {
-    println!("{}", f(Triple {x: 3, y: 4, z: 5}, 4i).a.x);
-    println!("{}", f(5i, 6i).a);
+    println!("{}", f(Triple {x: 3, y: 4, z: 5}, 4).a.x);
+    println!("{}", f(5, 6).a);
 }
diff --git a/src/test/run-pass/auto-loop.rs b/src/test/run-pass/auto-loop.rs
index 88884dfeb50..e5f4d078749 100644
--- a/src/test/run-pass/auto-loop.rs
+++ b/src/test/run-pass/auto-loop.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut sum = 0i;
+    let mut sum = 0;
     let xs = vec!(1, 2, 3, 4, 5);
     for x in xs.iter() {
         sum += *x;
diff --git a/src/test/run-pass/auto-ref-sliceable.rs b/src/test/run-pass/auto-ref-sliceable.rs
index fd3ede07e21..652f21c2ae3 100644
--- a/src/test/run-pass/auto-ref-sliceable.rs
+++ b/src/test/run-pass/auto-ref-sliceable.rs
@@ -20,7 +20,7 @@ impl<T> Pushable<T> for Vec<T> {
 }
 
 pub fn main() {
-    let mut v = vec!(1i);
+    let mut v = vec!(1);
     v.push_val(2);
     v.push_val(3);
     assert_eq!(v, vec!(1, 2, 3));
diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs
index af1cc3b1f4d..e9a3ab6be35 100644
--- a/src/test/run-pass/backtrace.rs
+++ b/src/test/run-pass/backtrace.rs
@@ -21,7 +21,7 @@ use std::ops::{Drop, FnMut, FnOnce};
 
 #[inline(never)]
 fn foo() {
-    let _v = vec![1i, 2, 3];
+    let _v = vec![1, 2, 3];
     if os::getenv("IS_TEST").is_some() {
         panic!()
     }
@@ -77,7 +77,7 @@ fn runtest(me: &str) {
     assert!(!out.status.success());
     let s = str::from_utf8(out.error.as_slice()).unwrap();
     let mut i = 0;
-    for _ in 0i..2 {
+    for _ in 0..2 {
         i += s[i + 10..].find_str("stack backtrace").unwrap() + 10;
     }
     assert!(s[i + 10..].find_str("stack backtrace").is_none(),
diff --git a/src/test/run-pass/binary-minus-without-space.rs b/src/test/run-pass/binary-minus-without-space.rs
index 8235b91273b..dc3b142f233 100644
--- a/src/test/run-pass/binary-minus-without-space.rs
+++ b/src/test/run-pass/binary-minus-without-space.rs
@@ -11,6 +11,6 @@
 // Check that issue #954 stays fixed
 
 pub fn main() {
-    match -1i { -1 => {}, _ => panic!("wat") }
-    assert_eq!(1i-1, 0i);
+    match -1 { -1 => {}, _ => panic!("wat") }
+    assert_eq!(1-1, 0);
 }
diff --git a/src/test/run-pass/bitv-perf-test.rs b/src/test/run-pass/bitv-perf-test.rs
index 167d0ace159..b6d428924e3 100644
--- a/src/test/run-pass/bitv-perf-test.rs
+++ b/src/test/run-pass/bitv-perf-test.rs
@@ -22,5 +22,5 @@ fn bitv_test() {
 }
 
 pub fn main() {
-    for _ in 0i..10000 { bitv_test(); }
+    for _ in 0..10000 { bitv_test(); }
 }
diff --git a/src/test/run-pass/bitwise.rs b/src/test/run-pass/bitwise.rs
index 251804e214b..8a57279e866 100644
--- a/src/test/run-pass/bitwise.rs
+++ b/src/test/run-pass/bitwise.rs
@@ -33,7 +33,7 @@ fn general() {
     assert_eq!(0xf0i | 0xf, 0xff);
     assert_eq!(0xfi << 4, 0xf0);
     assert_eq!(0xf0i >> 4, 0xf);
-    assert_eq!(-16i >> 2, -4);
+    assert_eq!(-16 >> 2, -4);
     assert_eq!(0b1010_1010i | 0b0101_0101, 0xff);
 }
 
diff --git a/src/test/run-pass/block-expr-precedence.rs b/src/test/run-pass/block-expr-precedence.rs
index 31d0d52f8b4..ace372dd2d3 100644
--- a/src/test/run-pass/block-expr-precedence.rs
+++ b/src/test/run-pass/block-expr-precedence.rs
@@ -58,9 +58,9 @@ pub fn main() {
 
   let num = 12;
 
-  assert_eq!(if (true) { 12i } else { 12 } - num, 0);
-  assert_eq!(12i - if (true) { 12i } else { 12 }, 0);
-  if (true) { 12i; } {-num};
-  if (true) { 12i; }; {-num};
-  if (true) { 12i; };;; -num;
+  assert_eq!(if (true) { 12 } else { 12 } - num, 0);
+  assert_eq!(12 - if (true) { 12 } else { 12 }, 0);
+  if (true) { 12; } {-num};
+  if (true) { 12; }; {-num};
+  if (true) { 12; };;; -num;
 }
diff --git a/src/test/run-pass/block-iter-1.rs b/src/test/run-pass/block-iter-1.rs
index 972bde5f29a..b5bd4d90c2e 100644
--- a/src/test/run-pass/block-iter-1.rs
+++ b/src/test/run-pass/block-iter-1.rs
@@ -11,8 +11,8 @@
 fn iter_vec<T, F>(v: Vec<T> , mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } }
 
 pub fn main() {
-    let v = vec!(1i, 2, 3, 4, 5, 6, 7);
-    let mut odds = 0i;
+    let v = vec![1i32, 2, 3, 4, 5, 6, 7];
+    let mut odds = 0i32;
     iter_vec(v, |i| {
         if *i % 2 == 1 {
             odds += 1;
diff --git a/src/test/run-pass/block-iter-2.rs b/src/test/run-pass/block-iter-2.rs
index 1032fb486a1..348d9df6e7e 100644
--- a/src/test/run-pass/block-iter-2.rs
+++ b/src/test/run-pass/block-iter-2.rs
@@ -11,7 +11,7 @@
 fn iter_vec<T, F>(v: Vec<T>, mut f: F) where F: FnMut(&T) { for x in v.iter() { f(x); } }
 
 pub fn main() {
-    let v = vec!(1i, 2, 3, 4, 5);
+    let v = vec![1i32, 2, 3, 4, 5];
     let mut sum = 0;
     iter_vec(v.clone(), |i| {
         iter_vec(v.clone(), |j| {
diff --git a/src/test/run-pass/borrow-tuple-fields.rs b/src/test/run-pass/borrow-tuple-fields.rs
index a151a837f77..2e5688d8b74 100644
--- a/src/test/run-pass/borrow-tuple-fields.rs
+++ b/src/test/run-pass/borrow-tuple-fields.rs
@@ -11,13 +11,13 @@
 struct Foo(int, int);
 
 fn main() {
-    let x = (1i, 2i);
+    let x = (1, 2);
     let a = &x.0;
     let b = &x.0;
     assert_eq!(*a, 1);
     assert_eq!(*b, 1);
 
-    let mut x = (1i, 2i);
+    let mut x = (1, 2);
     {
         let a = &x.0;
         let b = &mut x.1;
@@ -28,13 +28,13 @@ fn main() {
     assert_eq!(x.1, 5);
 
 
-    let x = Foo(1i, 2i);
+    let x = Foo(1, 2);
     let a = &x.0;
     let b = &x.0;
     assert_eq!(*a, 1);
     assert_eq!(*b, 1);
 
-    let mut x = Foo(1i, 2i);
+    let mut x = Foo(1, 2);
     {
         let a = &x.0;
         let b = &mut x.1;
diff --git a/src/test/run-pass/borrowck-closures-two-imm.rs b/src/test/run-pass/borrowck-closures-two-imm.rs
index 33e4294366f..df8dbdd03c7 100644
--- a/src/test/run-pass/borrowck-closures-two-imm.rs
+++ b/src/test/run-pass/borrowck-closures-two-imm.rs
@@ -14,28 +14,28 @@
 // that the main function can read the variable too while
 // the closures are in scope. Issue #6801.
 
-fn a() -> int {
-    let mut x = 3i;
+fn a() -> i32 {
+    let mut x = 3i32;
     x += 1;
     let c1 = |&:| x * 4;
     let c2 = |&:| x * 5;
     c1() * c2() * x
 }
 
-fn get(x: &int) -> int {
+fn get(x: &i32) -> i32 {
     *x * 4
 }
 
-fn b() -> int {
-    let mut x = 3;
+fn b() -> i32 {
+    let mut x = 3i32;
     x += 1;
     let c1 = |&:| get(&x);
     let c2 = |&:| get(&x);
     c1() * c2() * x
 }
 
-fn c() -> int {
-    let mut x = 3;
+fn c() -> i32 {
+    let mut x = 3i32;
     x += 1;
     let c1 = |&:| x * 5;
     let c2 = |&:| get(&x);
diff --git a/src/test/run-pass/borrowck-fixed-length-vecs.rs b/src/test/run-pass/borrowck-fixed-length-vecs.rs
index 71c8936570a..ee561fdb0be 100644
--- a/src/test/run-pass/borrowck-fixed-length-vecs.rs
+++ b/src/test/run-pass/borrowck-fixed-length-vecs.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [22i];
+    let x = [22];
     let y = &x[0];
     assert_eq!(*y, 22);
 }
diff --git a/src/test/run-pass/borrowck-freeze-frozen-mut.rs b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
index 21f5d0e6c14..30a921c9bd2 100644
--- a/src/test/run-pass/borrowck-freeze-frozen-mut.rs
+++ b/src/test/run-pass/borrowck-freeze-frozen-mut.rs
@@ -19,7 +19,7 @@ fn get<'a, T>(ms: &'a MutSlice<'a, T>, index: uint) -> &'a T {
 }
 
 pub fn main() {
-    let mut data = [1i, 2, 3];
+    let mut data = [1, 2, 3];
     {
         let slice = MutSlice { data: &mut data };
         slice.data[0] += 4;
diff --git a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
index 6136bc90fd4..4ccbf6b5b0f 100644
--- a/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
+++ b/src/test/run-pass/borrowck-pat-reassign-no-binding.rs
@@ -14,7 +14,7 @@ pub fn main() {
       None => {
         // It is ok to reassign x here, because there is in
         // fact no outstanding loan of x!
-        x = Some(0i);
+        x = Some(0);
       }
       Some(_) => { }
     }
diff --git a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
index 55ae6d3bebf..e57c001ea05 100644
--- a/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern-infallible.rs
@@ -10,7 +10,7 @@
 
 
 pub fn main() {
-    let (&x, &y) = (&3i, &'a');
+    let (&x, &y) = (&3, &'a');
     assert_eq!(x, 3);
     assert_eq!(y, 'a');
 }
diff --git a/src/test/run-pass/borrowed-ptr-pattern.rs b/src/test/run-pass/borrowed-ptr-pattern.rs
index 3636d4d769d..7ccb40c8e7b 100644
--- a/src/test/run-pass/borrowed-ptr-pattern.rs
+++ b/src/test/run-pass/borrowed-ptr-pattern.rs
@@ -15,6 +15,6 @@ fn foo<T:Clone>(x: &T) -> T{
 }
 
 pub fn main() {
-    assert_eq!(foo(&3i), 3i);
+    assert_eq!(foo(&3), 3);
     assert_eq!(foo(&'a'), 'a');
 }
diff --git a/src/test/run-pass/break.rs b/src/test/run-pass/break.rs
index 89745bd167c..bcfb8f6f914 100644
--- a/src/test/run-pass/break.rs
+++ b/src/test/run-pass/break.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut i = 0i;
+    let mut i = 0;
     while i < 20 { i += 1; if i == 10 { break; } }
     assert_eq!(i, 10);
     loop { i += 1; if i == 20 { break; } }
     assert_eq!(i, 20);
-    let xs = [1i, 2, 3, 4, 5, 6];
+    let xs = [1, 2, 3, 4, 5, 6];
     for x in xs.iter() {
         if *x == 3 { break; } assert!((*x <= 3));
     }
@@ -25,7 +25,7 @@ pub fn main() {
         i += 1; if i % 2 == 0 { continue; } assert!((i % 2 != 0));
         if i >= 10 { break; }
     }
-    let ys = vec!(1i, 2, 3, 4, 5, 6);
+    let ys = vec!(1, 2, 3, 4, 5, 6);
     for x in ys.iter() {
         if *x % 2 == 0 { continue; }
         assert!((*x % 2 != 0));
diff --git a/src/test/run-pass/bug-7183-generics.rs b/src/test/run-pass/bug-7183-generics.rs
index bf8d303f341..a3bb02d1d00 100644
--- a/src/test/run-pass/bug-7183-generics.rs
+++ b/src/test/run-pass/bug-7183-generics.rs
@@ -34,11 +34,11 @@ impl<T: Speak> Speak for Option<T> {
 
 
 pub fn main() {
-    assert_eq!(3i.hi(), "hello: 3".to_string());
-    assert_eq!(Some(Some(3i)).hi(),
+    assert_eq!(3.hi(), "hello: 3".to_string());
+    assert_eq!(Some(Some(3)).hi(),
                "something!something!hello: 3".to_string());
     assert_eq!(None::<int>.hi(), "hello - none".to_string());
 
     assert_eq!(Some(None::<int>).hi(), "something!hello - none".to_string());
-    assert_eq!(Some(3i).hi(), "something!hello: 3".to_string());
+    assert_eq!(Some(3).hi(), "something!hello: 3".to_string());
 }
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
index 365670db6f9..3df9dd25d86 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-transitive.rs
@@ -28,6 +28,6 @@ fn foo<T: Foo>(val: T, chan: Sender<T>) {
 
 pub fn main() {
     let (tx, rx) = channel();
-    foo(31337i, tx);
-    assert!(rx.recv().unwrap() == 31337i);
+    foo(31337, tx);
+    assert!(rx.recv().unwrap() == 31337);
 }
diff --git a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
index 126088d7f9d..52b826393e9 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities-xc.rs
@@ -31,6 +31,6 @@ fn foo<T: RequiresRequiresShareAndSend>(val: T, chan: Sender<T>) {
 
 pub fn main() {
     let (tx, rx): (Sender<X<int>>, Receiver<X<int>>) = channel();
-    foo(X(31337i), tx);
-    assert!(rx.recv().unwrap() == X(31337i));
+    foo(X(31337), tx);
+    assert!(rx.recv().unwrap() == X(31337));
 }
diff --git a/src/test/run-pass/builtin-superkinds-capabilities.rs b/src/test/run-pass/builtin-superkinds-capabilities.rs
index 7f4a2398f54..034e5ff2d3a 100644
--- a/src/test/run-pass/builtin-superkinds-capabilities.rs
+++ b/src/test/run-pass/builtin-superkinds-capabilities.rs
@@ -24,6 +24,6 @@ fn foo<T: Foo>(val: T, chan: Sender<T>) {
 
 pub fn main() {
     let (tx, rx): (Sender<int>, Receiver<int>) = channel();
-    foo(31337i, tx);
-    assert!(rx.recv().unwrap() == 31337i);
+    foo(31337, tx);
+    assert!(rx.recv().unwrap() == 31337);
 }
diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs
index d0db2542ccc..1b3070ba3b0 100644
--- a/src/test/run-pass/builtin-superkinds-self-type.rs
+++ b/src/test/run-pass/builtin-superkinds-self-type.rs
@@ -23,6 +23,6 @@ impl <T: Send> Foo for T { }
 
 pub fn main() {
     let (tx, rx) = channel();
-    1193182i.foo(tx);
-    assert!(rx.recv().unwrap() == 1193182i);
+    1193182.foo(tx);
+    assert!(rx.recv().unwrap() == 1193182);
 }
diff --git a/src/test/run-pass/cci_iter_exe.rs b/src/test/run-pass/cci_iter_exe.rs
index 7191d5078b8..e4b26ba74be 100644
--- a/src/test/run-pass/cci_iter_exe.rs
+++ b/src/test/run-pass/cci_iter_exe.rs
@@ -15,7 +15,7 @@ extern crate cci_iter_lib;
 pub fn main() {
     //let bt0 = sys::rusti::frame_address(1u32);
     //println!("%?", bt0);
-    cci_iter_lib::iter(&[1i, 2, 3], |i| {
+    cci_iter_lib::iter(&[1, 2, 3], |i| {
         println!("{}", *i);
         //assert!(bt0 == sys::rusti::frame_address(2u32));
     })
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index d94547a4dda..4f94673a2c0 100644
--- a/src/test/run-pass/class-poly-methods.rs
+++ b/src/test/run-pass/class-poly-methods.rs
@@ -36,7 +36,7 @@ pub fn main() {
   let mut kitty = cat(1000u, 2, vec!("tabby".to_string()));
   assert_eq!(nyan.how_hungry, 99);
   assert_eq!(kitty.how_hungry, 2);
-  nyan.speak(vec!(1i,2,3));
+  nyan.speak(vec!(1,2,3));
   assert_eq!(nyan.meow_count(), 55u);
   kitty.speak(vec!("meow".to_string(), "mew".to_string(), "purr".to_string(), "chirp".to_string()));
   assert_eq!(kitty.meow_count(), 1004u);
diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs
index bbfe0e6a18d..b39a4d7f685 100644
--- a/src/test/run-pass/cleanup-rvalue-scopes.rs
+++ b/src/test/run-pass/cleanup-rvalue-scopes.rs
@@ -110,7 +110,7 @@ pub fn main() {
     end_of_block!(ref _x, AddFlags(1));
     end_of_block!(AddFlags { bits: ref _x }, AddFlags(1));
     end_of_block!(&AddFlags { bits }, &AddFlags(1));
-    end_of_block!((_, ref _y), (AddFlags(1), 22i));
+    end_of_block!((_, ref _y), (AddFlags(1), 22));
     end_of_block!(box ref _x, box AddFlags(1));
     end_of_block!(box _x, box AddFlags(1));
     end_of_block!(_, { { check_flags(0); &AddFlags(1) } });
@@ -120,7 +120,7 @@ pub fn main() {
     // LHS does not create a ref binding, so temporary lives as long
     // as statement, and we do not move the AddFlags out:
     end_of_stmt!(_, AddFlags(1));
-    end_of_stmt!((_, _), (AddFlags(1), 22i));
+    end_of_stmt!((_, _), (AddFlags(1), 22));
 
     // `&` operator appears inside an arg to a function,
     // so it is not prolonged:
diff --git a/src/test/run-pass/closure-inference2.rs b/src/test/run-pass/closure-inference2.rs
index 03b10b881f7..c0877568b72 100644
--- a/src/test/run-pass/closure-inference2.rs
+++ b/src/test/run-pass/closure-inference2.rs
@@ -12,6 +12,6 @@
 
 pub fn main() {
     let f = {|&: i| i};
-    assert_eq!(f(2i), 2i);
-    assert_eq!(f(5i), 5i);
+    assert_eq!(f(2), 2);
+    assert_eq!(f(5), 5);
 }
diff --git a/src/test/run-pass/coerce-match-calls.rs b/src/test/run-pass/coerce-match-calls.rs
index 0ff28b471a3..34c9875f1de 100644
--- a/src/test/run-pass/coerce-match-calls.rs
+++ b/src/test/run-pass/coerce-match-calls.rs
@@ -13,9 +13,9 @@
 use std::boxed::Box;
 
 pub fn main() {
-    let _: Box<[int]> = if true { Box::new([1i, 2, 3]) } else { Box::new([1i]) };
+    let _: Box<[int]> = if true { Box::new([1, 2, 3]) } else { Box::new([1]) };
 
-    let _: Box<[int]> = match true { true => Box::new([1i, 2, 3]), false => Box::new([1i]) };
+    let _: Box<[int]> = match true { true => Box::new([1, 2, 3]), false => Box::new([1]) };
 
     // Check we don't get over-keen at propagating coercions in the case of casts.
     let x = if true { 42 } else { 42u8 } as u16;
diff --git a/src/test/run-pass/coerce-match.rs b/src/test/run-pass/coerce-match.rs
index 0992ee97d06..098a08b0787 100644
--- a/src/test/run-pass/coerce-match.rs
+++ b/src/test/run-pass/coerce-match.rs
@@ -14,9 +14,9 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let _: Box<[int]> = if true { box [1i, 2, 3] } else { box [1i] };
+    let _: Box<[int]> = if true { box [1, 2, 3] } else { box [1] };
 
-    let _: Box<[int]> = match true { true => box [1i, 2, 3], false => box [1i] };
+    let _: Box<[int]> = match true { true => box [1, 2, 3], false => box [1] };
 
     // Check we don't get over-keen at propagating coercions in the case of casts.
     let x = if true { 42 } else { 42u8 } as u16;
diff --git a/src/test/run-pass/complex.rs b/src/test/run-pass/complex.rs
index 34292453ec4..f8c8ac20d72 100644
--- a/src/test/run-pass/complex.rs
+++ b/src/test/run-pass/complex.rs
@@ -35,8 +35,8 @@ fn foo(x: int) -> int {
 }
 
 pub fn main() {
-    let x: int = 2i + 2;
+    let x: int = 2 + 2;
     println!("{}", x);
     println!("hello, world");
-    println!("{}", 10i);
+    println!("{}", 10);
 }
diff --git a/src/test/run-pass/concat.rs b/src/test/run-pass/concat.rs
index d78f948edc5..2a8443167d0 100644
--- a/src/test/run-pass/concat.rs
+++ b/src/test/run-pass/concat.rs
@@ -15,12 +15,12 @@ pub fn main() {
     assert_eq!(concat!("qux", "quux",).to_string(), "quxquux".to_string());
 
     assert_eq!(
-        concat!(1, 2i, 3u, 4f32, 4.0, 'a', true),
+        concat!(1, 2, 3u, 4f32, 4.0, 'a', true),
         "12344.0atrue"
     );
 
     assert!(match "12344.0atrue" {
-        concat!(1, 2i, 3u, 4f32, 4.0, 'a', true) => true,
+        concat!(1, 2, 3u, 4f32, 4.0, 'a', true) => true,
         _ => false
     })
 }
diff --git a/src/test/run-pass/const-binops.rs b/src/test/run-pass/const-binops.rs
index 11590ceb19d..1268fc4e435 100644
--- a/src/test/run-pass/const-binops.rs
+++ b/src/test/run-pass/const-binops.rs
@@ -52,27 +52,27 @@ static V: int = 1 << 3;
 static W: int = 1024 >> 4;
 static X: uint = 1024 >> 4;
 
-static Y: bool = 1i == 1;
+static Y: bool = 1 == 1;
 static Z: bool = 1.0f64 == 1.0;
 
-static AA: bool = 1i <= 2;
-static AB: bool = -1i <= 2;
+static AA: bool = 1 <= 2;
+static AB: bool = -1 <= 2;
 static AC: bool = 1.0f64 <= 2.0;
 
-static AD: bool = 1i < 2;
-static AE: bool = -1i < 2;
+static AD: bool = 1 < 2;
+static AE: bool = -1 < 2;
 static AF: bool = 1.0f64 < 2.0;
 
-static AG: bool = 1i != 2;
-static AH: bool = -1i != 2;
+static AG: bool = 1 != 2;
+static AH: bool = -1 != 2;
 static AI: bool = 1.0f64 != 2.0;
 
-static AJ: bool = 2i >= 1;
-static AK: bool = 2i >= -2;
+static AJ: bool = 2 >= 1;
+static AK: bool = 2 >= -2;
 static AL: bool = 1.0f64 >= -2.0;
 
-static AM: bool = 2i > 1;
-static AN: bool = 2i > -2;
+static AM: bool = 2 > 1;
+static AN: bool = 2 > -2;
 static AO: bool = 1.0f64 > -2.0;
 
 pub fn main() {
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 3a6973fe61c..e6a280a91d7 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -25,5 +25,5 @@ pub fn main() {
     foo(F{field: 42});
     foo((1, 2u));
     foo(@1);*/
-    foo(box 1i);
+    foo(box 1);
 }
diff --git a/src/test/run-pass/const-expr-in-vec-repeat.rs b/src/test/run-pass/const-expr-in-vec-repeat.rs
index d692f3a87e4..0b097c0b060 100644
--- a/src/test/run-pass/const-expr-in-vec-repeat.rs
+++ b/src/test/run-pass/const-expr-in-vec-repeat.rs
@@ -13,6 +13,6 @@
 pub fn main() {
 
     const FOO: uint = 2;
-    let _v = [0i; FOO*3*2/2];
+    let _v = [0; FOO*3*2/2];
 
 }
diff --git a/src/test/run-pass/consts-in-patterns.rs b/src/test/run-pass/consts-in-patterns.rs
index 87b7fcad385..e8f4948a165 100644
--- a/src/test/run-pass/consts-in-patterns.rs
+++ b/src/test/run-pass/consts-in-patterns.rs
@@ -12,11 +12,11 @@ const FOO: int = 10;
 const BAR: int = 3;
 
 pub fn main() {
-    let x: int = 3i;
+    let x: int = 3;
     let y = match x {
-        FOO => 1i,
-        BAR => 2i,
-        _ => 3i
+        FOO => 1,
+        BAR => 2,
+        _ => 3
     };
     assert_eq!(y, 2);
 }
diff --git a/src/test/run-pass/deref-lval.rs b/src/test/run-pass/deref-lval.rs
index ead0683b870..41c74250b3b 100644
--- a/src/test/run-pass/deref-lval.rs
+++ b/src/test/run-pass/deref-lval.rs
@@ -14,7 +14,7 @@
 use std::cell::Cell;
 
 pub fn main() {
-    let x = box Cell::new(5i);
-    x.set(1000i);
+    let x = box Cell::new(5);
+    x.set(1000);
     println!("{}", x.get());
 }
diff --git a/src/test/run-pass/deref-rc.rs b/src/test/run-pass/deref-rc.rs
index 03697875d56..fbb8a3a1720 100644
--- a/src/test/run-pass/deref-rc.rs
+++ b/src/test/run-pass/deref-rc.rs
@@ -11,6 +11,6 @@
 use std::rc::Rc;
 
 fn main() {
-    let x = Rc::new([1i, 2, 3, 4]);
+    let x = Rc::new([1, 2, 3, 4]);
     assert!(*x == [1, 2, 3, 4]);
 }
diff --git a/src/test/run-pass/deriving-clone-generic-enum.rs b/src/test/run-pass/deriving-clone-generic-enum.rs
index e8e65dcb8a9..e174ffae75d 100644
--- a/src/test/run-pass/deriving-clone-generic-enum.rs
+++ b/src/test/run-pass/deriving-clone-generic-enum.rs
@@ -16,5 +16,5 @@ enum E<T,U> {
 }
 
 pub fn main() {
-    let _ = E::A::<int, int>(1i).clone();
+    let _ = E::A::<int, int>(1).clone();
 }
diff --git a/src/test/run-pass/deriving-clone-generic-struct.rs b/src/test/run-pass/deriving-clone-generic-struct.rs
index d340fe9d3fb..329c7dab3eb 100644
--- a/src/test/run-pass/deriving-clone-generic-struct.rs
+++ b/src/test/run-pass/deriving-clone-generic-struct.rs
@@ -16,5 +16,5 @@ struct S<T> {
 }
 
 pub fn main() {
-    let _ = S { foo: (), bar: (), baz: 1i }.clone();
+    let _ = S { foo: (), bar: (), baz: 1 }.clone();
 }
diff --git a/src/test/run-pass/deriving-clone-generic-tuple-struct.rs b/src/test/run-pass/deriving-clone-generic-tuple-struct.rs
index ecf1fdc6e5f..bb07b08859f 100644
--- a/src/test/run-pass/deriving-clone-generic-tuple-struct.rs
+++ b/src/test/run-pass/deriving-clone-generic-tuple-struct.rs
@@ -12,5 +12,5 @@
 struct S<T>(T, ());
 
 pub fn main() {
-    let _ = S(1i, ()).clone();
+    let _ = S(1, ()).clone();
 }
diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs
index 04cb3b7c076..b3194d5820a 100644
--- a/src/test/run-pass/deriving-cmp-generic-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-enum.rs
@@ -19,10 +19,10 @@ enum E<T> {
 
 pub fn main() {
     let e0 = E::E0;
-    let e11 = E::E1(1i);
-    let e12 = E::E1(2i);
-    let e21 = E::E2(1i, 1i);
-    let e22 = E::E2(1i, 2i);
+    let e11 = E::E1(1);
+    let e12 = E::E1(2);
+    let e21 = E::E2(1, 1);
+    let e22 = E::E2(1, 2);
 
     // in order for both PartialOrd and Ord
     let es = [e0, e11, e12, e21, e22];
diff --git a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
index dbac7fa5bca..8b54536f3ab 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
@@ -19,15 +19,15 @@ enum ES<T> {
 
 pub fn main() {
     let (es11, es12, es21, es22) = (ES::ES1 {
-        x: 1i
+        x: 1
     }, ES::ES1 {
-        x: 2i
+        x: 2
     }, ES::ES2 {
-        x: 1i,
-        y: 1i
+        x: 1,
+        y: 1
     }, ES::ES2 {
-        x: 1i,
-        y: 2i
+        x: 1,
+        y: 2
     });
 
     // in order for both PartialOrd and Ord
diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs
index cd2cbb2d0a9..86887c3411f 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct.rs
@@ -17,8 +17,8 @@ struct S<T> {
 }
 
 pub fn main() {
-    let s1 = S {x: 1i, y: 1i};
-    let s2 = S {x: 1i, y: 2i};
+    let s1 = S {x: 1, y: 1};
+    let s2 = S {x: 1, y: 2};
 
     // in order for both PartialOrd and Ord
     let ss = [s1, s2];
diff --git a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
index 0a45b73755e..c7d7f8ded83 100644
--- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
@@ -15,8 +15,8 @@ struct TS<T>(T,T);
 
 
 pub fn main() {
-    let ts1 = TS(1i, 1i);
-    let ts2 = TS(1i, 2i);
+    let ts1 = TS(1, 1);
+    let ts2 = TS(1, 2);
 
     // in order for both PartialOrd and Ord
     let tss = [ts1, ts2];
diff --git a/src/test/run-pass/deriving-rand.rs b/src/test/run-pass/deriving-rand.rs
index 36b6b3cbeea..d6e5fedf182 100644
--- a/src/test/run-pass/deriving-rand.rs
+++ b/src/test/run-pass/deriving-rand.rs
@@ -31,7 +31,7 @@ enum D {
 
 pub fn main() {
     // check there's no segfaults
-    for _ in 0i..20 {
+    for _ in 0..20 {
         rand::random::<A>();
         rand::random::<B>();
         rand::random::<C>();
diff --git a/src/test/run-pass/drop-trait-generic.rs b/src/test/run-pass/drop-trait-generic.rs
index 9a93873f538..4ba3aa70dfc 100644
--- a/src/test/run-pass/drop-trait-generic.rs
+++ b/src/test/run-pass/drop-trait-generic.rs
@@ -22,5 +22,5 @@ impl<T> ::std::ops::Drop for S<T> {
 }
 
 pub fn main() {
-    let _x = S { x: 1i };
+    let _x = S { x: 1 };
 }
diff --git a/src/test/run-pass/dst-raw.rs b/src/test/run-pass/dst-raw.rs
index d3d2e3581aa..226025cd80e 100644
--- a/src/test/run-pass/dst-raw.rs
+++ b/src/test/run-pass/dst-raw.rs
@@ -45,7 +45,7 @@ pub fn main() {
     assert!(r == 42);
 
     // raw slice
-    let a: *const [_] = &[1i, 2, 3];
+    let a: *const [_] = &[1, 2, 3];
     unsafe {
         let b = (*a)[2];
         assert!(b == 3);
@@ -54,7 +54,7 @@ pub fn main() {
     }
 
     // raw slice with explicit cast
-    let a = &[1i, 2, 3] as *const [_];
+    let a = &[1, 2, 3] as *const [_];
     unsafe {
         let b = (*a)[2];
         assert!(b == 3);
@@ -63,7 +63,7 @@ pub fn main() {
     }
 
     // raw DST struct with slice
-    let c: *const Foo<[_]> = &Foo {f: [1i, 2, 3]};
+    let c: *const Foo<[_]> = &Foo {f: [1, 2, 3]};
     unsafe {
         let b = (&*c).f[0];
         assert!(b == 1);
@@ -86,7 +86,7 @@ pub fn main() {
     };
     assert!(r == 42);
 
-    let a: *mut [_] = &mut [1i, 2, 3];
+    let a: *mut [_] = &mut [1, 2, 3];
     unsafe {
         let b = (*a)[2];
         assert!(b == 3);
@@ -94,7 +94,7 @@ pub fn main() {
         assert!(len == 3);
     }
 
-    let a = &mut [1i, 2, 3] as *mut [_];
+    let a = &mut [1, 2, 3] as *mut [_];
     unsafe {
         let b = (*a)[2];
         assert!(b == 3);
@@ -102,7 +102,7 @@ pub fn main() {
         assert!(len == 3);
     }
 
-    let c: *mut Foo<[_]> = &mut Foo {f: [1i, 2, 3]};
+    let c: *mut Foo<[_]> = &mut Foo {f: [1, 2, 3]};
     unsafe {
         let b = (&*c).f[0];
         assert!(b == 1);
diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs
index fa2af29431c..ee5193adbc6 100644
--- a/src/test/run-pass/dst-struct.rs
+++ b/src/test/run-pass/dst-struct.rs
@@ -115,7 +115,7 @@ pub fn main() {
     foo3(f5);
 
     // Box.
-    let f1 = box [1i, 2, 3];
+    let f1 = box [1, 2, 3];
     assert!((*f1)[1] == 2);
     let f2: Box<[int]> = f1;
     assert!((*f2)[1] == 2);
diff --git a/src/test/run-pass/early-ret-binop-add.rs b/src/test/run-pass/early-ret-binop-add.rs
index b9efdeb3bed..97e873e9aff 100644
--- a/src/test/run-pass/early-ret-binop-add.rs
+++ b/src/test/run-pass/early-ret-binop-add.rs
@@ -8,5 +8,5 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn wsucc(n: int) -> int { 0i + { return n + 1 } }
+fn wsucc(n: int) -> int { 0 + { return n + 1 } }
 pub fn main() { }
diff --git a/src/test/run-pass/early-vtbl-resolution.rs b/src/test/run-pass/early-vtbl-resolution.rs
index 70030c66ca2..89fee7358a1 100644
--- a/src/test/run-pass/early-vtbl-resolution.rs
+++ b/src/test/run-pass/early-vtbl-resolution.rs
@@ -19,5 +19,5 @@ fn foo_func<A, B: thing<A>>(x: B) -> Option<A> { x.foo() }
 struct A { a: int }
 
 pub fn main() {
-    let _x: Option<f64> = foo_func(0i);
+    let _x: Option<f64> = foo_func(0);
 }
diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs
index 63f32ae702b..476d3f42d6e 100644
--- a/src/test/run-pass/else-if.rs
+++ b/src/test/run-pass/else-if.rs
@@ -11,20 +11,20 @@
 
 
 pub fn main() {
-    if 1i == 2 {
+    if 1 == 2 {
         assert!((false));
-    } else if 2i == 3 {
+    } else if 2 == 3 {
         assert!((false));
-    } else if 3i == 4 { assert!((false)); } else { assert!((true)); }
-    if 1i == 2 { assert!((false)); } else if 2i == 2 { assert!((true)); }
-    if 1i == 2 {
+    } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
+    if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
+    if 1 == 2 {
         assert!((false));
-    } else if 2i == 2 {
-        if 1i == 1 {
+    } else if 2 == 2 {
+        if 1 == 1 {
             assert!((true));
-        } else { if 2i == 1 { assert!((false)); } else { assert!((false)); } }
+        } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
     }
-    if 1i == 2 {
+    if 1 == 2 {
         assert!((false));
-    } else { if 1i == 2 { assert!((false)); } else { assert!((true)); } }
+    } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
 }
diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
index 81713657202..468e5f5f4b3 100644
--- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
+++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
@@ -19,8 +19,8 @@
 
 enum List<X> { Nil, Cons(X, Box<List<X>>) }
 pub fn main() {
-    match List::Cons(10i, box List::Nil) {
-        List::Cons(10i, _) => {}
+    match List::Cons(10, box List::Nil) {
+        List::Cons(10, _) => {}
         List::Nil => {}
         _ => panic!()
     }
diff --git a/src/test/run-pass/enum-vec-initializer.rs b/src/test/run-pass/enum-vec-initializer.rs
index d436916c279..86a998100b0 100644
--- a/src/test/run-pass/enum-vec-initializer.rs
+++ b/src/test/run-pass/enum-vec-initializer.rs
@@ -16,9 +16,9 @@ const BAR:uint = Flopsy::Bunny as uint;
 const BAR2:uint = BAR;
 
 pub fn main() {
-    let _v = [0i;  Flopsy::Bunny as uint];
-    let _v = [0i;  BAR];
-    let _v = [0i;  BAR2];
+    let _v = [0;  Flopsy::Bunny as uint];
+    let _v = [0;  BAR];
+    let _v = [0;  BAR2];
     const BAR3:uint = BAR2;
-    let _v = [0i;  BAR3];
+    let _v = [0;  BAR3];
 }
diff --git a/src/test/run-pass/explicit-i-suffix.rs b/src/test/run-pass/explicit-i-suffix.rs
index 45cfee76fb8..96c58b106f3 100644
--- a/src/test/run-pass/explicit-i-suffix.rs
+++ b/src/test/run-pass/explicit-i-suffix.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 pub fn main() {
-    let x: int = 8i;
-    let y = 9i;
+    let x: int = 8;
+    let y = 9;
     x + y;
 
-    let q: int = -8i;
-    let r = -9i;
+    let q: int = -8;
+    let r = -9;
     q + r;
 }
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index d934ce677d1..d10b209965f 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -12,4 +12,4 @@
 #![allow(unknown_features)]
 #![feature(box_syntax)]
 
-pub fn main() { let x = { box 100i }; assert!((*x == 100)); }
+pub fn main() { let x = { box 100 }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-block.rs b/src/test/run-pass/expr-block.rs
index 7af9e790504..ee1d955b0d3 100644
--- a/src/test/run-pass/expr-block.rs
+++ b/src/test/run-pass/expr-block.rs
@@ -20,7 +20,7 @@ struct RS { v1: int, v2: int }
 fn test_rec() { let rs = { RS {v1: 10, v2: 20} }; assert!((rs.v2 == 20)); }
 
 fn test_filled_with_stuff() {
-    let rs = { let mut a = 0i; while a < 10 { a += 1; } a };
+    let rs = { let mut a = 0; while a < 10 { a += 1; } a };
     assert_eq!(rs, 10);
 }
 
diff --git a/src/test/run-pass/expr-empty-ret.rs b/src/test/run-pass/expr-empty-ret.rs
index 7b08251967e..afc7dfaf9b4 100644
--- a/src/test/run-pass/expr-empty-ret.rs
+++ b/src/test/run-pass/expr-empty-ret.rs
@@ -12,7 +12,7 @@
 
 fn f() {
     let _x = match true {
-        true => { 10i }
+        true => { 10 }
         false => { return }
     };
 }
diff --git a/src/test/run-pass/expr-fn.rs b/src/test/run-pass/expr-fn.rs
index 8172c16abf2..0ea1f3fcdaf 100644
--- a/src/test/run-pass/expr-fn.rs
+++ b/src/test/run-pass/expr-fn.rs
@@ -22,7 +22,7 @@ fn test_vec() {
 
 fn test_generic() {
     fn f<T>(t: T) -> T { t }
-    assert_eq!(f(10i), 10);
+    assert_eq!(f(10), 10);
 }
 
 fn test_alt() {
diff --git a/src/test/run-pass/expr-if-panic-all.rs b/src/test/run-pass/expr-if-panic-all.rs
index 0dd7ddc3f84..52ccee05817 100644
--- a/src/test/run-pass/expr-if-panic-all.rs
+++ b/src/test/run-pass/expr-if-panic-all.rs
@@ -12,7 +12,7 @@
 // expression results in panic.
 pub fn main() {
     let _x = if true {
-        10i
+        10
     } else {
         if true { panic!() } else { panic!() }
     };
diff --git a/src/test/run-pass/expr-if-panic.rs b/src/test/run-pass/expr-if-panic.rs
index aa4240c60f1..87c7954fa49 100644
--- a/src/test/run-pass/expr-if-panic.rs
+++ b/src/test/run-pass/expr-if-panic.rs
@@ -9,18 +9,18 @@
 // except according to those terms.
 
 fn test_if_panic() {
-    let x = if false { panic!() } else { 10i };
+    let x = if false { panic!() } else { 10 };
     assert!((x == 10));
 }
 
 fn test_else_panic() {
-    let x = if true { 10i } else { panic!() };
-    assert_eq!(x, 10i);
+    let x = if true { 10 } else { panic!() };
+    assert_eq!(x, 10);
 }
 
 fn test_elseif_panic() {
-    let x = if false { 0i } else if false { panic!() } else { 10i };
-    assert_eq!(x, 10i);
+    let x = if false { 0 } else if false { panic!() } else { 10 };
+    assert_eq!(x, 10);
 }
 
 pub fn main() { test_if_panic(); test_else_panic(); test_elseif_panic(); }
diff --git a/src/test/run-pass/expr-if-unique.rs b/src/test/run-pass/expr-if-unique.rs
index 5294d05401c..317e5434930 100644
--- a/src/test/run-pass/expr-if-unique.rs
+++ b/src/test/run-pass/expr-if-unique.rs
@@ -15,8 +15,8 @@
 
 // Tests for if as expressions returning boxed types
 fn test_box() {
-    let rs = if true { box 100i } else { box 101i };
-    assert_eq!(*rs, 100i);
+    let rs = if true { box 100 } else { box 101 };
+    assert_eq!(*rs, 100);
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/expr-match-panic-all.rs b/src/test/run-pass/expr-match-panic-all.rs
index 3b33c18bbbd..3a8955917d6 100644
--- a/src/test/run-pass/expr-match-panic-all.rs
+++ b/src/test/run-pass/expr-match-panic-all.rs
@@ -16,7 +16,7 @@
 pub fn main() {
     let _x =
         match true {
-          true => { 10i }
+          true => { 10 }
           false => { match true { true => { panic!() } false => { panic!() } } }
         };
 }
diff --git a/src/test/run-pass/expr-match-panic.rs b/src/test/run-pass/expr-match-panic.rs
index d8ee21dfdc6..da24d4c57cc 100644
--- a/src/test/run-pass/expr-match-panic.rs
+++ b/src/test/run-pass/expr-match-panic.rs
@@ -15,8 +15,8 @@ fn test_simple() {
 }
 
 fn test_box() {
-    let r = match true { true => { vec!(10i) } false => { panic!() } };
-    assert_eq!(r[0], 10i);
+    let r = match true { true => { vec!(10) } false => { panic!() } };
+    assert_eq!(r[0], 10);
 }
 
 pub fn main() { test_simple(); test_box(); }
diff --git a/src/test/run-pass/expr-match-unique.rs b/src/test/run-pass/expr-match-unique.rs
index 7958f4927da..57ccfe1d5e0 100644
--- a/src/test/run-pass/expr-match-unique.rs
+++ b/src/test/run-pass/expr-match-unique.rs
@@ -13,8 +13,8 @@
 
 // Tests for match as expressions resulting in boxed types
 fn test_box() {
-    let res = match true { true => { box 100i }, _ => panic!() };
-    assert_eq!(*res, 100i);
+    let res = match true { true => { box 100 }, _ => panic!() };
+    assert_eq!(*res, 100);
 }
 
 pub fn main() { test_box(); }
diff --git a/src/test/run-pass/fat-arrow-match.rs b/src/test/run-pass/fat-arrow-match.rs
index 929d1c8e63d..004e6d48e37 100644
--- a/src/test/run-pass/fat-arrow-match.rs
+++ b/src/test/run-pass/fat-arrow-match.rs
@@ -17,8 +17,8 @@ enum color {
 
 pub fn main() {
     println!("{}", match color::red {
-        color::red => { 1i }
-        color::green => { 2i }
-        color::blue => { 3i }
+        color::red => { 1 }
+        color::green => { 2 }
+        color::blue => { 3 }
     });
 }
diff --git a/src/test/run-pass/fixed_length_copy.rs b/src/test/run-pass/fixed_length_copy.rs
index dc34cec7fa2..bbd7b9130e7 100644
--- a/src/test/run-pass/fixed_length_copy.rs
+++ b/src/test/run-pass/fixed_length_copy.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let arr = [1i,2i,3i];
+    let arr = [1,2,3];
     let arr2 = arr;
-    assert_eq!(arr[1], 2i);
-    assert_eq!(arr2[2], 3i);
+    assert_eq!(arr[1], 2);
+    assert_eq!(arr2[2], 3);
 }
diff --git a/src/test/run-pass/fn-type-infer.rs b/src/test/run-pass/fn-type-infer.rs
index ae22ff5cce0..785abbe449b 100644
--- a/src/test/run-pass/fn-type-infer.rs
+++ b/src/test/run-pass/fn-type-infer.rs
@@ -13,6 +13,6 @@
 pub fn main() {
     // We should be able to type infer inside of ||s.
     let _f = |&:| {
-        let i = 10i;
+        let i = 10;
     };
 }
diff --git a/src/test/run-pass/for-loop-goofiness.rs b/src/test/run-pass/for-loop-goofiness.rs
index 73f4cdd252e..ae509dc0862 100644
--- a/src/test/run-pass/for-loop-goofiness.rs
+++ b/src/test/run-pass/for-loop-goofiness.rs
@@ -16,7 +16,7 @@ enum BogusOption<T> {
 type Iterator = int;
 
 pub fn main() {
-    let x = [ 3i, 3, 3 ];
+    let x = [ 3, 3, 3 ];
     for i in x.iter() {
         assert_eq!(*i, 3);
     }
diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs
index 5f7770e97a9..9cbb4f4107a 100644
--- a/src/test/run-pass/foreach-external-iterators-break.rs
+++ b/src/test/run-pass/foreach-external-iterators-break.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [1i; 100];
-    let mut y = 0i;
+    let x = [1; 100];
+    let mut y = 0;
     for i in x.iter() {
         if y > 10 {
             break;
diff --git a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
index 4305ae95698..d16a964ea79 100644
--- a/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
+++ b/src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs
@@ -18,7 +18,7 @@ use std::collections::HashMap;
 
 pub fn main() {
     let mut h = HashMap::new();
-    let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)];
+    let kvs = [(1, 10), (2, 20), (3, 30)];
     for &(k,v) in kvs.iter() {
         h.insert(k,v);
     }
diff --git a/src/test/run-pass/foreach-external-iterators-hashmap.rs b/src/test/run-pass/foreach-external-iterators-hashmap.rs
index ab20f9f9778..1878997de5a 100644
--- a/src/test/run-pass/foreach-external-iterators-hashmap.rs
+++ b/src/test/run-pass/foreach-external-iterators-hashmap.rs
@@ -14,12 +14,12 @@ use std::collections::HashMap;
 
 pub fn main() {
     let mut h = HashMap::new();
-    let kvs = [(1i, 10i), (2i, 20i), (3i, 30i)];
+    let kvs = [(1, 10), (2, 20), (3, 30)];
     for &(k,v) in kvs.iter() {
         h.insert(k,v);
     }
-    let mut x = 0i;
-    let mut y = 0i;
+    let mut x = 0;
+    let mut y = 0;
     for (&k,&v) in h.iter() {
         x += k;
         y += v;
diff --git a/src/test/run-pass/foreach-external-iterators-loop.rs b/src/test/run-pass/foreach-external-iterators-loop.rs
index d8c6dd6a93d..d9abed50123 100644
--- a/src/test/run-pass/foreach-external-iterators-loop.rs
+++ b/src/test/run-pass/foreach-external-iterators-loop.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [1i; 100];
-    let mut y = 0i;
+    let x = [1; 100];
+    let mut y = 0;
     for (n,i) in x.iter().enumerate() {
         if n < 10 {
             continue;
diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs
index 20ea9c440a1..75471991620 100644
--- a/src/test/run-pass/foreach-external-iterators-nested.rs
+++ b/src/test/run-pass/foreach-external-iterators-nested.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [1i; 100];
-    let y = [2i; 100];
-    let mut p = 0i;
-    let mut q = 0i;
+    let x = [1; 100];
+    let y = [2; 100];
+    let mut p = 0;
+    let mut q = 0;
     for i in x.iter() {
         for j in y.iter() {
             p += *j;
diff --git a/src/test/run-pass/foreach-external-iterators.rs b/src/test/run-pass/foreach-external-iterators.rs
index 0ac642cc449..ef4692b2b51 100644
--- a/src/test/run-pass/foreach-external-iterators.rs
+++ b/src/test/run-pass/foreach-external-iterators.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [1i; 100];
-    let mut y = 0i;
+    let x = [1; 100];
+    let mut y = 0;
     for i in x.iter() {
         y += *i
     }
diff --git a/src/test/run-pass/foreign-call-no-runtime.rs b/src/test/run-pass/foreign-call-no-runtime.rs
index c1df9d53ad4..f99d3eb1c7d 100644
--- a/src/test/run-pass/foreign-call-no-runtime.rs
+++ b/src/test/run-pass/foreign-call-no-runtime.rs
@@ -22,7 +22,7 @@ extern {
 pub fn main() {
     unsafe {
         Thread::scoped(move|| {
-            let i = &100i;
+            let i = &100;
             rust_dbg_call(callback, mem::transmute(i));
         }).join();
     }
@@ -31,6 +31,6 @@ pub fn main() {
 extern fn callback(data: libc::uintptr_t) {
     unsafe {
         let data: *const int = mem::transmute(data);
-        assert_eq!(*data, 100i);
+        assert_eq!(*data, 100);
     }
 }
diff --git a/src/test/run-pass/generic-alias-unique.rs b/src/test/run-pass/generic-alias-unique.rs
index 34b7f15e4c6..db468ba1802 100644
--- a/src/test/run-pass/generic-alias-unique.rs
+++ b/src/test/run-pass/generic-alias-unique.rs
@@ -14,7 +14,7 @@
 fn id<T:Send>(t: T) -> T { return t; }
 
 pub fn main() {
-    let expected = box 100i;
+    let expected = box 100;
     let actual = id::<Box<int>>(expected.clone());
     println!("{}", *actual);
     assert_eq!(*expected, *actual);
diff --git a/src/test/run-pass/generic-fn-unique.rs b/src/test/run-pass/generic-fn-unique.rs
index be83cb04f2c..6599aa74124 100644
--- a/src/test/run-pass/generic-fn-unique.rs
+++ b/src/test/run-pass/generic-fn-unique.rs
@@ -13,4 +13,4 @@
 
 fn f<T>(x: Box<T>) -> Box<T> { return x; }
 
-pub fn main() { let x = f(box 3i); println!("{}", *x); }
+pub fn main() { let x = f(box 3); println!("{}", *x); }
diff --git a/src/test/run-pass/generic-ivec-leak.rs b/src/test/run-pass/generic-ivec-leak.rs
index 48b61bf745d..eb0546063f7 100644
--- a/src/test/run-pass/generic-ivec-leak.rs
+++ b/src/test/run-pass/generic-ivec-leak.rs
@@ -10,4 +10,4 @@
 
 enum wrapper<T> { wrapped(T), }
 
-pub fn main() { let _w = wrapper::wrapped(vec!(1i, 2, 3, 4, 5)); }
+pub fn main() { let _w = wrapper::wrapped(vec!(1, 2, 3, 4, 5)); }
diff --git a/src/test/run-pass/generic-newtype-struct.rs b/src/test/run-pass/generic-newtype-struct.rs
index f87e11cbb61..4e3c8204052 100644
--- a/src/test/run-pass/generic-newtype-struct.rs
+++ b/src/test/run-pass/generic-newtype-struct.rs
@@ -11,5 +11,5 @@
 struct S<T>(T);
 
 pub fn main() {
-    let _s = S(2i);
+    let _s = S(2);
 }
diff --git a/src/test/run-pass/generic-static-methods.rs b/src/test/run-pass/generic-static-methods.rs
index f992847e4e9..90a6349385d 100644
--- a/src/test/run-pass/generic-static-methods.rs
+++ b/src/test/run-pass/generic-static-methods.rs
@@ -24,5 +24,5 @@ impl<T> vec_utils<T> for Vec<T> {
 }
 
 pub fn main() {
-    assert_eq!(vec_utils::map_(&vec!(1i,2i,3i), |&x| x+1), vec!(2i,3i,4i));
+    assert_eq!(vec_utils::map_(&vec!(1,2,3), |&x| x+1), vec!(2,3,4));
 }
diff --git a/src/test/run-pass/generic-tag-local.rs b/src/test/run-pass/generic-tag-local.rs
index cd8b13421c4..24c31ab4ee6 100644
--- a/src/test/run-pass/generic-tag-local.rs
+++ b/src/test/run-pass/generic-tag-local.rs
@@ -12,4 +12,4 @@
 
 enum clam<T> { a(T), }
 
-pub fn main() { let _c = clam::a(3i); }
+pub fn main() { let _c = clam::a(3); }
diff --git a/src/test/run-pass/generic-tup.rs b/src/test/run-pass/generic-tup.rs
index dc9a90f7025..cd0e344b89c 100644
--- a/src/test/run-pass/generic-tup.rs
+++ b/src/test/run-pass/generic-tup.rs
@@ -11,7 +11,7 @@
 fn get_third<T>(t: (T, T, T)) -> T { let (_, _, x) = t; return x; }
 
 pub fn main() {
-    println!("{}", get_third((1i, 2i, 3i)));
-    assert_eq!(get_third((1i, 2i, 3i)), 3);
+    println!("{}", get_third((1, 2, 3)));
+    assert_eq!(get_third((1, 2, 3)), 3);
     assert_eq!(get_third((5u8, 6u8, 7u8)), 7u8);
 }
diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs
index e7031ae147e..188106ec107 100644
--- a/src/test/run-pass/guards.rs
+++ b/src/test/run-pass/guards.rs
@@ -13,14 +13,14 @@ struct Pair { x: int, y: int }
 
 pub fn main() {
     let a: int =
-        match 10i { x if x < 7 => { 1i } x if x < 11 => { 2i } 10 => { 3i } _ => { 4i } };
+        match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
     assert_eq!(a, 2);
 
     let b: int =
         match (Pair {x: 10, y: 20}) {
-          x if x.x < 5 && x.y < 5 => { 1i }
-          Pair {x: x, y: y} if x == 10 && y == 20 => { 2i }
-          Pair {x: _x, y: _y} => { 3i }
+          x if x.x < 5 && x.y < 5 => { 1 }
+          Pair {x: x, y: y} if x == 10 && y == 20 => { 2 }
+          Pair {x: _x, y: _y} => { 3 }
         };
     assert_eq!(b, 2);
 }
diff --git a/src/test/run-pass/hygiene-dodging-1.rs b/src/test/run-pass/hygiene-dodging-1.rs
index eb81f82a146..3969394a26b 100644
--- a/src/test/run-pass/hygiene-dodging-1.rs
+++ b/src/test/run-pass/hygiene-dodging-1.rs
@@ -14,7 +14,7 @@ mod x {
 
 pub fn main(){
     // should *not* shadow the module x:
-    let x = 9i;
+    let x = 9;
     // use it to avoid warnings:
     x+3;
     assert_eq!(x::g(),14);
diff --git a/src/test/run-pass/hygienic-labels-in-let.rs b/src/test/run-pass/hygienic-labels-in-let.rs
index d8c08a0e4ef..cca0e5b163c 100644
--- a/src/test/run-pass/hygienic-labels-in-let.rs
+++ b/src/test/run-pass/hygienic-labels-in-let.rs
@@ -20,19 +20,19 @@ macro_rules! loop_x {
 macro_rules! while_true {
     ($e: expr) => {
         // $e shouldn't be able to interact with this 'x
-        'x: while 1i + 1 == 2 { $e }
+        'x: while 1 + 1 == 2 { $e }
     }
 }
 
 macro_rules! run_once {
     ($e: expr) => {
         // ditto
-        'x: for _ in 0i..1 { $e }
+        'x: for _ in 0..1 { $e }
     }
 }
 
 pub fn main() {
-    let mut i = 0i;
+    let mut i = 0;
 
     let j: int = {
         'x: loop {
@@ -42,35 +42,35 @@ pub fn main() {
         }
         i + 1
     };
-    assert_eq!(j, 1i);
+    assert_eq!(j, 1);
 
     let k: int = {
-        'x: for _ in 0i..1 {
+        'x: for _ in 0..1 {
             // ditto
             loop_x!(break 'x);
             i += 1;
         }
         i + 1
     };
-    assert_eq!(k, 1i);
+    assert_eq!(k, 1);
 
     let l: int = {
-        'x: for _ in 0i..1 {
+        'x: for _ in 0..1 {
             // ditto
             while_true!(break 'x);
             i += 1;
         }
         i + 1
     };
-    assert_eq!(l, 1i);
+    assert_eq!(l, 1);
 
     let n: int = {
-        'x: for _ in 0i..1 {
+        'x: for _ in 0..1 {
             // ditto
             run_once!(continue 'x);
             i += 1;
         }
         i + 1
     };
-    assert_eq!(n, 1i);
+    assert_eq!(n, 1);
 }
diff --git a/src/test/run-pass/hygienic-labels.rs b/src/test/run-pass/hygienic-labels.rs
index ff8f248a082..0d8da2a9348 100644
--- a/src/test/run-pass/hygienic-labels.rs
+++ b/src/test/run-pass/hygienic-labels.rs
@@ -18,19 +18,19 @@ macro_rules! loop_x {
 macro_rules! run_once {
     ($e: expr) => {
         // ditto
-        'x: for _ in 0i..1 { $e }
+        'x: for _ in 0..1 { $e }
     }
 }
 
 macro_rules! while_x {
     ($e: expr) => {
         // ditto
-        'x: while 1i + 1 == 2 { $e }
+        'x: while 1 + 1 == 2 { $e }
     }
 }
 
 pub fn main() {
-    'x: for _ in 0i..1 {
+    'x: for _ in 0..1 {
         // this 'x should refer to the outer loop, lexically
         loop_x!(break 'x);
         panic!("break doesn't act hygienically inside for loop");
@@ -42,12 +42,12 @@ pub fn main() {
         panic!("break doesn't act hygienically inside infinite loop");
     }
 
-    'x: while 1i + 1 == 2 {
+    'x: while 1 + 1 == 2 {
         while_x!(break 'x);
         panic!("break doesn't act hygienically inside infinite while loop");
     }
 
-    'x: for _ in 0i..1 {
+    'x: for _ in 0..1 {
         // ditto
         run_once!(continue 'x);
         panic!("continue doesn't act hygienically inside for loop");
diff --git a/src/test/run-pass/if-let.rs b/src/test/run-pass/if-let.rs
index 4dff2ea55f1..5d97b886e8e 100644
--- a/src/test/run-pass/if-let.rs
+++ b/src/test/run-pass/if-let.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = Some(3i);
+    let x = Some(3);
     if let Some(y) = x {
-        assert_eq!(y, 3i);
+        assert_eq!(y, 3);
     } else {
         panic!("if-let panicked");
     }
@@ -32,9 +32,9 @@ pub fn main() {
     }
     assert_eq!(clause, 4u);
 
-    if 3i > 4 {
+    if 3 > 4 {
         panic!("bad math");
-    } else if let 1 = 2i {
+    } else if let 1 = 2 {
         panic!("bad pattern match");
     }
 
@@ -44,7 +44,7 @@ pub fn main() {
         Three(String, int)
     }
 
-    let foo = Foo::Three("three".to_string(), 42i);
+    let foo = Foo::Three("three".to_string(), 42);
     if let Foo::One = foo {
         panic!("bad pattern match");
     } else if let Foo::Two(_x) = foo {
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index 56de6726bfb..0acc70f6b5d 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -59,10 +59,10 @@ pub fn main() {
     // At least exercise all the formats
     t!(format!("{}", true), "true");
     t!(format!("{}", '☃'), "☃");
-    t!(format!("{}", 10i), "10");
+    t!(format!("{}", 10), "10");
     t!(format!("{}", 10u), "10");
     t!(format!("{:?}", '☃'), "'\\u{2603}'");
-    t!(format!("{:?}", 10i), "10");
+    t!(format!("{:?}", 10), "10");
     t!(format!("{:?}", 10u), "10");
     t!(format!("{:?}", "true"), "\"true\"");
     t!(format!("{:?}", "foo\nbar"), "\"foo\\nbar\"");
@@ -76,16 +76,16 @@ pub fn main() {
     t!(format!("{:x}", A), "aloha");
     t!(format!("{:X}", B), "adios");
     t!(format!("foo {} ☃☃☃☃☃☃", "bar"), "foo bar ☃☃☃☃☃☃");
-    t!(format!("{1} {0}", 0i, 1i), "1 0");
-    t!(format!("{foo} {bar}", foo=0i, bar=1is), "0 1");
+    t!(format!("{1} {0}", 0, 1), "1 0");
+    t!(format!("{foo} {bar}", foo=0, bar=1is), "0 1");
     t!(format!("{foo} {1} {bar} {0}", 0is, 1is, foo=2is, bar=3is), "2 1 3 0");
     t!(format!("{} {0}", "a"), "a a");
-    t!(format!("{foo_bar}", foo_bar=1i), "1");
-    t!(format!("{}", 5i + 5i), "10");
+    t!(format!("{foo_bar}", foo_bar=1), "1");
+    t!(format!("{}", 5 + 5), "10");
     t!(format!("{:#4}", C), "☃123");
 
     // FIXME(#20676)
-    // let a: &fmt::Debug = &1i;
+    // let a: &fmt::Debug = &1;
     // t!(format!("{:?}", a), "1");
 
 
@@ -146,7 +146,7 @@ pub fn main() {
     test_order();
 
     // make sure that format! doesn't move out of local variables
-    let a = box 3i;
+    let a = box 3;
     format!("{}", a);
     format!("{}", a);
 
@@ -169,10 +169,10 @@ pub fn main() {
 fn test_write() {
     use std::fmt::Writer;
     let mut buf = String::new();
-    write!(&mut buf, "{}", 3i);
+    write!(&mut buf, "{}", 3);
     {
         let w = &mut buf;
-        write!(w, "{foo}", foo=4i);
+        write!(w, "{foo}", foo=4);
         write!(w, "{}", "hello");
         writeln!(w, "{}", "line");
         writeln!(w, "{foo}", foo="bar");
@@ -198,9 +198,9 @@ fn test_format_args() {
     let mut buf = String::new();
     {
         let w = &mut buf;
-        write!(w, "{}", format_args!("{}", 1i));
+        write!(w, "{}", format_args!("{}", 1));
         write!(w, "{}", format_args!("test"));
-        write!(w, "{}", format_args!("{test}", test=3i));
+        write!(w, "{}", format_args!("{test}", test=3));
     }
     let s = buf;
     t!(s, "1test3");
diff --git a/src/test/run-pass/ignore-all-the-things.rs b/src/test/run-pass/ignore-all-the-things.rs
index 1c87b6dad89..65fc24ae746 100644
--- a/src/test/run-pass/ignore-all-the-things.rs
+++ b/src/test/run-pass/ignore-all-the-things.rs
@@ -23,28 +23,28 @@ pub fn main() {
     //let (a, b, ..) = (5, 5, 5, 5);
     //let (.., c, d) = (5, 5, 5, 5);
     let Bar{b: b, ..} = Bar{a: 5, b: 5, c: 5, d: 5};
-    match [5i, 5, 5, 5] {
+    match [5, 5, 5, 5] {
         [..] => { }
     }
-    match [5i, 5, 5, 5] {
+    match [5, 5, 5, 5] {
         [a, ..] => { }
     }
-    match [5i, 5, 5, 5] {
+    match [5, 5, 5, 5] {
         [.., b] => { }
     }
-    match [5i, 5, 5, 5] {
+    match [5, 5, 5, 5] {
         [a, .., b] => { }
     }
-    match [5i, 5, 5] {
+    match [5, 5, 5] {
         [..] => { }
     }
-    match [5i, 5, 5] {
+    match [5, 5, 5] {
         [a, ..] => { }
     }
-    match [5i, 5, 5] {
+    match [5, 5, 5] {
         [.., a] => { }
     }
-    match [5i, 5, 5] {
+    match [5, 5, 5] {
         [a, .., b] => { }
     }
 }
diff --git a/src/test/run-pass/import-glob-crate.rs b/src/test/run-pass/import-glob-crate.rs
index 24d90741bbc..f7874cc56fc 100644
--- a/src/test/run-pass/import-glob-crate.rs
+++ b/src/test/run-pass/import-glob-crate.rs
@@ -14,7 +14,7 @@ use std::mem::*;
 
 pub fn main() {
     assert_eq!(size_of::<u8>(), 1);
-    let (mut x, mut y) = (1i, 2i);
+    let (mut x, mut y) = (1, 2);
     swap(&mut x, &mut y);
     assert_eq!(x, 2);
     assert_eq!(y, 1);
diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index 3c28354dedc..4567651e892 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -10,11 +10,11 @@
 
 pub fn main() {
     use std::mem::replace;
-    let mut x = 5i;
+    let mut x = 5;
     replace(&mut x, 6);
     {
         use std::mem::*;
-        let mut y = 6i;
+        let mut y = 6;
         swap(&mut x, &mut y);
     }
 }
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 0639d732089..44f6b6140fb 100644
--- a/src/test/run-pass/import4.rs
+++ b/src/test/run-pass/import4.rs
@@ -16,4 +16,4 @@ mod zed {
     pub fn bar() { println!("bar"); }
 }
 
-pub fn main() { let _zed = 42i; bar(); }
+pub fn main() { let _zed = 42; bar(); }
diff --git a/src/test/run-pass/inferred-suffix-in-pattern-range.rs b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
index a104ee6baaa..be561dfffa6 100644
--- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs
+++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = 2i;
+    let x = 2;
     let x_message = match x {
       0 ... 1    => { "not many".to_string() }
       _          => { "lots".to_string() }
     };
     assert_eq!(x_message, "lots".to_string());
 
-    let y = 2i;
+    let y = 2;
     let y_message = match y {
       0 ... 1    => { "not many".to_string() }
       _          => { "lots".to_string() }
diff --git a/src/test/run-pass/init-res-into-things.rs b/src/test/run-pass/init-res-into-things.rs
index eeae3f35cfc..ee793359fbc 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -37,7 +37,7 @@ fn r(i: &Cell<int>) -> r {
 }
 
 fn test_rec() {
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     {
         let _a = BoxR {x: r(i)};
     }
@@ -49,7 +49,7 @@ fn test_tag() {
         t0(r<'a>),
     }
 
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     {
         let _a = t::t0(r(i));
     }
@@ -57,15 +57,15 @@ fn test_tag() {
 }
 
 fn test_tup() {
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     {
-        let _a = (r(i), 0i);
+        let _a = (r(i), 0);
     }
     assert_eq!(i.get(), 1);
 }
 
 fn test_unique() {
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     {
         let _a = box r(i);
     }
@@ -73,7 +73,7 @@ fn test_unique() {
 }
 
 fn test_unique_rec() {
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     {
         let _a = box BoxR {
             x: r(i)
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index 0644fbbc99f..d3f62f9d04a 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -40,7 +40,7 @@ mod rusti {
 
 pub fn main() {
     unsafe {
-        let mut x = box 1i;
+        let mut x = box 1;
 
         assert_eq!(rusti::atomic_load(&*x), 1);
         *x = 5;
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index fb04f67e380..0daf661c2f6 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -23,7 +23,7 @@ mod rusti {
 
 pub fn main() {
     unsafe {
-        let x = box 1i;
+        let x = box 1;
         let mut y = rusti::init();
         let mut z: *const uint = transmute(&x);
         rusti::move_val_init(&mut y, x);
diff --git a/src/test/run-pass/issue-10626.rs b/src/test/run-pass/issue-10626.rs
index 880a8b4d2e0..79a0a54f834 100644
--- a/src/test/run-pass/issue-10626.rs
+++ b/src/test/run-pass/issue-10626.rs
@@ -19,10 +19,10 @@ pub fn main () {
     let args = os::args();
     let args = args.as_slice();
     if args.len() > 1 && args[1].as_slice() == "child" {
-        for _ in 0i..1000i {
+        for _ in 0..1000 {
             println!("hello?");
         }
-        for _ in 0i..1000i {
+        for _ in 0..1000 {
             println!("hello?");
         }
         return;
diff --git a/src/test/run-pass/issue-10638.rs b/src/test/run-pass/issue-10638.rs
index a4ef77df311..bc77b4c5343 100644
--- a/src/test/run-pass/issue-10638.rs
+++ b/src/test/run-pass/issue-10638.rs
@@ -13,6 +13,6 @@ pub fn main() {
     ////////////////// still not a doc comment
     /////**** nope, me neither */
     /*** And neither am I! */
-    5i;
+    5;
     /*****! certainly not I */
 }
diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs
index 194208620a8..d7c6c1b1bb2 100644
--- a/src/test/run-pass/issue-11205.rs
+++ b/src/test/run-pass/issue-11205.rs
@@ -22,45 +22,45 @@ fn bar(_: [Box<Foo>; 2]) {}
 fn bars(_: &[Box<Foo>]) {}
 
 fn main() {
-    let x: [&Foo; 2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1, &2];
     foo(x);
-    foo([&1i, &2i]);
+    foo([&1, &2]);
 
-    let r = &1i;
+    let r = &1;
     let x: [&Foo; 2] = [r; 2];
     foo(x);
-    foo([&1i; 2]);
+    foo([&1; 2]);
 
-    let x: &[&Foo] = &[&1i, &2i];
+    let x: &[&Foo] = &[&1, &2];
     foos(x);
-    foos(&[&1i, &2i]);
+    foos(&[&1, &2]);
 
-    let x: &[&Foo] = &[&1i, &2i];
-    let r = &1i;
+    let x: &[&Foo] = &[&1, &2];
+    let r = &1;
     foog(x, &[r]);
 
-    let x: [Box<Foo>; 2] = [box 1i, box 2i];
+    let x: [Box<Foo>; 2] = [box 1, box 2];
     bar(x);
-    bar([box 1i, box 2i]);
+    bar([box 1, box 2]);
 
-    let x: &[Box<Foo>] = &[box 1i, box 2i];
+    let x: &[Box<Foo>] = &[box 1, box 2];
     bars(x);
-    bars(&[box 1i, box 2i]);
+    bars(&[box 1, box 2]);
 
-    let x: &[Box<Foo>] = &[box 1i, box 2i];
-    foog(x, &[box 1i]);
+    let x: &[Box<Foo>] = &[box 1, box 2];
+    foog(x, &[box 1]);
 
     struct T<'a> {
         t: [&'a (Foo+'a); 2]
     }
     let _n = T {
-        t: [&1i, &2i]
+        t: [&1, &2]
     };
-    let r = &1i;
+    let r = &1;
     let _n = T {
         t: [r; 2]
     };
-    let x: [&Foo; 2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1, &2];
     let _n = T {
         t: x
     };
@@ -69,14 +69,14 @@ fn main() {
         t: &'b [&'b (Foo+'b)]
     }
     let _n = F {
-        t: &[&1i, &2i]
+        t: &[&1, &2]
     };
-    let r = &1i;
+    let r = &1;
     let r: [&Foo; 2] = [r; 2];
     let _n = F {
         t: &r
     };
-    let x: [&Foo; 2] = [&1i, &2i];
+    let x: [&Foo; 2] = [&1, &2];
     let _n = F {
         t: &x
     };
@@ -85,9 +85,9 @@ fn main() {
         t: &'a [Box<Foo+'static>]
     }
     let _n = M {
-        t: &[box 1i, box 2i]
+        t: &[box 1, box 2]
     };
-    let x: [Box<Foo>; 2] = [box 1i, box 2i];
+    let x: [Box<Foo>; 2] = [box 1, box 2];
     let _n = M {
         t: &x
     };
diff --git a/src/test/run-pass/issue-11225-1.rs b/src/test/run-pass/issue-11225-1.rs
index 7d1c93fe9a4..a45d129ade2 100644
--- a/src/test/run-pass/issue-11225-1.rs
+++ b/src/test/run-pass/issue-11225-1.rs
@@ -13,5 +13,5 @@
 extern crate "issue-11225-1" as foo;
 
 pub fn main() {
-    foo::foo(1i);
+    foo::foo(1);
 }
diff --git a/src/test/run-pass/issue-11225-2.rs b/src/test/run-pass/issue-11225-2.rs
index 7f36c38283b..f07957b30ec 100644
--- a/src/test/run-pass/issue-11225-2.rs
+++ b/src/test/run-pass/issue-11225-2.rs
@@ -13,5 +13,5 @@
 extern crate "issue-11225-2" as foo;
 
 pub fn main() {
-    foo::foo(1i);
+    foo::foo(1);
 }
diff --git a/src/test/run-pass/issue-11958.rs b/src/test/run-pass/issue-11958.rs
index 13177880c5a..00613f35f17 100644
--- a/src/test/run-pass/issue-11958.rs
+++ b/src/test/run-pass/issue-11958.rs
@@ -19,6 +19,6 @@
 use std::thunk::Thunk;
 
 pub fn main() {
-    let mut x = 1i;
+    let mut x = 1i32;
     let _thunk = Thunk::new(move|| { x = 2; });
 }
diff --git a/src/test/run-pass/issue-1257.rs b/src/test/run-pass/issue-1257.rs
index ad3a050dde9..7d5bd9d6a74 100644
--- a/src/test/run-pass/issue-1257.rs
+++ b/src/test/run-pass/issue-1257.rs
@@ -10,7 +10,7 @@
 
 pub fn main () {
   let mut line = "".to_string();
-  let mut i = 0i;
+  let mut i = 0;
   while line != "exit".to_string() {
     line = if i == 9 { "exit".to_string() } else { "notexit".to_string() };
     i += 1;
diff --git a/src/test/run-pass/issue-12582.rs b/src/test/run-pass/issue-12582.rs
index ab2abc094f4..4009d17139d 100644
--- a/src/test/run-pass/issue-12582.rs
+++ b/src/test/run-pass/issue-12582.rs
@@ -11,10 +11,10 @@
 // ignore-lexer-test FIXME #15877
 
 pub fn main() {
-    let x = 1i;
-    let y = 2i;
+    let x = 1;
+    let y = 2;
 
-    assert_eq!(3i, match (x, y) {
+    assert_eq!(3, match (x, y) {
         (1, 1) => 1,
         (2, 2) => 2,
         (1...2, 2) => 3,
@@ -22,7 +22,7 @@ pub fn main() {
     });
 
     // nested tuple
-    assert_eq!(3i, match ((x, y),) {
+    assert_eq!(3, match ((x, y),) {
         ((1, 1),) => 1,
         ((2, 2),) => 2,
         ((1...2, 2),) => 3,
diff --git a/src/test/run-pass/issue-12744.rs b/src/test/run-pass/issue-12744.rs
index ec929a9c792..2f7ba315aa1 100644
--- a/src/test/run-pass/issue-12744.rs
+++ b/src/test/run-pass/issue-12744.rs
@@ -12,6 +12,6 @@
 #![feature(box_syntax)]
 
 fn main() {
-    fn test() -> Box<std::any::Any + 'static> { box 1i }
+    fn test() -> Box<std::any::Any + 'static> { box 1 }
     println!("{:?}", test())
 }
diff --git a/src/test/run-pass/issue-12909.rs b/src/test/run-pass/issue-12909.rs
index dfdf979fcec..3075bae44fe 100644
--- a/src/test/run-pass/issue-12909.rs
+++ b/src/test/run-pass/issue-12909.rs
@@ -15,7 +15,7 @@ fn copy<T: Copy>(&x: &T) -> T {
 }
 
 fn main() {
-    let arr = [(1i, 1u), (2, 2), (3, 3)];
+    let arr = [(1, 1u), (2, 2), (3, 3)];
 
     let v1: Vec<&_> = arr.iter().collect();
     let v2: Vec<_> = arr.iter().map(copy).collect();
diff --git a/src/test/run-pass/issue-13027.rs b/src/test/run-pass/issue-13027.rs
index 1f61da2f424..649cf63e84a 100644
--- a/src/test/run-pass/issue-13027.rs
+++ b/src/test/run-pass/issue-13027.rs
@@ -29,99 +29,99 @@ pub fn main() {
 }
 
 fn lit_shadow_range() {
-    assert_eq!(2i, match 1i {
-        1 if false => 1i,
+    assert_eq!(2, match 1 {
+        1 if false => 1,
         1...2 => 2,
         _ => 3
     });
 
-    let x = 0i;
-    assert_eq!(2i, match x+1 {
-        0 => 0i,
+    let x = 0;
+    assert_eq!(2, match x+1 {
+        0 => 0,
         1 if false => 1,
         1...2 => 2,
         _ => 3
     });
 
-    assert_eq!(2i, match val() {
-        1 if false => 1i,
+    assert_eq!(2, match val() {
+        1 if false => 1,
         1...2 => 2,
         _ => 3
     });
 
-    assert_eq!(2i, match CONST {
-        0 => 0i,
+    assert_eq!(2, match CONST {
+        0 => 0,
         1 if false => 1,
         1...2 => 2,
         _ => 3
     });
 
     // value is out of the range of second arm, should match wildcard pattern
-    assert_eq!(3i, match 3i {
-        1 if false => 1i,
+    assert_eq!(3, match 3 {
+        1 if false => 1,
         1...2 => 2,
         _ => 3
     });
 }
 
 fn range_shadow_lit() {
-    assert_eq!(2i, match 1i {
-        1...2 if false => 1i,
+    assert_eq!(2, match 1 {
+        1...2 if false => 1,
         1 => 2,
         _ => 3
     });
 
-    let x = 0i;
-    assert_eq!(2i, match x+1 {
-        0 => 0i,
+    let x = 0;
+    assert_eq!(2, match x+1 {
+        0 => 0,
         1...2 if false => 1,
         1 => 2,
         _ => 3
     });
 
-    assert_eq!(2i, match val() {
-        1...2 if false => 1i,
+    assert_eq!(2, match val() {
+        1...2 if false => 1,
         1 => 2,
         _ => 3
     });
 
-    assert_eq!(2i, match CONST {
-        0 => 0i,
+    assert_eq!(2, match CONST {
+        0 => 0,
         1...2 if false => 1,
         1 => 2,
         _ => 3
     });
 
     // ditto
-    assert_eq!(3i, match 3i {
-        1...2 if false => 1i,
+    assert_eq!(3, match 3 {
+        1...2 if false => 1,
         1 => 2,
         _ => 3
     });
 }
 
 fn range_shadow_range() {
-    assert_eq!(2i, match 1i {
-        0...2 if false => 1i,
+    assert_eq!(2, match 1 {
+        0...2 if false => 1,
         1...3 => 2,
         _ => 3,
     });
 
-    let x = 0i;
-    assert_eq!(2i, match x+1 {
+    let x = 0;
+    assert_eq!(2, match x+1 {
         100 => 0,
         0...2 if false => 1,
         1...3 => 2,
         _ => 3,
     });
 
-    assert_eq!(2i, match val() {
+    assert_eq!(2, match val() {
         0...2 if false => 1,
         1...3 => 2,
         _ => 3,
     });
 
-    assert_eq!(2i, match CONST {
+    assert_eq!(2, match CONST {
         100 => 0,
         0...2 if false => 1,
         1...3 => 2,
@@ -129,16 +129,16 @@ fn range_shadow_range() {
     });
 
     // ditto
-    assert_eq!(3i, match 5i {
-        0...2 if false => 1i,
+    assert_eq!(3, match 5 {
+        0...2 if false => 1,
         1...3 => 2,
         _ => 3,
     });
 }
 
 fn multi_pats_shadow_lit() {
-    assert_eq!(2i, match 1i {
-        100 => 0i,
+    assert_eq!(2, match 1 {
+        100 => 0,
         0 | 1...10 if false => 1,
         1 => 2,
         _ => 3,
@@ -146,8 +146,8 @@ fn multi_pats_shadow_lit() {
 }
 
 fn multi_pats_shadow_range() {
-    assert_eq!(2i, match 1i {
-        100 => 0i,
+    assert_eq!(2, match 1 {
+        100 => 0,
         0 | 1...10 if false => 1,
         1...3 => 2,
         _ => 3,
@@ -155,8 +155,8 @@ fn multi_pats_shadow_range() {
 }
 
 fn lit_shadow_multi_pats() {
-    assert_eq!(2i, match 1i {
-        100 => 0i,
+    assert_eq!(2, match 1 {
+        100 => 0,
         1 if false => 1,
         0 | 1...10 => 2,
         _ => 3,
@@ -164,8 +164,8 @@ fn lit_shadow_multi_pats() {
 }
 
 fn range_shadow_multi_pats() {
-    assert_eq!(2i, match 1i {
-        100 => 0i,
+    assert_eq!(2, match 1 {
+        100 => 0,
         1...3 if false => 1,
         0 | 1...10 => 2,
         _ => 3,
@@ -180,9 +180,9 @@ fn misc() {
     // which is a rare combination of vector patterns, multiple wild-card
     // patterns and guard functions.
     let r = match [Foo::Bar(0, false)].as_slice() {
-        [Foo::Bar(_, pred)] if pred => 1i,
-        [Foo::Bar(_, pred)] if !pred => 2i,
-        _ => 0i,
+        [Foo::Bar(_, pred)] if pred => 1,
+        [Foo::Bar(_, pred)] if !pred => 2,
+        _ => 0,
     };
-    assert_eq!(2i, r);
+    assert_eq!(2, r);
 }
diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs
index c10fd7328a1..5025d403468 100644
--- a/src/test/run-pass/issue-13494.rs
+++ b/src/test/run-pass/issue-13494.rs
@@ -24,7 +24,7 @@ fn main() {
     let (tx, rx) = channel();
     let _t = Thread::spawn(move|| { helper(rx) });
     let (snd, rcv) = channel::<int>();
-    for _ in 1i..100000i {
+    for _ in 1..100000 {
         snd.send(1i).unwrap();
         let (tx2, rx2) = channel();
         tx.send(tx2).unwrap();
diff --git a/src/test/run-pass/issue-13867.rs b/src/test/run-pass/issue-13867.rs
index 00ff837b981..960884c4aa5 100644
--- a/src/test/run-pass/issue-13867.rs
+++ b/src/test/run-pass/issue-13867.rs
@@ -18,39 +18,39 @@ enum Foo {
 
 fn main() {
     let r = match (Foo::FooNullary, 'a') {
-        (Foo::FooUint(..), 'a'...'z') => 1i,
-        (Foo::FooNullary, 'x') => 2i,
+        (Foo::FooUint(..), 'a'...'z') => 1,
+        (Foo::FooNullary, 'x') => 2,
         _ => 0
     };
     assert_eq!(r, 0);
 
     let r = match (Foo::FooUint(0), 'a') {
-        (Foo::FooUint(1), 'a'...'z') => 1i,
-        (Foo::FooUint(..), 'x') => 2i,
-        (Foo::FooNullary, 'a') => 3i,
+        (Foo::FooUint(1), 'a'...'z') => 1,
+        (Foo::FooUint(..), 'x') => 2,
+        (Foo::FooNullary, 'a') => 3,
         _ => 0
     };
     assert_eq!(r, 0);
 
     let r = match ('a', Foo::FooUint(0)) {
-        ('a'...'z', Foo::FooUint(1)) => 1i,
-        ('x', Foo::FooUint(..)) => 2i,
-        ('a', Foo::FooNullary) => 3i,
+        ('a'...'z', Foo::FooUint(1)) => 1,
+        ('x', Foo::FooUint(..)) => 2,
+        ('a', Foo::FooNullary) => 3,
         _ => 0
     };
     assert_eq!(r, 0);
 
     let r = match ('a', 'a') {
-        ('a'...'z', 'b') => 1i,
-        ('x', 'a'...'z') => 2i,
+        ('a'...'z', 'b') => 1,
+        ('x', 'a'...'z') => 2,
         _ => 0
     };
     assert_eq!(r, 0);
 
     let r = match ('a', 'a') {
-        ('a'...'z', 'b') => 1i,
-        ('x', 'a'...'z') => 2i,
-        ('a', 'a') => 3i,
+        ('a'...'z', 'b') => 1,
+        ('x', 'a'...'z') => 2,
+        ('a', 'a') => 3,
         _ => 0
     };
     assert_eq!(r, 3);
diff --git a/src/test/run-pass/issue-14308.rs b/src/test/run-pass/issue-14308.rs
index 82a1a16ba57..0e4b4a2c9cf 100644
--- a/src/test/run-pass/issue-14308.rs
+++ b/src/test/run-pass/issue-14308.rs
@@ -13,12 +13,12 @@ struct B;
 
 fn main() {
     let x = match A(3) {
-        A(..) => 1i
+        A(..) => 1
     };
     assert_eq!(x, 1);
     let x = match A(4) {
-        A(1) => 1i,
-        A(..) => 2i
+        A(1) => 1,
+        A(..) => 2
     };
     assert_eq!(x, 2);
 
@@ -26,7 +26,7 @@ fn main() {
     // There's no particularly good reason to support this, but it's currently allowed,
     // and this makes sure it doesn't ICE or break LLVM.
     let x = match B {
-        B(..) => 3i
+        B(..) => 3
     };
     assert_eq!(x, 3);
 }
diff --git a/src/test/run-pass/issue-1460.rs b/src/test/run-pass/issue-1460.rs
index 2091a5437c2..e7516639db0 100644
--- a/src/test/run-pass/issue-1460.rs
+++ b/src/test/run-pass/issue-1460.rs
@@ -10,5 +10,5 @@
 
 
 pub fn main() {
-    {|&: i| if 1i == i { }};
+    {|&: i| if 1 == i { }};
 }
diff --git a/src/test/run-pass/issue-14865.rs b/src/test/run-pass/issue-14865.rs
index 53af0c8635c..c322346c2a6 100644
--- a/src/test/run-pass/issue-14865.rs
+++ b/src/test/run-pass/issue-14865.rs
@@ -15,14 +15,14 @@ enum X {
 
 fn main() {
     let x = match X::Foo(42) {
-        X::Foo(..) => 1i,
+        X::Foo(..) => 1,
         _ if true => 0,
         X::Bar(..) => panic!("Oh dear")
     };
     assert_eq!(x, 1);
 
     let x = match X::Foo(42) {
-        _ if true => 0i,
+        _ if true => 0,
         X::Foo(..) => 1,
         X::Bar(..) => panic!("Oh dear")
     };
diff --git a/src/test/run-pass/issue-15080.rs b/src/test/run-pass/issue-15080.rs
index 76b8463a417..9752b01e52b 100644
--- a/src/test/run-pass/issue-15080.rs
+++ b/src/test/run-pass/issue-15080.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let mut x: &[_] = &[1i, 2, 3, 4];
+    let mut x: &[_] = &[1, 2, 3, 4];
 
     let mut result = vec!();
     loop {
diff --git a/src/test/run-pass/issue-15221.rs b/src/test/run-pass/issue-15221.rs
index e3c102e01ec..49e5b14aff8 100644
--- a/src/test/run-pass/issue-15221.rs
+++ b/src/test/run-pass/issue-15221.rs
@@ -17,7 +17,7 @@ macro_rules! outer {
 }
 
 fn main() {
-    let outer!(g1) = 13i;
+    let outer!(g1) = 13;
     g1;
 }
 
diff --git a/src/test/run-pass/issue-15571.rs b/src/test/run-pass/issue-15571.rs
index 6b273b5786a..7d53b672951 100644
--- a/src/test/run-pass/issue-15571.rs
+++ b/src/test/run-pass/issue-15571.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 fn match_on_local() {
-    let mut foo = Some(box 5i);
+    let mut foo = Some(box 5);
     match foo {
         None => {},
         Some(x) => {
@@ -22,7 +22,7 @@ fn match_on_local() {
     println!("'{}'", foo.unwrap());
 }
 
-fn match_on_arg(mut foo: Option<Box<int>>) {
+fn match_on_arg(mut foo: Option<Box<i32>>) {
     match foo {
         None => {}
         Some(x) => {
@@ -33,7 +33,7 @@ fn match_on_arg(mut foo: Option<Box<int>>) {
 }
 
 fn match_on_binding() {
-    match Some(box 7i) {
+    match Some(box 7) {
         mut foo => {
             match foo {
                 None => {},
@@ -47,7 +47,7 @@ fn match_on_binding() {
 }
 
 fn match_on_upvar() {
-    let mut foo = Some(box 8i);
+    let mut foo = Some(box 8i32);
     let f = move|:| {
         match foo {
             None => {},
@@ -62,7 +62,7 @@ fn match_on_upvar() {
 
 fn main() {
     match_on_local();
-    match_on_arg(Some(box 6i));
+    match_on_arg(Some(box 6));
     match_on_binding();
     match_on_upvar();
 }
diff --git a/src/test/run-pass/issue-15763.rs b/src/test/run-pass/issue-15763.rs
index f30991a1963..7bfd8e0ab71 100644
--- a/src/test/run-pass/issue-15763.rs
+++ b/src/test/run-pass/issue-15763.rs
@@ -87,12 +87,12 @@ fn main() {
     assert_eq!(cc().unwrap(), 3);
     assert_eq!(dd().unwrap(), 3);
 
-    let i = box 32i as Box<A>;
+    let i = box 32 as Box<A>;
     assert_eq!(i.aaa(), 3);
-    let i = box 32i as Box<A>;
+    let i = box 32 as Box<A>;
     assert_eq!(i.bbb(), 3);
-    let i = box 32i as Box<A>;
+    let i = box 32 as Box<A>;
     assert_eq!(i.ccc().unwrap(), 3);
-    let i = box 32i as Box<A>;
+    let i = box 32 as Box<A>;
     assert_eq!(i.ddd().unwrap(), 3);
 }
diff --git a/src/test/run-pass/issue-15924.rs b/src/test/run-pass/issue-15924.rs
index db9f1cc9df7..88b250af1c0 100644
--- a/src/test/run-pass/issue-15924.rs
+++ b/src/test/run-pass/issue-15924.rs
@@ -28,5 +28,5 @@ impl<T: Encodable> Drop for Foo<T> {
 }
 
 fn main() {
-    let _ = Foo { v: 10i };
+    let _ = Foo { v: 10 };
 }
diff --git a/src/test/run-pass/issue-16648.rs b/src/test/run-pass/issue-16648.rs
index 7ddb20811a3..0b58df56b6f 100644
--- a/src/test/run-pass/issue-16648.rs
+++ b/src/test/run-pass/issue-16648.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 fn main() {
-    let x: (int, &[int]) = (2i, &[1i, 2i]);
+    let x: (int, &[int]) = (2, &[1, 2]);
     assert_eq!(match x {
         (0, [_, _]) => 0,
         (1, _) => 1,
         (2, [_, _]) => 2,
         (2, _) => 3,
         _ => 4
-    }, 2i);
+    }, 2);
 }
diff --git a/src/test/run-pass/issue-16774.rs b/src/test/run-pass/issue-16774.rs
index 175e2188811..d426f82f89f 100644
--- a/src/test/run-pass/issue-16774.rs
+++ b/src/test/run-pass/issue-16774.rs
@@ -45,7 +45,7 @@ impl DerefMut for X {
 
 fn main() {
     {
-        let mut test = X(box 5i);
+        let mut test = X(box 5);
         {
             let mut change = |&mut:| { *test = 10 };
             change();
diff --git a/src/test/run-pass/issue-17074.rs b/src/test/run-pass/issue-17074.rs
index d35c3a587c5..d367e0e908e 100644
--- a/src/test/run-pass/issue-17074.rs
+++ b/src/test/run-pass/issue-17074.rs
@@ -17,6 +17,6 @@ fn main() {
     assert_eq!(match 1 {
         X => unreachable!(),
         Y => unreachable!(),
-        _ => 1i
+        _ => 1
     }, 1);
 }
diff --git a/src/test/run-pass/issue-19244.rs b/src/test/run-pass/issue-19244.rs
index 3ee5ce9bff9..9af4d30c4f6 100644
--- a/src/test/run-pass/issue-19244.rs
+++ b/src/test/run-pass/issue-19244.rs
@@ -13,8 +13,8 @@ const STRUCT: MyStruct = MyStruct { field: 42 };
 const TUP: (uint,) = (43,);
 
 fn main() {
-    let a = [0i; STRUCT.field];
-    let b = [0i; TUP.0];
+    let a = [0; STRUCT.field];
+    let b = [0; TUP.0];
 
     assert!(a.len() == 42);
     assert!(b.len() == 43);
diff --git a/src/test/run-pass/issue-19358.rs b/src/test/run-pass/issue-19358.rs
index 37d05453914..ff657376ecc 100644
--- a/src/test/run-pass/issue-19358.rs
+++ b/src/test/run-pass/issue-19358.rs
@@ -23,7 +23,7 @@ struct Bar<T> where T: Trait {
 impl Trait for int {}
 
 fn main() {
-    let a = Foo { foo: 12i };
-    let b = Bar { bar: 12i };
+    let a = Foo { foo: 12 };
+    let b = Bar { bar: 12 };
     println!("{:?} {:?}", a, b);
 }
diff --git a/src/test/run-pass/issue-19367.rs b/src/test/run-pass/issue-19367.rs
index 7db84d518ff..d5bb6ebb7de 100644
--- a/src/test/run-pass/issue-19367.rs
+++ b/src/test/run-pass/issue-19367.rs
@@ -16,7 +16,7 @@ struct S {
 // on field of struct or tuple which we reassign in the match body.
 
 fn main() {
-    let mut a = (0i, Some("right".to_string()));
+    let mut a = (0, Some("right".to_string()));
     let b = match a.1 {
         Some(v) => {
             a.1 = Some("wrong".to_string());
diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs
index 98e6e051343..c2f74a9d653 100644
--- a/src/test/run-pass/issue-2216.rs
+++ b/src/test/run-pass/issue-2216.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut x = 0i;
+    let mut x = 0;
 
     'foo: loop {
         'bar: loop {
             'quux: loop {
-                if 1i == 2 {
+                if 1 == 2 {
                     break 'foo;
                 }
                 else {
diff --git a/src/test/run-pass/issue-2383.rs b/src/test/run-pass/issue-2383.rs
index 94bff890820..b8136323df6 100644
--- a/src/test/run-pass/issue-2383.rs
+++ b/src/test/run-pass/issue-2383.rs
@@ -14,5 +14,5 @@ use std::collections::RingBuf;
 
 pub fn main() {
     let mut q = RingBuf::new();
-    q.push_front(10i);
+    q.push_front(10);
 }
diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs
index afa053de243..7ed26428be0 100644
--- a/src/test/run-pass/issue-2428.rs
+++ b/src/test/run-pass/issue-2428.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let _foo = 100i;
+    let _foo = 100;
     const quux: int = 5;
 
     enum Stuff {
diff --git a/src/test/run-pass/issue-2633-2.rs b/src/test/run-pass/issue-2633-2.rs
index c146f8a7a9a..80e9ca47025 100644
--- a/src/test/run-pass/issue-2633-2.rs
+++ b/src/test/run-pass/issue-2633-2.rs
@@ -17,6 +17,6 @@ fn a_val(x: Box<int>, y: Box<int>) -> int {
 }
 
 pub fn main() {
-    let z = box 22i;
+    let z = box 22;
     a_val(z.clone(), z.clone());
 }
diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs
index 3e4cffe5dfa..7ca439a1a19 100644
--- a/src/test/run-pass/issue-2734.rs
+++ b/src/test/run-pass/issue-2734.rs
@@ -23,5 +23,5 @@ fn deadcode() {
 }
 
 pub fn main() {
-    let _ = perform_hax(box 42i);
+    let _ = perform_hax(box 42);
 }
diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs
index cb376d0e439..962359537bf 100644
--- a/src/test/run-pass/issue-2735.rs
+++ b/src/test/run-pass/issue-2735.rs
@@ -23,5 +23,5 @@ fn deadcode() {
 }
 
 pub fn main() {
-    perform_hax(box 42i);
+    perform_hax(box 42);
 }
diff --git a/src/test/run-pass/issue-2935.rs b/src/test/run-pass/issue-2935.rs
index 295fd538de6..31599d0caad 100644
--- a/src/test/run-pass/issue-2935.rs
+++ b/src/test/run-pass/issue-2935.rs
@@ -24,9 +24,9 @@ impl it for t {
 }
 
 pub fn main() {
-  //    let x = ({a: 4i} as it);
-  //   let y = box ({a: 4i});
-  //    let z = box ({a: 4i} as it);
+  //    let x = ({a: 4} as it);
+  //   let y = box ({a: 4});
+  //    let z = box ({a: 4} as it);
   //    let z = box ({a: true} as it);
     let z = box() (box true as Box<it>);
     //  x.f();
diff --git a/src/test/run-pass/issue-3091.rs b/src/test/run-pass/issue-3091.rs
index 2e287e24e23..c4c2c2b7da8 100644
--- a/src/test/run-pass/issue-3091.rs
+++ b/src/test/run-pass/issue-3091.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = 1i;
-    let y = 1i;
+    let x = 1;
+    let y = 1;
     assert_eq!(&x, &y);
 }
diff --git a/src/test/run-pass/issue-3211.rs b/src/test/run-pass/issue-3211.rs
index c908c073d4f..28c9bf1e83a 100644
--- a/src/test/run-pass/issue-3211.rs
+++ b/src/test/run-pass/issue-3211.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut x = 0i;
-    for _ in 0i..4096 { x += 1; }
+    let mut x = 0;
+    for _ in 0..4096 { x += 1; }
     assert_eq!(x, 4096);
     println!("x = {}", x);
 }
diff --git a/src/test/run-pass/issue-3290.rs b/src/test/run-pass/issue-3290.rs
index a72b272abaa..c8d6e69801f 100644
--- a/src/test/run-pass/issue-3290.rs
+++ b/src/test/run-pass/issue-3290.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-   let mut x = box 3i;
+   let mut x = box 3;
    x = x;
    assert_eq!(*x, 3);
 }
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index ef49d0a170f..1217f32826f 100644
--- a/src/test/run-pass/issue-333.rs
+++ b/src/test/run-pass/issue-333.rs
@@ -12,4 +12,4 @@ fn quux<T>(x: T) -> T { let f = id::<T>; return f(x); }
 
 fn id<T>(x: T) -> T { return x; }
 
-pub fn main() { assert!((quux(10i) == 10i)); }
+pub fn main() { assert!((quux(10) == 10)); }
diff --git a/src/test/run-pass/issue-3500.rs b/src/test/run-pass/issue-3500.rs
index eb422c9a8b9..99def5476f9 100644
--- a/src/test/run-pass/issue-3500.rs
+++ b/src/test/run-pass/issue-3500.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = &Some(1i);
+    let x = &Some(1);
     match x {
         &Some(_) => (),
         &None => (),
diff --git a/src/test/run-pass/issue-3559.rs b/src/test/run-pass/issue-3559.rs
index 0118fce4ec3..69a148d4108 100644
--- a/src/test/run-pass/issue-3559.rs
+++ b/src/test/run-pass/issue-3559.rs
@@ -22,8 +22,8 @@ fn check_strs(actual: &str, expected: &str) -> bool {
 
 pub fn main() {
     let mut table = HashMap::new();
-    table.insert("one".to_string(), 1i);
-    table.insert("two".to_string(), 2i);
+    table.insert("one".to_string(), 1);
+    table.insert("two".to_string(), 2);
     assert!(check_strs(format!("{:?}", table).as_slice(), "HashMap {\"one\": 1, \"two\": 2}") ||
             check_strs(format!("{:?}", table).as_slice(), "HashMap {\"two\": 2, \"one\": 1}"));
 }
diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs
index 5434e44c173..c1d19f228db 100644
--- a/src/test/run-pass/issue-3878.rs
+++ b/src/test/run-pass/issue-3878.rs
@@ -13,6 +13,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let y = box 1i;
+    let y = box 1;
     y;
 }
diff --git a/src/test/run-pass/issue-4387.rs b/src/test/run-pass/issue-4387.rs
index 43948ef4a45..02601ba2f2a 100644
--- a/src/test/run-pass/issue-4387.rs
+++ b/src/test/run-pass/issue-4387.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _foo = [0i; 2*4];
+    let _foo = [0; 2*4];
 }
diff --git a/src/test/run-pass/issue-4401.rs b/src/test/run-pass/issue-4401.rs
index a03253b8efb..e4fea724c79 100644
--- a/src/test/run-pass/issue-4401.rs
+++ b/src/test/run-pass/issue-4401.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut count = 0i;
-    for _ in 0i..999_999 { count += 1; }
+    let mut count = 0;
+    for _ in 0..999_999 { count += 1; }
     assert_eq!(count, 999_999);
     println!("{}", count);
 }
diff --git a/src/test/run-pass/issue-5708.rs b/src/test/run-pass/issue-5708.rs
index 61ae273aef5..fd39bcc6b61 100644
--- a/src/test/run-pass/issue-5708.rs
+++ b/src/test/run-pass/issue-5708.rs
@@ -41,7 +41,7 @@ impl<'a> Outer<'a> {
 }
 
 pub fn main() {
-    let inner = 5i;
+    let inner = 5;
     let outer = Outer::new(&inner as &Inner);
     outer.inner.print();
 }
diff --git a/src/test/run-pass/issue-6117.rs b/src/test/run-pass/issue-6117.rs
index 85de03dfe34..93edffdcb47 100644
--- a/src/test/run-pass/issue-6117.rs
+++ b/src/test/run-pass/issue-6117.rs
@@ -14,7 +14,7 @@
 enum Either<T, U> { Left(T), Right(U) }
 
 pub fn main() {
-    match Either::Left(box 17i) {
+    match Either::Left(box 17) {
         Either::Right(()) => {}
         _ => {}
     }
diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs
index b9f1a8bda7b..1d8fe8bfce8 100644
--- a/src/test/run-pass/issue-6318.rs
+++ b/src/test/run-pass/issue-6318.rs
@@ -23,7 +23,7 @@ impl Foo for Struct {}
 
 pub fn main() {
     match Thing::A(box Struct as Box<Foo+'static>) {
-        Thing::A(_a) => 0i,
+        Thing::A(_a) => 0,
     };
 }
 
diff --git a/src/test/run-pass/issue-7178.rs b/src/test/run-pass/issue-7178.rs
index 4acb4959724..6ef740b2a50 100644
--- a/src/test/run-pass/issue-7178.rs
+++ b/src/test/run-pass/issue-7178.rs
@@ -13,5 +13,5 @@
 extern crate "issue-7178" as cross_crate_self;
 
 pub fn main() {
-    let _ = cross_crate_self::Foo::new(&1i);
+    let _ = cross_crate_self::Foo::new(&1);
 }
diff --git a/src/test/run-pass/issue-7575.rs b/src/test/run-pass/issue-7575.rs
index d60e5caee68..225213db6a4 100644
--- a/src/test/run-pass/issue-7575.rs
+++ b/src/test/run-pass/issue-7575.rs
@@ -20,5 +20,5 @@ impl Bar for int {}
 impl Foo for int {}
 
 fn main() {
-    assert!(1i.new());
+    assert!(1.new());
 }
diff --git a/src/test/run-pass/issue-7784.rs b/src/test/run-pass/issue-7784.rs
index 882ca00f1df..a61ee8c2a0b 100644
--- a/src/test/run-pass/issue-7784.rs
+++ b/src/test/run-pass/issue-7784.rs
@@ -20,7 +20,7 @@ fn bar(a: &'static str, b: &'static str) -> [&'static str; 4] {
 }
 
 fn main() {
-    assert_eq!(foo([1i, 2i, 3i]), (1i, 3i, 6i));
+    assert_eq!(foo([1, 2, 3]), (1, 3, 6));
 
     let [a, b, c, d] = bar("foo", "bar");
     assert_eq!(a, "foo");
diff --git a/src/test/run-pass/issue-8044.rs b/src/test/run-pass/issue-8044.rs
index c50cf845d00..504441e3ba9 100644
--- a/src/test/run-pass/issue-8044.rs
+++ b/src/test/run-pass/issue-8044.rs
@@ -14,5 +14,5 @@ extern crate "issue-8044" as minimal;
 use minimal::{BTree, leaf};
 
 pub fn main() {
-    BTree::<int> { node: leaf(1i) };
+    BTree::<int> { node: leaf(1) };
 }
diff --git a/src/test/run-pass/issue-8391.rs b/src/test/run-pass/issue-8391.rs
index 468e6563182..86c9b8c6964 100644
--- a/src/test/run-pass/issue-8391.rs
+++ b/src/test/run-pass/issue-8391.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 fn main() {
-    let x = match Some(1i) {
-        ref _y @ Some(_) => 1i,
-        None => 2i,
+    let x = match Some(1) {
+        ref _y @ Some(_) => 1,
+        None => 2,
     };
     assert_eq!(x, 1);
 }
diff --git a/src/test/run-pass/issue-8460.rs b/src/test/run-pass/issue-8460.rs
index 3ea6d5d4f2f..3944895460f 100644
--- a/src/test/run-pass/issue-8460.rs
+++ b/src/test/run-pass/issue-8460.rs
@@ -17,7 +17,7 @@ fn main() {
     assert!(Thread::scoped(move|| i16::MIN / -1).join().is_err());
     assert!(Thread::scoped(move|| i32::MIN / -1).join().is_err());
     assert!(Thread::scoped(move|| i64::MIN / -1).join().is_err());
-    assert!(Thread::scoped(move|| 1i / 0).join().is_err());
+    assert!(Thread::scoped(move|| 1 / 0).join().is_err());
     assert!(Thread::scoped(move|| 1i8 / 0).join().is_err());
     assert!(Thread::scoped(move|| 1i16 / 0).join().is_err());
     assert!(Thread::scoped(move|| 1i32 / 0).join().is_err());
@@ -27,7 +27,7 @@ fn main() {
     assert!(Thread::scoped(move|| i16::MIN % -1).join().is_err());
     assert!(Thread::scoped(move|| i32::MIN % -1).join().is_err());
     assert!(Thread::scoped(move|| i64::MIN % -1).join().is_err());
-    assert!(Thread::scoped(move|| 1i % 0).join().is_err());
+    assert!(Thread::scoped(move|| 1 % 0).join().is_err());
     assert!(Thread::scoped(move|| 1i8 % 0).join().is_err());
     assert!(Thread::scoped(move|| 1i16 % 0).join().is_err());
     assert!(Thread::scoped(move|| 1i32 % 0).join().is_err());
diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs
index 2a2ca4f0712..494b6217855 100644
--- a/src/test/run-pass/issue-8498.rs
+++ b/src/test/run-pass/issue-8498.rs
@@ -12,14 +12,14 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    match &[(box 5i,box 7i)] {
+    match &[(box 5,box 7)] {
         ps => {
            let (ref y, _) = ps[0];
            assert!(**y == 5);
         }
     }
 
-    match Some(&[(box 5i,)]) {
+    match Some(&[(box 5,)]) {
         Some(ps) => {
            let (ref y,) = ps[0];
            assert!(**y == 5);
@@ -27,7 +27,7 @@ pub fn main() {
         None => ()
     }
 
-    match Some(&[(box 5i,box 7i)]) {
+    match Some(&[(box 5,box 7)]) {
         Some(ps) => {
            let (ref y, ref z) = ps[0];
            assert!(**y == 5);
diff --git a/src/test/run-pass/issue-868.rs b/src/test/run-pass/issue-868.rs
index 72bdd1af746..b2ccc092358 100644
--- a/src/test/run-pass/issue-868.rs
+++ b/src/test/run-pass/issue-868.rs
@@ -11,7 +11,7 @@
 fn f<T, F>(g: F) -> T where F: FnOnce() -> T { g() }
 
 pub fn main() {
-  let _x = f( | | { 10i });
+  let _x = f( | | { 10 });
     // used to be: cannot determine a type for this expression
     f(| | { });
     // ditto
diff --git a/src/test/run-pass/issue-8827.rs b/src/test/run-pass/issue-8827.rs
index 80beeb7275c..d7a86749546 100644
--- a/src/test/run-pass/issue-8827.rs
+++ b/src/test/run-pass/issue-8827.rs
@@ -49,7 +49,7 @@ fn main() {
     let ints = integers();
     let threes = periodical(3);
     let fives = periodical(5);
-    for _ in 1i..100i {
+    for _ in 1..100 {
         match (ints.recv().unwrap(), threes.recv().unwrap(), fives.recv().unwrap()) {
             (_, true, true) => println!("FizzBuzz"),
             (_, true, false) => println!("Fizz"),
diff --git a/src/test/run-pass/issue-8860.rs b/src/test/run-pass/issue-8860.rs
index 35f713c4c2c..72e2a33b43e 100644
--- a/src/test/run-pass/issue-8860.rs
+++ b/src/test/run-pass/issue-8860.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static mut DROP: int = 0i;
-static mut DROP_S: int = 0i;
-static mut DROP_T: int = 0i;
+static mut DROP: int = 0;
+static mut DROP_S: int = 0;
+static mut DROP_T: int = 0;
 
 struct S;
 impl Drop for S {
diff --git a/src/test/run-pass/issue-9719.rs b/src/test/run-pass/issue-9719.rs
index 4c6b9a3aaa0..8fc86eb49e7 100644
--- a/src/test/run-pass/issue-9719.rs
+++ b/src/test/run-pass/issue-9719.rs
@@ -17,7 +17,7 @@ mod a {
     impl X for int {}
 
     pub struct Z<'a>(Enum<&'a (X+'a)>);
-    fn foo() { let x = 42i; let z = Z(Enum::A(&x as &X)); let _ = z; }
+    fn foo() { let x = 42; let z = Z(Enum::A(&x as &X)); let _ = z; }
 }
 
 mod b {
@@ -28,7 +28,7 @@ mod b {
     }
 
     fn bar() {
-        let x = 42i;
+        let x = 42;
         let _y = Y { x: Some(&x as &X) };
     }
 }
@@ -37,7 +37,7 @@ mod c {
     pub trait X { fn f(&self); }
     impl X for int { fn f(&self) {} }
     pub struct Z<'a>(Option<&'a (X+'a)>);
-    fn main() { let x = 42i; let z = Z(Some(&x as &X)); let _ = z; }
+    fn main() { let x = 42; let z = Z(Some(&x as &X)); let _ = z; }
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/issue-9906.rs b/src/test/run-pass/issue-9906.rs
index d8e28e449ee..921965b280b 100644
--- a/src/test/run-pass/issue-9906.rs
+++ b/src/test/run-pass/issue-9906.rs
@@ -14,5 +14,5 @@ extern crate "issue-9906" as testmod;
 
 pub fn main() {
     testmod::foo();
-    testmod::FooBar::new(1i);
+    testmod::FooBar::new(1);
 }
diff --git a/src/test/run-pass/issue-9942.rs b/src/test/run-pass/issue-9942.rs
index 321e22cd19c..c7dea719986 100644
--- a/src/test/run-pass/issue-9942.rs
+++ b/src/test/run-pass/issue-9942.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    const S: uint = 23 as uint; [0i; S]; ()
+    const S: uint = 23 as uint; [0; S]; ()
 }
diff --git a/src/test/run-pass/keyword-changes-2012-07-31.rs b/src/test/run-pass/keyword-changes-2012-07-31.rs
index 885f266ca3d..ff568b77f08 100644
--- a/src/test/run-pass/keyword-changes-2012-07-31.rs
+++ b/src/test/run-pass/keyword-changes-2012-07-31.rs
@@ -19,7 +19,7 @@ mod foo {
 }
 
 fn bar() -> int {
-    match 0i {
-      _ => { 0i }
+    match 0 {
+      _ => { 0 }
     }
 }
diff --git a/src/test/run-pass/kindck-owned-trait-contains-1.rs b/src/test/run-pass/kindck-owned-trait-contains-1.rs
index 999fb2c4b69..f05ac11d413 100644
--- a/src/test/run-pass/kindck-owned-trait-contains-1.rs
+++ b/src/test/run-pass/kindck-owned-trait-contains-1.rs
@@ -24,7 +24,7 @@ fn repeater<A:Clone + 'static>(v: Box<A>) -> Box<repeat<A>+'static> {
 }
 
 pub fn main() {
-    let x = 3i;
+    let x = 3;
     let y = repeater(box x);
     assert_eq!(x, y.get());
 }
diff --git a/src/test/run-pass/labeled-break.rs b/src/test/run-pass/labeled-break.rs
index ebfe1e353d8..30c2495d590 100644
--- a/src/test/run-pass/labeled-break.rs
+++ b/src/test/run-pass/labeled-break.rs
@@ -15,13 +15,13 @@ pub fn main() {
         }
     }
 
-    'bar: for _ in 0i..100i {
+    'bar: for _ in 0..100 {
         loop {
             break 'bar;
         }
     }
 
-    'foobar: while 1i + 1 == 2 {
+    'foobar: while 1 + 1 == 2 {
         loop {
             break 'foobar;
         }
diff --git a/src/test/run-pass/last-use-in-cap-clause.rs b/src/test/run-pass/last-use-in-cap-clause.rs
index 9be9f098264..0cdd4d3889c 100644
--- a/src/test/run-pass/last-use-in-cap-clause.rs
+++ b/src/test/run-pass/last-use-in-cap-clause.rs
@@ -17,7 +17,7 @@
 struct A { a: Box<int> }
 
 fn foo() -> Box<FnMut() -> int + 'static> {
-    let k = box 22i;
+    let k = box 22;
     let _u = A {a: k.clone()};
     let result  = |&mut:| 22;
     box result
diff --git a/src/test/run-pass/last-use-is-capture.rs b/src/test/run-pass/last-use-is-capture.rs
index 4a7e844268f..19a780d180f 100644
--- a/src/test/run-pass/last-use-is-capture.rs
+++ b/src/test/run-pass/last-use-is-capture.rs
@@ -17,7 +17,7 @@ struct A { a: Box<int> }
 
 pub fn main() {
     fn invoke<F>(f: F) where F: FnOnce() { f(); }
-    let k = box 22i;
+    let k = box 22;
     let _u = A {a: k.clone()};
     invoke(|| println!("{}", k.clone()) )
 }
diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
index 043961ce599..559c9e78945 100644
--- a/src/test/run-pass/lazy-and-or.rs
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -11,7 +11,7 @@
 fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }
 
 pub fn main() {
-    let x = 1i == 2 || 3i == 3;
+    let x = 1 == 2 || 3 == 3;
     assert!((x));
     let mut y: int = 10;
     println!("{}", x || incr(&mut y));
diff --git a/src/test/run-pass/lazy-init.rs b/src/test/run-pass/lazy-init.rs
index cd8be550d51..60f7689ecfa 100644
--- a/src/test/run-pass/lazy-init.rs
+++ b/src/test/run-pass/lazy-init.rs
@@ -12,4 +12,4 @@
 
 fn foo(x: int) { println!("{}", x); }
 
-pub fn main() { let mut x: int; if 1i > 2 { x = 12; } else { x = 10; } foo(x); }
+pub fn main() { let mut x: int; if 1 > 2 { x = 12; } else { x = 10; } foo(x); }
diff --git a/src/test/run-pass/let-var-hygiene.rs b/src/test/run-pass/let-var-hygiene.rs
index 2287cc48b66..d6409267eb6 100644
--- a/src/test/run-pass/let-var-hygiene.rs
+++ b/src/test/run-pass/let-var-hygiene.rs
@@ -10,10 +10,10 @@
 
 // shouldn't affect evaluation of $ex:
 macro_rules! bad_macro {
-    ($ex:expr) => ({let _x = 9i; $ex})
+    ($ex:expr) => ({let _x = 9; $ex})
 }
 
 pub fn main() {
-    let _x = 8i;
-    assert_eq!(bad_macro!(_x),8i)
+    let _x = 8;
+    assert_eq!(bad_macro!(_x),8)
 }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 6a2140d49cd..eda14222e91 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -11,8 +11,8 @@
 // no-pretty-expanded FIXME #15189
 
 pub fn main() {
-    let x = vec!(1i, 2i, 3i);
-    let mut y = 0i;
+    let x = vec!(1, 2, 3);
+    let mut y = 0;
     for i in x.iter() { println!("{}", *i); y += *i; }
     println!("{}", y);
     assert_eq!(y, 6);
diff --git a/src/test/run-pass/liveness-loop-break.rs b/src/test/run-pass/liveness-loop-break.rs
index 6ad2be68e8f..0dba1830cbd 100644
--- a/src/test/run-pass/liveness-loop-break.rs
+++ b/src/test/run-pass/liveness-loop-break.rs
@@ -11,7 +11,7 @@
 fn test() {
     let v;
     loop {
-        v = 3i;
+        v = 3;
         break;
     }
     println!("{}", v);
diff --git a/src/test/run-pass/log-poly.rs b/src/test/run-pass/log-poly.rs
index ce598c5d382..d8a69177caf 100644
--- a/src/test/run-pass/log-poly.rs
+++ b/src/test/run-pass/log-poly.rs
@@ -14,8 +14,8 @@ enum Numbers {
 }
 
 pub fn main() {
-    println!("{:?}", 1i);
+    println!("{:?}", 1);
     println!("{:?}", 2.0f64);
     println!("{:?}", Numbers::Three);
-    println!("{:?}", vec!(4i));
+    println!("{:?}", vec!(4));
 }
diff --git a/src/test/run-pass/long-while.rs b/src/test/run-pass/long-while.rs
index 7d30b22867c..cbe26844708 100644
--- a/src/test/run-pass/long-while.rs
+++ b/src/test/run-pass/long-while.rs
@@ -14,6 +14,6 @@ pub fn main() {
     let mut i: int = 0;
     while i < 1000000 {
         i += 1;
-        let x = 3i;
+        let x = 3;
     }
 }
diff --git a/src/test/run-pass/loop-diverges.rs b/src/test/run-pass/loop-diverges.rs
index 4fe73188b45..9c46ba2cb9b 100644
--- a/src/test/run-pass/loop-diverges.rs
+++ b/src/test/run-pass/loop-diverges.rs
@@ -16,5 +16,5 @@ fn forever() -> ! {
 }
 
 pub fn main() {
-  if (1i == 2) { forever(); }
+  if (1 == 2) { forever(); }
 }
diff --git a/src/test/run-pass/loop-label-shadowing.rs b/src/test/run-pass/loop-label-shadowing.rs
index 46d4fa460fe..cfe51fe7758 100644
--- a/src/test/run-pass/loop-label-shadowing.rs
+++ b/src/test/run-pass/loop-label-shadowing.rs
@@ -12,7 +12,7 @@
 
 fn main() {
     let mut foo = Vec::new();
-    'foo: for i in [1i, 2, 3].iter() {
+    'foo: for i in [1, 2, 3].iter() {
         foo.push(i);
     }
 }
diff --git a/src/test/run-pass/loop-no-reinit-needed-post-bot.rs b/src/test/run-pass/loop-no-reinit-needed-post-bot.rs
index 0f4dd881698..2582c2e6147 100644
--- a/src/test/run-pass/loop-no-reinit-needed-post-bot.rs
+++ b/src/test/run-pass/loop-no-reinit-needed-post-bot.rs
@@ -17,7 +17,7 @@ fn my_panic() -> ! { loop {} }
 
 pub fn step(f: bool) {
     let mut g = S;
-    let mut i = 0i;
+    let mut i = 0;
     loop
     {
         if i > 10 { break; } else { i += 1; }
diff --git a/src/test/run-pass/loop-scope.rs b/src/test/run-pass/loop-scope.rs
index 4b8ccad068c..1dc3700194c 100644
--- a/src/test/run-pass/loop-scope.rs
+++ b/src/test/run-pass/loop-scope.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = vec!(10i, 20i, 30i);
-    let mut sum = 0i;
+    let x = vec!(10, 20, 30);
+    let mut sum = 0;
     for x in x.iter() { sum += *x; }
     assert_eq!(sum, 60);
 }
diff --git a/src/test/run-pass/macro-crate-def-only.rs b/src/test/run-pass/macro-crate-def-only.rs
index 7505fa6e684..efee9ba963a 100644
--- a/src/test/run-pass/macro-crate-def-only.rs
+++ b/src/test/run-pass/macro-crate-def-only.rs
@@ -14,5 +14,5 @@
 extern crate macro_crate_def_only;
 
 pub fn main() {
-    assert_eq!(5i, make_a_5!());
+    assert_eq!(5, make_a_5!());
 }
diff --git a/src/test/run-pass/macro-export-inner-module.rs b/src/test/run-pass/macro-export-inner-module.rs
index ef22410751c..1c7b2530b90 100644
--- a/src/test/run-pass/macro-export-inner-module.rs
+++ b/src/test/run-pass/macro-export-inner-module.rs
@@ -15,5 +15,5 @@
 extern crate macro_export_inner_module;
 
 pub fn main() {
-    assert_eq!(1i, foo!());
+    assert_eq!(1, foo!());
 }
diff --git a/src/test/run-pass/macro-pat.rs b/src/test/run-pass/macro-pat.rs
index 07b75389cf4..30a74126b49 100644
--- a/src/test/run-pass/macro-pat.rs
+++ b/src/test/run-pass/macro-pat.rs
@@ -51,23 +51,23 @@ pub fn main() {
     assert_eq!(2u, f(Some('y')));
     assert_eq!(3u, f(None));
 
-    assert_eq!(1i, match Some('x') {
-        Some(char_x!()) => 1i,
-        _ => 2i,
+    assert_eq!(1, match Some('x') {
+        Some(char_x!()) => 1,
+        _ => 2,
     });
 
-    assert_eq!(1i, match Some('x') {
-        some!(char_x!()) => 1i,
-        _ => 2i,
+    assert_eq!(1, match Some('x') {
+        some!(char_x!()) => 1,
+        _ => 2,
     });
 
-    assert_eq!(1i, match Some('x') {
-        indirect!() => 1i,
-        _ => 2i,
+    assert_eq!(1, match Some('x') {
+        indirect!() => 1,
+        _ => 2,
     });
 
-    assert_eq!(3i, {
-        let ident_pat!(x) = 2i;
-        x+1i
+    assert_eq!(3, {
+        let ident_pat!(x) = 2;
+        x+1
     });
 }
diff --git a/src/test/run-pass/macro-stmt.rs b/src/test/run-pass/macro-stmt.rs
index cb5370c8bcb..3aa02987098 100644
--- a/src/test/run-pass/macro-stmt.rs
+++ b/src/test/run-pass/macro-stmt.rs
@@ -26,17 +26,17 @@ pub fn main() {
         )
     }
 
-    mylet!(y, 8i*2);
-    assert_eq!(y, 16i);
+    mylet!(y, 8*2);
+    assert_eq!(y, 16);
 
     myfn!(mult, (a,b), { a*b } );
 
     assert_eq!(mult(2, add(4,4)), 16);
 
     macro_rules! actually_an_expr_macro {
-        () => ( 16i )
+        () => ( 16 )
     }
 
-    assert_eq!({ actually_an_expr_macro!() }, 16i);
+    assert_eq!({ actually_an_expr_macro!() }, 16);
 
 }
diff --git a/src/test/run-pass/macro-with-attrs1.rs b/src/test/run-pass/macro-with-attrs1.rs
index 3f9d07466cc..f180922a052 100644
--- a/src/test/run-pass/macro-with-attrs1.rs
+++ b/src/test/run-pass/macro-with-attrs1.rs
@@ -11,11 +11,11 @@
 // compile-flags: --cfg foo
 
 #[cfg(foo)]
-macro_rules! foo { () => (1i) }
+macro_rules! foo { () => (1) }
 
 #[cfg(not(foo))]
-macro_rules! foo { () => (2i) }
+macro_rules! foo { () => (2) }
 
 pub fn main() {
-    assert_eq!(foo!(), 1i);
+    assert_eq!(foo!(), 1);
 }
diff --git a/src/test/run-pass/macro-with-attrs2.rs b/src/test/run-pass/macro-with-attrs2.rs
index f90a0dfa6b3..d683979462b 100644
--- a/src/test/run-pass/macro-with-attrs2.rs
+++ b/src/test/run-pass/macro-with-attrs2.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 #[cfg(foo)]
-macro_rules! foo { () => (1i) }
+macro_rules! foo { () => (1) }
 
 #[cfg(not(foo))]
-macro_rules! foo { () => (2i) }
+macro_rules! foo { () => (2) }
 
 pub fn main() {
-    assert_eq!(foo!(), 2i);
+    assert_eq!(foo!(), 2);
 }
 
diff --git a/src/test/run-pass/match-arm-statics.rs b/src/test/run-pass/match-arm-statics.rs
index 1964bf4bd7d..dfefe84518c 100644
--- a/src/test/run-pass/match-arm-statics.rs
+++ b/src/test/run-pass/match-arm-statics.rs
@@ -84,7 +84,7 @@ fn issue_14576() {
     enum C { D = 3, E = 4 }
     const F : C = C::D;
 
-    assert_eq!(match C::D { F => 1i, _ => 2, }, 1);
+    assert_eq!(match C::D { F => 1, _ => 2, }, 1);
 }
 
 fn issue_13731() {
@@ -113,14 +113,14 @@ fn issue_15393() {
 
 fn main() {
     assert_eq!(match (true, false) {
-        TRUE_TRUE => 1i,
+        TRUE_TRUE => 1,
         (false, false) => 2,
         (false, true) => 3,
         (true, false) => 4
     }, 4);
 
     assert_eq!(match Some(Some(Direction::North)) {
-        Some(NONE) => 1i,
+        Some(NONE) => 1,
         Some(Some(Direction::North)) => 2,
         Some(Some(EAST)) => 3,
         Some(Some(Direction::South)) => 4,
@@ -129,7 +129,7 @@ fn main() {
     }, 2);
 
     assert_eq!(match (Foo { bar: Some(Direction::West), baz: NewBool(true) }) {
-        Foo { bar: None, baz: NewBool(true) } => 1i,
+        Foo { bar: None, baz: NewBool(true) } => 1,
         Foo { bar: NONE, baz: NEW_FALSE } => 2,
         STATIC_FOO => 3,
         Foo { bar: _, baz: NEW_FALSE } => 4,
@@ -140,7 +140,7 @@ fn main() {
     }, 5);
 
     assert_eq!(match (EnumWithStructVariants::Variant2 { dir: Direction::North }) {
-        EnumWithStructVariants::Variant1(true) => 1i,
+        EnumWithStructVariants::Variant1(true) => 1,
         EnumWithStructVariants::Variant1(false) => 2,
         EnumWithStructVariants::Variant2 { dir: Direction::West } => 3,
         VARIANT2_NORTH => 4,
diff --git a/src/test/run-pass/match-bot-2.rs b/src/test/run-pass/match-bot-2.rs
index 5b48d0ff508..949fad11344 100644
--- a/src/test/run-pass/match-bot-2.rs
+++ b/src/test/run-pass/match-bot-2.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 // n.b. This was only ever failing with optimization disabled.
-fn a() -> int { match return 1i { 2i => 3i, _ => panic!() } }
+fn a() -> int { match return 1 { 2 => 3, _ => panic!() } }
 pub fn main() { a(); }
diff --git a/src/test/run-pass/match-naked-record-expr.rs b/src/test/run-pass/match-naked-record-expr.rs
index 170a3513a1a..433cf23626b 100644
--- a/src/test/run-pass/match-naked-record-expr.rs
+++ b/src/test/run-pass/match-naked-record-expr.rs
@@ -11,7 +11,7 @@
 struct X { x: int }
 
 pub fn main() {
-    let _x = match 0i {
+    let _x = match 0 {
       _ => X {
         x: 0
       }.x
diff --git a/src/test/run-pass/match-naked-record.rs b/src/test/run-pass/match-naked-record.rs
index 21c31b62183..fe12b7c1585 100644
--- a/src/test/run-pass/match-naked-record.rs
+++ b/src/test/run-pass/match-naked-record.rs
@@ -11,7 +11,7 @@
 struct X { x: int }
 
 pub fn main() {
-    let _x = match 0i {
+    let _x = match 0 {
       _ => X {
         x: 0
       }
diff --git a/src/test/run-pass/match-pattern-bindings.rs b/src/test/run-pass/match-pattern-bindings.rs
index e6ce94ec5d4..abb78fc8310 100644
--- a/src/test/run-pass/match-pattern-bindings.rs
+++ b/src/test/run-pass/match-pattern-bindings.rs
@@ -9,15 +9,15 @@
 // except according to those terms.
 
 fn main() {
-    let value = Some(1i);
+    let value = Some(1);
     assert_eq!(match value {
         ref a @ Some(_) => a,
         ref b @ None => b
-    }, &Some(1i));
+    }, &Some(1));
     assert_eq!(match value {
         ref c @ Some(_) => c,
         ref b @ None => b
-    }, &Some(1i));
+    }, &Some(1));
     assert_eq!(match "foobarbaz" {
         b @ _ => b
     }, "foobarbaz");
diff --git a/src/test/run-pass/match-pipe-binding.rs b/src/test/run-pass/match-pipe-binding.rs
index ed2f7c5cb47..bdf12d22edd 100644
--- a/src/test/run-pass/match-pipe-binding.rs
+++ b/src/test/run-pass/match-pipe-binding.rs
@@ -10,7 +10,7 @@
 
 fn test1() {
     // from issue 6338
-    match ((1i, "a".to_string()), (2i, "b".to_string())) {
+    match ((1, "a".to_string()), (2, "b".to_string())) {
         ((1, a), (2, b)) | ((2, b), (1, a)) => {
                 assert_eq!(a, "a".to_string());
                 assert_eq!(b, "b".to_string());
@@ -20,7 +20,7 @@ fn test1() {
 }
 
 fn test2() {
-    match (1i, 2i, 3i) {
+    match (1, 2, 3) {
         (1, a, b) | (2, b, a) => {
             assert_eq!(a, 2);
             assert_eq!(b, 3);
@@ -30,7 +30,7 @@ fn test2() {
 }
 
 fn test3() {
-    match (1i, 2i, 3i) {
+    match (1, 2, 3) {
         (1, ref a, ref b) | (2, ref b, ref a) => {
             assert_eq!(*a, 2);
             assert_eq!(*b, 3);
@@ -40,7 +40,7 @@ fn test3() {
 }
 
 fn test4() {
-    match (1i, 2i, 3i) {
+    match (1, 2, 3) {
         (1, a, b) | (2, b, a) if a == 2 => {
             assert_eq!(a, 2);
             assert_eq!(b, 3);
@@ -50,7 +50,7 @@ fn test4() {
 }
 
 fn test5() {
-    match (1i, 2i, 3i) {
+    match (1, 2, 3) {
         (1, ref a, ref b) | (2, ref b, ref a) if *a == 2 => {
             assert_eq!(*a, 2);
             assert_eq!(*b, 3);
diff --git a/src/test/run-pass/match-range.rs b/src/test/run-pass/match-range.rs
index 83066c126ce..b9ab0c85ec4 100644
--- a/src/test/run-pass/match-range.rs
+++ b/src/test/run-pass/match-range.rs
@@ -28,7 +28,7 @@ pub fn main() {
       'a'...'z' => {}
       _ => panic!("should suppport char ranges")
     }
-    match -3i {
+    match -3 {
       -7...5 => {}
       _ => panic!("should match signed range")
     }
diff --git a/src/test/run-pass/match-ref-binding-mut-option.rs b/src/test/run-pass/match-ref-binding-mut-option.rs
index c983903ac18..8d1e483bcd8 100644
--- a/src/test/run-pass/match-ref-binding-mut-option.rs
+++ b/src/test/run-pass/match-ref-binding-mut-option.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let mut v = Some(22i);
+    let mut v = Some(22);
     match v {
       None => {}
       Some(ref mut p) => { *p += 1; }
diff --git a/src/test/run-pass/match-str.rs b/src/test/run-pass/match-str.rs
index 544751754c6..60a5904cff3 100644
--- a/src/test/run-pass/match-str.rs
+++ b/src/test/run-pass/match-str.rs
@@ -23,7 +23,7 @@ pub fn main() {
       _ => panic!()
     }
 
-    let x = match "a" { "a" => 1i, "b" => 2i, _ => panic!() };
+    let x = match "a" { "a" => 1, "b" => 2, _ => panic!() };
     assert_eq!(x, 1);
 
     match "a" { "a" => { } "b" => { }, _ => panic!() }
diff --git a/src/test/run-pass/match-unique-bind.rs b/src/test/run-pass/match-unique-bind.rs
index ebe01a1d1f2..63817d42ae8 100644
--- a/src/test/run-pass/match-unique-bind.rs
+++ b/src/test/run-pass/match-unique-bind.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    match box 100i {
+    match box 100 {
       box x => {
         println!("{}", x);
         assert_eq!(x, 100);
diff --git a/src/test/run-pass/match-vec-alternatives.rs b/src/test/run-pass/match-vec-alternatives.rs
index ae4fd1f1993..98b9d11ecdd 100644
--- a/src/test/run-pass/match-vec-alternatives.rs
+++ b/src/test/run-pass/match-vec-alternatives.rs
@@ -55,28 +55,28 @@ fn match_nested_vecs_snoc<'a, T>(l1: Option<&'a [T]>, l2: Result<&'a [T], ()>) -
 }
 
 fn main() {
-    assert_eq!(match_vecs(&[1i, 2], &[2i, 3]), "both non-empty");
-    assert_eq!(match_vecs(&[], &[1i, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs(&[], &[1, 2, 3, 4]), "one empty");
     assert_eq!(match_vecs::<uint>(&[], &[]), "both empty");
-    assert_eq!(match_vecs(&[1i, 2, 3], &[]), "one empty");
+    assert_eq!(match_vecs(&[1, 2, 3], &[]), "one empty");
 
-    assert_eq!(match_vecs_cons(&[1i, 2], &[2i, 3]), "both non-empty");
-    assert_eq!(match_vecs_cons(&[], &[1i, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs_cons(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs_cons(&[], &[1, 2, 3, 4]), "one empty");
     assert_eq!(match_vecs_cons::<uint>(&[], &[]), "both empty");
-    assert_eq!(match_vecs_cons(&[1i, 2, 3], &[]), "one empty");
+    assert_eq!(match_vecs_cons(&[1, 2, 3], &[]), "one empty");
 
-    assert_eq!(match_vecs_snoc(&[1i, 2], &[2i, 3]), "both non-empty");
-    assert_eq!(match_vecs_snoc(&[], &[1i, 2, 3, 4]), "one empty");
+    assert_eq!(match_vecs_snoc(&[1, 2], &[2, 3]), "both non-empty");
+    assert_eq!(match_vecs_snoc(&[], &[1, 2, 3, 4]), "one empty");
     assert_eq!(match_vecs_snoc::<uint>(&[], &[]), "both empty");
-    assert_eq!(match_vecs_snoc(&[1i, 2, 3], &[]), "one empty");
+    assert_eq!(match_vecs_snoc(&[1, 2, 3], &[]), "one empty");
 
     assert_eq!(match_nested_vecs_cons(None, Ok::<&[_], ()>(&[4u, 2u])),
                "None, Ok(at least two elements)");
     assert_eq!(match_nested_vecs_cons::<uint>(None, Err(())), "None, Ok(less than one element)");
     assert_eq!(match_nested_vecs_cons::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
                "Some(empty), Ok(empty)");
-    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1i]), Err(())), "Some(non-empty), any");
-    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[(42i, ())]), Ok::<&[_], ()>(&[(1i, ())])),
+    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
+    assert_eq!(match_nested_vecs_cons(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])),
                "Some(non-empty), any");
 
     assert_eq!(match_nested_vecs_snoc(None, Ok::<&[_], ()>(&[4u, 2u])),
@@ -84,7 +84,7 @@ fn main() {
     assert_eq!(match_nested_vecs_snoc::<uint>(None, Err(())), "None, Ok(less than one element)");
     assert_eq!(match_nested_vecs_snoc::<bool>(Some::<&[_]>(&[]), Ok::<&[_], ()>(&[])),
                "Some(empty), Ok(empty)");
-    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1i]), Err(())), "Some(non-empty), any");
-    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[(42i, ())]), Ok::<&[_], ()>(&[(1i, ())])),
+    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[1]), Err(())), "Some(non-empty), any");
+    assert_eq!(match_nested_vecs_snoc(Some::<&[_]>(&[(42, ())]), Ok::<&[_], ()>(&[(1, ())])),
                "Some(non-empty), any");
 }
diff --git a/src/test/run-pass/match-vec-rvalue.rs b/src/test/run-pass/match-vec-rvalue.rs
index 0f058086add..04a0204d206 100644
--- a/src/test/run-pass/match-vec-rvalue.rs
+++ b/src/test/run-pass/match-vec-rvalue.rs
@@ -12,7 +12,7 @@
 
 
 pub fn main() {
-    match vec!(1i, 2i, 3i) {
+    match vec!(1, 2, 3) {
         x => {
             assert_eq!(x.len(), 3);
             assert_eq!(x[0], 1);
diff --git a/src/test/run-pass/method-two-trait-defer-resolution-1.rs b/src/test/run-pass/method-two-trait-defer-resolution-1.rs
index e4ae33c1c50..414b08b4335 100644
--- a/src/test/run-pass/method-two-trait-defer-resolution-1.rs
+++ b/src/test/run-pass/method-two-trait-defer-resolution-1.rs
@@ -12,28 +12,28 @@
 // type that is (ultimately) inferred for `x`.
 
 trait foo {
-    fn foo(&self) -> int;
+    fn foo(&self) -> i32;
 }
 
-impl foo for Vec<uint> {
-    fn foo(&self) -> int {1}
+impl foo for Vec<u32> {
+    fn foo(&self) -> i32 {1}
 }
 
-impl foo for Vec<int> {
-    fn foo(&self) -> int {2}
+impl foo for Vec<i32> {
+    fn foo(&self) -> i32 {2}
 }
 
-fn call_foo_uint() -> int {
+fn call_foo_uint() -> i32 {
     let mut x = Vec::new();
     let y = x.foo();
-    x.push(0u);
+    x.push(0u32);
     y
 }
 
-fn call_foo_int() -> int {
+fn call_foo_int() -> i32 {
     let mut x = Vec::new();
     let y = x.foo();
-    x.push(0i);
+    x.push(0i32);
     y
 }
 
diff --git a/src/test/run-pass/method-two-trait-defer-resolution-2.rs b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
index b18c29dc3c1..7f498b2b578 100644
--- a/src/test/run-pass/method-two-trait-defer-resolution-2.rs
+++ b/src/test/run-pass/method-two-trait-defer-resolution-2.rs
@@ -41,7 +41,7 @@ fn call_foo_copy() -> int {
 fn call_foo_other() -> int {
     let mut x = Vec::new();
     let y = x.foo();
-    x.push(box 0i);
+    x.push(box 0);
     y
 }
 
diff --git a/src/test/run-pass/method-where-clause.rs b/src/test/run-pass/method-where-clause.rs
index 4361c22f55a..6337538a332 100644
--- a/src/test/run-pass/method-where-clause.rs
+++ b/src/test/run-pass/method-where-clause.rs
@@ -12,24 +12,24 @@
 // where clause type, and not only type parameters.
 
 trait Foo {
-    fn foo(&self) -> int;
+    fn foo(&self) -> i32;
 }
 
-impl Foo for Option<int>
+impl Foo for Option<i32>
 {
-    fn foo(&self) -> int {
+    fn foo(&self) -> i32 {
         self.unwrap_or(22)
     }
 }
 
-impl Foo for Option<uint>
+impl Foo for Option<u32>
 {
-    fn foo(&self) -> int {
-        self.unwrap_or(22) as int
+    fn foo(&self) -> i32 {
+        self.unwrap_or(22) as i32
     }
 }
 
-fn check<T>(x: Option<T>) -> (int, int)
+fn check<T>(x: Option<T>) -> (i32, i32)
     where Option<T> : Foo
 {
     let y: Option<T> = None;
@@ -37,6 +37,6 @@ fn check<T>(x: Option<T>) -> (int, int)
 }
 
 fn main() {
-    assert_eq!(check(Some(23u)), (23i, 22i));
-    assert_eq!(check(Some(23i)), (23i, 22i));
+    assert_eq!(check(Some(23u32)), (23, 22));
+    assert_eq!(check(Some(23)), (23, 22));
 }
diff --git a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
index 4ebebc46018..eb17aa78bd9 100644
--- a/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
+++ b/src/test/run-pass/monomorphized-callees-with-ty-params-3314.rs
@@ -32,9 +32,9 @@ impl Serializer for int {
 }
 
 pub fn main() {
-    let foo = F { a: 1i };
-    foo.serialize(1i);
+    let foo = F { a: 1 };
+    foo.serialize(1);
 
-    let bar = F { a: F {a: 1i } };
-    bar.serialize(2i);
+    let bar = F { a: F {a: 1 } };
+    bar.serialize(2);
 }
diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs
index 201abeba073..eb1444be378 100644
--- a/src/test/run-pass/multi-let.rs
+++ b/src/test/run-pass/multi-let.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = 10i;
+    let x = 10;
     let y = x;
     assert!((y == 10));
 }
diff --git a/src/test/run-pass/multiple-trait-bounds.rs b/src/test/run-pass/multiple-trait-bounds.rs
index 10abe4ce710..7ce1afb52a2 100644
--- a/src/test/run-pass/multiple-trait-bounds.rs
+++ b/src/test/run-pass/multiple-trait-bounds.rs
@@ -12,5 +12,5 @@ fn f<T:PartialEq + PartialOrd>(_: T) {
 }
 
 pub fn main() {
-    f(3i);
+    f(3);
 }
diff --git a/src/test/run-pass/mut-in-ident-patterns.rs b/src/test/run-pass/mut-in-ident-patterns.rs
index ad9161f9bd4..8be200d3bf3 100644
--- a/src/test/run-pass/mut-in-ident-patterns.rs
+++ b/src/test/run-pass/mut-in-ident-patterns.rs
@@ -20,7 +20,7 @@ struct X;
 impl Foo for X {}
 
 pub fn main() {
-    let (a, mut b) = (23i, 4i);
+    let (a, mut b) = (23, 4);
     assert_eq!(a, 23);
     assert_eq!(b, 4);
     b = a + b;
@@ -34,7 +34,7 @@ pub fn main() {
        Baz(f32, u8)
     }
 
-    let (x, mut y) = (32i, Bar::Foo(21));
+    let (x, mut y) = (32, Bar::Foo(21));
 
     match x {
         mut z @ 32 => {
diff --git a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
index bf926a6c48a..7d6bbbe4240 100644
--- a/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
+++ b/src/test/run-pass/mutability-inherits-through-fixed-length-vec.rs
@@ -9,13 +9,13 @@
 // except according to those terms.
 
 fn test1() {
-    let mut ints = [0i; 32];
+    let mut ints = [0; 32];
     ints[0] += 1;
     assert_eq!(ints[0], 1);
 }
 
 fn test2() {
-    let mut ints = [0i; 32];
+    let mut ints = [0; 32];
     for i in ints.iter_mut() { *i += 22; }
     for i in ints.iter() { assert!(*i == 22); }
 }
diff --git a/src/test/run-pass/negative.rs b/src/test/run-pass/negative.rs
index 4bf91bf7035..435382666f1 100644
--- a/src/test/run-pass/negative.rs
+++ b/src/test/run-pass/negative.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    match -5i {
+    match -5 {
       -5 => {}
       _ => { panic!() }
     }
diff --git a/src/test/run-pass/nested-matchs.rs b/src/test/run-pass/nested-matchs.rs
index 55c1de2700f..b0ac9fb597a 100644
--- a/src/test/run-pass/nested-matchs.rs
+++ b/src/test/run-pass/nested-matchs.rs
@@ -14,7 +14,7 @@ fn foo() {
     match Some::<int>(5) {
       Some::<int>(_x) => {
         let mut bar;
-        match None::<int> { None::<int> => { bar = 5i; } _ => { baz(); } }
+        match None::<int> { None::<int> => { bar = 5; } _ => { baz(); } }
         println!("{}", bar);
       }
       None::<int> => { println!("hello"); }
diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs
index 4ea51b3b409..3d4847a119a 100644
--- a/src/test/run-pass/new-box-syntax.rs
+++ b/src/test/run-pass/new-box-syntax.rs
@@ -24,8 +24,8 @@ struct Structure {
 }
 
 pub fn main() {
-    let x: Box<int> = box(HEAP) 2i;
-    let y: Box<int> = box 2i;
-    let b: Box<int> = box()(1i + 2);
-    let c = box()(3i + 4);
+    let x: Box<int> = box(HEAP) 2;
+    let y: Box<int> = box 2;
+    let b: Box<int> = box()(1 + 2);
+    let c = box()(3 + 4);
 }
diff --git a/src/test/run-pass/newtype-polymorphic.rs b/src/test/run-pass/newtype-polymorphic.rs
index 74487f5b57d..4b7dbdc9e5b 100644
--- a/src/test/run-pass/newtype-polymorphic.rs
+++ b/src/test/run-pass/newtype-polymorphic.rs
@@ -23,7 +23,7 @@ fn myvec_elt<X>(mv: myvec<X>) -> X {
 }
 
 pub fn main() {
-    let mv = myvec(vec!(1i, 2, 3));
+    let mv = myvec(vec!(1, 2, 3));
     let mv_clone = mv.clone();
     let mv_clone = myvec_deref(mv_clone);
     assert_eq!(mv_clone[1], 2);
diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs
index b4d079d79d6..140cf33cd1d 100644
--- a/src/test/run-pass/numeric-method-autoexport.rs
+++ b/src/test/run-pass/numeric-method-autoexport.rs
@@ -21,7 +21,7 @@ use std::num::ToPrimitive;
 pub fn main() {
 // ints
     // num
-    assert_eq!(15i.add(6), 21);
+    assert_eq!(15is.add(6is), 21is);
     assert_eq!(15i8.add(6i8), 21i8);
     assert_eq!(15i16.add(6i16), 21i16);
     assert_eq!(15i32.add(6i32), 21i32);
@@ -29,7 +29,7 @@ pub fn main() {
 
 // uints
     // num
-    assert_eq!(15u.add(6u), 21u);
+    assert_eq!(15u.add(6us), 21us);
     assert_eq!(15u8.add(6u8), 21u8);
     assert_eq!(15u16.add(6u16), 21u16);
     assert_eq!(15u32.add(6u32), 21u32);
diff --git a/src/test/run-pass/object-one-type-two-traits.rs b/src/test/run-pass/object-one-type-two-traits.rs
index ebdf3c08a22..f8a3ce7cda0 100644
--- a/src/test/run-pass/object-one-type-two-traits.rs
+++ b/src/test/run-pass/object-one-type-two-traits.rs
@@ -35,7 +35,7 @@ fn is<T:'static>(x: &Any) -> bool {
 }
 
 fn main() {
-    let x = box 22i as Box<Wrap>;
+    let x = box 22 as Box<Wrap>;
     println!("x={}", x.get());
     let y = x.wrap();
 }
diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs
index 8d45b8ecb08..bee6d23a27d 100644
--- a/src/test/run-pass/operator-associativity.rs
+++ b/src/test/run-pass/operator-associativity.rs
@@ -12,4 +12,4 @@
 
 
 // Testcase for issue #130, operator associativity.
-pub fn main() { assert!((3i * 5i / 2i == 7i)); }
+pub fn main() { assert!((3 * 5 / 2 == 7)); }
diff --git a/src/test/run-pass/out-of-stack-new-thread-no-split.rs b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
index 1ede5f546d7..c9e2f893c0f 100644
--- a/src/test/run-pass/out-of-stack-new-thread-no-split.rs
+++ b/src/test/run-pass/out-of-stack-new-thread-no-split.rs
@@ -28,7 +28,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 #[no_stack_check]
 fn recurse() {
-    let buf = [0i; 10];
+    let buf = [0; 10];
     black_box(buf);
     recurse();
 }
diff --git a/src/test/run-pass/out-of-stack-no-split.rs b/src/test/run-pass/out-of-stack-no-split.rs
index adaa472c760..846fbd477e0 100644
--- a/src/test/run-pass/out-of-stack-no-split.rs
+++ b/src/test/run-pass/out-of-stack-no-split.rs
@@ -28,7 +28,7 @@ pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 #[no_stack_check]
 fn recurse() {
-    let buf = [0i; 10];
+    let buf = [0; 10];
     black_box(buf);
     recurse();
 }
diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs
index 9615cfab5c1..97539a076ff 100644
--- a/src/test/run-pass/out-of-stack.rs
+++ b/src/test/run-pass/out-of-stack.rs
@@ -22,7 +22,7 @@ use std::os;
 pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 fn silent_recurse() {
-    let buf = [0i; 1000];
+    let buf = [0; 1000];
     black_box(buf);
     silent_recurse();
 }
diff --git a/src/test/run-pass/overloaded-autoderef-indexing.rs b/src/test/run-pass/overloaded-autoderef-indexing.rs
index de37173810f..4cb7ece4ab8 100644
--- a/src/test/run-pass/overloaded-autoderef-indexing.rs
+++ b/src/test/run-pass/overloaded-autoderef-indexing.rs
@@ -23,6 +23,6 @@ impl<'a, T> Deref for DerefArray<'a, T> {
 }
 
 pub fn main() {
-    let a = &[1i, 2i, 3i];
+    let a = &[1, 2, 3];
     assert_eq!(DerefArray {inner: a}[1], 2);
 }
diff --git a/src/test/run-pass/overloaded-autoderef-order.rs b/src/test/run-pass/overloaded-autoderef-order.rs
index 4c48b0ba710..d023a01f4b1 100644
--- a/src/test/run-pass/overloaded-autoderef-order.rs
+++ b/src/test/run-pass/overloaded-autoderef-order.rs
@@ -59,7 +59,7 @@ mod priv_test {
 }
 
 pub fn main() {
-    let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0i, y: 1i}};
+    let nested = DerefWrapper {x: true, y: DerefWrapper {x: 0, y: 1}};
 
     // Use the first field that you can find.
     assert_eq!(nested.x, true);
@@ -73,7 +73,7 @@ pub fn main() {
     // Also go through multiple levels of indirection.
     assert_eq!(Rc::new(nested).x, true);
 
-    let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0i, y: 1i});
+    let nested_priv = priv_test::DerefWrapperHideX::new(true, DerefWrapper {x: 0, y: 1});
     // FIXME(eddyb) #12808 should skip private fields.
     // assert_eq!(nested_priv.x, 0);
     assert_eq!((*nested_priv).x, 0);
diff --git a/src/test/run-pass/overloaded-autoderef-xcrate.rs b/src/test/run-pass/overloaded-autoderef-xcrate.rs
index 4f449b344e3..f8dd729ec67 100644
--- a/src/test/run-pass/overloaded-autoderef-xcrate.rs
+++ b/src/test/run-pass/overloaded-autoderef-xcrate.rs
@@ -13,5 +13,5 @@
 extern crate overloaded_autoderef_xc;
 
 fn main() {
-    assert!(overloaded_autoderef_xc::check(5i, 5i));
+    assert!(overloaded_autoderef_xc::check(5, 5));
 }
diff --git a/src/test/run-pass/overloaded-autoderef.rs b/src/test/run-pass/overloaded-autoderef.rs
index 59e3a807d5a..baa9709eb76 100644
--- a/src/test/run-pass/overloaded-autoderef.rs
+++ b/src/test/run-pass/overloaded-autoderef.rs
@@ -28,7 +28,7 @@ pub fn main() {
     assert_eq!(point.x, 2);
     assert_eq!(point.y, 4);
 
-    let i = Rc::new(RefCell::new(2i));
+    let i = Rc::new(RefCell::new(2));
     let i_value = *i.borrow();
     *i.borrow_mut() = 5;
     assert_eq!((i_value, *i.borrow()), (2, 5));
@@ -47,7 +47,7 @@ pub fn main() {
     p.borrow_mut().y += 3;
     assert_eq!(*p.borrow(), Point {x: 3, y: 5});
 
-    let v = Rc::new(RefCell::new([1i, 2, 3]));
+    let v = Rc::new(RefCell::new([1, 2, 3]));
     v.borrow_mut()[0] = 3;
     v.borrow_mut()[1] += 3;
     assert_eq!((v.borrow()[0], v.borrow()[1], v.borrow()[2]), (3, 5, 3));
diff --git a/src/test/run-pass/overloaded-deref-count.rs b/src/test/run-pass/overloaded-deref-count.rs
index 5cd76879798..03fa64fb87f 100644
--- a/src/test/run-pass/overloaded-deref-count.rs
+++ b/src/test/run-pass/overloaded-deref-count.rs
@@ -49,7 +49,7 @@ impl<T> DerefMut for DerefCounter<T> {
 }
 
 pub fn main() {
-    let mut n = DerefCounter::new(0i);
+    let mut n = DerefCounter::new(0);
     let mut v = DerefCounter::new(Vec::new());
 
     let _ = *n; // Immutable deref + copy a POD.
@@ -62,7 +62,7 @@ pub fn main() {
     assert_eq!(n.counts(), (2, 1)); assert_eq!(v.counts(), (1, 1));
 
     let mut v2 = Vec::new();
-    v2.push(1i);
+    v2.push(1);
 
     *n = 5; *v = v2; // Mutable deref + assignment.
     assert_eq!(n.counts(), (2, 2)); assert_eq!(v.counts(), (1, 2));
diff --git a/src/test/run-pass/overloaded-deref.rs b/src/test/run-pass/overloaded-deref.rs
index d02951e981e..fdaddca091f 100644
--- a/src/test/run-pass/overloaded-deref.rs
+++ b/src/test/run-pass/overloaded-deref.rs
@@ -22,11 +22,11 @@ struct Point {
 }
 
 pub fn main() {
-    assert_eq!(*Rc::new(5i), 5);
-    assert_eq!(***Rc::new(box box 5i), 5);
+    assert_eq!(*Rc::new(5), 5);
+    assert_eq!(***Rc::new(box box 5), 5);
     assert_eq!(*Rc::new(Point {x: 2, y: 4}), Point {x: 2, y: 4});
 
-    let i = Rc::new(RefCell::new(2i));
+    let i = Rc::new(RefCell::new(2));
     let i_value = *(*i).borrow();
     *(*i).borrow_mut() = 5;
     assert_eq!((i_value, *(*i).borrow()), (2, 5));
@@ -46,7 +46,7 @@ pub fn main() {
     (*(*p).borrow_mut()).y += 3;
     assert_eq!(*(*p).borrow(), Point {x: 3, y: 5});
 
-    let v = Rc::new(RefCell::new(vec!(1i, 2, 3)));
+    let v = Rc::new(RefCell::new(vec!(1, 2, 3)));
     (*(*v).borrow_mut())[0] = 3;
     (*(*v).borrow_mut())[1] += 3;
     assert_eq!(((*(*v).borrow())[0],
diff --git a/src/test/run-pass/overloaded-index-assoc-list.rs b/src/test/run-pass/overloaded-index-assoc-list.rs
index 5e0523d7041..7e3ff198c43 100644
--- a/src/test/run-pass/overloaded-index-assoc-list.rs
+++ b/src/test/run-pass/overloaded-index-assoc-list.rs
@@ -46,8 +46,8 @@ pub fn main() {
     let bar = "bar".to_string();
 
     let mut list = AssociationList {pairs: Vec::new()};
-    list.push(foo.clone(), 22i);
-    list.push(bar.clone(), 44i);
+    list.push(foo.clone(), 22);
+    list.push(bar.clone(), 44);
 
     assert!(list[foo] == 22);
     assert!(list[bar] == 44);
diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs
index e784318fc76..2db6f7ffaaa 100644
--- a/src/test/run-pass/owned-implies-static.rs
+++ b/src/test/run-pass/owned-implies-static.rs
@@ -14,5 +14,5 @@
 fn f<T: 'static>(_x: T) {}
 
 pub fn main() {
-    f(box 5i);
+    f(box 5);
 }
diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs
index 569023c4439..d9669812d2a 100644
--- a/src/test/run-pass/paren-free.rs
+++ b/src/test/run-pass/paren-free.rs
@@ -10,6 +10,6 @@
 
 pub fn main() {
     let x = true;
-    if x { let mut i = 10i; while i > 0 { i -= 1; } }
+    if x { let mut i = 10; while i > 0 { i -= 1; } }
     match x { true => { println!("right"); } false => { println!("wrong"); } }
 }
diff --git a/src/test/run-pass/parse-complex-macro-invoc-op.rs b/src/test/run-pass/parse-complex-macro-invoc-op.rs
index e9ec624c13e..0995910fd4c 100644
--- a/src/test/run-pass/parse-complex-macro-invoc-op.rs
+++ b/src/test/run-pass/parse-complex-macro-invoc-op.rs
@@ -17,24 +17,24 @@ macro_rules! id {
 }
 
 fn foo() {
-    id!(1i) + 1;
-    id![1i] - 1;
-    id!(1i) * 1;
-    id![1i] / 1;
-    id!(1i) % 1;
+    id!(1) + 1;
+    id![1] - 1;
+    id!(1) * 1;
+    id![1] / 1;
+    id!(1) % 1;
 
-    id!(1i) & 1;
-    id![1i] | 1;
-    id!(1i) ^ 1;
+    id!(1) & 1;
+    id![1] | 1;
+    id!(1) ^ 1;
 
-    let mut x = 1i;
+    let mut x = 1;
     id![x] = 2;
     id!(x) += 1;
 
     id!(1f64).clone();
 
-    id!([1i, 2, 3])[1];
-    id![drop](1i);
+    id!([1, 2, 3])[1];
+    id![drop](1);
 
     id!(true) && true;
     id![true] || true;
diff --git a/src/test/run-pass/parse-panic.rs b/src/test/run-pass/parse-panic.rs
index 0dbba3654b6..22b24ebb3b5 100644
--- a/src/test/run-pass/parse-panic.rs
+++ b/src/test/run-pass/parse-panic.rs
@@ -10,6 +10,6 @@
 
 #![allow(unreachable_code)]
 
-fn dont_call_me() { panic!(); println!("{}", 1i); }
+fn dont_call_me() { panic!(); println!("{}", 1); }
 
 pub fn main() { }
diff --git a/src/test/run-pass/priv-impl-prim-ty.rs b/src/test/run-pass/priv-impl-prim-ty.rs
index a8cd5e789b1..679aa3d668f 100644
--- a/src/test/run-pass/priv-impl-prim-ty.rs
+++ b/src/test/run-pass/priv-impl-prim-ty.rs
@@ -13,6 +13,6 @@
 extern crate "priv-impl-prim-ty" as bar;
 
 pub fn main() {
-    bar::frob(1i);
+    bar::frob(1);
 
 }
diff --git a/src/test/run-pass/ptr-coercion.rs b/src/test/run-pass/ptr-coercion.rs
index 1b77c1316ed..a6a8890101c 100644
--- a/src/test/run-pass/ptr-coercion.rs
+++ b/src/test/run-pass/ptr-coercion.rs
@@ -12,24 +12,24 @@
 
 pub fn main() {
     // &mut -> &
-    let x: &mut int = &mut 42i;
+    let x: &mut int = &mut 42;
     let x: &int = x;
 
-    let x: &int = &mut 42i;
+    let x: &int = &mut 42;
 
     // & -> *const
-    let x: &int = &42i;
+    let x: &int = &42;
     let x: *const int = x;
 
-    let x: *const int = &42i;
+    let x: *const int = &42;
 
     // &mut -> *const
-    let x: &mut int = &mut 42i;
+    let x: &mut int = &mut 42;
     let x: *const int = x;
 
-    let x: *const int = &mut 42i;
+    let x: *const int = &mut 42;
 
     // *mut -> *const
-    let x: *mut int = &mut 42i;
+    let x: *mut int = &mut 42;
     let x: *const int = x;
 }
diff --git a/src/test/run-pass/range.rs b/src/test/run-pass/range.rs
index bfd3e43768f..11e8bfa48f6 100644
--- a/src/test/run-pass/range.rs
+++ b/src/test/run-pass/range.rs
@@ -45,9 +45,9 @@ pub fn main() {
     let _ = ..42u;
 
     // Test we can use two different types with a common supertype.
-    let x = &42i;
+    let x = &42;
     {
-        let y = 42i;
+        let y = 42;
         let _ = x..&y;
     }
 }
diff --git a/src/test/run-pass/reexported-static-methods-cross-crate.rs b/src/test/run-pass/reexported-static-methods-cross-crate.rs
index 0d0fdb13db3..5399f3cfd35 100644
--- a/src/test/run-pass/reexported-static-methods-cross-crate.rs
+++ b/src/test/run-pass/reexported-static-methods-cross-crate.rs
@@ -17,8 +17,8 @@ use reexported_static_methods::Boz;
 use reexported_static_methods::Bort;
 
 pub fn main() {
-    assert_eq!(42i, Foo::foo());
-    assert_eq!(84i, Baz::bar());
-    assert!(Boz::boz(1i));
+    assert_eq!(42, Foo::foo());
+    assert_eq!(84, Baz::bar());
+    assert!(Boz::boz(1));
     assert_eq!("bort()".to_string(), Bort::bort());
 }
diff --git a/src/test/run-pass/regions-copy-closure.rs b/src/test/run-pass/regions-copy-closure.rs
index 0152793d96c..dc6f377e9b2 100644
--- a/src/test/run-pass/regions-copy-closure.rs
+++ b/src/test/run-pass/regions-copy-closure.rs
@@ -21,7 +21,7 @@ fn box_it<'a>(x: Box<FnMut() + 'a>) -> closure_box<'a> {
 }
 
 pub fn main() {
-    let mut i = 3i;
+    let mut i = 3i32;
     assert_eq!(i, 3);
     {
         let cl = |&mut:| i += 1;
diff --git a/src/test/run-pass/regions-early-bound-trait-param.rs b/src/test/run-pass/regions-early-bound-trait-param.rs
index 3267ff2c7e0..6fcfaf58a02 100644
--- a/src/test/run-pass/regions-early-bound-trait-param.rs
+++ b/src/test/run-pass/regions-early-bound-trait-param.rs
@@ -81,7 +81,7 @@ impl<'s> Trait<'s> for (int,int) {
 }
 
 impl<'t> MakerTrait<'t> for Box<Trait<'t>+'static> {
-    fn mk() -> Box<Trait<'t>+'static> { box() (4i,5i) as Box<Trait> }
+    fn mk() -> Box<Trait<'t>+'static> { box() (4,5) as Box<Trait> }
 }
 
 enum List<'l> {
@@ -111,7 +111,7 @@ impl<'t> RefMakerTrait<'t> for List<'t> {
 }
 
 pub fn main() {
-    let t = (2i,3i);
+    let t = (2,3);
     let o = &t as &Trait;
     let s1 = Struct1 { f: o };
     let s2 = Struct2 { f: o };
diff --git a/src/test/run-pass/regions-early-bound-used-in-bound.rs b/src/test/run-pass/regions-early-bound-used-in-bound.rs
index 73eb7ca7188..a3602c5fbec 100644
--- a/src/test/run-pass/regions-early-bound-used-in-bound.rs
+++ b/src/test/run-pass/regions-early-bound-used-in-bound.rs
@@ -32,6 +32,6 @@ fn add<'a,G:GetRef<'a, int>>(g1: G, g2: G) -> int {
 }
 
 pub fn main() {
-    let b1 = Box { t: &3i };
-    assert_eq!(add(b1, b1), 6i);
+    let b1 = Box { t: &3 };
+    assert_eq!(add(b1, b1), 6);
 }
diff --git a/src/test/run-pass/regions-early-bound-used-in-type-param.rs b/src/test/run-pass/regions-early-bound-used-in-type-param.rs
index e0d5e0a1c78..caef4e3fa9c 100644
--- a/src/test/run-pass/regions-early-bound-used-in-type-param.rs
+++ b/src/test/run-pass/regions-early-bound-used-in-type-param.rs
@@ -31,6 +31,6 @@ fn add<'a,G:Get<&'a int>>(g1: G, g2: G) -> int {
 }
 
 pub fn main() {
-    let b1 = Box { t: &3i };
-    assert_eq!(add(b1, b1), 6i);
+    let b1 = Box { t: &3 };
+    assert_eq!(add(b1, b1), 6);
 }
diff --git a/src/test/run-pass/regions-infer-borrow-scope-view.rs b/src/test/run-pass/regions-infer-borrow-scope-view.rs
index ce9edb5678a..d247f864571 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-view.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-view.rs
@@ -12,7 +12,7 @@
 fn view<T>(x: &[T]) -> &[T] {x}
 
 pub fn main() {
-    let v = vec!(1i, 2, 3);
+    let v = vec!(1, 2, 3);
     let x = view(v.as_slice());
     let y = view(x.as_slice());
     assert!((v[0] == x[0]) && (v[0] == y[0]));
diff --git a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
index f397b5124ca..d07110fd721 100644
--- a/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
+++ b/src/test/run-pass/regions-infer-borrow-scope-within-loop-ok.rs
@@ -14,7 +14,7 @@
 fn borrow<T>(x: &T) -> &T {x}
 
 pub fn main() {
-    let x = box 3i;
+    let x = box 3;
     loop {
         let y = borrow(&*x);
         assert_eq!(*x, *y);
diff --git a/src/test/run-pass/regions-return-interior-of-option.rs b/src/test/run-pass/regions-return-interior-of-option.rs
index 54458f0d0df..ee1d6687307 100644
--- a/src/test/run-pass/regions-return-interior-of-option.rs
+++ b/src/test/run-pass/regions-return-interior-of-option.rs
@@ -16,14 +16,14 @@ fn get<T>(opt: &Option<T>) -> &T {
 }
 
 pub fn main() {
-    let mut x = Some(23i);
+    let mut x = Some(23);
 
     {
         let y = get(&x);
         assert_eq!(*y, 23);
     }
 
-    x = Some(24i);
+    x = Some(24);
 
     {
         let y = get(&x);
diff --git a/src/test/run-pass/regions-scope-chain-example.rs b/src/test/run-pass/regions-scope-chain-example.rs
index 0388ffb7894..e5ef88006c7 100644
--- a/src/test/run-pass/regions-scope-chain-example.rs
+++ b/src/test/run-pass/regions-scope-chain-example.rs
@@ -31,7 +31,7 @@ struct Context<'a> {
 
 impl<'a> Context<'a> {
     fn foo(&mut self, scope: Scope) {
-        let link = if 1i < 2 {
+        let link = if 1 < 2 {
             let l = ScopeChain::Link(scope);
             self.take_scope(&l);
             l
diff --git a/src/test/run-pass/repeated-vector-syntax.rs b/src/test/run-pass/repeated-vector-syntax.rs
index d1d37ea5bb0..6048e0d8673 100644
--- a/src/test/run-pass/repeated-vector-syntax.rs
+++ b/src/test/run-pass/repeated-vector-syntax.rs
@@ -10,7 +10,7 @@
 
 pub fn main() {
     let x = [ [true]; 512 ];
-    let y = [ 0i; 1 ];
+    let y = [ 0; 1 ];
 
     print!("[");
     for xi in x.iter() {
diff --git a/src/test/run-pass/resource-assign-is-not-copy.rs b/src/test/run-pass/resource-assign-is-not-copy.rs
index ff38b02ae76..abc33e9f2e6 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -31,11 +31,11 @@ fn r(i: &Cell<int>) -> r {
 }
 
 pub fn main() {
-    let i = &Cell::new(0i);
+    let i = &Cell::new(0);
     // Even though these look like copies, they are guaranteed not to be
     {
         let a = r(i);
-        let b = (a, 10i);
+        let b = (a, 10);
         let (c, _d) = b;
         println!("{:?}", c);
     }
diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs
index 3092898d986..cf09737e32e 100644
--- a/src/test/run-pass/self-re-assign.rs
+++ b/src/test/run-pass/self-re-assign.rs
@@ -17,11 +17,11 @@
 use std::rc::Rc;
 
 pub fn main() {
-   let mut x = box 3i;
+   let mut x = box 3;
    x = x;
    assert!(*x == 3);
 
-   let mut x = Rc::new(3i);
+   let mut x = Rc::new(3);
    x = x;
    assert!(*x == 3);
 }
diff --git a/src/test/run-pass/seq-compare.rs b/src/test/run-pass/seq-compare.rs
index 29729b15aa8..ef14e0ba931 100644
--- a/src/test/run-pass/seq-compare.rs
+++ b/src/test/run-pass/seq-compare.rs
@@ -13,13 +13,13 @@ pub fn main() {
     assert!(("hello".to_string() < "hellr".to_string()));
     assert!(("hello ".to_string() > "hello".to_string()));
     assert!(("hello".to_string() != "there".to_string()));
-    assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3)));
-    assert!((vec!(1i, 2, 3) < vec!(1, 2, 3, 4)));
-    assert!((vec!(1i, 2, 4, 4) > vec!(1, 2, 3, 4)));
-    assert!((vec!(1i, 2, 3, 4) < vec!(1, 2, 4, 4)));
-    assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3)));
-    assert!((vec!(1i, 2, 3) <= vec!(1, 2, 3, 3)));
-    assert!((vec!(1i, 2, 3, 4) > vec!(1, 2, 3)));
-    assert_eq!(vec!(1i, 2, 3), vec!(1, 2, 3));
-    assert!((vec!(1i, 2, 3) != vec!(1, 1, 3)));
+    assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
+    assert!((vec!(1, 2, 3) < vec!(1, 2, 3, 4)));
+    assert!((vec!(1, 2, 4, 4) > vec!(1, 2, 3, 4)));
+    assert!((vec!(1, 2, 3, 4) < vec!(1, 2, 4, 4)));
+    assert!((vec!(1, 2, 3) <= vec!(1, 2, 3)));
+    assert!((vec!(1, 2, 3) <= vec!(1, 2, 3, 3)));
+    assert!((vec!(1, 2, 3, 4) > vec!(1, 2, 3)));
+    assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3));
+    assert!((vec!(1, 2, 3) != vec!(1, 1, 3)));
 }
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index 06d707d3ab0..dbe73d1b94a 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -17,7 +17,7 @@ fn foo(c: Vec<int> ) {
         t::some::<int>(_) => {
             for _i in c.iter() {
                 println!("{}", a);
-                let a = 17i;
+                let a = 17;
                 b.push(a);
             }
         }
@@ -27,4 +27,4 @@ fn foo(c: Vec<int> ) {
 
 enum t<T> { none, some(T), }
 
-pub fn main() { let x = 10i; let x = x + 20; assert!((x == 30)); foo(Vec::new()); }
+pub fn main() { let x = 10; let x = x + 20; assert!((x == 30)); foo(Vec::new()); }
diff --git a/src/test/run-pass/shift.rs b/src/test/run-pass/shift.rs
index d8a67eef3f6..2dbedc3a573 100644
--- a/src/test/run-pass/shift.rs
+++ b/src/test/run-pass/shift.rs
@@ -18,7 +18,7 @@ pub fn main() {
 }
 
 fn test_misc() {
-    assert_eq!(1i << 1 << 1 << 1 << 1 << 1, 32);
+    assert_eq!(1 << 1 << 1 << 1 << 1 << 1, 32);
 }
 
 fn test_expr() {
diff --git a/src/test/run-pass/simple-infer.rs b/src/test/run-pass/simple-infer.rs
index 4f6feb544f4..04c1af4326b 100644
--- a/src/test/run-pass/simple-infer.rs
+++ b/src/test/run-pass/simple-infer.rs
@@ -10,4 +10,4 @@
 
 
 
-pub fn main() { let mut n; n = 1i; println!("{}", n); }
+pub fn main() { let mut n; n = 1; println!("{}", n); }
diff --git a/src/test/run-pass/static-assert.rs b/src/test/run-pass/static-assert.rs
index c695fa2b72e..f8fd81b9365 100644
--- a/src/test/run-pass/static-assert.rs
+++ b/src/test/run-pass/static-assert.rs
@@ -12,13 +12,13 @@
 static b: bool = true;
 
 #[static_assert]
-static c: bool = 1i == 1;
+static c: bool = 1 == 1;
 
 #[static_assert]
-static d: bool = 1i != 2;
+static d: bool = 1 != 2;
 
 #[static_assert]
-static f: bool = (4i/2) == 2;
+static f: bool = (4/2) == 2;
 
 pub fn main() {
 }
diff --git a/src/test/run-pass/static-fn-inline-xc.rs b/src/test/run-pass/static-fn-inline-xc.rs
index dbe9221066f..efc374e25bb 100644
--- a/src/test/run-pass/static-fn-inline-xc.rs
+++ b/src/test/run-pass/static-fn-inline-xc.rs
@@ -15,5 +15,5 @@ extern crate "static_fn_inline_xc_aux" as mycore;
 use mycore::num;
 
 pub fn main() {
-    let _1: f64 = num::Num2::from_int2(1i);
+    let _1: f64 = num::Num2::from_int2(1);
 }
diff --git a/src/test/run-pass/static-fn-trait-xc.rs b/src/test/run-pass/static-fn-trait-xc.rs
index 5dd6b6dbc53..cb9f7c3da02 100644
--- a/src/test/run-pass/static-fn-trait-xc.rs
+++ b/src/test/run-pass/static-fn-trait-xc.rs
@@ -15,5 +15,5 @@ extern crate "static_fn_trait_xc_aux" as mycore;
 use mycore::num;
 
 pub fn main() {
-    let _1: f64 = num::Num2::from_int2(1i);
+    let _1: f64 = num::Num2::from_int2(1);
 }
diff --git a/src/test/run-pass/static-impl.rs b/src/test/run-pass/static-impl.rs
index 74c0663971e..44d77e440d1 100644
--- a/src/test/run-pass/static-impl.rs
+++ b/src/test/run-pass/static-impl.rs
@@ -61,10 +61,10 @@ pub fn main() {
     assert_eq!(10u.plus(), 30);
     assert_eq!(("hi".to_string()).plus(), 200);
 
-    assert_eq!((vec!(1i)).length_().str(), "1".to_string());
-    let vect = vec!(3i, 4).map_(|a| *a + 4);
+    assert_eq!((vec!(1)).length_().str(), "1".to_string());
+    let vect = vec!(3, 4).map_(|a| *a + 4);
     assert_eq!(vect[0], 7);
-    let vect = (vec!(3i, 4)).map_::<uint, _>(|a| *a as uint + 4u);
+    let vect = (vec!(3, 4)).map_::<uint, _>(|a| *a as uint + 4u);
     assert_eq!(vect[0], 7u);
     let mut x = 0u;
     10u.multi(|_n| x += 2u );
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index dc1e23ca09c..612483f6909 100644
--- a/src/test/run-pass/string-self-append.rs
+++ b/src/test/run-pass/string-self-append.rs
@@ -11,7 +11,7 @@
 pub fn main() {
     // Make sure we properly handle repeated self-appends.
     let mut a: String = "A".to_string();
-    let mut i = 20i;
+    let mut i = 20;
     let mut expected_len = 1u;
     while i > 0 {
         println!("{}", a.len());
diff --git a/src/test/run-pass/struct-lit-functional-no-fields.rs b/src/test/run-pass/struct-lit-functional-no-fields.rs
index ebf2fbbe53c..c3b1ff0f057 100644
--- a/src/test/run-pass/struct-lit-functional-no-fields.rs
+++ b/src/test/run-pass/struct-lit-functional-no-fields.rs
@@ -16,8 +16,8 @@ struct Foo<T> {
 
 pub fn main() {
     let foo = Foo {
-        bar: 0i,
-        baz: 1i
+        bar: 0,
+        baz: 1
     };
 
     let foo_ = foo.clone();
diff --git a/src/test/run-pass/structured-compare.rs b/src/test/run-pass/structured-compare.rs
index d87ff64ebd9..12d8fe8f4c8 100644
--- a/src/test/run-pass/structured-compare.rs
+++ b/src/test/run-pass/structured-compare.rs
@@ -21,14 +21,14 @@ impl PartialEq for foo {
 }
 
 pub fn main() {
-    let a = (1i, 2i, 3i);
-    let b = (1i, 2i, 3i);
+    let a = (1, 2, 3);
+    let b = (1, 2, 3);
     assert_eq!(a, b);
     assert!((a != (1, 2, 4)));
     assert!((a < (1, 2, 4)));
     assert!((a <= (1, 2, 4)));
-    assert!(((1i, 2i, 4i) > a));
-    assert!(((1i, 2i, 4i) >= a));
+    assert!(((1, 2, 4) > a));
+    assert!(((1, 2, 4) >= a));
     let x = foo::large;
     let y = foo::small;
     assert!((x != y));
diff --git a/src/test/run-pass/supertrait-default-generics.rs b/src/test/run-pass/supertrait-default-generics.rs
index f31d9ca186f..e158ae672aa 100644
--- a/src/test/run-pass/supertrait-default-generics.rs
+++ b/src/test/run-pass/supertrait-default-generics.rs
@@ -38,7 +38,7 @@ impl<S: Clone> Positioned<S> for Point<S> {
 impl<S: Clone + Add<Output=S>> Movable<S> for Point<S> {}
 
 pub fn main() {
-    let mut p = Point{ x: 1i, y: 2i};
+    let mut p = Point{ x: 1, y: 2};
     p.translate(3);
     assert_eq!(p.X(), 4);
 }
diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs
index 7cba4533c7f..60431fbedd0 100644
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -34,8 +34,8 @@ pub fn main() {
   println!("{:?}", 1 as u16);
   println!("{:?}", 1 as u32);
   println!("{:?}", 1 as u64);
-  println!("{:?}", 1i as f32);
-  println!("{:?}", 1i as f64);
+  println!("{:?}", 1 as f32);
+  println!("{:?}", 1 as f64);
 
   println!("{:?}", 1u as int);
   println!("{:?}", 1u as uint);
diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs
index 9a77356d7eb..82a76512e08 100644
--- a/src/test/run-pass/swap-1.rs
+++ b/src/test/run-pass/swap-1.rs
@@ -11,7 +11,7 @@
 use std::mem::swap;
 
 pub fn main() {
-    let mut x = 3i; let mut y = 7i;
+    let mut x = 3; let mut y = 7;
     swap(&mut x, &mut y);
     assert!((x == 7)); assert!((y == 3));
 }
diff --git a/src/test/run-pass/tag-variant-disr-type-mismatch.rs b/src/test/run-pass/tag-variant-disr-type-mismatch.rs
index c04751d51b4..7e4bd9ab273 100644
--- a/src/test/run-pass/tag-variant-disr-type-mismatch.rs
+++ b/src/test/run-pass/tag-variant-disr-type-mismatch.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 enum color {
-    red = 1i,
+    red = 1,
     blue = 2,
 }
 
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index bfd1f5f4a74..185edb02cca 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -16,7 +16,7 @@ use std::thread::Thread;
 
 fn test_break() { loop { let _x: Box<int> = break; } }
 
-fn test_cont() { let mut i = 0i; while i < 1 { i += 1; let _x: Box<int> = continue; } }
+fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: Box<int> = continue; } }
 
 fn test_ret() { let _x: Box<int> = return; }
 
diff --git a/src/test/run-pass/trailing-comma.rs b/src/test/run-pass/trailing-comma.rs
index 00e05064080..b5ae259bc63 100644
--- a/src/test/run-pass/trailing-comma.rs
+++ b/src/test/run-pass/trailing-comma.rs
@@ -28,16 +28,16 @@ enum Baz {
 
 #[allow(unused,)]
 pub fn main() {
-    f::<int,>(0i,);
-    let (_, _,) = (1i, 1i,);
-    let [_, _,] = [1i, 1,];
-    let [_, _, .., _,] = [1i, 1, 1, 1,];
-    let [_, _, _.., _,] = [1i, 1, 1, 1,];
+    f::<int,>(0,);
+    let (_, _,) = (1, 1,);
+    let [_, _,] = [1, 1,];
+    let [_, _, .., _,] = [1, 1, 1, 1,];
+    let [_, _, _.., _,] = [1, 1, 1, 1,];
 
     let x: Foo<int,> = Foo::<int,>;
 
-    Bar::f(0i,);
-    Bar.g(0i,);
+    Bar::f(0,);
+    Bar.g(0,);
     Bar.h();
 
     let x = Baz::Qux(1,);
diff --git a/src/test/run-pass/trait-default-method-bound-subst.rs b/src/test/run-pass/trait-default-method-bound-subst.rs
index 6b0ab8910de..5f0e149eb28 100644
--- a/src/test/run-pass/trait-default-method-bound-subst.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst.rs
@@ -13,14 +13,14 @@ trait A<T> {
     fn g<U>(&self, x: T, y: U) -> (T, U) { (x, y) }
 }
 
-impl A<int> for int { }
-impl<T> A<T> for uint { }
+impl A<i32> for i32 { }
+impl<T> A<T> for u32 { }
 
 fn f<T, U, V: A<T>>(i: V, j: T, k: U) -> (T, U) {
     i.g(j, k)
 }
 
 pub fn main () {
-    assert_eq!(f(0i, 1i, 2i), (1, 2));
-    assert_eq!(f(0u, 1i, 2i), (1, 2));
+    assert_eq!(f(0, 1, 2), (1, 2));
+    assert_eq!(f(0, 1, 2), (1, 2));
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst2.rs b/src/test/run-pass/trait-default-method-bound-subst2.rs
index d9ba9ca9220..1ea3879e7fa 100644
--- a/src/test/run-pass/trait-default-method-bound-subst2.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst2.rs
@@ -20,5 +20,5 @@ fn f<T, V: A<T>>(i: V, j: T) -> T {
 }
 
 pub fn main () {
-    assert_eq!(f(0i, 2i), 2);
+    assert_eq!(f(0, 2), 2);
 }
diff --git a/src/test/run-pass/trait-default-method-bound-subst3.rs b/src/test/run-pass/trait-default-method-bound-subst3.rs
index 43fb19a58ed..aff20ffe962 100644
--- a/src/test/run-pass/trait-default-method-bound-subst3.rs
+++ b/src/test/run-pass/trait-default-method-bound-subst3.rs
@@ -20,6 +20,6 @@ fn f<T, V: A>(i: V, j: T, k: T) -> (T, T) {
 }
 
 pub fn main () {
-    assert_eq!(f(0i, 1i, 2i), (1, 2));
-    assert_eq!(f(0i, 1u8, 2u8), (1u8, 2u8));
+    assert_eq!(f(0, 1, 2), (1, 2));
+    assert_eq!(f(0, 1u8, 2u8), (1u8, 2u8));
 }
diff --git a/src/test/run-pass/trait-default-method-bound.rs b/src/test/run-pass/trait-default-method-bound.rs
index 1505d48839e..8a2f1b1743b 100644
--- a/src/test/run-pass/trait-default-method-bound.rs
+++ b/src/test/run-pass/trait-default-method-bound.rs
@@ -20,5 +20,5 @@ fn f<T:A>(i: T) {
 }
 
 pub fn main () {
-    f(0i);
+    f(0);
 }
diff --git a/src/test/run-pass/trait-default-method-xc-2.rs b/src/test/run-pass/trait-default-method-xc-2.rs
index 1aa958dafc7..b28e8bd24aa 100644
--- a/src/test/run-pass/trait-default-method-xc-2.rs
+++ b/src/test/run-pass/trait-default-method-xc-2.rs
@@ -20,15 +20,15 @@ use aux2::{a_struct, welp};
 
 pub fn main () {
 
-    let a = a_struct { x: 0i };
-    let b = a_struct { x: 1i };
+    let a = a_struct { x: 0 };
+    let b = a_struct { x: 1 };
 
-    assert_eq!(0i.g(), 10);
+    assert_eq!(0.g(), 10);
     assert_eq!(a.g(), 10);
     assert_eq!(a.h(), 11);
     assert_eq!(b.g(), 10);
     assert_eq!(b.h(), 11);
     assert_eq!(A::lurr(&a, &b), 21);
 
-    welp(&0i);
+    welp(&0);
 }
diff --git a/src/test/run-pass/trait-default-method-xc.rs b/src/test/run-pass/trait-default-method-xc.rs
index c4880e97c45..4745d057952 100644
--- a/src/test/run-pass/trait-default-method-xc.rs
+++ b/src/test/run-pass/trait-default-method-xc.rs
@@ -52,35 +52,35 @@ impl TestEquality for stuff::thing {
 
 pub fn main() {
     // Some tests of random things
-    f(0i);
+    f(0);
 
-    assert_eq!(A::lurr(&0i, &1i), 21);
+    assert_eq!(A::lurr(&0, &1), 21);
 
     let a = stuff::thing { x: 0 };
     let b = stuff::thing { x: 1 };
     let c = Something { x: 1 };
 
-    assert_eq!(0i.g(), 10);
+    assert_eq!(0.g(), 10);
     assert_eq!(a.g(), 10);
     assert_eq!(a.h(), 11);
     assert_eq!(c.h(), 11);
 
-    assert_eq!(0i.thing(3.14f64, 1i), (3.14f64, 1i));
-    assert_eq!(B::staticthing(&0i, 3.14f64, 1i), (3.14f64, 1i));
-    assert_eq!(B::<f64>::staticthing::<int>(&0i, 3.14, 1), (3.14, 1));
+    assert_eq!(0.thing(3.14f64, 1), (3.14f64, 1));
+    assert_eq!(B::staticthing(&0, 3.14f64, 1), (3.14f64, 1));
+    assert_eq!(B::<f64>::staticthing::<int>(&0, 3.14, 1), (3.14, 1));
 
-    assert_eq!(g(0i, 3.14f64, 1i), (3.14f64, 1i));
-    assert_eq!(g(false, 3.14f64, 1i), (3.14, 1));
+    assert_eq!(g(0, 3.14f64, 1), (3.14f64, 1));
+    assert_eq!(g(false, 3.14f64, 1), (3.14, 1));
 
 
     // Trying out a real one
-    assert!(12i.test_neq(&10i));
-    assert!(!10i.test_neq(&10i));
+    assert!(12.test_neq(&10));
+    assert!(!10.test_neq(&10));
     assert!(a.test_neq(&b));
     assert!(!a.test_neq(&a));
 
-    assert!(neq(&12i, &10i));
-    assert!(!neq(&10i, &10i));
+    assert!(neq(&12, &10));
+    assert!(!neq(&10, &10));
     assert!(neq(&a, &b));
     assert!(!neq(&a, &a));
 }
diff --git a/src/test/run-pass/trait-generic.rs b/src/test/run-pass/trait-generic.rs
index d4c1b688b47..e79b22f70cf 100644
--- a/src/test/run-pass/trait-generic.rs
+++ b/src/test/run-pass/trait-generic.rs
@@ -44,7 +44,7 @@ fn bar<U:to_str,T:map<U>>(x: T) -> Vec<String> {
 }
 
 pub fn main() {
-    assert_eq!(foo(vec!(1i)), vec!("hi".to_string()));
+    assert_eq!(foo(vec!(1)), vec!("hi".to_string()));
     assert_eq!(bar::<int, Vec<int> >(vec!(4, 5)), vec!("4".to_string(), "5".to_string()));
     assert_eq!(bar::<String, Vec<String> >(vec!("x".to_string(), "y".to_string())),
                vec!("x".to_string(), "y".to_string()));
diff --git a/src/test/run-pass/trait-impl.rs b/src/test/run-pass/trait-impl.rs
index 003686c0bbe..16ef315c206 100644
--- a/src/test/run-pass/trait-impl.rs
+++ b/src/test/run-pass/trait-impl.rs
@@ -33,7 +33,7 @@ struct Foo;
 impl<'a> Bar<'a> for Foo {}
 
 fn main() {
-    let x: &T = &42i;
+    let x: &T = &42;
 
     x.foo();
     T::foo(x);
diff --git a/src/test/run-pass/trait-inheritance-num.rs b/src/test/run-pass/trait-inheritance-num.rs
index e606018feb9..9a30d51f4c5 100644
--- a/src/test/run-pass/trait-inheritance-num.rs
+++ b/src/test/run-pass/trait-inheritance-num.rs
@@ -16,7 +16,7 @@ pub trait NumExt: NumCast + PartialEq + PartialOrd {}
 
 pub trait FloatExt: NumExt {}
 
-fn greater_than_one<T: NumExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() }
-fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { *n > NumCast::from(1i).unwrap() }
+fn greater_than_one<T: NumExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
+fn greater_than_one_float<T: FloatExt>(n: &T) -> bool { *n > NumCast::from(1).unwrap() }
 
 pub fn main() {}
diff --git a/src/test/run-pass/trait-inheritance-num0.rs b/src/test/run-pass/trait-inheritance-num0.rs
index 42eaaa09fcd..d68b6a54f71 100644
--- a/src/test/run-pass/trait-inheritance-num0.rs
+++ b/src/test/run-pass/trait-inheritance-num0.rs
@@ -22,7 +22,7 @@ pub trait Num {
 pub trait NumExt: NumCast + PartialOrd { }
 
 fn greater_than_one<T:NumExt>(n: &T) -> bool {
-    n.gt(&NumCast::from(1i).unwrap())
+    n.gt(&NumCast::from(1).unwrap())
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/trait-inheritance-num1.rs b/src/test/run-pass/trait-inheritance-num1.rs
index 9407afbdd6b..15fb5df4626 100644
--- a/src/test/run-pass/trait-inheritance-num1.rs
+++ b/src/test/run-pass/trait-inheritance-num1.rs
@@ -14,7 +14,7 @@ use std::num::NumCast;
 pub trait NumExt: NumCast + PartialOrd { }
 
 fn greater_than_one<T:NumExt>(n: &T) -> bool {
-    *n > NumCast::from(1i).unwrap()
+    *n > NumCast::from(1).unwrap()
 }
 
 pub fn main() {}
diff --git a/src/test/run-pass/trait-inheritance-num3.rs b/src/test/run-pass/trait-inheritance-num3.rs
index bd93223093a..09015d983ea 100644
--- a/src/test/run-pass/trait-inheritance-num3.rs
+++ b/src/test/run-pass/trait-inheritance-num3.rs
@@ -16,7 +16,7 @@ pub trait NumExt: PartialEq + PartialOrd + NumCast {}
 impl NumExt for f32 {}
 
 fn num_eq_one<T: NumExt>(n: T) {
-    println!("{}", n == NumCast::from(1i).unwrap())
+    println!("{}", n == NumCast::from(1).unwrap())
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-num5.rs b/src/test/run-pass/trait-inheritance-num5.rs
index 4c79600e2e9..a21026839a7 100644
--- a/src/test/run-pass/trait-inheritance-num5.rs
+++ b/src/test/run-pass/trait-inheritance-num5.rs
@@ -17,7 +17,7 @@ impl NumExt for f32 {}
 impl NumExt for int {}
 
 fn num_eq_one<T:NumExt>() -> T {
-    NumCast::from(1i).unwrap()
+    NumCast::from(1).unwrap()
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/trait-inheritance-visibility.rs b/src/test/run-pass/trait-inheritance-visibility.rs
index dc84cbfb09a..3cdedd884a4 100644
--- a/src/test/run-pass/trait-inheritance-visibility.rs
+++ b/src/test/run-pass/trait-inheritance-visibility.rs
@@ -24,5 +24,5 @@ fn f<T:Quux>(x: &T) {
 }
 
 pub fn main() {
-    f(&0i)
+    f(&0)
 }
diff --git a/src/test/run-pass/trait-to-str.rs b/src/test/run-pass/trait-to-str.rs
index 9b910d24bdc..ea8a5a28c34 100644
--- a/src/test/run-pass/trait-to-str.rs
+++ b/src/test/run-pass/trait-to-str.rs
@@ -31,15 +31,15 @@ impl<T:to_str> to_str for Vec<T> {
 
 pub fn main() {
     assert!(1.to_string_() == "1".to_string());
-    assert!((vec!(2i, 3, 4)).to_string_() == "[2, 3, 4]".to_string());
+    assert!((vec!(2, 3, 4)).to_string_() == "[2, 3, 4]".to_string());
 
     fn indirect<T:to_str>(x: T) -> String {
         format!("{}!", x.to_string_())
     }
-    assert!(indirect(vec!(10i, 20)) == "[10, 20]!".to_string());
+    assert!(indirect(vec!(10, 20)) == "[10, 20]!".to_string());
 
     fn indirect2<T:to_str>(x: T) -> String {
         indirect(x)
     }
-    assert!(indirect2(vec!(1i)) == "[1]!".to_string());
+    assert!(indirect2(vec!(1)) == "[1]!".to_string());
 }
diff --git a/src/test/run-pass/traits-conditional-dispatch.rs b/src/test/run-pass/traits-conditional-dispatch.rs
index 7e2b7ae0663..5af2d4ee806 100644
--- a/src/test/run-pass/traits-conditional-dispatch.rs
+++ b/src/test/run-pass/traits-conditional-dispatch.rs
@@ -35,5 +35,5 @@ fn main() {
     assert_eq!(get_it(&1_u32), 1_u32);
     assert_eq!(get_it(&1_u16), 1_u16);
     assert_eq!(get_it(&Some(1_u16)), Some(1_u16));
-    assert_eq!(get_it(&box 1i), box 1i);
+    assert_eq!(get_it(&box 1), box 1);
 }
diff --git a/src/test/run-pass/trivial-message.rs b/src/test/run-pass/trivial-message.rs
index df8efb42e30..fd60c614638 100644
--- a/src/test/run-pass/trivial-message.rs
+++ b/src/test/run-pass/trivial-message.rs
@@ -17,7 +17,7 @@ use std::sync::mpsc::channel;
 
 pub fn main() {
     let (tx, rx) = channel();
-    tx.send(42i);
+    tx.send(42);
     let r = rx.recv();
     println!("{:?}", r);
 }
diff --git a/src/test/run-pass/tuple-index-fat-types.rs b/src/test/run-pass/tuple-index-fat-types.rs
index eccd841e357..924b861a911 100644
--- a/src/test/run-pass/tuple-index-fat-types.rs
+++ b/src/test/run-pass/tuple-index-fat-types.rs
@@ -11,11 +11,11 @@
 struct Foo<'a>(&'a [int]);
 
 fn main() {
-    let x: &[int] = &[1i, 2, 3];
+    let x: &[int] = &[1, 2, 3];
     let y = (x,);
     assert_eq!(y.0, x);
 
-    let x: &[int] = &[1i, 2, 3];
+    let x: &[int] = &[1, 2, 3];
     let y = Foo(x);
     assert_eq!(y.0, x);
 }
diff --git a/src/test/run-pass/tuple-index.rs b/src/test/run-pass/tuple-index.rs
index 78e0cad4712..abdf6172779 100644
--- a/src/test/run-pass/tuple-index.rs
+++ b/src/test/run-pass/tuple-index.rs
@@ -24,7 +24,7 @@ fn main() {
     }
     assert_eq!(x.1, 0);
 
-    let mut x = (3i, 2i);
+    let mut x = (3, 2);
     assert_eq!(x.0, 3);
     assert_eq!(x.1, 2);
     x.0 += 5;
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index 3fcb04d6848..7d1fad5d281 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -33,12 +33,12 @@ pub fn main() {
     p_foo(r(10));
 
     p_foo(box r(10));
-    p_foo(box 10i);
-    p_foo(10i);
+    p_foo(box 10);
+    p_foo(10);
 
-    s_foo(box 10i);
-    s_foo(10i);
+    s_foo(box 10);
+    s_foo(10);
 
-    u_foo(box 10i);
-    u_foo(10i);
+    u_foo(box 10);
+    u_foo(10);
 }
diff --git a/src/test/run-pass/typestate-cfg-nesting.rs b/src/test/run-pass/typestate-cfg-nesting.rs
index f1e40cc3e58..37d06bf4f83 100644
--- a/src/test/run-pass/typestate-cfg-nesting.rs
+++ b/src/test/run-pass/typestate-cfg-nesting.rs
@@ -12,12 +12,12 @@
 #![allow(unused_variable)]
 
 fn f() {
-    let x = 10i; let mut y = 11i;
+    let x = 10; let mut y = 11;
     if true { match x { _ => { y = x; } } } else { }
 }
 
 pub fn main() {
-    let x = 10i;
-    let mut y = 11i;
+    let x = 10;
+    let mut y = 11;
     if true { while false { y = x; } } else { }
 }
diff --git a/src/test/run-pass/typestate-multi-decl.rs b/src/test/run-pass/typestate-multi-decl.rs
index cbb0dcc8f2b..42910c47005 100644
--- a/src/test/run-pass/typestate-multi-decl.rs
+++ b/src/test/run-pass/typestate-multi-decl.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let (x, y) = (10i, 20i);
+    let (x, y) = (10, 20);
     let z = x + y;
     assert!((z == 30));
 }
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
index fdd85b71cd2..5bebc70ca54 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-bound.rs
@@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F)
 }
 
 pub fn main() {
-    doit(0i, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|&: x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
index cce8cd64a14..a678c7a852f 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-from-expected-object-type.rs
@@ -18,5 +18,5 @@ use std::num::ToPrimitive;
 fn doit<T>(val: T, f: &Fn(T)) { f.call((val,)) }
 
 pub fn main() {
-    doit(0i, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|&: x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
index 8497bf7f987..6e0b3625a2e 100644
--- a/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
+++ b/src/test/run-pass/unboxed-closures-infer-argument-types-with-bound-regions-from-expected-bound.rs
@@ -22,5 +22,5 @@ fn doit<T,F>(val: T, f: &F)
 }
 
 pub fn main() {
-    doit(0i, &|&: x /*: int*/ | { x.to_int(); });
+    doit(0, &|&: x /*: int*/ | { x.to_int(); });
 }
diff --git a/src/test/run-pass/unboxed-closures-prelude.rs b/src/test/run-pass/unboxed-closures-prelude.rs
index 915715727e8..f9fc5770a38 100644
--- a/src/test/run-pass/unboxed-closures-prelude.rs
+++ b/src/test/run-pass/unboxed-closures-prelude.rs
@@ -16,10 +16,10 @@
 
 fn main() {
     let task: Box<Fn(int) -> int> = box |&: x| x;
-    task.call((0i, ));
+    task.call((0, ));
 
     let mut task: Box<FnMut(int) -> int> = box |&mut: x| x;
-    task(0i);
+    task(0);
 
     call(|:x| x, 22);
 }
diff --git a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
index 780a1e6cdf0..e4b35aada9f 100644
--- a/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
+++ b/src/test/run-pass/unboxed-closures-static-call-fn-once.rs
@@ -12,6 +12,6 @@
 
 fn main() {
     let onetime = |: x| x;
-    onetime(0i);
+    onetime(0);
 }
 
diff --git a/src/test/run-pass/unique-assign-copy.rs b/src/test/run-pass/unique-assign-copy.rs
index 9e3d9544d42..c19063fe464 100644
--- a/src/test/run-pass/unique-assign-copy.rs
+++ b/src/test/run-pass/unique-assign-copy.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let mut i = box 1i;
+    let mut i = box 1;
     // Should be a copy
     let mut j;
     j = i.clone();
diff --git a/src/test/run-pass/unique-assign-drop.rs b/src/test/run-pass/unique-assign-drop.rs
index 81c4b6ab7e5..241258f089c 100644
--- a/src/test/run-pass/unique-assign-drop.rs
+++ b/src/test/run-pass/unique-assign-drop.rs
@@ -13,8 +13,8 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 1i;
-    let mut j = box 2i;
+    let i = box 1;
+    let mut j = box 2;
     // Should drop the previous value of j
     j = i;
     assert_eq!(*j, 1);
diff --git a/src/test/run-pass/unique-assign-generic.rs b/src/test/run-pass/unique-assign-generic.rs
index 7c9bbd64171..c8abb080848 100644
--- a/src/test/run-pass/unique-assign-generic.rs
+++ b/src/test/run-pass/unique-assign-generic.rs
@@ -18,6 +18,6 @@ fn f<T>(t: T) -> T {
 }
 
 pub fn main() {
-    let t = f(box 100i);
-    assert_eq!(t, box 100i);
+    let t = f(box 100);
+    assert_eq!(t, box 100);
 }
diff --git a/src/test/run-pass/unique-assign.rs b/src/test/run-pass/unique-assign.rs
index 199657fd995..cbcb6afb4c8 100644
--- a/src/test/run-pass/unique-assign.rs
+++ b/src/test/run-pass/unique-assign.rs
@@ -13,6 +13,6 @@
 
 pub fn main() {
     let mut i;
-    i = box 1i;
+    i = box 1;
     assert_eq!(*i, 1);
 }
diff --git a/src/test/run-pass/unique-autoderef-index.rs b/src/test/run-pass/unique-autoderef-index.rs
index 1c7b4c534ed..30c4b2d7b56 100644
--- a/src/test/run-pass/unique-autoderef-index.rs
+++ b/src/test/run-pass/unique-autoderef-index.rs
@@ -12,6 +12,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box vec!(100i);
-    assert_eq!((*i)[0], 100i);
+    let i = box vec!(100);
+    assert_eq!((*i)[0], 100);
 }
diff --git a/src/test/run-pass/unique-cmp.rs b/src/test/run-pass/unique-cmp.rs
index dba4d8db849..a2962dc00d5 100644
--- a/src/test/run-pass/unique-cmp.rs
+++ b/src/test/run-pass/unique-cmp.rs
@@ -12,10 +12,10 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
-    assert!(i == box 100i);
-    assert!(i < box 101i);
-    assert!(i <= box 100i);
-    assert!(i > box 99i);
-    assert!(i >= box 99i);
+    let i = box 100;
+    assert!(i == box 100);
+    assert!(i < box 101);
+    assert!(i <= box 100);
+    assert!(i > box 99);
+    assert!(i >= box 99);
 }
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index cec74d251b3..975f1e9da82 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -12,9 +12,9 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    box 100i;
+    box 100;
 }
 
 fn vec() {
-    vec!(0i);
+    vec!(0);
 }
diff --git a/src/test/run-pass/unique-decl-init-copy.rs b/src/test/run-pass/unique-decl-init-copy.rs
index d0ad03b773c..3af38784add 100644
--- a/src/test/run-pass/unique-decl-init-copy.rs
+++ b/src/test/run-pass/unique-decl-init-copy.rs
@@ -12,11 +12,11 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let mut i = box 1i;
+    let mut i = box 1;
     // Should be a copy
     let mut j = i.clone();
-    *i = 2i;
-    *j = 3i;
-    assert_eq!(*i, 2i);
-    assert_eq!(*j, 3i);
+    *i = 2;
+    *j = 3;
+    assert_eq!(*i, 2);
+    assert_eq!(*j, 3);
 }
diff --git a/src/test/run-pass/unique-decl-init.rs b/src/test/run-pass/unique-decl-init.rs
index d7c19eb6358..c9192748809 100644
--- a/src/test/run-pass/unique-decl-init.rs
+++ b/src/test/run-pass/unique-decl-init.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 1i;
+    let i = box 1;
     let j = i;
     assert_eq!(*j, 1);
 }
diff --git a/src/test/run-pass/unique-decl-move.rs b/src/test/run-pass/unique-decl-move.rs
index 0acdc8f3b80..96dd9f51fbe 100644
--- a/src/test/run-pass/unique-decl-move.rs
+++ b/src/test/run-pass/unique-decl-move.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
+    let i = box 100;
     let j = i;
     assert_eq!(*j, 100);
 }
diff --git a/src/test/run-pass/unique-deref.rs b/src/test/run-pass/unique-deref.rs
index 752ea830aa5..41d3b87a003 100644
--- a/src/test/run-pass/unique-deref.rs
+++ b/src/test/run-pass/unique-deref.rs
@@ -12,6 +12,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
+    let i = box 100;
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index ec2c9f8c666..c5a0a4df275 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -12,5 +12,5 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let _x = box vec!(0i,0,0,0,0);
+    let _x = box vec!(0,0,0,0,0);
 }
diff --git a/src/test/run-pass/unique-fn-arg-move.rs b/src/test/run-pass/unique-fn-arg-move.rs
index 0e47d39e55f..1b3f7e72a4d 100644
--- a/src/test/run-pass/unique-fn-arg-move.rs
+++ b/src/test/run-pass/unique-fn-arg-move.rs
@@ -16,6 +16,6 @@ fn f(i: Box<int>) {
 }
 
 pub fn main() {
-    let i = box 100i;
+    let i = box 100;
     f(i);
 }
diff --git a/src/test/run-pass/unique-in-vec-copy.rs b/src/test/run-pass/unique-in-vec-copy.rs
index 4620815e74e..3bde79fdce0 100644
--- a/src/test/run-pass/unique-in-vec-copy.rs
+++ b/src/test/run-pass/unique-in-vec-copy.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let mut a = vec!(box 10i);
+    let mut a = vec!(box 10);
     let b = a.clone();
 
     assert_eq!(*a[0], 10);
diff --git a/src/test/run-pass/unique-in-vec.rs b/src/test/run-pass/unique-in-vec.rs
index 389ca2c18b1..05b0c7244de 100644
--- a/src/test/run-pass/unique-in-vec.rs
+++ b/src/test/run-pass/unique-in-vec.rs
@@ -12,6 +12,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let vect = vec!(box 100i);
+    let vect = vec!(box 100);
     assert!(vect[0] == box 100);
 }
diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs
index b36d08364a2..d3f13f1609f 100644
--- a/src/test/run-pass/unique-init.rs
+++ b/src/test/run-pass/unique-init.rs
@@ -12,5 +12,5 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let _i = box 100i;
+    let _i = box 100;
 }
diff --git a/src/test/run-pass/unique-kinds.rs b/src/test/run-pass/unique-kinds.rs
index 56f7a3f7990..4c93c379b48 100644
--- a/src/test/run-pass/unique-kinds.rs
+++ b/src/test/run-pass/unique-kinds.rs
@@ -23,11 +23,11 @@ fn sendable() {
         assert!(i != j);
     }
 
-    let i = box 100i;
-    let j = box 100i;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = box 100i;
-    let j = box 101i;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
@@ -41,11 +41,11 @@ fn copyable() {
         assert!(i != j);
     }
 
-    let i = box 100i;
-    let j = box 100i;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = box 100i;
-    let j = box 101i;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
@@ -59,11 +59,11 @@ fn noncopyable() {
         assert!(i != j);
     }
 
-    let i = box 100i;
-    let j = box 100i;
+    let i = box 100;
+    let j = box 100;
     f(i, j);
-    let i = box 100i;
-    let j = box 101i;
+    let i = box 100;
+    let j = box 101;
     g(i, j);
 }
 
diff --git a/src/test/run-pass/unique-log.rs b/src/test/run-pass/unique-log.rs
index 05579796dab..4b21b949f88 100644
--- a/src/test/run-pass/unique-log.rs
+++ b/src/test/run-pass/unique-log.rs
@@ -12,6 +12,6 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
+    let i = box 100;
     println!("{}", i);
 }
diff --git a/src/test/run-pass/unique-move-drop.rs b/src/test/run-pass/unique-move-drop.rs
index 1388c6c5d2b..705b9d6e92c 100644
--- a/src/test/run-pass/unique-move-drop.rs
+++ b/src/test/run-pass/unique-move-drop.rs
@@ -13,8 +13,8 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
-    let j = box 200i;
+    let i = box 100;
+    let j = box 200;
     let j = i;
     assert_eq!(*j, 100);
 }
diff --git a/src/test/run-pass/unique-move-temp.rs b/src/test/run-pass/unique-move-temp.rs
index af82d3e14ea..b6c24f5be28 100644
--- a/src/test/run-pass/unique-move-temp.rs
+++ b/src/test/run-pass/unique-move-temp.rs
@@ -13,6 +13,6 @@
 
 pub fn main() {
     let mut i;
-    i = box 100i;
+    i = box 100;
     assert_eq!(*i, 100);
 }
diff --git a/src/test/run-pass/unique-move.rs b/src/test/run-pass/unique-move.rs
index 791c4799bf0..ed13bf6a5c4 100644
--- a/src/test/run-pass/unique-move.rs
+++ b/src/test/run-pass/unique-move.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let i = box 100i;
+    let i = box 100;
     let mut j;
     j = i;
     assert_eq!(*j, 100);
diff --git a/src/test/run-pass/unique-mutable.rs b/src/test/run-pass/unique-mutable.rs
index c4f860d930b..403b8bf18b8 100644
--- a/src/test/run-pass/unique-mutable.rs
+++ b/src/test/run-pass/unique-mutable.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let mut i = box 0i;
+    let mut i = box 0;
     *i = 1;
     assert_eq!(*i, 1);
 }
diff --git a/src/test/run-pass/unique-send.rs b/src/test/run-pass/unique-send.rs
index 13728585455..2a462e9cdd8 100644
--- a/src/test/run-pass/unique-send.rs
+++ b/src/test/run-pass/unique-send.rs
@@ -15,7 +15,7 @@ use std::sync::mpsc::channel;
 
 pub fn main() {
     let (tx, rx) = channel();
-    tx.send(box 100i).unwrap();
+    tx.send(box 100).unwrap();
     let v = rx.recv().unwrap();
-    assert_eq!(v, box 100i);
+    assert_eq!(v, box 100);
 }
diff --git a/src/test/run-pass/unique-swap.rs b/src/test/run-pass/unique-swap.rs
index cd3b59a69ba..2adb9c22f60 100644
--- a/src/test/run-pass/unique-swap.rs
+++ b/src/test/run-pass/unique-swap.rs
@@ -14,9 +14,9 @@
 use std::mem::swap;
 
 pub fn main() {
-    let mut i = box 100i;
-    let mut j = box 200i;
+    let mut i = box 100;
+    let mut j = box 200;
     swap(&mut i, &mut j);
-    assert_eq!(i, box 200i);
-    assert_eq!(j, box 100i);
+    assert_eq!(i, box 200);
+    assert_eq!(j, box 100);
 }
diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs
index a9ac78c5d76..a28dc2c1f15 100644
--- a/src/test/run-pass/unreachable-code.rs
+++ b/src/test/run-pass/unreachable-code.rs
@@ -24,7 +24,7 @@ fn call_id_2() { id(true) && id(return); }
 fn call_id_3() { id(return) && id(return); }
 
 fn ret_guard() {
-    match 2i {
+    match 2 {
       x if (return) => { x; }
       _ => {}
     }
diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs
index 27945f46920..a2d1b8780aa 100644
--- a/src/test/run-pass/unused-move-capture.rs
+++ b/src/test/run-pass/unused-move-capture.rs
@@ -12,7 +12,7 @@
 #![feature(box_syntax)]
 
 pub fn main() {
-    let _x = box 1i;
+    let _x = box 1;
     let lam_move = |&:| {};
     lam_move();
 }
diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs
index 22201c7d83f..d053b03a2ca 100644
--- a/src/test/run-pass/unused-move.rs
+++ b/src/test/run-pass/unused-move.rs
@@ -18,6 +18,6 @@
 
 pub fn main()
 {
-    let y = box 1i;
+    let y = box 1;
     y;
 }
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index 74802c156a2..ea52802d245 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -14,7 +14,7 @@
 use std::thread::Thread;
 
 fn f() {
-    let _a = box 0i;
+    let _a = box 0;
     panic!();
 }
 
diff --git a/src/test/run-pass/use-uninit-match.rs b/src/test/run-pass/use-uninit-match.rs
index 3f23d714c0f..efa6a2c5834 100644
--- a/src/test/run-pass/use-uninit-match.rs
+++ b/src/test/run-pass/use-uninit-match.rs
@@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 enum myoption<T> { none, some(T), }
 
-pub fn main() { println!("{}", 5i); }
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/use-uninit-match2.rs b/src/test/run-pass/use-uninit-match2.rs
index de5b32dd176..f2b487b7034 100644
--- a/src/test/run-pass/use-uninit-match2.rs
+++ b/src/test/run-pass/use-uninit-match2.rs
@@ -21,4 +21,4 @@ fn foo<T>(o: myoption<T>) -> int {
 
 enum myoption<T> { none, some(T), }
 
-pub fn main() { println!("{}", 5i); }
+pub fn main() { println!("{}", 5); }
diff --git a/src/test/run-pass/utf8_idents.rs b/src/test/run-pass/utf8_idents.rs
index c99c394969c..0e6f20358aa 100644
--- a/src/test/run-pass/utf8_idents.rs
+++ b/src/test/run-pass/utf8_idents.rs
@@ -26,25 +26,25 @@ fn საჭმელად_გემრიელი_სადილი() -> int
 
     // Lunch in several languages.
 
-    let ランチ = 10i;
-    let 午餐 = 10i;
+    let ランチ = 10;
+    let 午餐 = 10;
 
-    let ארוחת_צהריי = 10i;
+    let ארוחת_צהריי = 10;
     let غداء = 10u;
-    let լանչ = 10i;
-    let обед = 10i;
-    let абед = 10i;
-    let μεσημεριανό = 10i;
-    let hádegismatur = 10i;
-    let ручек = 10i;
+    let լանչ = 10;
+    let обед = 10;
+    let абед = 10;
+    let μεσημεριανό = 10;
+    let hádegismatur = 10;
+    let ручек = 10;
 
-    let ăn_trưa = 10i;
-    let อาหารกลางวัน = 10i;
+    let ăn_trưa = 10;
+    let อาหารกลางวัน = 10;
 
     // Lunchy arithmetic, mm.
 
     assert_eq!(hádegismatur * ручек * обед, 1000);
-    assert_eq!(10i, ארוחת_צהריי);
+    assert_eq!(10, ארוחת_צהריי);
     assert_eq!(ランチ + 午餐 + μεσημεριανό, 30);
     assert_eq!(ăn_trưa + อาหารกลางวัน, 20);
     return (абед + լանչ) >> غداء;
diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs
index 9600a242ca1..a729fedb271 100644
--- a/src/test/run-pass/variadic-ffi.rs
+++ b/src/test/run-pass/variadic-ffi.rs
@@ -35,7 +35,7 @@ pub fn main() {
         // Call with variable number of arguments
         let c = CString::from_slice(b"%d %f %c %s\n");
         check("42 42.500000 a %d %f %c %s\n\n", |s| {
-            sprintf(s, c.as_ptr(), 42i, 42.5f64, 'a' as c_int, c.as_ptr());
+            sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr());
         });
 
         // Make a function pointer
@@ -50,7 +50,7 @@ pub fn main() {
             // Call with variable number of arguments
             let c = CString::from_slice(b"%d %f %c %s\n");
             check("42 42.500000 a %d %f %c %s\n\n", |s| {
-                sprintf(s, c.as_ptr(), 42i, 42.5f64, 'a' as c_int, c.as_ptr());
+                sprintf(s, c.as_ptr(), 42, 42.5f64, 'a' as c_int, c.as_ptr());
             });
         }
 
diff --git a/src/test/run-pass/vec-growth.rs b/src/test/run-pass/vec-growth.rs
index d5e5f94d261..b8626b9c8a9 100644
--- a/src/test/run-pass/vec-growth.rs
+++ b/src/test/run-pass/vec-growth.rs
@@ -10,11 +10,11 @@
 
 
 pub fn main() {
-    let mut v = vec!(1i);
-    v.push(2i);
-    v.push(3i);
-    v.push(4i);
-    v.push(5i);
+    let mut v = vec!(1);
+    v.push(2);
+    v.push(3);
+    v.push(4);
+    v.push(5);
     assert_eq!(v[0], 1);
     assert_eq!(v[1], 2);
     assert_eq!(v[2], 3);
diff --git a/src/test/run-pass/vec-macro-with-brackets.rs b/src/test/run-pass/vec-macro-with-brackets.rs
index a263501f8fe..5d1f43fb230 100644
--- a/src/test/run-pass/vec-macro-with-brackets.rs
+++ b/src/test/run-pass/vec-macro-with-brackets.rs
@@ -17,5 +17,5 @@ macro_rules! vec [
 ];
 
 pub fn main() {
-    let my_vec = vec![1i, 2, 3, 4, 5];
+    let my_vec = vec![1, 2, 3, 4, 5];
 }
diff --git a/src/test/run-pass/vec-macro-with-trailing-comma.rs b/src/test/run-pass/vec-macro-with-trailing-comma.rs
index 80c2a5fe83e..07033d60497 100644
--- a/src/test/run-pass/vec-macro-with-trailing-comma.rs
+++ b/src/test/run-pass/vec-macro-with-trailing-comma.rs
@@ -10,6 +10,6 @@
 
 
 pub fn main() {
-    assert_eq!(vec!(1i), vec!(1i,));
-    assert_eq!(vec!(1i, 2, 3), vec!(1i, 2, 3,));
+    assert_eq!(vec!(1), vec!(1,));
+    assert_eq!(vec!(1, 2, 3), vec!(1, 2, 3,));
 }
diff --git a/src/test/run-pass/vec-matching-autoslice.rs b/src/test/run-pass/vec-matching-autoslice.rs
index 6476f734ae6..4ed73dc2301 100644
--- a/src/test/run-pass/vec-matching-autoslice.rs
+++ b/src/test/run-pass/vec-matching-autoslice.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = [1i, 2, 3];
+    let x = [1, 2, 3];
     match x {
         [2, _, _] => panic!(),
         [1, a, b] => {
@@ -18,7 +18,7 @@ pub fn main() {
         [_, _, _] => panic!(),
     }
 
-    let y = ([(1i, true), (2i, false)], 0.5f64);
+    let y = ([(1, true), (2, false)], 0.5f64);
     match y {
         ([(1, a), (b, false)], _) => {
             assert_eq!(a, true);
diff --git a/src/test/run-pass/vec-matching-fixed.rs b/src/test/run-pass/vec-matching-fixed.rs
index a1a14823ff5..6ef1dc4ea26 100644
--- a/src/test/run-pass/vec-matching-fixed.rs
+++ b/src/test/run-pass/vec-matching-fixed.rs
@@ -11,7 +11,7 @@
 #![feature(advanced_slice_patterns)]
 
 fn a() {
-    let x = [1i, 2, 3];
+    let x = [1, 2, 3];
     match x {
         [1, 2, 4] => unreachable!(),
         [0, 2, 3, ..] => unreachable!(),
diff --git a/src/test/run-pass/vec-matching-fold.rs b/src/test/run-pass/vec-matching-fold.rs
index 57660183333..e72170cb730 100644
--- a/src/test/run-pass/vec-matching-fold.rs
+++ b/src/test/run-pass/vec-matching-fold.rs
@@ -39,11 +39,11 @@ fn foldr<T, U, F>(values: &[T],
 }
 
 pub fn main() {
-    let x = &[1i, 2, 3, 4, 5];
+    let x = &[1, 2, 3, 4, 5];
 
-    let product = foldl(x, 1i, |a, b| a * *b);
+    let product = foldl(x, 1, |a, b| a * *b);
     assert_eq!(product, 120);
 
-    let sum = foldr(x, 0i, |a, b| *a + b);
+    let sum = foldr(x, 0, |a, b| *a + b);
     assert_eq!(sum, 15);
 }
diff --git a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
index a140399447b..64309906156 100644
--- a/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
+++ b/src/test/run-pass/vec-matching-legal-tail-element-borrow.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = &[1i, 2, 3, 4, 5];
+    let x = &[1, 2, 3, 4, 5];
     let x: &[int] = &[1, 2, 3, 4, 5];
     if !x.is_empty() {
         let el = match x {
diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs
index 77226df7fa2..8dcf4612f47 100644
--- a/src/test/run-pass/vec-matching.rs
+++ b/src/test/run-pass/vec-matching.rs
@@ -11,7 +11,7 @@
 #![feature(advanced_slice_patterns)]
 
 fn a() {
-    let x = [1i];
+    let x = [1];
     match x {
         [a] => {
             assert_eq!(a, 1);
@@ -20,7 +20,7 @@ fn a() {
 }
 
 fn b() {
-    let x = [1i, 2, 3];
+    let x = [1, 2, 3];
     match x {
         [a, b, c..] => {
             assert_eq!(a, 1);
@@ -55,7 +55,7 @@ fn b() {
 }
 
 fn c() {
-    let x = [1i];
+    let x = [1];
     match x {
         [2, ..] => panic!(),
         [..] => ()
@@ -63,18 +63,18 @@ fn c() {
 }
 
 fn d() {
-    let x = [1i, 2, 3];
+    let x = [1, 2, 3];
     let branch = match x {
-        [1, 1, ..] => 0i,
-        [1, 2, 3, ..] => 1i,
-        [1, 2, ..] => 2i,
+        [1, 1, ..] => 0,
+        [1, 2, 3, ..] => 1,
+        [1, 2, ..] => 2,
         _ => 3
     };
     assert_eq!(branch, 1);
 }
 
 fn e() {
-    let x: &[int] = &[1i, 2, 3];
+    let x: &[int] = &[1, 2, 3];
     match x {
         [1, 2] => (),
         [..] => ()
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index fe0f92a0c11..33f01c5bd41 100644
--- a/src/test/run-pass/vec-push.rs
+++ b/src/test/run-pass/vec-push.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let mut v = vec!(1i, 2, 3); v.push(1); }
+pub fn main() { let mut v = vec!(1, 2, 3); v.push(1); }
diff --git a/src/test/run-pass/vec-repeat-with-cast.rs b/src/test/run-pass/vec-repeat-with-cast.rs
index 97a443cb3b8..22ca6c37a8e 100644
--- a/src/test/run-pass/vec-repeat-with-cast.rs
+++ b/src/test/run-pass/vec-repeat-with-cast.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn main() { let _a = [0i; 1 as uint]; }
+pub fn main() { let _a = [0; 1 as uint]; }
diff --git a/src/test/run-pass/vec-slice.rs b/src/test/run-pass/vec-slice.rs
index 374913e3cfd..5375e54e27f 100644
--- a/src/test/run-pass/vec-slice.rs
+++ b/src/test/run-pass/vec-slice.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let  v = vec!(1i,2,3,4,5);
+    let  v = vec![1,2,3,4,5];
     let v2 = &v[1..3];
     assert_eq!(v2[0], 2);
     assert_eq!(v2[1], 3);
diff --git a/src/test/run-pass/vec-to_str.rs b/src/test/run-pass/vec-to_str.rs
index 31f26126242..5d132b2a749 100644
--- a/src/test/run-pass/vec-to_str.rs
+++ b/src/test/run-pass/vec-to_str.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 pub fn main() {
-    assert_eq!(format!("{:?}", vec!(0i, 1)), "[0, 1]".to_string());
+    assert_eq!(format!("{:?}", vec!(0, 1)), "[0, 1]".to_string());
 
-    let foo = vec!(3i, 4);
+    let foo = vec!(3, 4);
     let bar: &[int] = &[4, 5];
 
     assert_eq!(format!("{:?}", foo), "[3, 4]");
diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs
index 250bafc712d..aaefbc42d70 100644
--- a/src/test/run-pass/vector-sort-panic-safe.rs
+++ b/src/test/run-pass/vector-sort-panic-safe.rs
@@ -12,8 +12,8 @@ use std::sync::atomic::{AtomicUsize, ATOMIC_USIZE_INIT, Ordering};
 use std::rand::{thread_rng, Rng, Rand};
 use std::thread::Thread;
 
-const REPEATS: uint = 5;
-const MAX_LEN: uint = 32;
+const REPEATS: usize = 5;
+const MAX_LEN: usize = 32;
 static drop_counts: [AtomicUsize;  MAX_LEN] =
     // FIXME #5244: AtomicUsize is not Copy.
     [
@@ -33,7 +33,7 @@ static drop_counts: [AtomicUsize;  MAX_LEN] =
 static creation_count: AtomicUsize = ATOMIC_USIZE_INIT;
 
 #[derive(Clone, PartialEq, PartialOrd, Eq, Ord)]
-struct DropCounter { x: uint, creation_id: uint }
+struct DropCounter { x: usize, creation_id: usize }
 
 impl Rand for DropCounter {
     fn rand<R: Rng>(rng: &mut R) -> DropCounter {
@@ -53,7 +53,7 @@ impl Drop for DropCounter {
 }
 
 pub fn main() {
-    assert!(MAX_LEN <= std::uint::BITS);
+    assert!(MAX_LEN <= std::usize::BITS);
     // len can't go above 64.
     for len in 2..MAX_LEN {
         for _ in 0..REPEATS {
@@ -67,11 +67,11 @@ pub fn main() {
 
             // work out the total number of comparisons required to sort
             // this array...
-            let mut count = 0;
+            let mut count = 0us;
             main.clone().as_mut_slice().sort_by(|a, b| { count += 1; a.cmp(b) });
 
             // ... and then panic on each and every single one.
-            for panic_countdown in 0i..count {
+            for panic_countdown in 0..count {
                 // refresh the counters.
                 for c in drop_counts.iter() {
                     c.store(0, Ordering::Relaxed);
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index c8ed1a26105..4080796b7a7 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -36,7 +36,7 @@ fn zombiejesus() {
         while (return) {
             if (return) {
                 match (return) {
-                    1i => {
+                    1 => {
                         if (return) {
                             return
                         } else {
@@ -65,13 +65,13 @@ fn canttouchthis() -> uint {
     fn p() -> bool { true }
     let _a = (assert!((true)) == (assert!(p())));
     let _c = (assert!((p())) == ());
-    let _b: bool = (println!("{}", 0i) == (return 0u));
+    let _b: bool = (println!("{}", 0) == (return 0u));
 }
 
 fn angrydome() {
     loop { if break { } }
-    let mut i = 0i;
-    loop { i += 1; if i == 1 { match (continue) { 1i => { }, _ => panic!("wat") } }
+    let mut i = 0;
+    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => panic!("wat") } }
       break; }
 }
 
diff --git a/src/test/run-pass/where-clause-region-outlives.rs b/src/test/run-pass/where-clause-region-outlives.rs
index 1ecb4b6c2dc..aa39325277e 100644
--- a/src/test/run-pass/where-clause-region-outlives.rs
+++ b/src/test/run-pass/where-clause-region-outlives.rs
@@ -11,7 +11,7 @@
 struct A<'a, 'b> where 'a : 'b { x: &'a int, y: &'b int }
 
 fn main() {
-    let x = 1i;
-    let y = 1i;
+    let x = 1;
+    let y = 1;
     let a = A { x: &x, y: &y };
 }
diff --git a/src/test/run-pass/where-clauses-cross-crate.rs b/src/test/run-pass/where-clauses-cross-crate.rs
index 648f646b637..b822abd6732 100644
--- a/src/test/run-pass/where-clauses-cross-crate.rs
+++ b/src/test/run-pass/where-clauses-cross-crate.rs
@@ -15,9 +15,9 @@ extern crate where_clauses_xc;
 use where_clauses_xc::{Equal, equal};
 
 fn main() {
-    println!("{}", equal(&1i, &2i));
-    println!("{}", equal(&1i, &1i));
+    println!("{}", equal(&1, &2));
+    println!("{}", equal(&1, &1));
     println!("{}", "hello".equal(&"hello"));
-    println!("{}", "hello".equals::<int,&str>(&1i, &1i, &"foo", &"bar"));
+    println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar"));
 }
 
diff --git a/src/test/run-pass/where-clauses-lifetimes.rs b/src/test/run-pass/where-clauses-lifetimes.rs
index 237c83c8aa2..e3ea7cd80e7 100644
--- a/src/test/run-pass/where-clauses-lifetimes.rs
+++ b/src/test/run-pass/where-clauses-lifetimes.rs
@@ -11,5 +11,5 @@
 fn foo<'a, I>(mut it: I) where I: Iterator<Item=&'a int> {}
 
 fn main() {
-    foo([1i, 2].iter());
+    foo([1, 2].iter());
 }
diff --git a/src/test/run-pass/where-clauses-method.rs b/src/test/run-pass/where-clauses-method.rs
index 2b87bcd4b39..29efe727276 100644
--- a/src/test/run-pass/where-clauses-method.rs
+++ b/src/test/run-pass/where-clauses-method.rs
@@ -22,8 +22,8 @@ impl<T> Foo<T> {
 }
 
 fn main() {
-    let x = Foo { value: 1i };
-    let y = Foo { value: 2i };
+    let x = Foo { value: 1 };
+    let y = Foo { value: 2 };
     println!("{}", x.equals(&x));
     println!("{}", x.equals(&y));
 }
diff --git a/src/test/run-pass/where-clauses.rs b/src/test/run-pass/where-clauses.rs
index 807d95691f4..92bc7edf285 100644
--- a/src/test/run-pass/where-clauses.rs
+++ b/src/test/run-pass/where-clauses.rs
@@ -29,9 +29,9 @@ fn equal<T>(x: &T, y: &T) -> bool where T: Eq {
 }
 
 fn main() {
-    println!("{}", equal(&1i, &2i));
-    println!("{}", equal(&1i, &1i));
+    println!("{}", equal(&1, &2));
+    println!("{}", equal(&1, &1));
     println!("{}", "hello".equal(&"hello"));
-    println!("{}", "hello".equals::<int,&str>(&1i, &1i, &"foo", &"bar"));
+    println!("{}", "hello".equals::<int,&str>(&1, &1, &"foo", &"bar"));
 }
 
diff --git a/src/test/run-pass/while-cont.rs b/src/test/run-pass/while-cont.rs
index 50feb3ef4e1..3e1a232115f 100644
--- a/src/test/run-pass/while-cont.rs
+++ b/src/test/run-pass/while-cont.rs
@@ -10,7 +10,7 @@
 
 // Issue #825: Should recheck the loop condition after continuing
 pub fn main() {
-    let mut i = 1i;
+    let mut i = 1;
     while i > 0 {
         assert!((i > 0));
         println!("{}", i);
diff --git a/src/test/run-pass/while-label.rs b/src/test/run-pass/while-label.rs
index 41712f7c64d..4a3cd115d20 100644
--- a/src/test/run-pass/while-label.rs
+++ b/src/test/run-pass/while-label.rs
@@ -10,8 +10,8 @@
 
 
 pub fn main() {
-    let mut i = 100i;
-    'w: while 1i + 1 == 2 {
+    let mut i = 100;
+    'w: while 1 + 1 == 2 {
         i -= 1;
         if i == 95 {
             break 'w;
diff --git a/src/test/run-pass/while-let.rs b/src/test/run-pass/while-let.rs
index 94a45817ee5..1780445fb3b 100644
--- a/src/test/run-pass/while-let.rs
+++ b/src/test/run-pass/while-let.rs
@@ -11,16 +11,16 @@
 use std::collections::BinaryHeap;
 
 fn make_pq() -> BinaryHeap<int> {
-    BinaryHeap::from_vec(vec![1i,2,3])
+    BinaryHeap::from_vec(vec![1,2,3])
 }
 
 pub fn main() {
     let mut pq = make_pq();
-    let mut sum = 0i;
+    let mut sum = 0;
     while let Some(x) = pq.pop() {
         sum += x;
     }
-    assert_eq!(sum, 6i);
+    assert_eq!(sum, 6);
 
     pq = make_pq();
     sum = 0;
@@ -30,7 +30,7 @@ pub fn main() {
             break 'a;
         }
     }
-    assert_eq!(sum, 5i);
+    assert_eq!(sum, 5);
 
     pq = make_pq();
     sum = 0;
@@ -40,7 +40,7 @@ pub fn main() {
         }
         sum += x;
     }
-    assert_eq!(sum, 3i);
+    assert_eq!(sum, 3);
 
     let mut pq1 = make_pq();
     sum = 0;
@@ -50,5 +50,5 @@ pub fn main() {
             sum += x * y;
         }
     }
-    assert_eq!(sum, 6i + 12 + 18);
+    assert_eq!(sum, 6 + 12 + 18);
 }