Merge remote-tracking branch 'origin/master' into 0.11.0-release

Conflicts: src/libstd/lib.rs
author: Alex Crichton <alex@alexcrichton.com> 2014-07-02 11:08:21 -0700
committer: Alex Crichton <alex@alexcrichton.com> 2014-07-02 11:08:21 -0700
commit: ff1dd44b40a7243f43a8d32ba8bd6026197c320b (patch)
tree: 4460cbf0a917a289d1d3744d9645c5ab131ea9df /src/test/run-pass
parent: aa1163b92de7717eb7c5eba002b4012e0574a7fe (diff)
parent: ca2778ede7c21efc3cf2e4e1152875ec09360770 (diff)
download: rust-ff1dd44b40a7243f43a8d32ba8bd6026197c320b.tar.gz
rust-ff1dd44b40a7243f43a8d32ba8bd6026197c320b.zip
189 files changed, 675 insertions, 426 deletions
diff --git a/src/test/run-pass/attr-start.rs b/src/test/run-pass/attr-start.rs
index 35a0da4dcf3..3bea7e84807 100644
--- a/src/test/run-pass/attr-start.rs
+++ b/src/test/run-pass/attr-start.rs
@@ -10,6 +10,6 @@
 
 
 #[start]
-fn start(_argc: int, _argv: **u8) -> int {
+fn start(_argc: int, _argv: *const *const u8) -> int {
     return 0;
 }
diff --git a/src/test/run-pass/auto-instantiate.rs b/src/test/run-pass/auto-instantiate.rs
index f1fe1e94587..5167764dd28 100644
--- a/src/test/run-pass/auto-instantiate.rs
+++ b/src/test/run-pass/auto-instantiate.rs
@@ -16,6 +16,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}, 4).a.x);
+    println!("{:?}", f(Triple {x: 3, y: 4, z: 5}, 4i).a.x);
     println!("{:?}", f(5i, 6i).a);
 }
diff --git a/src/test/run-pass/backtrace.rs b/src/test/run-pass/backtrace.rs
index 3b74ec4add3..97862844030 100644
--- a/src/test/run-pass/backtrace.rs
+++ b/src/test/run-pass/backtrace.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 // ignore-win32 FIXME #13259
 extern crate native;
 
@@ -18,7 +18,9 @@ use std::finally::Finally;
 use std::str;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int { native::start(argc, argv, main) }
+fn start(argc: int, argv: *const *const u8) -> int {
+    native::start(argc, argv, main)
+}
 
 #[inline(never)]
 fn foo() {
diff --git a/src/test/run-pass/binops.rs b/src/test/run-pass/binops.rs
index ff4dcc18bb4..21824700860 100644
--- a/src/test/run-pass/binops.rs
+++ b/src/test/run-pass/binops.rs
@@ -52,9 +52,9 @@ fn test_box() {
 
 fn test_ptr() {
     unsafe {
-        let p1: *u8 = ::std::mem::transmute(0u);
-        let p2: *u8 = ::std::mem::transmute(0u);
-        let p3: *u8 = ::std::mem::transmute(1u);
+        let p1: *const u8 = ::std::mem::transmute(0u);
+        let p2: *const u8 = ::std::mem::transmute(0u);
+        let p3: *const u8 = ::std::mem::transmute(1u);
 
         assert_eq!(p1, p2);
         assert!(p1 != p3);
@@ -86,8 +86,8 @@ fn test_class() {
 
   unsafe {
   println!("q = {:x}, r = {:x}",
-         (::std::mem::transmute::<*p, uint>(&q)),
-         (::std::mem::transmute::<*p, uint>(&r)));
+         (::std::mem::transmute::<*const p, uint>(&q)),
+         (::std::mem::transmute::<*const p, uint>(&r)));
   }
   assert_eq!(q, r);
   r.y = 17;
diff --git a/src/test/run-pass/borrowck-borrow-from-expr-block.rs b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
index dd1224929c7..c9e1c2c8d42 100644
--- a/src/test/run-pass/borrowck-borrow-from-expr-block.rs
+++ b/src/test/run-pass/borrowck-borrow-from-expr-block.rs
@@ -18,8 +18,8 @@ fn borrow(x: &int, f: |x: &int|) {
 
 fn test1(x: Gc<Box<int>>) {
     borrow(&*(*x).clone(), |p| {
-        let x_a = &**x as *int;
-        assert!((x_a as uint) != (p as *int as uint));
+        let x_a = &**x as *const int;
+        assert!((x_a as uint) != (p as *const int as uint));
         assert_eq!(unsafe{*x_a}, *p);
     })
 }
diff --git a/src/test/run-pass/builtin-superkinds-self-type.rs b/src/test/run-pass/builtin-superkinds-self-type.rs
index d0ccfe0e21d..1c156f6551c 100644
--- a/src/test/run-pass/builtin-superkinds-self-type.rs
+++ b/src/test/run-pass/builtin-superkinds-self-type.rs
@@ -21,6 +21,6 @@ impl <T: Send> Foo for T { }
 
 pub fn main() {
     let (tx, rx) = channel();
-    1193182.foo(tx);
-    assert!(rx.recv() == 1193182);
+    1193182i.foo(tx);
+    assert!(rx.recv() == 1193182i);
 }
diff --git a/src/test/run-pass/by-value-self-objects.rs b/src/test/run-pass/by-value-self-objects.rs
new file mode 100644
index 00000000000..3a588367a97
--- /dev/null
+++ b/src/test/run-pass/by-value-self-objects.rs
@@ -0,0 +1,77 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+static mut destructor_count: uint = 0;
+
+trait Foo {
+    fn foo(self, x: int);
+}
+
+struct S {
+    x: int,
+    y: int,
+    z: int,
+    s: String,
+}
+
+impl Foo for S {
+    fn foo(self, x: int) {
+        assert!(self.x == 2);
+        assert!(self.y == 3);
+        assert!(self.z == 4);
+        assert!(self.s.as_slice() == "hello");
+        assert!(x == 5);
+    }
+}
+
+impl Drop for S {
+    fn drop(&mut self) {
+        println!("bye 1!");
+        unsafe {
+            destructor_count += 1;
+        }
+    }
+}
+
+impl Foo for int {
+    fn foo(self, x: int) {
+        println!("{}", x * x);
+    }
+}
+
+fn f() {
+    let s = S {
+        x: 2,
+        y: 3,
+        z: 4,
+        s: "hello".to_string(),
+    };
+    let st = box s as Box<Foo>;
+    st.foo(5);
+    println!("bye 2!");
+}
+
+fn g() {
+    let s = 2i;
+    let st = box s as Box<Foo>;
+    st.foo(3);
+    println!("bye 3!");
+}
+
+fn main() {
+    f();
+
+    unsafe {
+        assert!(destructor_count == 1);
+    }
+
+    g();
+}
+
diff --git a/src/test/run-pass/c-stack-returning-int64.rs b/src/test/run-pass/c-stack-returning-int64.rs
index 540a00d3a31..597e067b8b6 100644
--- a/src/test/run-pass/c-stack-returning-int64.rs
+++ b/src/test/run-pass/c-stack-returning-int64.rs
@@ -16,8 +16,8 @@ mod mlibc {
     use libc::{c_char, c_long, c_longlong};
 
     extern {
-        pub fn atol(x: *c_char) -> c_long;
-        pub fn atoll(x: *c_char) -> c_longlong;
+        pub fn atol(x: *const c_char) -> c_long;
+        pub fn atoll(x: *const c_char) -> c_longlong;
     }
 }
 
diff --git a/src/test/run-pass/capturing-logging.rs b/src/test/run-pass/capturing-logging.rs
index 23607e16795..19186f4b46b 100644
--- a/src/test/run-pass/capturing-logging.rs
+++ b/src/test/run-pass/capturing-logging.rs
@@ -31,7 +31,7 @@ impl Logger for MyWriter {
 }
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     native::start(argc, argv, proc() {
         main();
     })
diff --git a/src/test/run-pass/cast-region-to-uint.rs b/src/test/run-pass/cast-region-to-uint.rs
index eacdd8f3978..a298a08a1b7 100644
--- a/src/test/run-pass/cast-region-to-uint.rs
+++ b/src/test/run-pass/cast-region-to-uint.rs
@@ -10,5 +10,5 @@
 
 pub fn main() {
     let x = 3;
-    println!("&x={:x}", (&x as *int as uint));
+    println!("&x={:x}", (&x as *const int as uint));
 }
diff --git a/src/test/run-pass/class-poly-methods.rs b/src/test/run-pass/class-poly-methods.rs
index 4f94673a2c0..d94547a4dda 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!(1,2,3));
+  nyan.speak(vec!(1i,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-auto-borrow-obj.rs b/src/test/run-pass/cleanup-auto-borrow-obj.rs
new file mode 100644
index 00000000000..23142082a8c
--- /dev/null
+++ b/src/test/run-pass/cleanup-auto-borrow-obj.rs
@@ -0,0 +1,38 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+
+// This would previously leak the Box<Trait> because we wouldn't
+// schedule cleanups when auto borrowing trait objects.
+// This program should be valgrind clean.
+
+
+static mut DROP_RAN: bool = false;
+
+struct Foo;
+impl Drop for Foo {
+    fn drop(&mut self) {
+        unsafe { DROP_RAN = true; }
+    }
+}
+
+
+trait Trait {}
+impl Trait for Foo {}
+
+pub fn main() {
+    {
+        let _x: &Trait = box Foo as Box<Trait>;
+    }
+    unsafe {
+        assert!(DROP_RAN);
+    }
+}
+
diff --git a/src/test/run-pass/cleanup-rvalue-scopes.rs b/src/test/run-pass/cleanup-rvalue-scopes.rs
index 470e16b4888..35c69705925 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), 22));
+    end_of_block!((_, ref _y), (AddFlags(1), 22i));
     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), 22));
+    end_of_stmt!((_, _), (AddFlags(1), 22i));
 
     // `&` operator appears inside an arg to a function,
     // so it is not prolonged:
diff --git a/src/test/run-pass/cmp-default.rs b/src/test/run-pass/cmp-default.rs
index 7805a2bb49e..cfba87c3f69 100644
--- a/src/test/run-pass/cmp-default.rs
+++ b/src/test/run-pass/cmp-default.rs
@@ -31,10 +31,10 @@ impl PartialEq for Int {
 }
 
 impl PartialOrd for Int {
-    fn lt(&self, other: &Int) -> bool {
+    fn partial_cmp(&self, other: &Int) -> Option<Ordering> {
         let Int(this) = *self;
         let Int(other) = *other;
-        this < other
+        this.partial_cmp(&other)
     }
 }
 
@@ -49,10 +49,10 @@ impl PartialEq for RevInt {
 }
 
 impl PartialOrd for RevInt {
-    fn lt(&self, other: &RevInt) -> bool {
+    fn partial_cmp(&self, other: &RevInt) -> Option<Ordering> {
         let RevInt(this) = *self;
         let RevInt(other) = *other;
-        this > other
+        other.partial_cmp(&this)
     }
 }
 
diff --git a/src/test/run-pass/const-binops.rs b/src/test/run-pass/const-binops.rs
index be186a95a77..c14f430e709 100644
--- a/src/test/run-pass/const-binops.rs
+++ b/src/test/run-pass/const-binops.rs
@@ -53,28 +53,28 @@ static V: int = 1 << 3;
 static W: int = 1024 >> 4;
 static X: uint = 1024 >> 4;
 
-static Y: bool = 1 == 1;
-static Z: bool = 1.0 == 1.0;
+static Y: bool = 1i == 1;
+static Z: bool = 1.0f64 == 1.0;
 
-static AA: bool = 1 <= 2;
-static AB: bool = -1 <= 2;
-static AC: bool = 1.0 <= 2.0;
+static AA: bool = 1i <= 2;
+static AB: bool = -1i <= 2;
+static AC: bool = 1.0f64 <= 2.0;
 
-static AD: bool = 1 < 2;
-static AE: bool = -1 < 2;
-static AF: bool = 1.0 < 2.0;
+static AD: bool = 1i < 2;
+static AE: bool = -1i < 2;
+static AF: bool = 1.0f64 < 2.0;
 
-static AG: bool = 1 != 2;
-static AH: bool = -1 != 2;
-static AI: bool = 1.0 != 2.0;
+static AG: bool = 1i != 2;
+static AH: bool = -1i != 2;
+static AI: bool = 1.0f64 != 2.0;
 
-static AJ: bool = 2 >= 1;
-static AK: bool = 2 >= -2;
-static AL: bool = 1.0 >= -2.0;
+static AJ: bool = 2i >= 1;
+static AK: bool = 2i >= -2;
+static AL: bool = 1.0f64 >= -2.0;
 
-static AM: bool = 2 > 1;
-static AN: bool = 2 > -2;
-static AO: bool = 1.0 > -2.0;
+static AM: bool = 2i > 1;
+static AN: bool = 2i > -2;
+static AO: bool = 1.0f64 > -2.0;
 
 pub fn main() {
     assert_eq!(A, -1);
diff --git a/src/test/run-pass/const-block.rs b/src/test/run-pass/const-block.rs
index feac6e68e48..01eccc53427 100644
--- a/src/test/run-pass/const-block.rs
+++ b/src/test/run-pass/const-block.rs
@@ -13,7 +13,7 @@
 
 struct Foo {
     a: uint,
-    b: *()
+    b: *const ()
 }
 
 fn foo<T>(a: T) -> T {
@@ -25,7 +25,7 @@ static BLOCK_EXPLICIT_UNIT: () = { () };
 static BLOCK_IMPLICIT_UNIT: () = { };
 static BLOCK_FLOAT: f64 = { 1.0 };
 static BLOCK_ENUM: Option<uint> = { Some(100) };
-static BLOCK_STRUCT: Foo = { Foo { a: 12, b: 0 as *() } };
+static BLOCK_STRUCT: Foo = { Foo { a: 12, b: 0 as *const () } };
 static BLOCK_UNSAFE: uint = unsafe { 1000 };
 
 // FIXME: #13970
@@ -50,7 +50,7 @@ pub fn main() {
     assert_eq!(BLOCK_IMPLICIT_UNIT, ());
     assert_eq!(BLOCK_FLOAT, 1.0_f64);
     assert_eq!(BLOCK_STRUCT.a, 12);
-    assert_eq!(BLOCK_STRUCT.b, 0 as *());
+    assert_eq!(BLOCK_STRUCT.b, 0 as *const ());
     assert_eq!(BLOCK_ENUM, Some(100));
     assert_eq!(BLOCK_UNSAFE, 1000);
 
diff --git a/src/test/run-pass/const-bound.rs b/src/test/run-pass/const-bound.rs
index 7ca4e25a74d..08912419b5c 100644
--- a/src/test/run-pass/const-bound.rs
+++ b/src/test/run-pass/const-bound.rs
@@ -23,5 +23,5 @@ pub fn main() {
     foo(F{field: 42});
     foo((1, 2u));
     foo(@1);*/
-    foo(box 1);
+    foo(box 1i);
 }
diff --git a/src/test/run-pass/const-cast-ptr-int.rs b/src/test/run-pass/const-cast-ptr-int.rs
index 88ab70f596a..e4734fc3e55 100644
--- a/src/test/run-pass/const-cast-ptr-int.rs
+++ b/src/test/run-pass/const-cast-ptr-int.rs
@@ -10,7 +10,7 @@
 
 use std::ptr;
 
-static a: *u8 = 0 as *u8;
+static a: *const u8 = 0 as *const u8;
 
 pub fn main() {
     assert_eq!(a, ptr::null());
diff --git a/src/test/run-pass/const-cast.rs b/src/test/run-pass/const-cast.rs
index 7b17b578b82..87a4fd1153f 100644
--- a/src/test/run-pass/const-cast.rs
+++ b/src/test/run-pass/const-cast.rs
@@ -13,11 +13,11 @@ extern crate libc;
 extern fn foo() {}
 
 static x: extern "C" fn() = foo;
-static y: *libc::c_void = x as *libc::c_void;
+static y: *const libc::c_void = x as *const libc::c_void;
 static a: &'static int = &10;
-static b: *int = a as *int;
+static b: *const int = a as *const int;
 
 pub fn main() {
-    assert_eq!(x as *libc::c_void, y);
-    assert_eq!(a as *int, b);
+    assert_eq!(x as *const libc::c_void, y);
+    assert_eq!(a as *const int, b);
 }
diff --git a/src/test/run-pass/const-region-ptrs-noncopy.rs b/src/test/run-pass/const-region-ptrs-noncopy.rs
index 87363c0e55e..36fe021b97e 100644
--- a/src/test/run-pass/const-region-ptrs-noncopy.rs
+++ b/src/test/run-pass/const-region-ptrs-noncopy.rs
@@ -14,5 +14,5 @@ static x: &'static Big = &([13, 14, 10, 13, 11, 14, 14, 15]);
 static y: &'static Pair<'static> = &Pair {a: 15, b: x};
 
 pub fn main() {
-    assert_eq!(x as *Big, y.b as *Big);
+    assert_eq!(x as *const Big, y.b as *const Big);
 }
diff --git a/src/test/run-pass/const-str-ptr.rs b/src/test/run-pass/const-str-ptr.rs
index 77c7a08f4ca..6790e237e26 100644
--- a/src/test/run-pass/const-str-ptr.rs
+++ b/src/test/run-pass/const-str-ptr.rs
@@ -12,18 +12,18 @@ use std::str;
 
 static A: [u8, ..2] = ['h' as u8, 'i' as u8];
 static B: &'static [u8, ..2] = &A;
-static C: *u8 = B as *u8;
+static C: *const u8 = B as *const u8;
 
 pub fn main() {
     unsafe {
-        let foo = &A as *u8;
+        let foo = &A as *const u8;
         assert_eq!(str::raw::from_utf8(A), "hi");
         assert_eq!(str::raw::from_buf_len(foo, A.len()), "hi".to_string());
         assert_eq!(str::raw::from_buf_len(C, B.len()), "hi".to_string());
         assert!(*C == A[0]);
-        assert!(*(&B[0] as *u8) == A[0]);
+        assert!(*(&B[0] as *const u8) == A[0]);
 
         let bar = str::raw::from_utf8(A).to_c_str();
-        assert_eq!(bar.with_ref(|buf| str::raw::from_c_str(buf)), "hi".to_string());
+        assert_eq!(str::raw::from_c_str(bar.as_ptr()), "hi".to_string());
     }
 }
diff --git a/src/test/run-pass/core-run-destroy.rs b/src/test/run-pass/core-run-destroy.rs
index a0d4785d8d2..8e84278c10e 100644
--- a/src/test/run-pass/core-run-destroy.rs
+++ b/src/test/run-pass/core-run-destroy.rs
@@ -54,7 +54,7 @@ macro_rules! iotest (
 )
 
 #[cfg(test)] #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, __test::main)
 }
 
diff --git a/src/test/run-pass/deriving-cmp-generic-enum.rs b/src/test/run-pass/deriving-cmp-generic-enum.rs
index 4a9324dd201..ccd0d967a51 100644
--- a/src/test/run-pass/deriving-cmp-generic-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-enum.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 #[deriving(PartialEq, Eq, PartialOrd, Ord)]
 enum E<T> {
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 b21c95d7b50..2abdf4c7c7e 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct-enum.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 #![feature(struct_variant)]
 
diff --git a/src/test/run-pass/deriving-cmp-generic-struct.rs b/src/test/run-pass/deriving-cmp-generic-struct.rs
index e2b8e1b6b82..d1610978e2e 100644
--- a/src/test/run-pass/deriving-cmp-generic-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-struct.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 #[deriving(PartialEq, Eq, PartialOrd, Ord)]
 struct S<T> {
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 c07f124a08d..25f62e85ba6 100644
--- a/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
+++ b/src/test/run-pass/deriving-cmp-generic-tuple-struct.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 #[deriving(PartialEq, Eq, PartialOrd, Ord)]
 struct TS<T>(T,T);
diff --git a/src/test/run-pass/deriving-cmp-shortcircuit.rs b/src/test/run-pass/deriving-cmp-shortcircuit.rs
index 69ee47fd1d9..df5c58ff04b 100644
--- a/src/test/run-pass/deriving-cmp-shortcircuit.rs
+++ b/src/test/run-pass/deriving-cmp-shortcircuit.rs
@@ -18,7 +18,7 @@ impl PartialEq for FailCmp {
 }
 
 impl PartialOrd for FailCmp {
-    fn lt(&self, _: &FailCmp) -> bool { fail!("lt") }
+    fn partial_cmp(&self, _: &FailCmp) -> Option<Ordering> { fail!("partial_cmp") }
 }
 
 impl Eq for FailCmp {}
diff --git a/src/test/run-pass/drop-trait-generic.rs b/src/test/run-pass/drop-trait-generic.rs
index 4ba3aa70dfc..9a93873f538 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: 1 };
+    let _x = S { x: 1i };
 }
diff --git a/src/test/run-pass/str-idx.rs b/src/test/run-pass/drop-with-type-ascription-1.rs
index 8ac13e81463..c4ea169cb79 100644
--- a/src/test/run-pass/str-idx.rs
+++ b/src/test/run-pass/drop-with-type-ascription-1.rs
@@ -8,11 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-extern crate debug;
-
-pub fn main() {
-    let s = "hello".to_string();
-    let c: u8 = s.as_slice()[4];
-    println!("{:?}", c);
-    assert_eq!(c, 0x6f as u8);
+fn main() {
+    let foo = "hello".to_string();
+    let foo: Vec<&str> = foo.as_slice().words().collect();
+    let invalid_string = foo.get(0);
+    assert_eq!(*invalid_string, "hello");
 }
+
diff --git a/src/test/run-pass/drop-with-type-ascription-2.rs b/src/test/run-pass/drop-with-type-ascription-2.rs
new file mode 100644
index 00000000000..634b1004e53
--- /dev/null
+++ b/src/test/run-pass/drop-with-type-ascription-2.rs
@@ -0,0 +1,17 @@
+// Copyright 2012 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+fn main() {
+    let args = vec!("foobie", "asdf::asdf");
+    let arr: Vec<&str> = args.get(1).as_slice().split_str("::").collect();
+    assert_eq!(*arr.get(0), "asdf");
+    assert_eq!(*arr.get(0), "asdf");
+}
+
diff --git a/src/test/run-pass/early-ret-binop-add.rs b/src/test/run-pass/early-ret-binop-add.rs
index 97e873e9aff..b9efdeb3bed 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 { 0 + { return n + 1 } }
+fn wsucc(n: int) -> int { 0i + { return n + 1 } }
 pub fn main() { }
diff --git a/src/test/run-pass/else-if.rs b/src/test/run-pass/else-if.rs
index 476d3f42d6e..63f32ae702b 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 1 == 2 {
+    if 1i == 2 {
         assert!((false));
-    } else if 2 == 3 {
+    } else if 2i == 3 {
         assert!((false));
-    } else if 3 == 4 { assert!((false)); } else { assert!((true)); }
-    if 1 == 2 { assert!((false)); } else if 2 == 2 { assert!((true)); }
-    if 1 == 2 {
+    } else if 3i == 4 { assert!((false)); } else { assert!((true)); }
+    if 1i == 2 { assert!((false)); } else if 2i == 2 { assert!((true)); }
+    if 1i == 2 {
         assert!((false));
-    } else if 2 == 2 {
-        if 1 == 1 {
+    } else if 2i == 2 {
+        if 1i == 1 {
             assert!((true));
-        } else { if 2 == 1 { assert!((false)); } else { assert!((false)); } }
+        } else { if 2i == 1 { assert!((false)); } else { assert!((false)); } }
     }
-    if 1 == 2 {
+    if 1i == 2 {
         assert!((false));
-    } else { if 1 == 2 { assert!((false)); } else { assert!((true)); } }
+    } else { if 1i == 2 { assert!((false)); } else { assert!((true)); } }
 }
diff --git a/src/test/run-pass/enum-alignment.rs b/src/test/run-pass/enum-alignment.rs
index 2a8293fcba8..a1ef12a7657 100644
--- a/src/test/run-pass/enum-alignment.rs
+++ b/src/test/run-pass/enum-alignment.rs
@@ -11,7 +11,7 @@
 use std::mem;
 
 fn addr_of<T>(ptr: &T) -> uint {
-    ptr as *T as uint
+    ptr as *const T as uint
 }
 
 fn is_aligned<T>(ptr: &T) -> bool {
diff --git a/src/test/run-pass/enum-discr.rs b/src/test/run-pass/enum-discr.rs
index 1d7ec0aa1bc..5fe8bb27e15 100644
--- a/src/test/run-pass/enum-discr.rs
+++ b/src/test/run-pass/enum-discr.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 enum Animal {
-    Cat = 0u,
-    Dog = 1u,
-    Horse = 2u,
-    Snake = 3u
+    Cat = 0,
+    Dog = 1,
+    Horse = 2,
+    Snake = 3,
 }
 
 enum Hero {
diff --git a/src/test/run-pass/enum-discrim-width-stuff.rs b/src/test/run-pass/enum-discrim-width-stuff.rs
index 814e2cca97c..ccbc5d12191 100644
--- a/src/test/run-pass/enum-discrim-width-stuff.rs
+++ b/src/test/run-pass/enum-discrim-width-stuff.rs
@@ -23,8 +23,8 @@ macro_rules! check {
             static C: E = V;
             pub fn check() {
                 assert_eq!(size_of::<E>(), size_of::<$t>());
-                assert_eq!(V as $t, $v);
-                assert_eq!(C as $t, $v);
+                assert_eq!(V as $t, $v as $t);
+                assert_eq!(C as $t, $v as $t);
                 assert_eq!(format!("{:?}", V), "V".to_string());
                 assert_eq!(format!("{:?}", C), "V".to_string());
             }
@@ -40,8 +40,6 @@ pub fn main() {
     check!(d, u16, 0xe8d8);
     check!(e, u32, 0x17273747);
     check!(f, u32, 0xe8d8c8b8);
-    check!(g, u64, 0x1727374757677787u64);
-    check!(h, u64, 0xe8d8c8b8a8988878u64);
 
     check!(z, i8, 0x17);
     check!(y, i8, -0x17);
@@ -49,8 +47,6 @@ pub fn main() {
     check!(w, i16, -0x1727);
     check!(v, i32, 0x17273747);
     check!(u, i32, -0x17273747);
-    check!(t, i64, 0x1727374757677787);
-    check!(s, i64, -0x1727374757677787);
 
     enum Simple { A, B }
     assert_eq!(::std::mem::size_of::<Simple>(), 1);
diff --git a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
index 4ddff8d899a..da35ffb5295 100644
--- a/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
+++ b/src/test/run-pass/enum-nullable-simplifycfg-misopt.rs
@@ -20,8 +20,8 @@ use std::gc::{Gc, GC};
 
 enum List<X> { Nil, Cons(X, Gc<List<X>>) }
 pub fn main() {
-    match Cons(10, box(GC) Nil) {
-        Cons(10, _) => {}
+    match Cons(10i, box(GC) Nil) {
+        Cons(10i, _) => {}
         Nil => {}
         _ => fail!()
     }
diff --git a/src/test/run-pass/enum-vec-initializer.rs b/src/test/run-pass/enum-vec-initializer.rs
index a55b5eebefb..b04f5e11042 100644
--- a/src/test/run-pass/enum-vec-initializer.rs
+++ b/src/test/run-pass/enum-vec-initializer.rs
@@ -16,9 +16,9 @@ static BAR:uint = Bunny as uint;
 static BAR2:uint = BAR;
 
 pub fn main() {
-    let _v = [0, .. Bunny as uint];
-    let _v = [0, .. BAR];
-    let _v = [0, .. BAR2];
+    let _v = [0i, .. Bunny as uint];
+    let _v = [0i, .. BAR];
+    let _v = [0i, .. BAR2];
     static BAR3:uint = BAR2;
-    let _v = [0, .. BAR3];
+    let _v = [0i, .. BAR3];
 }
diff --git a/src/test/run-pass/estr-slice.rs b/src/test/run-pass/estr-slice.rs
index 3d6b6ba626d..5364cdc627f 100644
--- a/src/test/run-pass/estr-slice.rs
+++ b/src/test/run-pass/estr-slice.rs
@@ -17,8 +17,8 @@ pub fn main() {
     println!("{}", x);
     println!("{}", y);
 
-    assert_eq!(x[0], 'h' as u8);
-    assert_eq!(x[4], 'o' as u8);
+    assert_eq!(x.as_bytes()[0], 'h' as u8);
+    assert_eq!(x.as_bytes()[4], 'o' as u8);
 
     let z : &str = "thing";
     assert_eq!(v, x);
diff --git a/src/test/run-pass/estr-uniq.rs b/src/test/run-pass/estr-uniq.rs
index 1652016b51b..b562558822c 100644
--- a/src/test/run-pass/estr-uniq.rs
+++ b/src/test/run-pass/estr-uniq.rs
@@ -15,6 +15,6 @@ pub fn main() {
     let _y : String = "there".to_string();
     let mut z = "thing".to_string();
     z = x;
-    assert_eq!(z.as_slice()[0], ('h' as u8));
-    assert_eq!(z.as_slice()[4], ('o' as u8));
+    assert_eq!(z.as_bytes()[0], ('h' as u8));
+    assert_eq!(z.as_bytes()[4], ('o' as u8));
 }
diff --git a/src/test/run-pass/expr-block-box.rs b/src/test/run-pass/expr-block-box.rs
index b9d005d945f..5652cdea879 100644
--- a/src/test/run-pass/expr-block-box.rs
+++ b/src/test/run-pass/expr-block-box.rs
@@ -12,4 +12,4 @@
 
 use std::gc::GC;
 
-pub fn main() { let x = { box(GC) 100 }; assert!((*x == 100)); }
+pub fn main() { let x = { box(GC) 100i }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-block-ref.rs b/src/test/run-pass/expr-block-ref.rs
index df7ea0c943b..050ecebb2a1 100644
--- a/src/test/run-pass/expr-block-ref.rs
+++ b/src/test/run-pass/expr-block-ref.rs
@@ -13,4 +13,4 @@
 use std::gc::GC;
 
 // Regression test for issue #388
-pub fn main() { let _x = { { box(GC) 10 } }; }
+pub fn main() { let _x = { { box(GC) 10i } }; }
diff --git a/src/test/run-pass/expr-block-unique.rs b/src/test/run-pass/expr-block-unique.rs
index 12777bce710..0dff989002f 100644
--- a/src/test/run-pass/expr-block-unique.rs
+++ b/src/test/run-pass/expr-block-unique.rs
@@ -11,4 +11,4 @@
 
 
 
-pub fn main() { let x = { box 100 }; assert!((*x == 100)); }
+pub fn main() { let x = { box 100i }; assert!((*x == 100)); }
diff --git a/src/test/run-pass/expr-empty-ret.rs b/src/test/run-pass/expr-empty-ret.rs
index afc7dfaf9b4..7b08251967e 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 => { 10 }
+        true => { 10i }
         false => { return }
     };
 }
diff --git a/src/test/run-pass/expr-if-fail-all.rs b/src/test/run-pass/expr-if-fail-all.rs
index a34620d2e1b..8e56011e6dc 100644
--- a/src/test/run-pass/expr-if-fail-all.rs
+++ b/src/test/run-pass/expr-if-fail-all.rs
@@ -12,7 +12,7 @@
 // expression results in fail.
 pub fn main() {
     let _x = if true {
-        10
+        10i
     } else {
         if true { fail!() } else { fail!() }
     };
diff --git a/src/test/run-pass/expr-if-fail.rs b/src/test/run-pass/expr-if-fail.rs
index 023ba508ae5..e9f116fcdd4 100644
--- a/src/test/run-pass/expr-if-fail.rs
+++ b/src/test/run-pass/expr-if-fail.rs
@@ -8,7 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn test_if_fail() { let x = if false { fail!() } else { 10 }; assert!((x == 10)); }
+fn test_if_fail() {
+    let x = if false { fail!() } else { 10i };
+    assert!((x == 10));
+}
 
 fn test_else_fail() {
     let x = if true { 10i } else { fail!() };
@@ -16,7 +19,7 @@ fn test_else_fail() {
 }
 
 fn test_elseif_fail() {
-    let x = if false { 0 } else if false { fail!() } else { 10i };
+    let x = if false { 0i } else if false { fail!() } else { 10i };
     assert_eq!(x, 10i);
 }
 
diff --git a/src/test/run-pass/expr-match-fail-all.rs b/src/test/run-pass/expr-match-fail-all.rs
index 5c83e81d8be..0d23098d8fc 100644
--- a/src/test/run-pass/expr-match-fail-all.rs
+++ b/src/test/run-pass/expr-match-fail-all.rs
@@ -16,7 +16,7 @@
 pub fn main() {
     let _x =
         match true {
-          true => { 10 }
+          true => { 10i }
           false => { match true { true => { fail!() } false => { fail!() } } }
         };
 }
diff --git a/src/test/run-pass/extern-pub.rs b/src/test/run-pass/extern-pub.rs
index 28025728472..cefc266b5c7 100644
--- a/src/test/run-pass/extern-pub.rs
+++ b/src/test/run-pass/extern-pub.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 extern {
-    pub fn free(p: *u8);
+    pub fn free(p: *const u8);
 }
 
 pub fn main() {
diff --git a/src/test/run-pass/floatlits.rs b/src/test/run-pass/floatlits.rs
index d1300e7f30c..09df423d2da 100644
--- a/src/test/run-pass/floatlits.rs
+++ b/src/test/run-pass/floatlits.rs
@@ -11,10 +11,10 @@
 
 
 pub fn main() {
-    let f = 4.999999999999;
-    assert!((f > 4.90));
-    assert!((f < 5.0));
-    let g = 4.90000000001e-10;
-    assert!((g > 5e-11));
-    assert!((g < 5e-9));
+    let f = 4.999999999999f64;
+    assert!((f > 4.90f64));
+    assert!((f < 5.0f64));
+    let g = 4.90000000001e-10f64;
+    assert!((g > 5e-11f64));
+    assert!((g < 5e-9f64));
 }
diff --git a/src/test/run-pass/fn-type-infer.rs b/src/test/run-pass/fn-type-infer.rs
index 34417891197..80d3527736f 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 = 10;
+        let i = 10i;
     };
 }
diff --git a/src/test/run-pass/foreach-external-iterators-break.rs b/src/test/run-pass/foreach-external-iterators-break.rs
index 87ed7826fed..d9d3e320260 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 = [1,..100];
-    let mut y = 0;
+    let x = [1i,..100];
+    let mut y = 0i;
     for i in x.iter() {
         if y > 10 {
             break;
diff --git a/src/test/run-pass/foreach-external-iterators-nested.rs b/src/test/run-pass/foreach-external-iterators-nested.rs
index 78aba778421..f4d38dfcfc3 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 = [1,..100];
-    let y = [2,..100];
-    let mut p = 0;
-    let mut q = 0;
+    let x = [1i,..100];
+    let y = [2i,..100];
+    let mut p = 0i;
+    let mut q = 0i;
     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 593a996d8df..684a9b81fb2 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 = [1,..100];
-    let mut y = 0;
+    let x = [1i,..100];
+    let mut y = 0i;
     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 bd4c89eb8ab..9dd52dfb6da 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::start(proc() {
-            let i = &100;
+            let i = &100i;
             rust_dbg_call(callback, mem::transmute(i));
         }).join();
     }
@@ -30,7 +30,7 @@ pub fn main() {
 
 extern fn callback(data: libc::uintptr_t) {
     unsafe {
-        let data: *int = mem::transmute(data);
-        assert_eq!(*data, 100);
+        let data: *const int = mem::transmute(data);
+        assert_eq!(*data, 100i);
     }
 }
diff --git a/src/test/run-pass/foreign-fn-linkname.rs b/src/test/run-pass/foreign-fn-linkname.rs
index 890f5158a65..750c0c8ed68 100644
--- a/src/test/run-pass/foreign-fn-linkname.rs
+++ b/src/test/run-pass/foreign-fn-linkname.rs
@@ -18,7 +18,7 @@ mod mlibc {
 
     extern {
         #[link_name = "strlen"]
-        pub fn my_strlen(str: *c_char) -> size_t;
+        pub fn my_strlen(str: *const c_char) -> size_t;
     }
 }
 
diff --git a/src/test/run-pass/foreign2.rs b/src/test/run-pass/foreign2.rs
index 3c7e878c318..ce2f8955664 100644
--- a/src/test/run-pass/foreign2.rs
+++ b/src/test/run-pass/foreign2.rs
@@ -24,7 +24,7 @@ mod mlibc {
     use libc::{c_int, c_void, size_t, ssize_t};
 
     extern {
-        pub fn write(fd: c_int, buf: *c_void, count: size_t) -> ssize_t;
+        pub fn write(fd: c_int, buf: *const c_void, count: size_t) -> ssize_t;
     }
 }
 
diff --git a/src/test/run-pass/func-arg-incomplete-pattern.rs b/src/test/run-pass/func-arg-incomplete-pattern.rs
index 5ab3930e7a3..6d06c12c450 100644
--- a/src/test/run-pass/func-arg-incomplete-pattern.rs
+++ b/src/test/run-pass/func-arg-incomplete-pattern.rs
@@ -17,14 +17,14 @@ struct Foo {
     y: Box<uint>,
 }
 
-fn foo(Foo {x, ..}: Foo) -> *uint {
-    let addr: *uint = &*x;
+fn foo(Foo {x, ..}: Foo) -> *const uint {
+    let addr: *const uint = &*x;
     addr
 }
 
 pub fn main() {
     let obj = box 1;
-    let objptr: *uint = &*obj;
+    let objptr: *const uint = &*obj;
     let f = Foo {x: obj, y: box 2};
     let xptr = foo(f);
     assert_eq!(objptr, xptr);
diff --git a/src/test/run-pass/func-arg-ref-pattern.rs b/src/test/run-pass/func-arg-ref-pattern.rs
index bb4be948a5e..5eeace65054 100644
--- a/src/test/run-pass/func-arg-ref-pattern.rs
+++ b/src/test/run-pass/func-arg-ref-pattern.rs
@@ -15,8 +15,8 @@
 // pattern.
 
 
-fn getaddr(box ref x: Box<uint>) -> *uint {
-    let addr: *uint = &*x;
+fn getaddr(box ref x: Box<uint>) -> *const uint {
+    let addr: *const uint = &*x;
     addr
 }
 
@@ -26,7 +26,7 @@ fn checkval(box ref x: Box<uint>) -> uint {
 
 pub fn main() {
     let obj = box 1;
-    let objptr: *uint = &*obj;
+    let objptr: *const uint = &*obj;
     let xptr = getaddr(obj);
     assert_eq!(objptr, xptr);
 
diff --git a/src/test/run-pass/generic-ivec-leak.rs b/src/test/run-pass/generic-ivec-leak.rs
index f879e195292..ac97a2aa9e8 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 = wrapped(vec!(1, 2, 3, 4, 5)); }
+pub fn main() { let _w = wrapped(vec!(1i, 2, 3, 4, 5)); }
diff --git a/src/test/run-pass/generic-ivec.rs b/src/test/run-pass/generic-ivec.rs
index 18d1b7f03a1..4402dd35d09 100644
--- a/src/test/run-pass/generic-ivec.rs
+++ b/src/test/run-pass/generic-ivec.rs
@@ -13,4 +13,4 @@
 use std::gc::{Gc, GC};
 
 fn f<T>(_v: Gc<T>) { }
-pub fn main() { f(box(GC) vec!(1, 2, 3, 4, 5)); }
+pub fn main() { f(box(GC) vec!(1i, 2, 3, 4, 5)); }
diff --git a/src/test/run-pass/generic-tag-local.rs b/src/test/run-pass/generic-tag-local.rs
index fb8140790e3..7d011e57671 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 = a(3); }
+pub fn main() { let _c = a(3i); }
diff --git a/src/test/run-pass/guards.rs b/src/test/run-pass/guards.rs
index 450620767e3..5bfbe4bf5a0 100644
--- a/src/test/run-pass/guards.rs
+++ b/src/test/run-pass/guards.rs
@@ -12,14 +12,14 @@ struct Pair { x: int, y: int }
 
 pub fn main() {
     let a: int =
-        match 10 { x if x < 7 => { 1 } x if x < 11 => { 2 } 10 => { 3 } _ => { 4 } };
+        match 10i { x if x < 7 => { 1i } x if x < 11 => { 2i } 10 => { 3i } _ => { 4i } };
     assert_eq!(a, 2);
 
     let b: int =
         match (Pair {x: 10, y: 20}) {
-          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 }
+          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 }
         };
     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 3969394a26b..eb81f82a146 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 = 9;
+    let x = 9i;
     // use it to avoid warnings:
     x+3;
     assert_eq!(x::g(),14);
diff --git a/src/test/run-pass/ifmt.rs b/src/test/run-pass/ifmt.rs
index 4b678d78834..e349f91a309 100644
--- a/src/test/run-pass/ifmt.rs
+++ b/src/test/run-pass/ifmt.rs
@@ -69,7 +69,7 @@ pub fn main() {
     t!(format!("{:X}", 10u), "A");
     t!(format!("{:s}", "foo"), "foo");
     t!(format!("{:s}", "foo".to_string()), "foo");
-    t!(format!("{:p}", 0x1234 as *int), "0x1234");
+    t!(format!("{:p}", 0x1234 as *const int), "0x1234");
     t!(format!("{:p}", 0x1234 as *mut int), "0x1234");
     t!(format!("{:d}", A), "aloha");
     t!(format!("{:d}", B), "adios");
@@ -81,6 +81,9 @@ pub fn main() {
     t!(format!("{foo_bar}", foo_bar=1i), "1");
     t!(format!("{:d}", 5i + 5i), "10");
 
+    let a: &fmt::Show = &1i;
+    t!(format!("{}", a), "1");
+
     // Formatting strings and their arguments
     t!(format!("{:s}", "a"), "a");
     t!(format!("{:4s}", "a"), "a   ");
diff --git a/src/test/run-pass/ignore-all-the-things.rs b/src/test/run-pass/ignore-all-the-things.rs
index b176254a878..27c63d425bf 100644
--- a/src/test/run-pass/ignore-all-the-things.rs
+++ b/src/test/run-pass/ignore-all-the-things.rs
@@ -21,28 +21,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 [5, 5, 5, 5] {
+    match [5i, 5, 5, 5] {
         [..] => { }
     }
-    match [5, 5, 5, 5] {
+    match [5i, 5, 5, 5] {
         [a, ..] => { }
     }
-    match [5, 5, 5, 5] {
+    match [5i, 5, 5, 5] {
         [.., b] => { }
     }
-    match [5, 5, 5, 5] {
+    match [5i, 5, 5, 5] {
         [a, .., b] => { }
     }
-    match [5, 5, 5] {
+    match [5i, 5, 5] {
         [..] => { }
     }
-    match [5, 5, 5] {
+    match [5i, 5, 5] {
         [a, ..] => { }
     }
-    match [5, 5, 5] {
+    match [5i, 5, 5] {
         [.., a] => { }
     }
-    match [5, 5, 5] {
+    match [5i, 5, 5] {
         [a, .., b] => { }
     }
 }
diff --git a/src/test/run-pass/import-in-block.rs b/src/test/run-pass/import-in-block.rs
index 24196c22571..19300569d20 100644
--- a/src/test/run-pass/import-in-block.rs
+++ b/src/test/run-pass/import-in-block.rs
@@ -12,11 +12,11 @@
 
 pub fn main() {
     use std::mem::replace;
-    let mut x = 5;
+    let mut x = 5i;
     replace(&mut x, 6);
     {
         use std::mem::*;
-        let mut y = 6;
+        let mut y = 6i;
         swap(&mut x, &mut y);
     }
 }
diff --git a/src/test/run-pass/import4.rs b/src/test/run-pass/import4.rs
index 44f6b6140fb..0639d732089 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 = 42; bar(); }
+pub fn main() { let _zed = 42i; 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 b2b16c4ef84..a7b2a46f0c3 100644
--- a/src/test/run-pass/inferred-suffix-in-pattern-range.rs
+++ b/src/test/run-pass/inferred-suffix-in-pattern-range.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let x = 2;
+    let x = 2i;
     let x_message = match x {
       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 5e0aeeb6bed..5d4f6458cf9 100644
--- a/src/test/run-pass/init-res-into-things.rs
+++ b/src/test/run-pass/init-res-into-things.rs
@@ -36,7 +36,7 @@ fn r(i: Gc<Cell<int>>) -> r {
 }
 
 fn test_box() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
         let _a = box(GC) r(i);
     }
@@ -44,7 +44,7 @@ fn test_box() {
 }
 
 fn test_rec() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
         let _a = Box {x: r(i)};
     }
@@ -56,7 +56,7 @@ fn test_tag() {
         t0(r),
     }
 
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
         let _a = t0(r(i));
     }
@@ -64,15 +64,15 @@ fn test_tag() {
 }
 
 fn test_tup() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
-        let _a = (r(i), 0);
+        let _a = (r(i), 0i);
     }
     assert_eq!(i.get(), 1);
 }
 
 fn test_unique() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
         let _a = box r(i);
     }
@@ -80,7 +80,7 @@ fn test_unique() {
 }
 
 fn test_box_rec() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     {
         let _a = box(GC) Box {
             x: r(i)
diff --git a/src/test/run-pass/instantiable.rs b/src/test/run-pass/instantiable.rs
index 41ddce7a96e..35897d5b823 100644
--- a/src/test/run-pass/instantiable.rs
+++ b/src/test/run-pass/instantiable.rs
@@ -14,7 +14,7 @@ use std::ptr;
 // even though it would be if the nxt field had type @foo:
 struct foo(X);
 
-struct X { x: uint, nxt: *foo }
+struct X { x: uint, nxt: *const foo }
 
 pub fn main() {
     let _x = foo(X {x: 0, nxt: ptr::null()});
diff --git a/src/test/run-pass/intrinsic-atomics.rs b/src/test/run-pass/intrinsic-atomics.rs
index f28ba7b8bc0..3b81943000b 100644
--- a/src/test/run-pass/intrinsic-atomics.rs
+++ b/src/test/run-pass/intrinsic-atomics.rs
@@ -16,8 +16,8 @@ mod rusti {
         pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> T;
         pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> T;
 
-        pub fn atomic_load<T>(src: *T) -> T;
-        pub fn atomic_load_acq<T>(src: *T) -> T;
+        pub fn atomic_load<T>(src: *const T) -> T;
+        pub fn atomic_load_acq<T>(src: *const T) -> T;
 
         pub fn atomic_store<T>(dst: *mut T, val: T);
         pub fn atomic_store_rel<T>(dst: *mut T, val: T);
diff --git a/src/test/run-pass/intrinsic-move-val.rs b/src/test/run-pass/intrinsic-move-val.rs
index 4375c63a1b8..f1bbf353f71 100644
--- a/src/test/run-pass/intrinsic-move-val.rs
+++ b/src/test/run-pass/intrinsic-move-val.rs
@@ -23,7 +23,7 @@ pub fn main() {
     unsafe {
         let x = box 1i;
         let mut y = rusti::init();
-        let mut z: *uint = transmute(&x);
+        let mut z: *const uint = transmute(&x);
         rusti::move_val_init(&mut y, x);
         assert_eq!(*y, 1);
         assert_eq!(*z, 0); // `x` is nulled out, not directly visible
diff --git a/src/test/run-pass/issue-10638.rs b/src/test/run-pass/issue-10638.rs
index bc77b4c5343..a4ef77df311 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! */
-    5;
+    5i;
     /*****! certainly not I */
 }
diff --git a/src/test/run-pass/issue-11205.rs b/src/test/run-pass/issue-11205.rs
new file mode 100644
index 00000000000..5b52bc34d2b
--- /dev/null
+++ b/src/test/run-pass/issue-11205.rs
@@ -0,0 +1,92 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![allow(dead_code)]
+
+trait Foo {}
+impl Foo for int {}
+fn foo(_: [&Foo, ..2]) {}
+fn foos(_: &[&Foo]) {}
+fn foog<T>(_: &[T], _: &[T]) {}
+
+fn bar(_: [Box<Foo>, ..2]) {}
+fn bars(_: &[Box<Foo>]) {}
+
+fn main() {
+    let x: [&Foo, ..2] = [&1i, &2i];
+    foo(x);
+    foo([&1i, &2i]);
+
+    let r = &1i;
+    let x: [&Foo, ..2] = [r, ..2];
+    foo(x);
+    foo([&1i, ..2]);
+
+    let x: &[&Foo] = &[&1i, &2i];
+    foos(x);
+    foos(&[&1i, &2i]);
+
+    let x: &[&Foo] = &[&1i, &2i];
+    let r = &1i;
+    foog(x, &[r]);
+
+    let x: [Box<Foo>, ..2] = [box 1i, box 2i];
+    bar(x);
+    bar([box 1i, box 2i]);
+
+    let x: &[Box<Foo>] = &[box 1i, box 2i];
+    bars(x);
+    bars(&[box 1i, box 2i]);
+
+    let x: &[Box<Foo>] = &[box 1i, box 2i];
+    foog(x, &[box 1i]);
+
+    struct T<'a> {
+        t: [&'a Foo, ..2]
+    }
+    let _n = T {
+        t: [&1i, &2i]
+    };
+    let r = &1i;
+    let _n = T {
+        t: [r, ..2]
+    };
+    let x: [&Foo, ..2] = [&1i, &2i];
+    let _n = T {
+        t: x
+    };
+
+    struct F<'b> {
+        t: &'b [&'b Foo]
+    }
+    let _n = F {
+        t: &[&1i, &2i]
+    };
+    let r = &1i;
+    let r: [&Foo, ..2] = [r, ..2];
+    let _n = F {
+        t: r
+    };
+    let x: [&Foo, ..2] = [&1i, &2i];
+    let _n = F {
+        t: x
+    };
+
+    struct M<'a> {
+        t: &'a [Box<Foo>]
+    }
+    let _n = M {
+        t: &[box 1i, box 2i]
+    };
+    let x: [Box<Foo>, ..2] = [box 1i, box 2i];
+    let _n = M {
+        t: x
+    };
+}
diff --git a/src/test/run-pass/issue-1257.rs b/src/test/run-pass/issue-1257.rs
index 7d5bd9d6a74..ad3a050dde9 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 = 0;
+  let mut i = 0i;
   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-12684.rs b/src/test/run-pass/issue-12684.rs
index 009a0783b58..37e675b52eb 100644
--- a/src/test/run-pass/issue-12684.rs
+++ b/src/test/run-pass/issue-12684.rs
@@ -14,7 +14,7 @@ extern crate green;
 extern crate rustuv;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, main)
 }
 
diff --git a/src/test/run-pass/issue-12699.rs b/src/test/run-pass/issue-12699.rs
index 02790dab7b9..c24128f97e3 100644
--- a/src/test/run-pass/issue-12699.rs
+++ b/src/test/run-pass/issue-12699.rs
@@ -14,7 +14,7 @@ extern crate native;
 use std::io::timer;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     native::start(argc, argv, main)
 }
 
diff --git a/src/test/run-pass/issue-13027.rs b/src/test/run-pass/issue-13027.rs
index 8acaa889a04..e1634e44847 100644
--- a/src/test/run-pass/issue-13027.rs
+++ b/src/test/run-pass/issue-13027.rs
@@ -27,80 +27,80 @@ pub fn main() {
 }
 
 fn lit_shadow_range() {
-    assert_eq!(2i, match 1 {
-        1 if false => 1,
+    assert_eq!(2i, match 1i {
+        1 if false => 1i,
         1..2 => 2,
         _ => 3
     });
 
     let x = 0i;
     assert_eq!(2i, match x+1 {
-        0 => 0,
+        0 => 0i,
         1 if false => 1,
         1..2 => 2,
         _ => 3
     });
 
     assert_eq!(2i, match val() {
-        1 if false => 1,
+        1 if false => 1i,
         1..2 => 2,
         _ => 3
     });
 
     assert_eq!(2i, match CONST {
-        0 => 0,
+        0 => 0i,
         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 3 {
-        1 if false => 1,
+    assert_eq!(3i, match 3i {
+        1 if false => 1i,
         1..2 => 2,
         _ => 3
     });
 }
 
 fn range_shadow_lit() {
-    assert_eq!(2i, match 1 {
-        1..2 if false => 1,
+    assert_eq!(2i, match 1i {
+        1..2 if false => 1i,
         1 => 2,
         _ => 3
     });
 
     let x = 0i;
     assert_eq!(2i, match x+1 {
-        0 => 0,
+        0 => 0i,
         1..2 if false => 1,
         1 => 2,
         _ => 3
     });
 
     assert_eq!(2i, match val() {
-        1..2 if false => 1,
+        1..2 if false => 1i,
         1 => 2,
         _ => 3
     });
 
     assert_eq!(2i, match CONST {
-        0 => 0,
+        0 => 0i,
         1..2 if false => 1,
         1 => 2,
         _ => 3
     });
 
     // ditto
-    assert_eq!(3i, match 3 {
-        1..2 if false => 1,
+    assert_eq!(3i, match 3i {
+        1..2 if false => 1i,
         1 => 2,
         _ => 3
     });
 }
 
 fn range_shadow_range() {
-    assert_eq!(2i, match 1 {
-        0..2 if false => 1,
+    assert_eq!(2i, match 1i {
+        0..2 if false => 1i,
         1..3 => 2,
         _ => 3,
     });
@@ -127,16 +127,16 @@ fn range_shadow_range() {
     });
 
     // ditto
-    assert_eq!(3i, match 5 {
-        0..2 if false => 1,
+    assert_eq!(3i, match 5i {
+        0..2 if false => 1i,
         1..3 => 2,
         _ => 3,
     });
 }
 
 fn multi_pats_shadow_lit() {
-    assert_eq!(2i, match 1 {
-        100 => 0,
+    assert_eq!(2i, match 1i {
+        100 => 0i,
         0 | 1..10 if false => 1,
         1 => 2,
         _ => 3,
@@ -144,8 +144,8 @@ fn multi_pats_shadow_lit() {
 }
 
 fn multi_pats_shadow_range() {
-    assert_eq!(2i, match 1 {
-        100 => 0,
+    assert_eq!(2i, match 1i {
+        100 => 0i,
         0 | 1..10 if false => 1,
         1..3 => 2,
         _ => 3,
@@ -153,8 +153,8 @@ fn multi_pats_shadow_range() {
 }
 
 fn lit_shadow_multi_pats() {
-    assert_eq!(2i, match 1 {
-        100 => 0,
+    assert_eq!(2i, match 1i {
+        100 => 0i,
         1 if false => 1,
         0 | 1..10 => 2,
         _ => 3,
@@ -162,8 +162,8 @@ fn lit_shadow_multi_pats() {
 }
 
 fn range_shadow_multi_pats() {
-    assert_eq!(2i, match 1 {
-        100 => 0,
+    assert_eq!(2i, match 1i {
+        100 => 0i,
         1..3 if false => 1,
         0 | 1..10 => 2,
         _ => 3,
@@ -182,5 +182,5 @@ fn misc() {
         [Bar(_, pred)] if !pred => 2i,
         _ => 0i,
     };
-    assert_eq!(2, r);
+    assert_eq!(2i, r);
 }
diff --git a/src/test/run-pass/issue-13304.rs b/src/test/run-pass/issue-13304.rs
index 37df74031ac..6ca605742ef 100644
--- a/src/test/run-pass/issue-13304.rs
+++ b/src/test/run-pass/issue-13304.rs
@@ -19,7 +19,7 @@ use std::io;
 use std::str;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, main)
 }
 
diff --git a/src/test/run-pass/issue-13494.rs b/src/test/run-pass/issue-13494.rs
index a4f88d7c04c..d8f8b979ad0 100644
--- a/src/test/run-pass/issue-13494.rs
+++ b/src/test/run-pass/issue-13494.rs
@@ -16,7 +16,7 @@ extern crate rustuv;
 extern crate native;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, main)
 }
 
@@ -29,9 +29,9 @@ fn helper(rx: Receiver<Sender<()>>) {
 fn test() {
     let (tx, rx) = channel();
     spawn(proc() { helper(rx) });
-    let (snd, rcv) = channel();
+    let (snd, rcv) = channel::<int>();
     for _ in range(1i, 100000i) {
-        snd.send(1);
+        snd.send(1i);
         let (tx2, rx2) = channel();
         tx.send(tx2);
         select! {
diff --git a/src/test/run-pass/issue-14254.rs b/src/test/run-pass/issue-14254.rs
index a3ead0a6685..160828d42fc 100644
--- a/src/test/run-pass/issue-14254.rs
+++ b/src/test/run-pass/issue-14254.rs
@@ -25,11 +25,11 @@ impl BarTy {
 }
 
 // If these fail, it's necessary to update middle::resolve and the cfail tests.
-impl Foo for *BarTy {
+impl Foo for *const BarTy {
     fn bar(&self) {
         self.baz();
         BarTy::a();
-        Foo::bah(None::<*BarTy>);
+        Foo::bah(None::<*const BarTy>);
     }
 }
 
@@ -66,10 +66,10 @@ impl Foo for Box<BarTy> {
 }
 
 // If these fail, it's necessary to update middle::resolve and the cfail tests.
-impl Foo for *int {
+impl Foo for *const int {
     fn bar(&self) {
         self.baz();
-        Foo::bah(None::<*int>);
+        Foo::bah(None::<*const int>);
     }
 }
 
diff --git a/src/test/run-pass/issue-1460.rs b/src/test/run-pass/issue-1460.rs
index 44465fe5f80..8176262abd9 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 1 == i { }};
+    {|i| if 1i == i { }};
 }
diff --git a/src/test/run-pass/issue-15221.rs b/src/test/run-pass/issue-15221.rs
new file mode 100644
index 00000000000..378fd4a222e
--- /dev/null
+++ b/src/test/run-pass/issue-15221.rs
@@ -0,0 +1,23 @@
+// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// file at the top-level directory of this distribution and at
+// http://rust-lang.org/COPYRIGHT.
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#![feature(macro_rules)]
+
+macro_rules! inner (
+    ($e:pat ) => ($e))
+
+macro_rules! outer (
+    ($e:pat ) => (inner!($e)))
+
+fn main() {
+    let outer!(g1) = 13i;
+    g1;
+}
+
diff --git a/src/test/run-pass/issue-1866.rs b/src/test/run-pass/issue-1866.rs
index 037c7b80cc8..10ae2749a09 100644
--- a/src/test/run-pass/issue-1866.rs
+++ b/src/test/run-pass/issue-1866.rs
@@ -13,7 +13,7 @@ mod a {
     pub mod rustrt {
         use super::rust_task;
         extern {
-            pub fn rust_task_is_unwinding(rt: *rust_task) -> bool;
+            pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool;
         }
     }
 }
@@ -23,7 +23,7 @@ mod b {
     pub mod rustrt {
         use super::rust_task;
         extern {
-            pub fn rust_task_is_unwinding(rt: *rust_task) -> bool;
+            pub fn rust_task_is_unwinding(rt: *const rust_task) -> bool;
         }
     }
 }
diff --git a/src/test/run-pass/issue-2216.rs b/src/test/run-pass/issue-2216.rs
index 7276b11b181..d9d4120d4f4 100644
--- a/src/test/run-pass/issue-2216.rs
+++ b/src/test/run-pass/issue-2216.rs
@@ -16,7 +16,7 @@ pub fn main() {
     'foo: loop {
         'bar: loop {
             'quux: loop {
-                if 1 == 2 {
+                if 1i == 2 {
                     break 'foo;
                 }
                 else {
diff --git a/src/test/run-pass/issue-2383.rs b/src/test/run-pass/issue-2383.rs
index 5cdda4e5548..41cf3eaf7e3 100644
--- a/src/test/run-pass/issue-2383.rs
+++ b/src/test/run-pass/issue-2383.rs
@@ -15,5 +15,5 @@ use std::collections::Deque;
 
 pub fn main() {
     let mut q = RingBuf::new();
-    q.push_back(10);
+    q.push_back(10i);
 }
diff --git a/src/test/run-pass/issue-2428.rs b/src/test/run-pass/issue-2428.rs
index 4e73be8d84e..8c8b9d5df13 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 = 100;
+    let _foo = 100i;
     static quux: int = 5;
 
     enum Stuff {
diff --git a/src/test/run-pass/issue-2718.rs b/src/test/run-pass/issue-2718.rs
index 5eb9453134d..b4807964d46 100644
--- a/src/test/run-pass/issue-2718.rs
+++ b/src/test/run-pass/issue-2718.rs
@@ -42,9 +42,9 @@ pub mod pipes {
         payload: Option<T>
     }
 
-    pub fn packet<T:Send>() -> *packet<T> {
+    pub fn packet<T:Send>() -> *const packet<T> {
         unsafe {
-            let p: *packet<T> = mem::transmute(box Stuff{
+            let p: *const packet<T> = mem::transmute(box Stuff{
                 state: empty,
                 blocked_task: None::<Task>,
                 payload: None::<T>
@@ -61,7 +61,7 @@ pub mod pipes {
 
     // We should consider moving this to ::std::unsafe, although I
     // suspect graydon would want us to use void pointers instead.
-    pub unsafe fn uniquify<T>(x: *T) -> Box<T> {
+    pub unsafe fn uniquify<T>(x: *const T) -> Box<T> {
         mem::transmute(x)
     }
 
@@ -123,7 +123,7 @@ pub mod pipes {
         }
     }
 
-    pub fn sender_terminate<T:Send>(p: *packet<T>) {
+    pub fn sender_terminate<T:Send>(p: *const packet<T>) {
         let mut p = unsafe { uniquify(p) };
         match swap_state_rel(&mut (*p).state, terminated) {
           empty | blocked => {
@@ -140,7 +140,7 @@ pub mod pipes {
         }
     }
 
-    pub fn receiver_terminate<T:Send>(p: *packet<T>) {
+    pub fn receiver_terminate<T:Send>(p: *const packet<T>) {
         let mut p = unsafe { uniquify(p) };
         match swap_state_rel(&mut (*p).state, terminated) {
           empty => {
@@ -158,7 +158,7 @@ pub mod pipes {
     }
 
     pub struct send_packet<T> {
-        p: Option<*packet<T>>,
+        p: Option<*const packet<T>>,
     }
 
     #[unsafe_destructor]
@@ -166,7 +166,7 @@ pub mod pipes {
         fn drop(&mut self) {
             unsafe {
                 if self.p != None {
-                    let self_p: &mut Option<*packet<T>> =
+                    let self_p: &mut Option<*const packet<T>> =
                         mem::transmute(&self.p);
                     let p = replace(self_p, None);
                     sender_terminate(p.unwrap())
@@ -176,19 +176,19 @@ pub mod pipes {
     }
 
     impl<T:Send> send_packet<T> {
-        pub fn unwrap(&mut self) -> *packet<T> {
+        pub fn unwrap(&mut self) -> *const packet<T> {
             replace(&mut self.p, None).unwrap()
         }
     }
 
-    pub fn send_packet<T:Send>(p: *packet<T>) -> send_packet<T> {
+    pub fn send_packet<T:Send>(p: *const packet<T>) -> send_packet<T> {
         send_packet {
             p: Some(p)
         }
     }
 
     pub struct recv_packet<T> {
-        p: Option<*packet<T>>,
+        p: Option<*const packet<T>>,
     }
 
     #[unsafe_destructor]
@@ -196,7 +196,7 @@ pub mod pipes {
         fn drop(&mut self) {
             unsafe {
                 if self.p != None {
-                    let self_p: &mut Option<*packet<T>> =
+                    let self_p: &mut Option<*const packet<T>> =
                         mem::transmute(&self.p);
                     let p = replace(self_p, None);
                     receiver_terminate(p.unwrap())
@@ -206,12 +206,12 @@ pub mod pipes {
     }
 
     impl<T:Send> recv_packet<T> {
-        pub fn unwrap(&mut self) -> *packet<T> {
+        pub fn unwrap(&mut self) -> *const packet<T> {
             replace(&mut self.p, None).unwrap()
         }
     }
 
-    pub fn recv_packet<T:Send>(p: *packet<T>) -> recv_packet<T> {
+    pub fn recv_packet<T:Send>(p: *const packet<T>) -> recv_packet<T> {
         recv_packet {
             p: Some(p)
         }
@@ -231,7 +231,7 @@ pub mod pingpong {
 
     pub fn liberate_ping(p: ping) -> ::pipes::send_packet<pong> {
         unsafe {
-            let _addr : *::pipes::send_packet<pong> = match &p {
+            let _addr : *const ::pipes::send_packet<pong> = match &p {
               &ping(ref x) => { mem::transmute(x) }
             };
             fail!()
@@ -240,7 +240,7 @@ pub mod pingpong {
 
     pub fn liberate_pong(p: pong) -> ::pipes::send_packet<ping> {
         unsafe {
-            let _addr : *::pipes::send_packet<ping> = match &p {
+            let _addr : *const ::pipes::send_packet<ping> = match &p {
               &pong(ref x) => { mem::transmute(x) }
             };
             fail!()
diff --git a/src/test/run-pass/issue-2734.rs b/src/test/run-pass/issue-2734.rs
index e331173a158..11ebf014bc6 100644
--- a/src/test/run-pass/issue-2734.rs
+++ b/src/test/run-pass/issue-2734.rs
@@ -21,5 +21,5 @@ fn deadcode() {
 }
 
 pub fn main() {
-    let _ = perform_hax(box 42);
+    let _ = perform_hax(box 42i);
 }
diff --git a/src/test/run-pass/issue-2735.rs b/src/test/run-pass/issue-2735.rs
index 622b35b93ae..1a5b175cffc 100644
--- a/src/test/run-pass/issue-2735.rs
+++ b/src/test/run-pass/issue-2735.rs
@@ -21,5 +21,5 @@ fn deadcode() {
 }
 
 pub fn main() {
-    perform_hax(box 42);
+    perform_hax(box 42i);
 }
diff --git a/src/test/run-pass/issue-2804.rs b/src/test/run-pass/issue-2804.rs
index beba39602de..a0a800e0890 100644
--- a/src/test/run-pass/issue-2804.rs
+++ b/src/test/run-pass/issue-2804.rs
@@ -22,11 +22,11 @@ enum object {
     int_value(i64),
 }
 
-fn lookup(table: Box<json::Object>, key: String, default: String) -> String
+fn lookup(table: json::Object, key: String, default: String) -> String
 {
     match table.find(&key.to_string()) {
         option::Some(&json::String(ref s)) => {
-            (*s).to_string()
+            s.to_string()
         }
         option::Some(value) => {
             println!("{} was expected to be a string but is a {:?}", key, value);
@@ -42,7 +42,7 @@ fn add_interface(_store: int, managed_ip: String, data: json::Json) -> (String,
 {
     match &data {
         &json::Object(ref interface) => {
-            let name = lookup((*interface).clone(),
+            let name = lookup(interface.clone(),
                               "ifDescr".to_string(),
                               "".to_string());
             let label = format!("{}-{}", managed_ip, name);
diff --git a/src/test/run-pass/issue-333.rs b/src/test/run-pass/issue-333.rs
index 1217f32826f..ef49d0a170f 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(10) == 10)); }
+pub fn main() { assert!((quux(10i) == 10i)); }
diff --git a/src/test/run-pass/issue-3500.rs b/src/test/run-pass/issue-3500.rs
index 99def5476f9..eb422c9a8b9 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(1);
+    let x = &Some(1i);
     match x {
         &Some(_) => (),
         &None => (),
diff --git a/src/test/run-pass/issue-3656.rs b/src/test/run-pass/issue-3656.rs
index 6d70b15c621..8fd603781ba 100644
--- a/src/test/run-pass/issue-3656.rs
+++ b/src/test/run-pass/issue-3656.rs
@@ -18,7 +18,7 @@ use libc::{c_uint, uint32_t, c_void};
 struct KEYGEN {
     hash_algorithm: [c_uint, ..2],
     count: uint32_t,
-    salt: *c_void,
+    salt: *const c_void,
     salt_size: uint32_t,
 }
 
diff --git a/src/test/run-pass/issue-3878.rs b/src/test/run-pass/issue-3878.rs
index 1b09889c887..063b2d70301 100644
--- a/src/test/run-pass/issue-3878.rs
+++ b/src/test/run-pass/issue-3878.rs
@@ -11,6 +11,6 @@
 #![allow(path_statement)]
 
 pub fn main() {
-    let y = box 1;
+    let y = box 1i;
     y;
 }
diff --git a/src/test/run-pass/issue-4387.rs b/src/test/run-pass/issue-4387.rs
index f2973256199..447bf3b4b26 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 = [0, ..2*4];
+    let _foo = [0i, ..2*4];
 }
diff --git a/src/test/run-pass/issue-4735.rs b/src/test/run-pass/issue-4735.rs
index d96568df63a..7730d75a3a9 100644
--- a/src/test/run-pass/issue-4735.rs
+++ b/src/test/run-pass/issue-4735.rs
@@ -15,17 +15,17 @@ extern crate libc;
 use std::mem::transmute;
 use libc::c_void;
 
-struct NonCopyable(*c_void);
+struct NonCopyable(*const c_void);
 
 impl Drop for NonCopyable {
     fn drop(&mut self) {
         let NonCopyable(p) = *self;
-        let _v = unsafe { transmute::<*c_void, Box<int>>(p) };
+        let _v = unsafe { transmute::<*const c_void, Box<int>>(p) };
     }
 }
 
 pub fn main() {
     let t = box 0;
-    let p = unsafe { transmute::<Box<int>, *c_void>(t) };
+    let p = unsafe { transmute::<Box<int>, *const c_void>(t) };
     let _z = NonCopyable(p);
 }
diff --git a/src/test/run-pass/issue-5791.rs b/src/test/run-pass/issue-5791.rs
index 1bda73a16c9..468f420624a 100644
--- a/src/test/run-pass/issue-5791.rs
+++ b/src/test/run-pass/issue-5791.rs
@@ -12,9 +12,9 @@ extern crate libc;
 
 extern {
     #[link_name = "malloc"]
-    fn malloc1(len: libc::c_int) -> *libc::c_void;
+    fn malloc1(len: libc::c_int) -> *const libc::c_void;
     #[link_name = "malloc"]
-    fn malloc2(len: libc::c_int, foo: libc::c_int) -> *libc::c_void;
+    fn malloc2(len: libc::c_int, foo: libc::c_int) -> *const libc::c_void;
 }
 
 pub fn main () {}
diff --git a/src/test/run-pass/issue-6117.rs b/src/test/run-pass/issue-6117.rs
index 80727b569de..e1ecf47e926 100644
--- a/src/test/run-pass/issue-6117.rs
+++ b/src/test/run-pass/issue-6117.rs
@@ -15,7 +15,7 @@ use std::gc::GC;
 enum Either<T, U> { Left(T), Right(U) }
 
 pub fn main() {
-    match Left(box(GC) 17) {
+    match Left(box(GC) 17i) {
         Right(()) => {}
         _ => {}
     }
diff --git a/src/test/run-pass/issue-6318.rs b/src/test/run-pass/issue-6318.rs
index 4eb005f3397..6512db3b1c5 100644
--- a/src/test/run-pass/issue-6318.rs
+++ b/src/test/run-pass/issue-6318.rs
@@ -21,7 +21,7 @@ impl Foo for Struct {}
 
 pub fn main() {
     match A(box Struct as Box<Foo>) {
-        A(_a) => 0,
+        A(_a) => 0i,
     };
 }
 
diff --git a/src/test/run-pass/issue-6470.rs b/src/test/run-pass/issue-6470.rs
index 860b23849c6..ef164150804 100644
--- a/src/test/run-pass/issue-6470.rs
+++ b/src/test/run-pass/issue-6470.rs
@@ -14,7 +14,7 @@ pub mod Bar {
     }
 
     extern {
-        pub fn foo(v: *Foo) -> Foo;
+        pub fn foo(v: *const Foo) -> Foo;
     }
 }
 
diff --git a/src/test/run-pass/issue-8044.rs b/src/test/run-pass/issue-8044.rs
index 06f41e9cb7a..e5949e23467 100644
--- a/src/test/run-pass/issue-8044.rs
+++ b/src/test/run-pass/issue-8044.rs
@@ -14,5 +14,5 @@ extern crate minimal = "issue-8044";
 use minimal::{BTree, leaf};
 
 pub fn main() {
-    BTree::<int> { node: leaf(1) };
+    BTree::<int> { node: leaf(1i) };
 }
diff --git a/src/test/run-pass/issue-8498.rs b/src/test/run-pass/issue-8498.rs
index 770de8f5346..e4f4db6ea63 100644
--- a/src/test/run-pass/issue-8498.rs
+++ b/src/test/run-pass/issue-8498.rs
@@ -9,14 +9,14 @@
 // except according to those terms.
 
 pub fn main() {
-    match &[(box 5,box 7)] {
+    match &[(box 5i,box 7i)] {
         ps => {
            let (ref y, _) = ps[0];
            assert!(**y == 5);
         }
     }
 
-    match Some(&[(box 5,)]) {
+    match Some(&[(box 5i,)]) {
         Some(ps) => {
            let (ref y,) = ps[0];
            assert!(**y == 5);
@@ -24,7 +24,7 @@ pub fn main() {
         None => ()
     }
 
-    match Some(&[(box 5,box 7)]) {
+    match Some(&[(box 5i,box 7i)]) {
         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 12dcc4ecd2c..99ab83ec620 100644
--- a/src/test/run-pass/issue-868.rs
+++ b/src/test/run-pass/issue-868.rs
@@ -11,7 +11,7 @@
 fn f<T>(g: || -> T) -> T { g() }
 
 pub fn main() {
-  let _x = f( | | { 10 });
+  let _x = f( | | { 10i });
     // used to be: cannot determine a type for this expression
     f(| | { });
     // ditto
diff --git a/src/test/run-pass/issue-8851.rs b/src/test/run-pass/issue-8851.rs
index 62970369579..21037120569 100644
--- a/src/test/run-pass/issue-8851.rs
+++ b/src/test/run-pass/issue-8851.rs
@@ -10,23 +10,28 @@
 
 #![feature(macro_rules)]
 
+// after fixing #9384 and implementing hygiene for match bindings,
+// this now fails because the insertion of the 'y' into the match
+// doesn't cause capture. Making this macro hygienic (as I've done)
+// could very well make this test case completely pointless....
+
 enum T {
     A(int),
     B(uint)
 }
 
 macro_rules! test(
-    ($e:expr) => (
+    ($id:ident, $e:expr) => (
         fn foo(t: T) -> int {
             match t {
-                A(y) => $e,
-                B(y) => $e
+                A($id) => $e,
+                B($id) => $e
             }
         }
     )
 )
 
-test!(10 + (y as int))
+test!(y, 10 + (y as int))
 
 pub fn main() {
     foo(A(20));
diff --git a/src/test/run-pass/issue-8860.rs b/src/test/run-pass/issue-8860.rs
index c665c1da3fc..d775f23bab4 100644
--- a/src/test/run-pass/issue-8860.rs
+++ b/src/test/run-pass/issue-8860.rs
@@ -16,7 +16,7 @@ static mut DROP_S: int = 0i;
 static mut DROP_T: int = 0i;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     let ret = green::start(argc, argv, green::basic::event_loop, main);
     unsafe {
         assert_eq!(2, DROP);
diff --git a/src/test/run-pass/issue-8898.rs b/src/test/run-pass/issue-8898.rs
index 84e9de9b924..e787962bb81 100644
--- a/src/test/run-pass/issue-8898.rs
+++ b/src/test/run-pass/issue-8898.rs
@@ -19,7 +19,7 @@ fn assert_repr_eq<T>(obj : T, expected : String) {
 }
 
 pub fn main() {
-    let abc = [1, 2, 3];
+    let abc = [1i, 2, 3];
     let tf = [true, false];
     let x  = [(), ()];
     let slice = x.slice(0,1);
diff --git a/src/test/run-pass/issue-8983.rs b/src/test/run-pass/issue-8983.rs
index 9f6b281810e..2fb96f593ef 100644
--- a/src/test/run-pass/issue-8983.rs
+++ b/src/test/run-pass/issue-8983.rs
@@ -16,6 +16,6 @@ fn main() {
     fn f(_: proc()) {}
     fn eat<T>(_: T) {}
 
-    let x = box(GC) 1;
+    let x = box(GC) 1i;
     f(proc() { eat(x) });
 }
diff --git a/src/test/run-pass/issue-9906.rs b/src/test/run-pass/issue-9906.rs
index 6b8e250ea74..dd12ea8b765 100644
--- a/src/test/run-pass/issue-9906.rs
+++ b/src/test/run-pass/issue-9906.rs
@@ -14,5 +14,5 @@ extern crate testmod = "issue-9906";
 
 pub fn main() {
     testmod::foo();
-    testmod::FooBar::new(1);
+    testmod::FooBar::new(1i);
 }
diff --git a/src/test/run-pass/issue-9942.rs b/src/test/run-pass/issue-9942.rs
index 7864f4fbdd6..aa86f488906 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() {
-    static S: uint = 23 as uint; [0, ..S]; ()
+    static S: uint = 23 as uint; [0i, ..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 ff568b77f08..885f266ca3d 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 0 {
-      _ => { 0 }
+    match 0i {
+      _ => { 0i }
     }
 }
diff --git a/src/test/run-pass/lang-item-public.rs b/src/test/run-pass/lang-item-public.rs
index 23e48b97427..6330e1bf3c1 100644
--- a/src/test/run-pass/lang-item-public.rs
+++ b/src/test/run-pass/lang-item-public.rs
@@ -33,6 +33,6 @@ extern {}
 extern {}
 
 #[start]
-fn main(_: int, _: **u8) -> int {
+fn main(_: int, _: *const *const u8) -> int {
     1 % 1
 }
diff --git a/src/test/run-pass/lazy-and-or.rs b/src/test/run-pass/lazy-and-or.rs
index c4f37ccf88a..366b3c41328 100644
--- a/src/test/run-pass/lazy-and-or.rs
+++ b/src/test/run-pass/lazy-and-or.rs
@@ -13,7 +13,7 @@ extern crate debug;
 fn incr(x: &mut int) -> bool { *x += 1; assert!((false)); return false; }
 
 pub fn main() {
-    let x = 1 == 2 || 3 == 3;
+    let x = 1i == 2 || 3i == 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 60f7689ecfa..cd8be550d51 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 1 > 2 { x = 12; } else { x = 10; } foo(x); }
+pub fn main() { let mut x: int; if 1i > 2 { x = 12; } else { x = 10; } foo(x); }
diff --git a/src/test/run-pass/linear-for-loop.rs b/src/test/run-pass/linear-for-loop.rs
index 640ed3883eb..e9e2a753469 100644
--- a/src/test/run-pass/linear-for-loop.rs
+++ b/src/test/run-pass/linear-for-loop.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 extern crate debug;
 
diff --git a/src/test/run-pass/linkage1.rs b/src/test/run-pass/linkage1.rs
index 2eafd34afca..2ab1e911180 100644
--- a/src/test/run-pass/linkage1.rs
+++ b/src/test/run-pass/linkage1.rs
@@ -19,7 +19,7 @@ extern crate other = "linkage1";
 
 extern {
     #[linkage = "extern_weak"]
-    static foo: *int;
+    static foo: *const int;
     #[linkage = "extern_weak"]
     static something_that_should_never_exist: *mut int;
 }
diff --git a/src/test/run-pass/long-while.rs b/src/test/run-pass/long-while.rs
index cbe26844708..7d30b22867c 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 = 3;
+        let x = 3i;
     }
 }
diff --git a/src/test/run-pass/loop-diverges.rs b/src/test/run-pass/loop-diverges.rs
index 9c46ba2cb9b..4fe73188b45 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 (1 == 2) { forever(); }
+  if (1i == 2) { forever(); }
 }
diff --git a/src/test/run-pass/loop-label-shadowing.rs b/src/test/run-pass/loop-label-shadowing.rs
index cfe51fe7758..46d4fa460fe 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 [1, 2, 3].iter() {
+    'foo: for i in [1i, 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 8b775002250..14aee4c3be8 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_fail() -> ! { loop {} }
 
 pub fn step(f: bool) {
     let mut g = S;
-    let mut i = 0;
+    let mut i = 0i;
     loop
     {
         if i > 10 { break; } else { i += 1; }
diff --git a/src/test/run-pass/match-bot-2.rs b/src/test/run-pass/match-bot-2.rs
index ba897bd92c0..f3c299bd1f9 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 1 { 2 => 3, _ => fail!() } }
+fn a() -> int { match return 1i { 2i => 3i, _ => fail!() } }
 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 433cf23626b..170a3513a1a 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 0 {
+    let _x = match 0i {
       _ => 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 fe12b7c1585..21c31b62183 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 0 {
+    let _x = match 0i {
       _ => X {
         x: 0
       }
diff --git a/src/test/run-pass/match-pipe-binding.rs b/src/test/run-pass/match-pipe-binding.rs
index 52d966a12d7..2169e996577 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 ((1, "a".to_string()), (2, "b".to_string())) {
+    match ((1i, "a".to_string()), (2i, "b".to_string())) {
         ((1, a), (2, b)) | ((2, b), (1, a)) => {
                 assert_eq!(a, "a".to_string());
                 assert_eq!(b, "b".to_string());
diff --git a/src/test/run-pass/match-range.rs b/src/test/run-pass/match-range.rs
index 6b02b21a084..7421ae95884 100644
--- a/src/test/run-pass/match-range.rs
+++ b/src/test/run-pass/match-range.rs
@@ -26,15 +26,15 @@ pub fn main() {
       'a'..'z' => {}
       _ => fail!("should suppport char ranges")
     }
-    match -3 {
+    match -3i {
       -7..5 => {}
       _ => fail!("should match signed range")
     }
-    match 3.0 {
+    match 3.0f64 {
       1.0..5.0 => {}
       _ => fail!("should match float range")
     }
-    match -1.5 {
+    match -1.5f64 {
       -3.6..3.6 => {}
       _ => fail!("should match negative float range")
     }
diff --git a/src/test/run-pass/multi-let.rs b/src/test/run-pass/multi-let.rs
index eb1444be378..201abeba073 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 = 10;
+    let x = 10i;
     let y = x;
     assert!((y == 10));
 }
diff --git a/src/test/run-pass/native-always-waits.rs b/src/test/run-pass/native-always-waits.rs
index 94a4308ab08..ea3eb299648 100644
--- a/src/test/run-pass/native-always-waits.rs
+++ b/src/test/run-pass/native-always-waits.rs
@@ -15,7 +15,7 @@ extern crate native;
 static mut set: bool = false;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     // make sure that native::start always waits for all children to finish
     native::start(argc, argv, proc() {
         spawn(proc() {
diff --git a/src/test/run-pass/native-print-no-runtime.rs b/src/test/run-pass/native-print-no-runtime.rs
index bf1a97f84b6..a7937efd66f 100644
--- a/src/test/run-pass/native-print-no-runtime.rs
+++ b/src/test/run-pass/native-print-no-runtime.rs
@@ -10,7 +10,7 @@
 
 
 #[start]
-pub fn main(_: int, _: **u8) -> int {
+pub fn main(_: int, _: *const *const u8) -> int {
     println!("hello");
     0
 }
diff --git a/src/test/run-pass/negative.rs b/src/test/run-pass/negative.rs
index d92496c4b7b..148c1c9f0cf 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 -5 {
+    match -5i {
       -5 => {}
       _ => { fail!() }
     }
diff --git a/src/test/run-pass/new-box-syntax.rs b/src/test/run-pass/new-box-syntax.rs
index 0150120e1db..b16bef3fc99 100644
--- a/src/test/run-pass/new-box-syntax.rs
+++ b/src/test/run-pass/new-box-syntax.rs
@@ -22,15 +22,15 @@ struct Structure {
 }
 
 pub fn main() {
-    let x: Box<int> = box(HEAP) 2;
-    let y: Box<int> = box 2;
-    let z: Gc<int> = box(GC) 2;
+    let x: Box<int> = box(HEAP) 2i;
+    let y: Box<int> = box 2i;
+    let z: Gc<int> = box(GC) 2i;
     let a: Gc<Structure> = box(GC) Structure {
         x: 10,
         y: 20,
     };
-    let b: Box<int> = box()(1 + 2);
-    let c = box()(3 + 4);
-    let d = box(GC)(5 + 6);
+    let b: Box<int> = box()(1i + 2);
+    let c = box()(3i + 4);
+    let d = box(GC)(5i + 6);
 }
 
diff --git a/src/test/run-pass/operator-associativity.rs b/src/test/run-pass/operator-associativity.rs
index bee6d23a27d..8d45b8ecb08 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!((3 * 5 / 2 == 7)); }
+pub fn main() { assert!((3i * 5i / 2i == 7i)); }
diff --git a/src/test/run-pass/out-of-stack.rs b/src/test/run-pass/out-of-stack.rs
index 1566b9ed6f1..19d1635a9a5 100644
--- a/src/test/run-pass/out-of-stack.rs
+++ b/src/test/run-pass/out-of-stack.rs
@@ -21,7 +21,7 @@ use std::str;
 pub fn black_box<T>(dummy: T) { unsafe { asm!("" : : "r"(&dummy)) } }
 
 fn silent_recurse() {
-    let buf = [0, ..1000];
+    let buf = [0i, ..1000];
     black_box(buf);
     silent_recurse();
 }
diff --git a/src/test/run-pass/owned-implies-static.rs b/src/test/run-pass/owned-implies-static.rs
index d1e9fb270d7..498b81d307e 100644
--- a/src/test/run-pass/owned-implies-static.rs
+++ b/src/test/run-pass/owned-implies-static.rs
@@ -11,5 +11,5 @@
 fn f<T: 'static>(_x: T) {}
 
 pub fn main() {
-    f(box 5);
+    f(box 5i);
 }
diff --git a/src/test/run-pass/paren-free.rs b/src/test/run-pass/paren-free.rs
index d9669812d2a..569023c4439 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 = 10; while i > 0 { i -= 1; } }
+    if x { let mut i = 10i; while i > 0 { i -= 1; } }
     match x { true => { println!("right"); } false => { println!("wrong"); } }
 }
diff --git a/src/test/run-pass/process-detach.rs b/src/test/run-pass/process-detach.rs
index 44ff58c151e..69ff9fca6ce 100644
--- a/src/test/run-pass/process-detach.rs
+++ b/src/test/run-pass/process-detach.rs
@@ -28,7 +28,7 @@ use std::io::process::Command;
 use std::io::signal::{Listener, Interrupt};
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, main)
 }
 
diff --git a/src/test/run-pass/pub-extern-privacy.rs b/src/test/run-pass/pub-extern-privacy.rs
index 26bf06794ca..16f5a06b886 100644
--- a/src/test/run-pass/pub-extern-privacy.rs
+++ b/src/test/run-pass/pub-extern-privacy.rs
@@ -12,12 +12,12 @@ use std::mem::transmute;
 
 mod a {
     extern {
-        pub fn free(x: *u8);
+        pub fn free(x: *const u8);
     }
 }
 
 pub fn main() {
     unsafe {
-        a::free(transmute(0));
+        a::free(transmute(0u));
     }
 }
diff --git a/src/test/run-pass/reflect-visit-type.rs b/src/test/run-pass/reflect-visit-type.rs
index 9757db9df4c..a8a9afc6156 100644
--- a/src/test/run-pass/reflect-visit-type.rs
+++ b/src/test/run-pass/reflect-visit-type.rs
@@ -66,44 +66,44 @@ impl TyVisitor for MyVisitor {
                         _sz: uint, _sz2: uint,
                         _align: uint) -> bool { true }
 
-    fn visit_box(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_uniq(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_ptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_rptr(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_box(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
+    fn visit_uniq(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
+    fn visit_ptr(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
+    fn visit_rptr(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
 
-    fn visit_evec_slice(&mut self, _mtbl: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_evec_slice(&mut self, _mtbl: uint, _inner: *const TyDesc) -> bool { true }
     fn visit_evec_fixed(&mut self, _n: uint, _sz: uint, _align: uint,
-                        _mtbl: uint, _inner: *TyDesc) -> bool { true }
+                        _mtbl: uint, _inner: *const TyDesc) -> bool { true }
 
     fn visit_enter_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
     fn visit_rec_field(&mut self, _i: uint, _name: &str,
-                       _mtbl: uint, _inner: *TyDesc) -> bool { true }
+                       _mtbl: uint, _inner: *const TyDesc) -> bool { true }
     fn visit_leave_rec(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
     fn visit_class_field(&mut self, _i: uint, _name: &str, _named: bool,
-                         _mtbl: uint, _inner: *TyDesc) -> bool { true }
+                         _mtbl: uint, _inner: *const TyDesc) -> bool { true }
     fn visit_leave_class(&mut self, _name: &str, _named_fields: bool, _n_fields: uint,
                          _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_tup(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
-    fn visit_tup_field(&mut self, _i: uint, _inner: *TyDesc) -> bool { true }
+    fn visit_tup_field(&mut self, _i: uint, _inner: *const TyDesc) -> bool { true }
     fn visit_leave_tup(&mut self, _n_fields: uint,
                        _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_enum(&mut self, _n_variants: uint,
-                        _get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        _get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
                         _sz: uint, _align: uint) -> bool { true }
     fn visit_enter_enum_variant(&mut self,
                                 _variant: uint,
                                 _disr_val: Disr,
                                 _n_fields: uint,
                                 _name: &str) -> bool { true }
-    fn visit_enum_variant_field(&mut self, _i: uint, _offset: uint, _inner: *TyDesc)
+    fn visit_enum_variant_field(&mut self, _i: uint, _offset: uint, _inner: *const TyDesc)
         -> bool { true }
     fn visit_leave_enum_variant(&mut self,
                                 _variant: uint,
@@ -112,13 +112,13 @@ impl TyVisitor for MyVisitor {
                                 _name: &str) -> bool { true }
     fn visit_leave_enum(&mut self,
                         _n_variants: uint,
-                        _get_disr: unsafe extern fn(ptr: *Opaque) -> Disr,
+                        _get_disr: unsafe extern fn(ptr: *const Opaque) -> Disr,
                         _sz: uint, _align: uint) -> bool { true }
 
     fn visit_enter_fn(&mut self, _purity: uint, _proto: uint,
                       _n_inputs: uint, _retstyle: uint) -> bool { true }
-    fn visit_fn_input(&mut self, _i: uint, _mode: uint, _inner: *TyDesc) -> bool { true }
-    fn visit_fn_output(&mut self, _retstyle: uint, _variadic: bool, _inner: *TyDesc)
+    fn visit_fn_input(&mut self, _i: uint, _mode: uint, _inner: *const TyDesc) -> bool { true }
+    fn visit_fn_output(&mut self, _retstyle: uint, _variadic: bool, _inner: *const TyDesc)
         -> bool { true }
     fn visit_leave_fn(&mut self, _purity: uint, _proto: uint,
                       _n_inputs: uint, _retstyle: uint) -> bool { true }
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 1342c2e77f2..13200d619d0 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<'r, T>(x: &'r [T]) -> &'r [T] {x}
 
 pub fn main() {
-    let v = vec!(1, 2, 3);
+    let v = vec!(1i, 2, 3);
     let x = view(v.as_slice());
     let y = view(x.as_slice());
     assert!((*v.get(0) == x[0]) && (*v.get(0) == y[0]));
diff --git a/src/test/run-pass/rename-directory.rs b/src/test/run-pass/rename-directory.rs
index bf7a8fabff3..e0609782a0a 100644
--- a/src/test/run-pass/rename-directory.rs
+++ b/src/test/run-pass/rename-directory.rs
@@ -37,7 +37,7 @@ fn rename_directory() {
         assert!((ostream as uint != 0u));
         let s = "hello".to_string();
         "hello".with_c_str(|buf| {
-            let write_len = libc::fwrite(buf as *libc::c_void,
+            let write_len = libc::fwrite(buf as *const libc::c_void,
                                          1u as libc::size_t,
                                          (s.len() + 1u) as libc::size_t,
                                          ostream);
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 dc6dac15bb2..9dc3b7a0f80 100644
--- a/src/test/run-pass/resource-assign-is-not-copy.rs
+++ b/src/test/run-pass/resource-assign-is-not-copy.rs
@@ -33,11 +33,11 @@ fn r(i: Gc<Cell<int>>) -> r {
 }
 
 pub fn main() {
-    let i = box(GC) Cell::new(0);
+    let i = box(GC) Cell::new(0i);
     // Even though these look like copies, they are guaranteed not to be
     {
         let a = r(i);
-        let b = (a, 10);
+        let b = (a, 10i);
         let (c, _d) = b;
         println!("{:?}", c);
     }
diff --git a/src/test/run-pass/running-with-no-runtime.rs b/src/test/run-pass/running-with-no-runtime.rs
index 0ef48c99782..44435dc2398 100644
--- a/src/test/run-pass/running-with-no-runtime.rs
+++ b/src/test/run-pass/running-with-no-runtime.rs
@@ -18,7 +18,7 @@ use std::rt::unwind::try;
 local_data_key!(foo: int)
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     if argc > 1 {
         unsafe {
             match **argv.offset(1) {
diff --git a/src/test/run-pass/self-re-assign.rs b/src/test/run-pass/self-re-assign.rs
index e613a83737e..75fb98f8e24 100644
--- a/src/test/run-pass/self-re-assign.rs
+++ b/src/test/run-pass/self-re-assign.rs
@@ -14,11 +14,11 @@
 use std::rc::Rc;
 
 pub fn main() {
-   let mut x = box 3;
+   let mut x = box 3i;
    x = x;
    assert!(*x == 3);
 
-   let mut x = Rc::new(3);
+   let mut x = Rc::new(3i);
    x = x;
    assert!(*x == 3);
 }
diff --git a/src/test/run-pass/shadow.rs b/src/test/run-pass/shadow.rs
index a65e44166e9..96a12494b2f 100644
--- a/src/test/run-pass/shadow.rs
+++ b/src/test/run-pass/shadow.rs
@@ -19,7 +19,7 @@ fn foo(c: Vec<int> ) {
         some::<int>(_) => {
             for _i in c.iter() {
                 println!("{:?}", a);
-                let a = 17;
+                let a = 17i;
                 b.push(a);
             }
         }
@@ -29,4 +29,4 @@ fn foo(c: Vec<int> ) {
 
 enum t<T> { none, some(T), }
 
-pub fn main() { let x = 10; let x = x + 20; assert!((x == 30)); foo(Vec::new()); }
+pub fn main() { let x = 10i; let x = x + 20; assert!((x == 30)); foo(Vec::new()); }
diff --git a/src/test/run-pass/smallest-hello-world.rs b/src/test/run-pass/smallest-hello-world.rs
index bdba5aa9cfe..4f1a3817fab 100644
--- a/src/test/run-pass/smallest-hello-world.rs
+++ b/src/test/run-pass/smallest-hello-world.rs
@@ -17,7 +17,7 @@
 
 extern crate libc;
 
-extern { fn puts(s: *u8); }
+extern { fn puts(s: *const u8); }
 extern "rust-intrinsic" { fn transmute<T, U>(t: T) -> U; }
 
 #[lang = "stack_exhausted"] extern fn stack_exhausted() {}
@@ -25,9 +25,9 @@ extern "rust-intrinsic" { fn transmute<T, U>(t: T) -> U; }
 
 #[start]
 #[no_split_stack]
-fn main(_: int, _: **u8) -> int {
+fn main(_: int, _: *const *const u8) -> int {
     unsafe {
-        let (ptr, _): (*u8, uint) = transmute("Hello!\0");
+        let (ptr, _): (*const u8, uint) = transmute("Hello!\0");
         puts(ptr);
     }
     return 0;
diff --git a/src/test/run-pass/stable-addr-of.rs b/src/test/run-pass/stable-addr-of.rs
index 083d2e167a0..515198f7a71 100644
--- a/src/test/run-pass/stable-addr-of.rs
+++ b/src/test/run-pass/stable-addr-of.rs
@@ -12,5 +12,5 @@
 
 pub fn main() {
     let foo = 1;
-    assert_eq!(&foo as *int, &foo as *int);
+    assert_eq!(&foo as *const int, &foo as *const int);
 }
diff --git a/src/test/run-pass/static-assert.rs b/src/test/run-pass/static-assert.rs
index f8fd81b9365..c695fa2b72e 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 = 1 == 1;
+static c: bool = 1i == 1;
 
 #[static_assert]
-static d: bool = 1 != 2;
+static d: bool = 1i != 2;
 
 #[static_assert]
-static f: bool = (4/2) == 2;
+static f: bool = (4i/2) == 2;
 
 pub fn main() {
 }
diff --git a/src/test/run-pass/str-concat.rs b/src/test/run-pass/str-concat.rs
index 7141d0b9df5..ad0d2f11abd 100644
--- a/src/test/run-pass/str-concat.rs
+++ b/src/test/run-pass/str-concat.rs
@@ -16,5 +16,5 @@ pub fn main() {
     let b: String = "world".to_string();
     let s: String = format!("{}{}", a, b);
     println!("{}", s.clone());
-    assert_eq!(s.as_slice()[9], 'd' as u8);
+    assert_eq!(s.as_bytes()[9], 'd' as u8);
 }
diff --git a/src/test/run-pass/string-self-append.rs b/src/test/run-pass/string-self-append.rs
index 612483f6909..dc1e23ca09c 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 = 20;
+    let mut i = 20i;
     let mut expected_len = 1u;
     while i > 0 {
         println!("{}", a.len());
diff --git a/src/test/run-pass/supported-cast.rs b/src/test/run-pass/supported-cast.rs
index b87535713a7..2757439828d 100644
--- a/src/test/run-pass/supported-cast.rs
+++ b/src/test/run-pass/supported-cast.rs
@@ -11,7 +11,7 @@
 extern crate libc;
 
 pub fn main() {
-  let f = 1 as *libc::FILE;
+  let f = 1u as *const libc::FILE;
   println!("{}", f as int);
   println!("{}", f as uint);
   println!("{}", f as i8);
@@ -25,7 +25,7 @@ pub fn main() {
 
   println!("{}", 1 as int);
   println!("{}", 1 as uint);
-  println!("{}", 1 as *libc::FILE);
+  println!("{}", 1 as *const libc::FILE);
   println!("{}", 1 as i8);
   println!("{}", 1 as i16);
   println!("{}", 1 as i32);
@@ -34,12 +34,12 @@ pub fn main() {
   println!("{}", 1 as u16);
   println!("{}", 1 as u32);
   println!("{}", 1 as u64);
-  println!("{}", 1 as f32);
-  println!("{}", 1 as f64);
+  println!("{}", 1i as f32);
+  println!("{}", 1i as f64);
 
   println!("{}", 1u as int);
   println!("{}", 1u as uint);
-  println!("{}", 1u as *libc::FILE);
+  println!("{}", 1u as *const libc::FILE);
   println!("{}", 1u as i8);
   println!("{}", 1u as i16);
   println!("{}", 1u as i32);
@@ -53,7 +53,7 @@ pub fn main() {
 
   println!("{}", 1i8 as int);
   println!("{}", 1i8 as uint);
-  println!("{}", 1i8 as *libc::FILE);
+  println!("{}", 1i8 as *const libc::FILE);
   println!("{}", 1i8 as i8);
   println!("{}", 1i8 as i16);
   println!("{}", 1i8 as i32);
@@ -67,7 +67,7 @@ pub fn main() {
 
   println!("{}", 1u8 as int);
   println!("{}", 1u8 as uint);
-  println!("{}", 1u8 as *libc::FILE);
+  println!("{}", 1u8 as *const libc::FILE);
   println!("{}", 1u8 as i8);
   println!("{}", 1u8 as i16);
   println!("{}", 1u8 as i32);
@@ -81,7 +81,7 @@ pub fn main() {
 
   println!("{}", 1i16 as int);
   println!("{}", 1i16 as uint);
-  println!("{}", 1i16 as *libc::FILE);
+  println!("{}", 1i16 as *const libc::FILE);
   println!("{}", 1i16 as i8);
   println!("{}", 1i16 as i16);
   println!("{}", 1i16 as i32);
@@ -95,7 +95,7 @@ pub fn main() {
 
   println!("{}", 1u16 as int);
   println!("{}", 1u16 as uint);
-  println!("{}", 1u16 as *libc::FILE);
+  println!("{}", 1u16 as *const libc::FILE);
   println!("{}", 1u16 as i8);
   println!("{}", 1u16 as i16);
   println!("{}", 1u16 as i32);
@@ -109,7 +109,7 @@ pub fn main() {
 
   println!("{}", 1i32 as int);
   println!("{}", 1i32 as uint);
-  println!("{}", 1i32 as *libc::FILE);
+  println!("{}", 1i32 as *const libc::FILE);
   println!("{}", 1i32 as i8);
   println!("{}", 1i32 as i16);
   println!("{}", 1i32 as i32);
@@ -123,7 +123,7 @@ pub fn main() {
 
   println!("{}", 1u32 as int);
   println!("{}", 1u32 as uint);
-  println!("{}", 1u32 as *libc::FILE);
+  println!("{}", 1u32 as *const libc::FILE);
   println!("{}", 1u32 as i8);
   println!("{}", 1u32 as i16);
   println!("{}", 1u32 as i32);
@@ -137,7 +137,7 @@ pub fn main() {
 
   println!("{}", 1i64 as int);
   println!("{}", 1i64 as uint);
-  println!("{}", 1i64 as *libc::FILE);
+  println!("{}", 1i64 as *const libc::FILE);
   println!("{}", 1i64 as i8);
   println!("{}", 1i64 as i16);
   println!("{}", 1i64 as i32);
@@ -151,7 +151,7 @@ pub fn main() {
 
   println!("{}", 1u64 as int);
   println!("{}", 1u64 as uint);
-  println!("{}", 1u64 as *libc::FILE);
+  println!("{}", 1u64 as *const libc::FILE);
   println!("{}", 1u64 as i8);
   println!("{}", 1u64 as i16);
   println!("{}", 1u64 as i32);
@@ -165,7 +165,7 @@ pub fn main() {
 
   println!("{}", 1u64 as int);
   println!("{}", 1u64 as uint);
-  println!("{}", 1u64 as *libc::FILE);
+  println!("{}", 1u64 as *const libc::FILE);
   println!("{}", 1u64 as i8);
   println!("{}", 1u64 as i16);
   println!("{}", 1u64 as i32);
@@ -179,7 +179,7 @@ pub fn main() {
 
   println!("{}", true as int);
   println!("{}", true as uint);
-  println!("{}", true as *libc::FILE);
+  println!("{}", true as *const libc::FILE);
   println!("{}", true as i8);
   println!("{}", true as i16);
   println!("{}", true as i32);
@@ -191,19 +191,6 @@ pub fn main() {
   println!("{}", true as f32);
   println!("{}", true as f64);
 
-  println!("{}", 1. as int);
-  println!("{}", 1. as uint);
-  println!("{}", 1. as i8);
-  println!("{}", 1. as i16);
-  println!("{}", 1. as i32);
-  println!("{}", 1. as i64);
-  println!("{}", 1. as u8);
-  println!("{}", 1. as u16);
-  println!("{}", 1. as u32);
-  println!("{}", 1. as u64);
-  println!("{}", 1. as f32);
-  println!("{}", 1. as f64);
-
   println!("{}", 1f32 as int);
   println!("{}", 1f32 as uint);
   println!("{}", 1f32 as i8);
diff --git a/src/test/run-pass/swap-1.rs b/src/test/run-pass/swap-1.rs
index 82a76512e08..9a77356d7eb 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 = 3; let mut y = 7;
+    let mut x = 3i; let mut y = 7i;
     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 3d63acd5b83..c04751d51b4 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 = 1u,
+    red = 1i,
     blue = 2,
 }
 
diff --git a/src/test/run-pass/task-comm-12.rs b/src/test/run-pass/task-comm-12.rs
index 851f87adfc2..f72c0ef8d7b 100644
--- a/src/test/run-pass/task-comm-12.rs
+++ b/src/test/run-pass/task-comm-12.rs
@@ -21,7 +21,7 @@ fn test00() {
     });
 
     // Sleep long enough for the task to finish.
-    let mut i = 0;
+    let mut i = 0u;
     while i < 10000 {
         task::deschedule();
         i += 1;
diff --git a/src/test/run-pass/task-comm-16.rs b/src/test/run-pass/task-comm-16.rs
index 9263cd1d485..d45e7a20c3b 100644
--- a/src/test/run-pass/task-comm-16.rs
+++ b/src/test/run-pass/task-comm-16.rs
@@ -39,10 +39,10 @@ fn test_str() {
     let s0 = "test".to_string();
     tx.send(s0);
     let s1 = rx.recv();
-    assert_eq!(s1.as_slice()[0], 't' as u8);
-    assert_eq!(s1.as_slice()[1], 'e' as u8);
-    assert_eq!(s1.as_slice()[2], 's' as u8);
-    assert_eq!(s1.as_slice()[3], 't' as u8);
+    assert_eq!(s1.as_bytes()[0], 't' as u8);
+    assert_eq!(s1.as_bytes()[1], 'e' as u8);
+    assert_eq!(s1.as_bytes()[2], 's' as u8);
+    assert_eq!(s1.as_bytes()[3], 't' as u8);
 }
 
 #[deriving(Show)]
diff --git a/src/test/run-pass/task-comm-3.rs b/src/test/run-pass/task-comm-3.rs
index 1c14153a110..afeb9125fe6 100644
--- a/src/test/run-pass/task-comm-3.rs
+++ b/src/test/run-pass/task-comm-3.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 extern crate debug;
 
diff --git a/src/test/run-pass/task-spawn-move-and-copy.rs b/src/test/run-pass/task-spawn-move-and-copy.rs
index cf6c2754829..fafb9412c01 100644
--- a/src/test/run-pass/task-spawn-move-and-copy.rs
+++ b/src/test/run-pass/task-spawn-move-and-copy.rs
@@ -14,10 +14,10 @@ pub fn main() {
     let (tx, rx) = channel::<uint>();
 
     let x = box 1;
-    let x_in_parent = &(*x) as *int as uint;
+    let x_in_parent = &(*x) as *const int as uint;
 
     task::spawn(proc() {
-        let x_in_child = &(*x) as *int as uint;
+        let x_in_child = &(*x) as *const int as uint;
         tx.send(x_in_child);
     });
 
diff --git a/src/test/run-pass/tcp-connect-timeouts.rs b/src/test/run-pass/tcp-connect-timeouts.rs
index b066d8a8ae0..ebc720aa0c8 100644
--- a/src/test/run-pass/tcp-connect-timeouts.rs
+++ b/src/test/run-pass/tcp-connect-timeouts.rs
@@ -24,7 +24,7 @@ extern crate green;
 extern crate rustuv;
 
 #[cfg(test)] #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, __test::main)
 }
 
diff --git a/src/test/run-pass/tcp-stress.rs b/src/test/run-pass/tcp-stress.rs
index efad0cecbde..de3366708c5 100644
--- a/src/test/run-pass/tcp-stress.rs
+++ b/src/test/run-pass/tcp-stress.rs
@@ -25,7 +25,7 @@ use std::io::{Acceptor, Listener};
 use std::task::TaskBuilder;
 
 #[start]
-fn start(argc: int, argv: **u8) -> int {
+fn start(argc: int, argv: *const *const u8) -> int {
     green::start(argc, argv, rustuv::event_loop, main)
 }
 
diff --git a/src/test/run-pass/terminate-in-initializer.rs b/src/test/run-pass/terminate-in-initializer.rs
index 391f0e20fcc..eb0bfc969f3 100644
--- a/src/test/run-pass/terminate-in-initializer.rs
+++ b/src/test/run-pass/terminate-in-initializer.rs
@@ -18,7 +18,7 @@ use std::gc::{Gc};
 
 fn test_break() { loop { let _x: Gc<int> = break; } }
 
-fn test_cont() { let mut i = 0; while i < 1 { i += 1; let _x: Gc<int> = continue; } }
+fn test_cont() { let mut i = 0i; while i < 1 { i += 1; let _x: Gc<int> = continue; } }
 
 fn test_ret() { let _x: Gc<int> = return; }
 
diff --git a/src/test/run-pass/trailing-comma.rs b/src/test/run-pass/trailing-comma.rs
index 13d79959f81..8d580729da9 100644
--- a/src/test/run-pass/trailing-comma.rs
+++ b/src/test/run-pass/trailing-comma.rs
@@ -11,6 +11,6 @@
 fn f(_: int,) {}
 
 pub fn main() {
-    f(0,);
-    let (_, _,) = (1, 1,);
+    f(0i,);
+    let (_, _,) = (1i, 1i,);
 }
diff --git a/src/test/run-pass/trait-bounds-in-arc.rs b/src/test/run-pass/trait-bounds-in-arc.rs
index 18a0e5d471c..cfe9a772b2e 100644
--- a/src/test/run-pass/trait-bounds-in-arc.rs
+++ b/src/test/run-pass/trait-bounds-in-arc.rs
@@ -99,7 +99,7 @@ fn check_legs(arc: Arc<Vec<Box<Pet+Share+Send>>>) {
 fn check_names(arc: Arc<Vec<Box<Pet+Share+Send>>>) {
     for pet in arc.iter() {
         pet.name(|name| {
-            assert!(name[0] == 'a' as u8 && name[1] == 'l' as u8);
+            assert!(name.as_bytes()[0] == 'a' as u8 && name.as_bytes()[1] == 'l' as u8);
         })
     }
 }
diff --git a/src/test/run-pass/trait-contravariant-self.rs b/src/test/run-pass/trait-contravariant-self.rs
index d8df5d5600c..e06e01b9e05 100644
--- a/src/test/run-pass/trait-contravariant-self.rs
+++ b/src/test/run-pass/trait-contravariant-self.rs
@@ -1,3 +1,5 @@
+// ignore-test
+
 // Copyright 2014 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
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 9e4a7c4be97..447968eb8c4 100644
--- a/src/test/run-pass/trait-default-method-xc-2.rs
+++ b/src/test/run-pass/trait-default-method-xc-2.rs
@@ -20,8 +20,8 @@ use aux2::{a_struct, welp};
 
 pub fn main () {
 
-    let a = a_struct { x: 0 };
-    let b = a_struct { x: 1 };
+    let a = a_struct { x: 0i };
+    let b = a_struct { x: 1i };
 
     assert_eq!(0i.g(), 10);
     assert_eq!(a.g(), 10);
@@ -30,5 +30,5 @@ pub fn main () {
     assert_eq!(b.h(), 11);
     assert_eq!(A::lurr(&a, &b), 21);
 
-    welp(&0);
+    welp(&0i);
 }
diff --git a/src/test/run-pass/type-param-constraints.rs b/src/test/run-pass/type-param-constraints.rs
index b87517940c2..fd7e749935b 100644
--- a/src/test/run-pass/type-param-constraints.rs
+++ b/src/test/run-pass/type-param-constraints.rs
@@ -35,15 +35,15 @@ pub fn main() {
     p_foo(box(GC) r(10));
 
     p_foo(box r(10));
-    p_foo(box(GC) 10);
-    p_foo(box 10);
-    p_foo(10);
+    p_foo(box(GC) 10i);
+    p_foo(box 10i);
+    p_foo(10i);
 
     s_foo(box(GC) r(10));
-    s_foo(box(GC) 10);
-    s_foo(box 10);
-    s_foo(10);
+    s_foo(box(GC) 10i);
+    s_foo(box 10i);
+    s_foo(10i);
 
-    u_foo(box 10);
-    u_foo(10);
+    u_foo(box 10i);
+    u_foo(10i);
 }
diff --git a/src/test/run-pass/type-ptr.rs b/src/test/run-pass/type-ptr.rs
index a00b6b8153e..410e3df9e2a 100644
--- a/src/test/run-pass/type-ptr.rs
+++ b/src/test/run-pass/type-ptr.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(a: *int) -> *int { return a; }
+fn f(a: *const int) -> *const int { return a; }
 
-fn g(a: *int) -> *int { let b = f(a); return b; }
+fn g(a: *const int) -> *const int { let b = f(a); return b; }
 
 pub fn main() { return; }
diff --git a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
index 50ef1922c8f..6be79cb62dd 100644
--- a/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
+++ b/src/test/run-pass/typeck-macro-interaction-issue-8852.rs
@@ -15,19 +15,24 @@ enum T {
     B(f64)
 }
 
+// after fixing #9384 and implementing hygiene for match bindings,
+// this now fails because the insertion of the 'y' into the match
+// doesn't cause capture. Making this macro hygienic (as I've done)
+// could very well make this test case completely pointless....
+
 macro_rules! test(
-    ($e:expr) => (
+    ($id1:ident, $id2:ident, $e:expr) => (
         fn foo(a:T, b:T) -> T {
             match (a, b) {
-                (A(x), A(y)) => A($e),
-                (B(x), B(y)) => B($e),
+                (A($id1), A($id2)) => A($e),
+                (B($id1), B($id2)) => B($e),
                 _ => fail!()
             }
         }
     )
 )
 
-test!(x + y)
+test!(x,y,x + y)
 
 pub fn main() {
     foo(A(1), A(2));
diff --git a/src/test/run-pass/typeck_type_placeholder_1.rs b/src/test/run-pass/typeck_type_placeholder_1.rs
index 0316311993a..1a79edb30c9 100644
--- a/src/test/run-pass/typeck_type_placeholder_1.rs
+++ b/src/test/run-pass/typeck_type_placeholder_1.rs
@@ -11,7 +11,7 @@
 // This test checks that the `_` type placeholder works
 // correctly for enabling type inference.
 
-static CONSTEXPR: *int = &'static 413 as *_;
+static CONSTEXPR: *const int = &'static 413 as *const _;
 
 pub fn main() {
     let x: Vec<_> = range(0u, 5).collect();
@@ -24,7 +24,7 @@ pub fn main() {
     assert_eq!(y.len(), 5);
 
     let ptr = &5u;
-    let ptr2 = ptr as *_;
+    let ptr2 = ptr as *const _;
 
-    assert_eq!(ptr as *uint as uint, ptr2 as uint);
+    assert_eq!(ptr as *const uint as uint, ptr2 as uint);
 }
diff --git a/src/test/run-pass/typestate-cfg-nesting.rs b/src/test/run-pass/typestate-cfg-nesting.rs
index 37d06bf4f83..f1e40cc3e58 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 = 10; let mut y = 11;
+    let x = 10i; let mut y = 11i;
     if true { match x { _ => { y = x; } } } else { }
 }
 
 pub fn main() {
-    let x = 10;
-    let mut y = 11;
+    let x = 10i;
+    let mut y = 11i;
     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 42910c47005..cbb0dcc8f2b 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) = (10, 20);
+    let (x, y) = (10i, 20i);
     let z = x + y;
     assert!((z == 30));
 }
diff --git a/src/test/run-pass/unfold-cross-crate.rs b/src/test/run-pass/unfold-cross-crate.rs
index d3e70706867..2af38047264 100644
--- a/src/test/run-pass/unfold-cross-crate.rs
+++ b/src/test/run-pass/unfold-cross-crate.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 use std::iter::Unfold;
 
diff --git a/src/test/run-pass/unify-return-ty.rs b/src/test/run-pass/unify-return-ty.rs
index 7f46b0ff6e7..a189d4528ae 100644
--- a/src/test/run-pass/unify-return-ty.rs
+++ b/src/test/run-pass/unify-return-ty.rs
@@ -14,9 +14,9 @@
 
 use std::mem;
 
-fn null<T>() -> *T {
+fn null<T>() -> *const T {
     unsafe {
-        mem::transmute(0)
+        mem::transmute(0u)
     }
 }
 
diff --git a/src/test/run-pass/uniq-cc-generic.rs b/src/test/run-pass/uniq-cc-generic.rs
index 77a8009c975..eb0a3c0eda8 100644
--- a/src/test/run-pass/uniq-cc-generic.rs
+++ b/src/test/run-pass/uniq-cc-generic.rs
@@ -26,7 +26,7 @@ struct Pointy {
 }
 
 fn make_uniq_closure<A:Send>(a: A) -> proc():Send -> uint {
-    proc() { &a as *A as uint }
+    proc() { &a as *const A as uint }
 }
 
 fn empty_pointy() -> Gc<RefCell<Pointy>> {
diff --git a/src/test/run-pass/unique-create.rs b/src/test/run-pass/unique-create.rs
index 834b549d4f4..acd405e2659 100644
--- a/src/test/run-pass/unique-create.rs
+++ b/src/test/run-pass/unique-create.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 pub fn main() {
-    box 100;
+    box 100i;
 }
 
 fn vec() {
-    vec!(0);
+    vec!(0i);
 }
diff --git a/src/test/run-pass/unique-drop-complex.rs b/src/test/run-pass/unique-drop-complex.rs
index 01aac804bb6..a4b6ff5accf 100644
--- a/src/test/run-pass/unique-drop-complex.rs
+++ b/src/test/run-pass/unique-drop-complex.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _x = box vec!(0,0,0,0,0);
+    let _x = box vec!(0i,0,0,0,0);
 }
diff --git a/src/test/run-pass/unique-init.rs b/src/test/run-pass/unique-init.rs
index d7105b472cc..6e58ec23a3b 100644
--- a/src/test/run-pass/unique-init.rs
+++ b/src/test/run-pass/unique-init.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 pub fn main() {
-    let _i = box 100;
+    let _i = box 100i;
 }
diff --git a/src/test/run-pass/unreachable-code.rs b/src/test/run-pass/unreachable-code.rs
index 2d74b3163d2..6b6754f3432 100644
--- a/src/test/run-pass/unreachable-code.rs
+++ b/src/test/run-pass/unreachable-code.rs
@@ -23,10 +23,10 @@ fn call_id_2() { id(true) && id(return); }
 
 fn call_id_3() { id(return) && id(return); }
 
-fn ret_ret() -> int { return (return 2) + 3; }
+fn ret_ret() -> int { return (return 2i) + 3i; }
 
 fn ret_guard() {
-    match 2 {
+    match 2i {
       x if (return) => { x; }
       _ => {}
     }
diff --git a/src/test/run-pass/unsafe-pointer-assignability.rs b/src/test/run-pass/unsafe-pointer-assignability.rs
index 3385c6f6fef..7a624109a55 100644
--- a/src/test/run-pass/unsafe-pointer-assignability.rs
+++ b/src/test/run-pass/unsafe-pointer-assignability.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(x: *int) {
+fn f(x: *const int) {
     unsafe {
         assert_eq!(*x, 3);
     }
diff --git a/src/test/run-pass/unused-move-capture.rs b/src/test/run-pass/unused-move-capture.rs
index 83795e64467..ba48ae1c0ce 100644
--- a/src/test/run-pass/unused-move-capture.rs
+++ b/src/test/run-pass/unused-move-capture.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let _x = box 1;
+    let _x = box 1i;
     let lam_move: || = || {};
     lam_move();
 }
diff --git a/src/test/run-pass/unused-move.rs b/src/test/run-pass/unused-move.rs
index bac9ce814bc..883ec44bf2e 100644
--- a/src/test/run-pass/unused-move.rs
+++ b/src/test/run-pass/unused-move.rs
@@ -16,6 +16,6 @@
 
 pub fn main()
 {
-    let y = box 1;
+    let y = box 1i;
     y;
 }
diff --git a/src/test/run-pass/unwind-box.rs b/src/test/run-pass/unwind-box.rs
index f06791ff2c7..a81f88e2af3 100644
--- a/src/test/run-pass/unwind-box.rs
+++ b/src/test/run-pass/unwind-box.rs
@@ -14,7 +14,7 @@ use std::task;
 use std::gc::GC;
 
 fn f() {
-    let _a = box(GC) 0;
+    let _a = box(GC) 0i;
     fail!();
 }
 
diff --git a/src/test/run-pass/unwind-unique.rs b/src/test/run-pass/unwind-unique.rs
index ce252439618..e5497427755 100644
--- a/src/test/run-pass/unwind-unique.rs
+++ b/src/test/run-pass/unwind-unique.rs
@@ -11,7 +11,7 @@
 use std::task;
 
 fn f() {
-    let _a = box 0;
+    let _a = box 0i;
     fail!();
 }
 
diff --git a/src/test/run-pass/use.rs b/src/test/run-pass/use.rs
index e5a79bfaa99..3f152cc1061 100644
--- a/src/test/run-pass/use.rs
+++ b/src/test/run-pass/use.rs
@@ -26,4 +26,4 @@ mod baz {
 }
 
 #[start]
-pub fn start(_: int, _: **u8) -> int { 0 }
+pub fn start(_: int, _: *const *const u8) -> int { 0 }
diff --git a/src/test/run-pass/utf8.rs b/src/test/run-pass/utf8.rs
index 6cf0d518628..557d2e5878e 100644
--- a/src/test/run-pass/utf8.rs
+++ b/src/test/run-pass/utf8.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// ignore-pretty FIXME #15189
+// no-pretty-expanded FIXME #15189
 
 pub fn main() {
     let yen: char = '¥'; // 0xa5
@@ -46,7 +46,7 @@ pub fn main() {
         for ab in a.as_slice().bytes() {
             println!("{}", i);
             println!("{}", ab);
-            let bb: u8 = b.as_slice()[i as uint];
+            let bb: u8 = b.as_bytes()[i as uint];
             println!("{}", bb);
             assert_eq!(ab, bb);
             i += 1;
diff --git a/src/test/run-pass/variadic-ffi.rs b/src/test/run-pass/variadic-ffi.rs
index c6a1654bfe4..570b881650a 100644
--- a/src/test/run-pass/variadic-ffi.rs
+++ b/src/test/run-pass/variadic-ffi.rs
@@ -15,7 +15,7 @@ use libc::{c_char, c_int};
 // ignore-fast doesn't like extern crate
 
 extern {
-    fn sprintf(s: *mut c_char, format: *c_char, ...) -> c_int;
+    fn sprintf(s: *mut c_char, format: *const c_char, ...) -> c_int;
 }
 
 unsafe fn check<T>(expected: &str, f: |*mut c_char| -> T) {
@@ -41,10 +41,10 @@ pub fn main() {
         });
 
         // Make a function pointer
-        let x: unsafe extern "C" fn(*mut c_char, *c_char, ...) -> c_int = sprintf;
+        let x: unsafe extern "C" fn(*mut c_char, *const c_char, ...) -> c_int = sprintf;
 
         // A function that takes a function pointer
-        unsafe fn call(p: unsafe extern "C" fn(*mut c_char, *c_char, ...) -> c_int) {
+        unsafe fn call(p: unsafe extern "C" fn(*mut c_char, *const c_char, ...) -> c_int) {
             // Call with just the named parameter via fn pointer
             "Hello World\n".with_c_str(|c| {
                 check("Hello World\n", |s| p(s, c));
diff --git a/src/test/run-pass/vec-macro-with-brackets.rs b/src/test/run-pass/vec-macro-with-brackets.rs
index 87b18f841ed..d06e3dc0633 100644
--- a/src/test/run-pass/vec-macro-with-brackets.rs
+++ b/src/test/run-pass/vec-macro-with-brackets.rs
@@ -19,5 +19,5 @@ macro_rules! vec [
 ]
 
 pub fn main() {
-    let my_vec = vec![1, 2, 3, 4, 5];
+    let my_vec = vec![1i, 2, 3, 4, 5];
 }
diff --git a/src/test/run-pass/vec-matching.rs b/src/test/run-pass/vec-matching.rs
index ac869a10d2e..8ba8ba4482e 100644
--- a/src/test/run-pass/vec-matching.rs
+++ b/src/test/run-pass/vec-matching.rs
@@ -69,7 +69,7 @@ fn d() {
 }
 
 fn e() {
-    match &[1, 2, 3] {
+    match &[1i, 2, 3] {
         [1, 2] => (),
         [..] => ()
     }
diff --git a/src/test/run-pass/vec-push.rs b/src/test/run-pass/vec-push.rs
index 33f01c5bd41..fe0f92a0c11 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!(1, 2, 3); v.push(1); }
+pub fn main() { let mut v = vec!(1i, 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 f5d09e308ba..18ccd8c96ab 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 = [0, ..1 as uint]; }
+pub fn main() { let _a = [0i, ..1 as uint]; }
diff --git a/src/test/run-pass/warn-ctypes-inhibit.rs b/src/test/run-pass/warn-ctypes-inhibit.rs
index 9b0a2340156..93112e3e7ec 100644
--- a/src/test/run-pass/warn-ctypes-inhibit.rs
+++ b/src/test/run-pass/warn-ctypes-inhibit.rs
@@ -14,7 +14,7 @@
 
 mod libc {
     extern {
-        pub fn malloc(size: int) -> *u8;
+        pub fn malloc(size: int) -> *const u8;
     }
 }
 
diff --git a/src/test/run-pass/weird-exprs.rs b/src/test/run-pass/weird-exprs.rs
index 61578578ab6..bae1a7c45e4 100644
--- a/src/test/run-pass/weird-exprs.rs
+++ b/src/test/run-pass/weird-exprs.rs
@@ -38,7 +38,7 @@ fn zombiejesus() {
         while (return) {
             if (return) {
                 match (return) {
-                    1 => {
+                    1i => {
                         if (return) {
                             return
                         } else {
@@ -56,7 +56,7 @@ fn zombiejesus() {
 }
 
 fn notsure() {
-    let mut _x;
+    let mut _x: int;
     let mut _y = (_x = 0) == (_x = 0);
     let mut _z = (_x = 0) < (_x = 0);
     let _a = (_x += 0) == (_x = 0);
@@ -72,8 +72,8 @@ fn canttouchthis() -> uint {
 
 fn angrydome() {
     loop { if break { } }
-    let mut i = 0;
-    loop { i += 1; if i == 1 { match (continue) { 1 => { }, _ => fail!("wat") } }
+    let mut i = 0i;
+    loop { i += 1; if i == 1 { match (continue) { 1i => { }, _ => fail!("wat") } }
       break; }
 }
 
diff --git a/src/test/run-pass/while-flow-graph.rs b/src/test/run-pass/while-flow-graph.rs
index 36d902dc2e0..01c5986b130 100644
--- a/src/test/run-pass/while-flow-graph.rs
+++ b/src/test/run-pass/while-flow-graph.rs
@@ -10,4 +10,4 @@
 
 
 
-pub fn main() { let x: int = 10; while x == 10 && x == 11 { let _y = 0xf00; } }
+pub fn main() { let x: int = 10; while x == 10 && x == 11 { let _y = 0xf00u; } }
author	Alex Crichton <alex@alexcrichton.com>	2014-07-02 11:08:21 -0700
committer	Alex Crichton <alex@alexcrichton.com>	2014-07-02 11:08:21 -0700
commit	ff1dd44b40a7243f43a8d32ba8bd6026197c320b (patch)
tree	4460cbf0a917a289d1d3744d9645c5ab131ea9df /src/test/run-pass
parent	aa1163b92de7717eb7c5eba002b4012e0574a7fe (diff)
parent	ca2778ede7c21efc3cf2e4e1152875ec09360770 (diff)
download	rust-ff1dd44b40a7243f43a8d32ba8bd6026197c320b.tar.gz rust-ff1dd44b40a7243f43a8d32ba8bd6026197c320b.zip