diff --git a/src/test/compile-fail/access-mode-in-closures.rs b/src/test/compile-fail/access-mode-in-closures.rs
index f15157d126e..bad192fc2cf 100644
--- a/src/test/compile-fail/access-mode-in-closures.rs
+++ b/src/test/compile-fail/access-mode-in-closures.rs
@@ -9,9 +9,9 @@
 // except according to those terms.
 
 
-struct sty(Vec<int> );
+struct sty(Vec<isize> );
 
-fn unpack<F>(_unpack: F) where F: FnOnce(&sty) -> Vec<int> {}
+fn unpack<F>(_unpack: F) where F: FnOnce(&sty) -> Vec<isize> {}
 
 fn main() {
     let _foo = unpack(|s| {
diff --git a/src/test/compile-fail/arg-count-mismatch.rs b/src/test/compile-fail/arg-count-mismatch.rs
index 472c66d9aad..673314ec4c9 100644
--- a/src/test/compile-fail/arg-count-mismatch.rs
+++ b/src/test/compile-fail/arg-count-mismatch.rs
@@ -10,6 +10,6 @@
 
 // error-pattern: parameters were supplied
 
-fn f(x: int) { }
+fn f(x: isize) { }
 
 fn main() { let i: (); i = f(); }
diff --git a/src/test/compile-fail/arg-type-mismatch.rs b/src/test/compile-fail/arg-type-mismatch.rs
index 06fcc40f2e4..1f657ca5832 100644
--- a/src/test/compile-fail/arg-type-mismatch.rs
+++ b/src/test/compile-fail/arg-type-mismatch.rs
@@ -11,6 +11,6 @@
 
 // error-pattern: mismatched types
 
-fn f(x: int) { }
+fn f(x: isize) { }
 
 fn main() { let i: (); i = f(()); }
diff --git a/src/test/compile-fail/array-old-syntax-1.rs b/src/test/compile-fail/array-old-syntax-1.rs
index 3c01a7756a6..2dbc9e3da21 100644
--- a/src/test/compile-fail/array-old-syntax-1.rs
+++ b/src/test/compile-fail/array-old-syntax-1.rs
@@ -11,5 +11,5 @@
 // Test that the old fixed length array syntax is a parsing error.
 
 fn main() {
-    let _x: [int, ..3] = [0i, 1, 2]; //~ ERROR
+    let _x: [isize, ..3] = [0i, 1, 2]; //~ ERROR
 }
diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs
index bc240df9b3b..deff677ad03 100644
--- a/src/test/compile-fail/asm-in-bad-modifier.rs
+++ b/src/test/compile-fail/asm-in-bad-modifier.rs
@@ -10,15 +10,15 @@
 
 #![feature(asm)]
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 #[cfg(any(target_arch = "x86",
           target_arch = "x86_64",
           target_arch = "arm",
           target_arch = "aarch64"))]
 pub fn main() {
-    let x: int;
-    let y: int;
+    let x: isize;
+    let y: isize;
     unsafe {
         asm!("mov $1, $0" : "=r"(x) : "=r"(5u)); //~ ERROR input operand constraint contains '='
         asm!("mov $1, $0" : "=r"(y) : "+r"(5u)); //~ ERROR input operand constraint contains '+'
diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs
index b29899e1940..42f3c1692c1 100644
--- a/src/test/compile-fail/asm-misplaced-option.rs
+++ b/src/test/compile-fail/asm-misplaced-option.rs
@@ -18,7 +18,7 @@
           target_arch = "x86_64"))]
 pub fn main() {
     // assignment not dead
-    let mut x: int = 0;
+    let mut x: isize = 0;
     unsafe {
         // extra colon
         asm!("mov $1, $0" : "=r"(x) : "r"(5u), "0"(x) : : "cc");
diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs
index 387b4bec47e..031b1de91f2 100644
--- a/src/test/compile-fail/asm-out-assign-imm.rs
+++ b/src/test/compile-fail/asm-out-assign-imm.rs
@@ -10,14 +10,14 @@
 
 #![feature(asm)]
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 #[cfg(any(target_arch = "x86",
           target_arch = "x86_64",
           target_arch = "arm",
           target_arch = "aarch64"))]
 pub fn main() {
-    let x: int;
+    let x: isize;
     x = 1; //~ NOTE prior assignment occurs here
     foo(x);
     unsafe {
diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs
index 4690bdc40cb..76f60a34f3c 100644
--- a/src/test/compile-fail/asm-out-no-modifier.rs
+++ b/src/test/compile-fail/asm-out-no-modifier.rs
@@ -10,14 +10,14 @@
 
 #![feature(asm)]
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 #[cfg(any(target_arch = "x86",
           target_arch = "x86_64",
           target_arch = "arm",
           target_arch = "aarch64"))]
 pub fn main() {
-    let x: int;
+    let x: isize;
     unsafe {
         asm!("mov $1, $0" : "r"(x) : "r"(5u)); //~ ERROR output operand constraint lacks '='
     }
diff --git a/src/test/compile-fail/asm-out-read-uninit.rs b/src/test/compile-fail/asm-out-read-uninit.rs
index 2577dcc3f99..5e71a2c731d 100644
--- a/src/test/compile-fail/asm-out-read-uninit.rs
+++ b/src/test/compile-fail/asm-out-read-uninit.rs
@@ -10,14 +10,14 @@
 
 #![feature(asm)]
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 #[cfg(any(target_arch = "x86",
           target_arch = "x86_64",
           target_arch = "arm",
           target_arch = "aarch64"))]
 pub fn main() {
-    let x: int;
+    let x: isize;
     unsafe {
         asm!("mov $1, $0" : "=r"(x) : "r"(x)); //~ ERROR use of possibly uninitialized variable: `x`
     }
diff --git a/src/test/compile-fail/assign-imm-local-twice.rs b/src/test/compile-fail/assign-imm-local-twice.rs
index 77f47a028d6..540272a8e2c 100644
--- a/src/test/compile-fail/assign-imm-local-twice.rs
+++ b/src/test/compile-fail/assign-imm-local-twice.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn test() {
-    let v: int;
+    let v: isize;
     v = 1; //~ NOTE prior assignment occurs here
     println!("v={}", v);
     v = 2; //~ ERROR re-assignment of immutable variable
diff --git a/src/test/compile-fail/assign-to-method.rs b/src/test/compile-fail/assign-to-method.rs
index f14668192f8..f8108519492 100644
--- a/src/test/compile-fail/assign-to-method.rs
+++ b/src/test/compile-fail/assign-to-method.rs
@@ -11,14 +11,14 @@
 struct cat {
   meows : uint,
 
-  how_hungry : int,
+  how_hungry : isize,
 }
 
 impl cat {
     pub fn speak(&self) { self.meows += 1u; }
 }
 
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : uint, in_y : isize) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y
diff --git a/src/test/compile-fail/assoc-inherent.rs b/src/test/compile-fail/assoc-inherent.rs
index 8025011bfa7..ba8e4a652d3 100644
--- a/src/test/compile-fail/assoc-inherent.rs
+++ b/src/test/compile-fail/assoc-inherent.rs
@@ -13,7 +13,7 @@
 struct Foo;
 
 impl Foo {
-    type Bar = int; //~ERROR associated items are not allowed in inherent impls
+    type Bar = isize; //~ERROR associated items are not allowed in inherent impls
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/associated-types-bound-failure.rs b/src/test/compile-fail/associated-types-bound-failure.rs
index 918826bb390..adccd73beae 100644
--- a/src/test/compile-fail/associated-types-bound-failure.rs
+++ b/src/test/compile-fail/associated-types-bound-failure.rs
@@ -11,7 +11,7 @@
 // Test equality constraints on associated types in a where clause.
 
 pub trait ToInt {
-    fn to_int(&self) -> int;
+    fn to_int(&self) -> isize;
 }
 
 pub trait GetToInt
@@ -21,13 +21,13 @@ pub trait GetToInt
     fn get(&self) -> <Self as GetToInt>::R;
 }
 
-fn foo<G>(g: G) -> int
+fn foo<G>(g: G) -> isize
     where G : GetToInt
 {
     ToInt::to_int(&g.get()) //~ ERROR not implemented
 }
 
-fn bar<G : GetToInt>(g: G) -> int
+fn bar<G : GetToInt>(g: G) -> isize
     where G::R : ToInt
 {
     ToInt::to_int(&g.get()) // OK
diff --git a/src/test/compile-fail/associated-types-eq-2.rs b/src/test/compile-fail/associated-types-eq-2.rs
index e298d05d11d..34c7a6eaa6c 100644
--- a/src/test/compile-fail/associated-types-eq-2.rs
+++ b/src/test/compile-fail/associated-types-eq-2.rs
@@ -18,7 +18,7 @@ pub trait Foo {
 
 struct Bar;
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
     fn boo(&self) -> uint { 42 }
 }
diff --git a/src/test/compile-fail/associated-types-eq-3.rs b/src/test/compile-fail/associated-types-eq-3.rs
index b56f971db74..f04698100fc 100644
--- a/src/test/compile-fail/associated-types-eq-3.rs
+++ b/src/test/compile-fail/associated-types-eq-3.rs
@@ -18,7 +18,7 @@ pub trait Foo {
 
 struct Bar;
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
     fn boo(&self) -> uint {
         42
diff --git a/src/test/compile-fail/associated-types-eq-expr-path.rs b/src/test/compile-fail/associated-types-eq-expr-path.rs
index ef56fdeb051..90c4c97b5bd 100644
--- a/src/test/compile-fail/associated-types-eq-expr-path.rs
+++ b/src/test/compile-fail/associated-types-eq-expr-path.rs
@@ -12,15 +12,15 @@
 
 trait Foo {
     type A;
-    fn bar() -> int;
+    fn bar() -> isize;
 }
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
-    fn bar() -> int { 42 }
+    fn bar() -> isize { 42 }
 }
 
 pub fn main() {
-    let x: int = Foo::<A=uint>::bar();
+    let x: isize = Foo::<A=uint>::bar();
     //~^ERROR unexpected binding of associated item in expression path
 }
diff --git a/src/test/compile-fail/associated-types-eq-hr.rs b/src/test/compile-fail/associated-types-eq-hr.rs
index 2532977b1ca..c180e2f6112 100644
--- a/src/test/compile-fail/associated-types-eq-hr.rs
+++ b/src/test/compile-fail/associated-types-eq-hr.rs
@@ -17,43 +17,43 @@ pub trait TheTrait<T> {
 }
 
 struct IntStruct {
-    x: int
+    x: isize
 }
 
-impl<'a> TheTrait<&'a int> for IntStruct {
-    type A = &'a int;
+impl<'a> TheTrait<&'a isize> for IntStruct {
+    type A = &'a isize;
 
-    fn get(&self, t: &'a int) -> &'a int {
+    fn get(&self, t: &'a isize) -> &'a isize {
         t
     }
 }
 
 struct UintStruct {
-    x: int
+    x: isize
 }
 
-impl<'a> TheTrait<&'a int> for UintStruct {
+impl<'a> TheTrait<&'a isize> for UintStruct {
     type A = &'a uint;
 
-    fn get(&self, t: &'a int) -> &'a uint {
+    fn get(&self, t: &'a isize) -> &'a uint {
         panic!()
     }
 }
 
 fn foo<T>()
-    where T : for<'x> TheTrait<&'x int, A = &'x int>
+    where T : for<'x> TheTrait<&'x isize, A = &'x isize>
 {
     // ok for IntStruct, but not UintStruct
 }
 
 fn bar<T>()
-    where T : for<'x> TheTrait<&'x int, A = &'x uint>
+    where T : for<'x> TheTrait<&'x isize, A = &'x uint>
 {
     // ok for UintStruct, but not IntStruct
 }
 
 fn baz<T>()
-    where T : for<'x,'y> TheTrait<&'x int, A = &'y int>
+    where T : for<'x,'y> TheTrait<&'x isize, A = &'y isize>
 {
     // not ok for either struct, due to the use of two lifetimes
 }
diff --git a/src/test/compile-fail/associated-types-incomplete-object.rs b/src/test/compile-fail/associated-types-incomplete-object.rs
index 371f97e867a..898403f1d61 100644
--- a/src/test/compile-fail/associated-types-incomplete-object.rs
+++ b/src/test/compile-fail/associated-types-incomplete-object.rs
@@ -19,7 +19,7 @@ pub trait Foo {
 
 struct Bar;
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
     type B = char;
     fn boo(&self) -> uint {
diff --git a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs
index 13f6dcc9fde..b6c4d59c848 100644
--- a/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs
+++ b/src/test/compile-fail/associated-types-invalid-trait-ref-issue-18865.rs
@@ -16,7 +16,7 @@ trait Foo<T> {
     fn get_bar(&self) -> Self::Bar;
 }
 
-fn f<T:Foo<int>>(t: &T) {
+fn f<T:Foo<isize>>(t: &T) {
     let u: <T as Foo<usize>>::Bar = t.get_bar();
     //~^ ERROR the trait `Foo<usize>` is not implemented for the type `T`
 }
diff --git a/src/test/compile-fail/associated-types-issue-17359.rs b/src/test/compile-fail/associated-types-issue-17359.rs
index 6c79105abee..fa09ae793bf 100644
--- a/src/test/compile-fail/associated-types-issue-17359.rs
+++ b/src/test/compile-fail/associated-types-issue-17359.rs
@@ -15,7 +15,7 @@ trait Trait {
     type Type;
 }
 
-impl Trait for int {}  //~ ERROR missing: `Type`
+impl Trait for isize {}  //~ ERROR missing: `Type`
 
 fn main() {}
 
diff --git a/src/test/compile-fail/associated-types-no-suitable-bound.rs b/src/test/compile-fail/associated-types-no-suitable-bound.rs
index 98f2355f9be..fd60896c298 100644
--- a/src/test/compile-fail/associated-types-no-suitable-bound.rs
+++ b/src/test/compile-fail/associated-types-no-suitable-bound.rs
@@ -14,7 +14,7 @@ trait Get {
 }
 
 struct Struct {
-    x: int,
+    x: isize,
 }
 
 impl Struct {
diff --git a/src/test/compile-fail/associated-types-path-2.rs b/src/test/compile-fail/associated-types-path-2.rs
index 9994a0c465f..4a9e0777697 100644
--- a/src/test/compile-fail/associated-types-path-2.rs
+++ b/src/test/compile-fail/associated-types-path-2.rs
@@ -14,7 +14,7 @@ pub trait Foo {
     type A;
 }
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
 }
 
@@ -45,7 +45,7 @@ pub fn f1_uint_int() {
 }
 
 pub fn f2_int() {
-    let _: int = f2(2is);
+    let _: isize = f2(2is);
     //~^ ERROR expected `isize`, found `usize`
 }
 
diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs b/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs
index c5245840c42..917c03fbf4b 100644
--- a/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs
+++ b/src/test/compile-fail/associated-types-project-from-hrtb-explicit.rs
@@ -17,7 +17,7 @@ pub trait Foo<T> {
     fn get(&self, t: T) -> Self::A;
 }
 
-fn foo2<I>(x: <I as for<'x> Foo<&'x int>>::A)
+fn foo2<I>(x: <I as for<'x> Foo<&'x isize>>::A)
     //~^ ERROR expected identifier, found keyword `for`
     //~| ERROR expected one of `::` or `>`
 {
diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs
index 1f1ab4ca4b6..285a77d6b65 100644
--- a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs
+++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn-body.rs
@@ -17,15 +17,15 @@ pub trait Foo<T> {
     fn get(&self, t: T) -> Self::A;
 }
 
-fn foo<'a, I : for<'x> Foo<&'x int>>(
-    x: <I as Foo<&'a int>>::A)
+fn foo<'a, I : for<'x> Foo<&'x isize>>(
+    x: <I as Foo<&'a isize>>::A)
 {
     let y: I::A = x;
 }
 
-fn bar<'a, 'b, I : for<'x> Foo<&'x int>>(
-    x: <I as Foo<&'a int>>::A,
-    y: <I as Foo<&'b int>>::A,
+fn bar<'a, 'b, I : for<'x> Foo<&'x isize>>(
+    x: <I as Foo<&'a isize>>::A,
+    y: <I as Foo<&'b isize>>::A,
     cond: bool)
 {
     // x and y here have two distinct lifetimes:
diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs
index 0920bfab32b..a79d5c4649a 100644
--- a/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs
+++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-fn.rs
@@ -17,7 +17,7 @@ pub trait Foo<T> {
     fn get(&self, t: T) -> Self::A;
 }
 
-fn foo2<I : for<'x> Foo<&'x int>>(
+fn foo2<I : for<'x> Foo<&'x isize>>(
     x: I::A)
     //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context
 {
@@ -28,15 +28,15 @@ fn foo2<I : for<'x> Foo<&'x int>>(
     // specifically for fn signatures.
 }
 
-fn foo3<I : for<'x> Foo<&'x int>>(
-    x: <I as Foo<&int>>::A)
+fn foo3<I : for<'x> Foo<&'x isize>>(
+    x: <I as Foo<&isize>>::A)
 {
     // OK, in this case we spelled out the precise regions involved, though we left one of
     // them anonymous.
 }
 
-fn foo4<'a, I : for<'x> Foo<&'x int>>(
-    x: <I as Foo<&'a int>>::A)
+fn foo4<'a, I : for<'x> Foo<&'x isize>>(
+    x: <I as Foo<&'a isize>>::A)
 {
     // OK, in this case we spelled out the precise regions involved.
 }
diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs
index 0acb0f4853b..44ad0bb0113 100644
--- a/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs
+++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-struct.rs
@@ -17,18 +17,18 @@ pub trait Foo<T> {
     fn get(&self, t: T) -> Self::A;
 }
 
-struct SomeStruct<I : for<'x> Foo<&'x int>> {
+struct SomeStruct<I : for<'x> Foo<&'x isize>> {
     field: I::A
     //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context
 }
 
-struct AnotherStruct<I : for<'x> Foo<&'x int>> {
-    field: <I as Foo<&int>>::A
+struct AnotherStruct<I : for<'x> Foo<&'x isize>> {
+    field: <I as Foo<&isize>>::A
     //~^ ERROR missing lifetime specifier
 }
 
-struct YetAnotherStruct<'a, I : for<'x> Foo<&'x int>> {
-    field: <I as Foo<&'a int>>::A
+struct YetAnotherStruct<'a, I : for<'x> Foo<&'x isize>> {
+    field: <I as Foo<&'a isize>>::A
 }
 
 pub fn main() {}
diff --git a/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs b/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs
index 21e92c53058..af46a1b42d0 100644
--- a/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs
+++ b/src/test/compile-fail/associated-types-project-from-hrtb-in-trait-method.rs
@@ -17,17 +17,17 @@ pub trait Foo<T> {
     fn get(&self, t: T) -> Self::A;
 }
 
-trait SomeTrait<I : for<'x> Foo<&'x int>> {
+trait SomeTrait<I : for<'x> Foo<&'x isize>> {
     fn some_method(&self, arg: I::A);
     //~^ ERROR cannot extract an associated type from a higher-ranked trait bound in this context
 }
 
-trait AnotherTrait<I : for<'x> Foo<&'x int>> {
-    fn some_method(&self, arg: <I as Foo<&int>>::A);
+trait AnotherTrait<I : for<'x> Foo<&'x isize>> {
+    fn some_method(&self, arg: <I as Foo<&isize>>::A);
 }
 
-trait YetAnotherTrait<I : for<'x> Foo<&'x int>> {
-    fn some_method<'a>(&self, arg: <I as Foo<&'a int>>::A);
+trait YetAnotherTrait<I : for<'x> Foo<&'x isize>> {
+    fn some_method<'a>(&self, arg: <I as Foo<&'a isize>>::A);
 }
 
 pub fn main() {}
diff --git a/src/test/compile-fail/associated-types-unconstrained.rs b/src/test/compile-fail/associated-types-unconstrained.rs
index 96863466944..8b80ab92e07 100644
--- a/src/test/compile-fail/associated-types-unconstrained.rs
+++ b/src/test/compile-fail/associated-types-unconstrained.rs
@@ -12,15 +12,15 @@
 
 trait Foo {
     type A;
-    fn bar() -> int;
+    fn bar() -> isize;
 }
 
-impl Foo for int {
+impl Foo for isize {
     type A = uint;
-    fn bar() -> int { 42 }
+    fn bar() -> isize { 42 }
 }
 
 pub fn main() {
-    let x: int = Foo::bar();
+    let x: isize = Foo::bar();
     //~^ ERROR type annotations required
 }
diff --git a/src/test/compile-fail/auto-ref-slice-plus-ref.rs b/src/test/compile-fail/auto-ref-slice-plus-ref.rs
index fb935cf1030..ad3f467a454 100644
--- a/src/test/compile-fail/auto-ref-slice-plus-ref.rs
+++ b/src/test/compile-fail/auto-ref-slice-plus-ref.rs
@@ -27,7 +27,7 @@ trait MyIter {
     fn test(&self);
 }
 
-impl<'a> MyIter for &'a [int] {
+impl<'a> MyIter for &'a [isize] {
     fn test_mut(&mut self) { }
     fn test(&self) { }
 }
diff --git a/src/test/compile-fail/autoderef-full-lval.rs b/src/test/compile-fail/autoderef-full-lval.rs
index fb58028658e..2c5749e0d5d 100644
--- a/src/test/compile-fail/autoderef-full-lval.rs
+++ b/src/test/compile-fail/autoderef-full-lval.rs
@@ -28,7 +28,7 @@ fn main() {
     assert_eq!(z, 21);
     let forty: fish = fish{a: box 40};
     let two: fish = fish{a: box 2};
-    let answer: int = forty.a + two.a;
+    let answer: isize = forty.a + two.a;
     //~^ ERROR binary operation `+` cannot be applied to type `Box<isize>`
     println!("{}", answer);
     assert_eq!(answer, 42);
diff --git a/src/test/compile-fail/bad-env-capture.rs b/src/test/compile-fail/bad-env-capture.rs
index ac5a4c220a4..93866488732 100644
--- a/src/test/compile-fail/bad-env-capture.rs
+++ b/src/test/compile-fail/bad-env-capture.rs
@@ -10,7 +10,7 @@
 
 // error-pattern: can't capture dynamic environment in a fn item;
 fn foo() {
-    let x: int;
+    let x: isize;
     fn bar() { log(debug, x); }
 }
 fn main() { foo(); }
diff --git a/src/test/compile-fail/bad-env-capture2.rs b/src/test/compile-fail/bad-env-capture2.rs
index c97069acd9a..39a6922cfd0 100644
--- a/src/test/compile-fail/bad-env-capture2.rs
+++ b/src/test/compile-fail/bad-env-capture2.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // error-pattern: can't capture dynamic environment in a fn item;
-fn foo(x: int) {
+fn foo(x: isize) {
     fn bar() { log(debug, x); }
 }
 fn main() { foo(2); }
diff --git a/src/test/compile-fail/bad-env-capture3.rs b/src/test/compile-fail/bad-env-capture3.rs
index e3a6ac2cdfc..8857b94ddce 100644
--- a/src/test/compile-fail/bad-env-capture3.rs
+++ b/src/test/compile-fail/bad-env-capture3.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 // error-pattern: can't capture dynamic environment in a fn item;
-fn foo(x: int) {
+fn foo(x: isize) {
     fn mth() {
         fn bar() { log(debug, x); }
     }
diff --git a/src/test/compile-fail/bad-main.rs b/src/test/compile-fail/bad-main.rs
index da8596fa25b..321dca89891 100644
--- a/src/test/compile-fail/bad-main.rs
+++ b/src/test/compile-fail/bad-main.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn main(x: int) { } //~ ERROR: main function expects type
+fn main(x: isize) { } //~ ERROR: main function expects type
diff --git a/src/test/compile-fail/bad-match.rs b/src/test/compile-fail/bad-match.rs
index 728b577df1d..33043ff5524 100644
--- a/src/test/compile-fail/bad-match.rs
+++ b/src/test/compile-fail/bad-match.rs
@@ -11,7 +11,7 @@
 // error-pattern: expected
 
 fn main() {
-  let int x = 5;
+  let isize x = 5;
   match x;
 }
 
diff --git a/src/test/compile-fail/bad-mid-path-type-params.rs b/src/test/compile-fail/bad-mid-path-type-params.rs
index 3a2a7558657..79fe4e7165e 100644
--- a/src/test/compile-fail/bad-mid-path-type-params.rs
+++ b/src/test/compile-fail/bad-mid-path-type-params.rs
@@ -33,11 +33,11 @@ trait Trait<T> {
 }
 
 struct S2 {
-    contents: int,
+    contents: isize,
 }
 
-impl Trait<int> for S2 {
-    fn new<U>(x: int, _: U) -> S2 {
+impl Trait<isize> for S2 {
+    fn new<U>(x: isize, _: U) -> S2 {
         S2 {
             contents: x,
         }
@@ -45,16 +45,16 @@ impl Trait<int> for S2 {
 }
 
 fn foo<'a>() {
-    let _ = S::new::<int,f64>(1, 1.0);
+    let _ = S::new::<isize,f64>(1, 1.0);
     //~^ ERROR too many type parameters provided
 
-    let _ = S::<'a,int>::new::<f64>(1, 1.0);
+    let _ = S::<'a,isize>::new::<f64>(1, 1.0);
     //~^ ERROR too many lifetime parameters provided
 
-    let _: S2 = Trait::new::<int,f64>(1, 1.0);
+    let _: S2 = Trait::new::<isize,f64>(1, 1.0);
     //~^ ERROR too many type parameters provided
 
-    let _: S2 = Trait::<'a,int>::new::<f64>(1, 1.0);
+    let _: S2 = Trait::<'a,isize>::new::<f64>(1, 1.0);
     //~^ ERROR too many lifetime parameters provided
 }
 
diff --git a/src/test/compile-fail/bad-name.rs b/src/test/compile-fail/bad-name.rs
index e320d5918b6..b208c6f4244 100644
--- a/src/test/compile-fail/bad-name.rs
+++ b/src/test/compile-fail/bad-name.rs
@@ -11,5 +11,5 @@
 // error-pattern: expected
 
 fn main() {
-  let x.y::<int>.z foo;
+  let x.y::<isize>.z foo;
 }
diff --git a/src/test/compile-fail/better-expected.rs b/src/test/compile-fail/better-expected.rs
index 672d8a30fc5..0d84a5e7d02 100644
--- a/src/test/compile-fail/better-expected.rs
+++ b/src/test/compile-fail/better-expected.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let x: [int 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `3`
+    let x: [isize 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `3`
 }
diff --git a/src/test/compile-fail/bind-struct-early-modifiers.rs b/src/test/compile-fail/bind-struct-early-modifiers.rs
index 3671cf110d8..375f6c5d047 100644
--- a/src/test/compile-fail/bind-struct-early-modifiers.rs
+++ b/src/test/compile-fail/bind-struct-early-modifiers.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    struct Foo { x: int }
+    struct Foo { x: isize }
     match (Foo { x: 10 }) {
         Foo { ref x: ref x } => {}, //~ ERROR unexpected `:`
         _ => {}
diff --git a/src/test/compile-fail/bogus-tag.rs b/src/test/compile-fail/bogus-tag.rs
index cc0ed214103..704d856f106 100644
--- a/src/test/compile-fail/bogus-tag.rs
+++ b/src/test/compile-fail/bogus-tag.rs
@@ -11,7 +11,7 @@
 
 // error-pattern: unresolved
 
-enum color { rgb(int, int, int), rgba(int, int, int, int), }
+enum color { rgb(isize, isize, isize), rgba(isize, isize, isize, isize), }
 
 fn main() {
     let red: color = rgb(255, 0, 0);
diff --git a/src/test/compile-fail/borrow-tuple-fields.rs b/src/test/compile-fail/borrow-tuple-fields.rs
index 59ed0e5fa06..63fd3c60e8c 100644
--- a/src/test/compile-fail/borrow-tuple-fields.rs
+++ b/src/test/compile-fail/borrow-tuple-fields.rs
@@ -11,9 +11,9 @@
 #![allow(unknown_features)]
 #![feature(box_syntax)]
 
-struct Foo(Box<int>, int);
+struct Foo(Box<isize>, isize);
 
-struct Bar(int, int);
+struct Bar(isize, isize);
 
 fn main() {
     let x = (box 1i, 2i);
diff --git a/src/test/compile-fail/borrowck-and-init.rs b/src/test/compile-fail/borrowck-and-init.rs
index 0f07cab3acc..92f16d8ffce 100644
--- a/src/test/compile-fail/borrowck-and-init.rs
+++ b/src/test/compile-fail/borrowck-and-init.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let i: int;
+    let i: isize;
 
     println!("{}", false && { i = 5; true });
     println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
diff --git a/src/test/compile-fail/borrowck-assign-comp-idx.rs b/src/test/compile-fail/borrowck-assign-comp-idx.rs
index a6801a6a51a..3a2c6f03851 100644
--- a/src/test/compile-fail/borrowck-assign-comp-idx.rs
+++ b/src/test/compile-fail/borrowck-assign-comp-idx.rs
@@ -9,22 +9,22 @@
 // except according to those terms.
 
 struct Point {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 fn a() {
     let mut p = vec!(1);
 
     // Create an immutable pointer into p's contents:
-    let q: &int = &p[0];
+    let q: &isize = &p[0];
 
     p[0] = 5; //~ ERROR cannot borrow
 
     println!("{}", *q);
 }
 
-fn borrow<F>(_x: &[int], _f: F) where F: FnOnce() {}
+fn borrow<F>(_x: &[isize], _f: F) where F: FnOnce() {}
 
 fn b() {
     // here we alias the mutable vector into an imm slice and try to
diff --git a/src/test/compile-fail/borrowck-assign-comp.rs b/src/test/compile-fail/borrowck-assign-comp.rs
index ccd0542ca7f..802b83119b7 100644
--- a/src/test/compile-fail/borrowck-assign-comp.rs
+++ b/src/test/compile-fail/borrowck-assign-comp.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct point { x: int, y: int }
+struct point { x: isize, y: isize }
 
 fn a() {
     let mut p = point {x: 3, y: 4};
@@ -16,7 +16,7 @@ fn a() {
 
     // This assignment is illegal because the field x is not
     // inherently mutable; since `p` was made immutable, `p.x` is now
-    // immutable.  Otherwise the type of &_q.x (&int) would be wrong.
+    // immutable.  Otherwise the type of &_q.x (&isize) would be wrong.
     p.x = 5; //~ ERROR cannot assign to `p.x`
     q.x;
 }
diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs
index 3fa840f6a4e..d66cdb99a74 100644
--- a/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs
+++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-aliasable-loc.rs
@@ -12,7 +12,7 @@
 // borrowed (but otherwise non-aliasable) location is illegal.
 
 struct S<'a> {
-    pointer: &'a mut int
+    pointer: &'a mut isize
 }
 
 fn a(s: &S) {
diff --git a/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs
index ccbbc2ea6c3..77aa57ef1b5 100644
--- a/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs
+++ b/src/test/compile-fail/borrowck-assign-to-andmut-in-borrowed-loc.rs
@@ -12,7 +12,7 @@
 // borrowed (but otherwise non-aliasable) location is illegal.
 
 struct S<'a> {
-    pointer: &'a mut int
+    pointer: &'a mut isize
 }
 
 fn copy_borrowed_ptr<'a>(p: &'a mut S<'a>) -> S<'a> {
diff --git a/src/test/compile-fail/borrowck-assign-to-constants.rs b/src/test/compile-fail/borrowck-assign-to-constants.rs
index c0fb24c83e3..1b5b1899e0d 100644
--- a/src/test/compile-fail/borrowck-assign-to-constants.rs
+++ b/src/test/compile-fail/borrowck-assign-to-constants.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static foo: int = 5;
+static foo: isize = 5;
 
 fn main() {
     // assigning to various global constants
diff --git a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs
index dcfef4e1d9c..ea020dc0685 100644
--- a/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs
+++ b/src/test/compile-fail/borrowck-auto-mut-ref-to-immut-var.rs
@@ -11,7 +11,7 @@
 // Tests that auto-ref can't create mutable aliases to immutable memory.
 
 struct Foo {
-    x: int
+    x: isize
 }
 
 impl Foo {
diff --git a/src/test/compile-fail/borrowck-block-unint.rs b/src/test/compile-fail/borrowck-block-unint.rs
index e519e57d178..a09ee439245 100644
--- a/src/test/compile-fail/borrowck-block-unint.rs
+++ b/src/test/compile-fail/borrowck-block-unint.rs
@@ -10,7 +10,7 @@
 
 fn force<F>(f: F) where F: FnOnce() { f(); }
 fn main() {
-    let x: int;
+    let x: isize;
     force(|| {  //~ ERROR capture of possibly uninitialized variable: `x`
         println!("{}", x);
     });
diff --git a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
index d5998c8ca99..397c55a502a 100644
--- a/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
+++ b/src/test/compile-fail/borrowck-borrow-from-owned-ptr.rs
@@ -17,8 +17,8 @@ struct Foo {
 impl Copy for Foo {}
 
 struct Bar {
-  int1: int,
-  int2: int,
+  int1: isize,
+  int2: isize,
 }
 
 impl Copy for Bar {}
diff --git a/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs b/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs
index d252d442297..ae4c09c59d7 100644
--- a/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs
+++ b/src/test/compile-fail/borrowck-borrow-from-stack-variable.rs
@@ -16,8 +16,8 @@ struct Foo {
 impl Copy for Foo {}
 
 struct Bar {
-  int1: int,
-  int2: int,
+  int1: isize,
+  int2: isize,
 }
 
 impl Copy for Bar {}
diff --git a/src/test/compile-fail/borrowck-borrow-from-temporary.rs b/src/test/compile-fail/borrowck-borrow-from-temporary.rs
index 784bd1e8ae4..fbb3824cd40 100644
--- a/src/test/compile-fail/borrowck-borrow-from-temporary.rs
+++ b/src/test/compile-fail/borrowck-borrow-from-temporary.rs
@@ -11,9 +11,9 @@
 // Test lifetimes are linked properly when we take reference
 // to interior.
 
-struct Foo(int);
+struct Foo(isize);
 
-fn foo<'a>() -> &'a int {
+fn foo<'a>() -> &'a isize {
     let &Foo(ref x) = &Foo(3); //~ ERROR borrowed value does not live long enough
     x
 }
diff --git a/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs b/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs
index 7bee06b7804..9126058a4e6 100644
--- a/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs
+++ b/src/test/compile-fail/borrowck-borrow-mut-base-ptr-in-aliasable-loc.rs
@@ -13,20 +13,20 @@
 //
 // Example from src/middle/borrowck/doc.rs
 
-fn foo(t0: & &mut int) {
+fn foo(t0: & &mut isize) {
     let t1 = t0;
-    let p: &int = &**t0;
+    let p: &isize = &**t0;
     **t1 = 22; //~ ERROR cannot assign
 }
 
-fn foo3(t0: &mut &mut int) {
+fn foo3(t0: &mut &mut isize) {
     let t1 = &mut *t0;
-    let p: &int = &**t0; //~ ERROR cannot borrow
+    let p: &isize = &**t0; //~ ERROR cannot borrow
     **t1 = 22;
 }
 
-fn foo4(t0: & &mut int) {
-    let x:  &mut int = &mut **t0; //~ ERROR cannot borrow
+fn foo4(t0: & &mut isize) {
+    let x:  &mut isize = &mut **t0; //~ ERROR cannot borrow
     *x += 1;
 }
 
diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
index 66bcfc23808..5db9ad2e3a4 100644
--- a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
+++ b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref-mut.rs
@@ -32,25 +32,25 @@ impl<T> DerefMut for Own<T> {
 }
 
 struct Point {
-    x: int,
-    y: int
+    x: isize,
+    y: isize
 }
 
 impl Point {
-    fn get(&self) -> (int, int) {
+    fn get(&self) -> (isize, isize) {
         (self.x, self.y)
     }
 
-    fn set(&mut self, x: int, y: int) {
+    fn set(&mut self, x: isize, y: isize) {
         self.x = x;
         self.y = y;
     }
 
-    fn x_ref(&self) -> &int {
+    fn x_ref(&self) -> &isize {
         &self.x
     }
 
-    fn y_mut(&mut self) -> &mut int {
+    fn y_mut(&mut self) -> &mut isize {
         &mut self.y
     }
 }
@@ -67,15 +67,15 @@ fn deref_mut_field2(mut x: Own<Point>) {
     let _i = &mut x.y;
 }
 
-fn deref_extend_field(x: &Own<Point>) -> &int {
+fn deref_extend_field(x: &Own<Point>) -> &isize {
     &x.y
 }
 
-fn deref_extend_mut_field1(x: &Own<Point>) -> &mut int {
+fn deref_extend_mut_field1(x: &Own<Point>) -> &mut isize {
     &mut x.y //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut_field2(x: &mut Own<Point>) -> &mut int {
+fn deref_extend_mut_field2(x: &mut Own<Point>) -> &mut isize {
     &mut x.y
 }
 
@@ -126,15 +126,15 @@ fn deref_mut_method2(mut x: Own<Point>) {
     x.set(0, 0);
 }
 
-fn deref_extend_method(x: &Own<Point>) -> &int {
+fn deref_extend_method(x: &Own<Point>) -> &isize {
     x.x_ref()
 }
 
-fn deref_extend_mut_method1(x: &Own<Point>) -> &mut int {
+fn deref_extend_mut_method1(x: &Own<Point>) -> &mut isize {
     x.y_mut() //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut_method2(x: &mut Own<Point>) -> &mut int {
+fn deref_extend_mut_method2(x: &mut Own<Point>) -> &mut isize {
     x.y_mut()
 }
 
diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs
index abab9e57ffe..75680de9c9e 100644
--- a/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs
+++ b/src/test/compile-fail/borrowck-borrow-overloaded-auto-deref.rs
@@ -26,25 +26,25 @@ impl<T> Deref for Rc<T> {
 }
 
 struct Point {
-    x: int,
-    y: int
+    x: isize,
+    y: isize
 }
 
 impl Point {
-    fn get(&self) -> (int, int) {
+    fn get(&self) -> (isize, isize) {
         (self.x, self.y)
     }
 
-    fn set(&mut self, x: int, y: int) {
+    fn set(&mut self, x: isize, y: isize) {
         self.x = x;
         self.y = y;
     }
 
-    fn x_ref(&self) -> &int {
+    fn x_ref(&self) -> &isize {
         &self.x
     }
 
-    fn y_mut(&mut self) -> &mut int {
+    fn y_mut(&mut self) -> &mut isize {
         &mut self.y
     }
 }
@@ -61,15 +61,15 @@ fn deref_mut_field2(mut x: Rc<Point>) {
     let _i = &mut x.y; //~ ERROR cannot borrow
 }
 
-fn deref_extend_field(x: &Rc<Point>) -> &int {
+fn deref_extend_field(x: &Rc<Point>) -> &isize {
     &x.y
 }
 
-fn deref_extend_mut_field1(x: &Rc<Point>) -> &mut int {
+fn deref_extend_mut_field1(x: &Rc<Point>) -> &mut isize {
     &mut x.y //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut_field2(x: &mut Rc<Point>) -> &mut int {
+fn deref_extend_mut_field2(x: &mut Rc<Point>) -> &mut isize {
     &mut x.y //~ ERROR cannot borrow
 }
 
@@ -97,15 +97,15 @@ fn deref_mut_method2(mut x: Rc<Point>) {
     x.set(0, 0); //~ ERROR cannot borrow
 }
 
-fn deref_extend_method(x: &Rc<Point>) -> &int {
+fn deref_extend_method(x: &Rc<Point>) -> &isize {
     x.x_ref()
 }
 
-fn deref_extend_mut_method1(x: &Rc<Point>) -> &mut int {
+fn deref_extend_mut_method1(x: &Rc<Point>) -> &mut isize {
     x.y_mut() //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut_method2(x: &mut Rc<Point>) -> &mut int {
+fn deref_extend_mut_method2(x: &mut Rc<Point>) -> &mut isize {
     x.y_mut() //~ ERROR cannot borrow
 }
 
diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs b/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs
index dda7e4d1047..bfe53b739f4 100644
--- a/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs
+++ b/src/test/compile-fail/borrowck-borrow-overloaded-deref-mut.rs
@@ -31,39 +31,39 @@ impl<T> DerefMut for Own<T> {
     }
 }
 
-fn deref_imm(x: Own<int>) {
+fn deref_imm(x: Own<isize>) {
     let _i = &*x;
 }
 
-fn deref_mut1(x: Own<int>) {
+fn deref_mut1(x: Own<isize>) {
     let _i = &mut *x; //~ ERROR cannot borrow
 }
 
-fn deref_mut2(mut x: Own<int>) {
+fn deref_mut2(mut x: Own<isize>) {
     let _i = &mut *x;
 }
 
-fn deref_extend<'a>(x: &'a Own<int>) -> &'a int {
+fn deref_extend<'a>(x: &'a Own<isize>) -> &'a isize {
     &**x
 }
 
-fn deref_extend_mut1<'a>(x: &'a Own<int>) -> &'a mut int {
+fn deref_extend_mut1<'a>(x: &'a Own<isize>) -> &'a mut isize {
     &mut **x //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut2<'a>(x: &'a mut Own<int>) -> &'a mut int {
+fn deref_extend_mut2<'a>(x: &'a mut Own<isize>) -> &'a mut isize {
     &mut **x
 }
 
-fn assign1<'a>(x: Own<int>) {
+fn assign1<'a>(x: Own<isize>) {
     *x = 3; //~ ERROR cannot borrow
 }
 
-fn assign2<'a>(x: &'a Own<int>) {
+fn assign2<'a>(x: &'a Own<isize>) {
     **x = 3; //~ ERROR cannot borrow
 }
 
-fn assign3<'a>(x: &'a mut Own<int>) {
+fn assign3<'a>(x: &'a mut Own<isize>) {
     **x = 3;
 }
 
diff --git a/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs b/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs
index 001a5232b12..153368f4894 100644
--- a/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs
+++ b/src/test/compile-fail/borrowck-borrow-overloaded-deref.rs
@@ -25,39 +25,39 @@ impl<T> Deref for Rc<T> {
     }
 }
 
-fn deref_imm(x: Rc<int>) {
+fn deref_imm(x: Rc<isize>) {
     let _i = &*x;
 }
 
-fn deref_mut1(x: Rc<int>) {
+fn deref_mut1(x: Rc<isize>) {
     let _i = &mut *x; //~ ERROR cannot borrow
 }
 
-fn deref_mut2(mut x: Rc<int>) {
+fn deref_mut2(mut x: Rc<isize>) {
     let _i = &mut *x; //~ ERROR cannot borrow
 }
 
-fn deref_extend<'a>(x: &'a Rc<int>) -> &'a int {
+fn deref_extend<'a>(x: &'a Rc<isize>) -> &'a isize {
     &**x
 }
 
-fn deref_extend_mut1<'a>(x: &'a Rc<int>) -> &'a mut int {
+fn deref_extend_mut1<'a>(x: &'a Rc<isize>) -> &'a mut isize {
     &mut **x //~ ERROR cannot borrow
 }
 
-fn deref_extend_mut2<'a>(x: &'a mut Rc<int>) -> &'a mut int {
+fn deref_extend_mut2<'a>(x: &'a mut Rc<isize>) -> &'a mut isize {
     &mut **x //~ ERROR cannot borrow
 }
 
-fn assign1<'a>(x: Rc<int>) {
+fn assign1<'a>(x: Rc<isize>) {
     *x = 3; //~ ERROR cannot assign
 }
 
-fn assign2<'a>(x: &'a Rc<int>) {
+fn assign2<'a>(x: &'a Rc<isize>) {
     **x = 3; //~ ERROR cannot assign
 }
 
-fn assign3<'a>(x: &'a mut Rc<int>) {
+fn assign3<'a>(x: &'a mut Rc<isize>) {
     **x = 3; //~ ERROR cannot assign
 }
 
diff --git a/src/test/compile-fail/borrowck-box-insensitivity.rs b/src/test/compile-fail/borrowck-box-insensitivity.rs
index bd22b61fe3b..648d0d81ffb 100644
--- a/src/test/compile-fail/borrowck-box-insensitivity.rs
+++ b/src/test/compile-fail/borrowck-box-insensitivity.rs
@@ -11,23 +11,23 @@
 #![feature(box_syntax)]
 
 struct A {
-    x: Box<int>,
-    y: int,
+    x: Box<isize>,
+    y: isize,
 }
 
 struct B {
-    x: Box<int>,
-    y: Box<int>,
+    x: Box<isize>,
+    y: Box<isize>,
 }
 
 struct C {
     x: Box<A>,
-    y: int,
+    y: isize,
 }
 
 struct D {
     x: Box<A>,
-    y: Box<int>,
+    y: Box<isize>,
 }
 
 fn copy_after_move() {
diff --git a/src/test/compile-fail/borrowck-break-uninit-2.rs b/src/test/compile-fail/borrowck-break-uninit-2.rs
index 0b10ccfdca1..1ecf9f999b7 100644
--- a/src/test/compile-fail/borrowck-break-uninit-2.rs
+++ b/src/test/compile-fail/borrowck-break-uninit-2.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo() -> int {
-    let x: int;
+fn foo() -> isize {
+    let x: isize;
 
     while 1i != 2  {
         break;
diff --git a/src/test/compile-fail/borrowck-break-uninit.rs b/src/test/compile-fail/borrowck-break-uninit.rs
index aa7ce4fa347..8a6a036945b 100644
--- a/src/test/compile-fail/borrowck-break-uninit.rs
+++ b/src/test/compile-fail/borrowck-break-uninit.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo() -> int {
-    let x: int;
+fn foo() -> isize {
+    let x: isize;
 
     loop {
         break;
diff --git a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
index 9aec8de46b6..6a77b35f91d 100644
--- a/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
+++ b/src/test/compile-fail/borrowck-call-is-borrow-issue-12224.rs
@@ -56,8 +56,8 @@ fn test6() {
 }
 
 fn test7() {
-    fn foo<F>(_: F) where F: FnMut(Box<FnMut(int)>, int) {}
-    let mut f = |&mut: g: Box<FnMut(int)>, b: int| {};
+    fn foo<F>(_: F) where F: FnMut(Box<FnMut(isize)>, isize) {}
+    let mut f = |&mut: g: Box<FnMut(isize)>, b: isize| {};
     f(box |a| { //~ ERROR: cannot borrow `f` as immutable because it is also borrowed as mutable
         foo(f); //~ ERROR: cannot move out of captured outer variable
     }, 3);
diff --git a/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs b/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs
index 537e52120d9..bc0b667e895 100644
--- a/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs
+++ b/src/test/compile-fail/borrowck-call-method-from-mut-aliasable.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 impl Foo {
diff --git a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
index 126003b5d82..14d57062660 100644
--- a/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-and-imm.rs
@@ -13,11 +13,11 @@
 
 #![feature(box_syntax)]
 
-fn get(x: &int) -> int {
+fn get(x: &isize) -> isize {
     *x
 }
 
-fn set(x: &mut int) {
+fn set(x: &mut isize) {
     *x = 4;
 }
 
@@ -59,7 +59,7 @@ fn f() {
 
 fn g() {
     struct Foo {
-        f: Box<int>
+        f: Box<isize>
     }
 
     let mut x = box Foo { f: box 3 };
@@ -69,7 +69,7 @@ fn g() {
 
 fn h() {
     struct Foo {
-        f: Box<int>
+        f: Box<isize>
     }
 
     let mut x = box Foo { f: box 3 };
diff --git a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
index 30e1421ba26..82607741909 100644
--- a/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-mut-of-imm.rs
@@ -11,15 +11,15 @@
 // Tests that two closures cannot simultaneously have mutable
 // and immutable access to the variable. Issue #6801.
 
-fn get(x: &int) -> int {
+fn get(x: &isize) -> isize {
     *x
 }
 
-fn set(x: &mut int) {
+fn set(x: &mut isize) {
     *x = 4;
 }
 
-fn a(x: &int) {
+fn a(x: &isize) {
     let c1 = |&mut:| set(&mut *x);
     //~^ ERROR cannot borrow
     let c2 = |&mut:| set(&mut *x);
diff --git a/src/test/compile-fail/borrowck-closures-two-mut.rs b/src/test/compile-fail/borrowck-closures-two-mut.rs
index e1f557cfab2..d442e3ac3f8 100644
--- a/src/test/compile-fail/borrowck-closures-two-mut.rs
+++ b/src/test/compile-fail/borrowck-closures-two-mut.rs
@@ -20,7 +20,7 @@ fn a() {
     let c2 = |&mut:| x = 5; //~ ERROR cannot borrow `x` as mutable more than once
 }
 
-fn set(x: &mut int) {
+fn set(x: &mut isize) {
     *x = 4;
 }
 
@@ -45,7 +45,7 @@ fn d() {
 
 fn g() {
     struct Foo {
-        f: Box<int>
+        f: Box<isize>
     }
 
     let mut x = box Foo { f: box 3 };
diff --git a/src/test/compile-fail/borrowck-closures-unique-imm.rs b/src/test/compile-fail/borrowck-closures-unique-imm.rs
index a9cc9e967f6..cf86602af0b 100644
--- a/src/test/compile-fail/borrowck-closures-unique-imm.rs
+++ b/src/test/compile-fail/borrowck-closures-unique-imm.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/borrowck-closures-unique.rs b/src/test/compile-fail/borrowck-closures-unique.rs
index 9a772cc49b8..f9a6d5ac845 100644
--- a/src/test/compile-fail/borrowck-closures-unique.rs
+++ b/src/test/compile-fail/borrowck-closures-unique.rs
@@ -14,35 +14,35 @@
 //  may be *immutable*, but we cannot allow
 // multiple borrows.
 
-fn get(x: &int) -> int {
+fn get(x: &isize) -> isize {
     *x
 }
 
-fn set(x: &mut int) -> int {
+fn set(x: &mut isize) -> isize {
     *x
 }
 
-fn a(x: &mut int) {
+fn a(x: &mut isize) {
     let c1 = |&mut:| get(x);
     let c2 = |&mut:| get(x);
 }
 
-fn b(x: &mut int) {
+fn b(x: &mut isize) {
     let c1 = |&mut:| get(x);
     let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x`
 }
 
-fn c(x: &mut int) {
+fn c(x: &mut isize) {
     let c1 = |&mut:| get(x);
     let c2 = |&mut:| { get(x); set(x); }; //~ ERROR closure requires unique access to `x`
 }
 
-fn d(x: &mut int) {
+fn d(x: &mut isize) {
     let c1 = |&mut:| set(x);
     let c2 = |&mut:| set(x); //~ ERROR closure requires unique access to `x`
 }
 
-fn e(x: &mut int) {
+fn e(x: &mut isize) {
     let c1 = |&mut:| x = panic!(); //~ ERROR closure cannot assign to immutable local variable
 }
 
diff --git a/src/test/compile-fail/borrowck-closures-use-after-free.rs b/src/test/compile-fail/borrowck-closures-use-after-free.rs
index 9aa9a50483c..b6529da1883 100644
--- a/src/test/compile-fail/borrowck-closures-use-after-free.rs
+++ b/src/test/compile-fail/borrowck-closures-use-after-free.rs
@@ -15,7 +15,7 @@
 #![feature(box_syntax)]
 
 struct Foo {
-  x: int
+  x: isize
 }
 
 impl Drop for Foo {
diff --git a/src/test/compile-fail/borrowck-field-sensitivity.rs b/src/test/compile-fail/borrowck-field-sensitivity.rs
index 52761fa3488..fe5142a7734 100644
--- a/src/test/compile-fail/borrowck-field-sensitivity.rs
+++ b/src/test/compile-fail/borrowck-field-sensitivity.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-struct A { a: int, b: Box<int> }
+struct A { a: isize, b: Box<isize> }
 
 fn deref_after_move() {
     let x = A { a: 1, b: box 2 };
diff --git a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
index bdcbc839c00..17c69a40e58 100644
--- a/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
+++ b/src/test/compile-fail/borrowck-for-loop-correct-cmt-for-pattern.rs
@@ -13,7 +13,7 @@
 #![feature(box_syntax)]
 
 struct Foo {
-    a: [Box<int>; 3],
+    a: [Box<isize>; 3],
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-if-no-else.rs b/src/test/compile-fail/borrowck-if-no-else.rs
index 854d42219ea..08f91e729cd 100644
--- a/src/test/compile-fail/borrowck-if-no-else.rs
+++ b/src/test/compile-fail/borrowck-if-no-else.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 fn main() {
-    let x: int; if 1i > 2 { x = 10; }
+    let x: isize; if 1i > 2 { x = 10; }
     foo(x); //~ ERROR use of possibly uninitialized variable: `x`
 }
diff --git a/src/test/compile-fail/borrowck-if-with-else.rs b/src/test/compile-fail/borrowck-if-with-else.rs
index e6d59062af2..01e292ec89d 100644
--- a/src/test/compile-fail/borrowck-if-with-else.rs
+++ b/src/test/compile-fail/borrowck-if-with-else.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 fn main() {
-    let x: int;
+    let x: isize;
     if 1i > 2 {
         println!("whoops");
     } else {
diff --git a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
index 5496a9dd4b3..3c20abab8bd 100644
--- a/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
+++ b/src/test/compile-fail/borrowck-init-in-called-fn-expr.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    let j = |&:| -> int {
-        let i: int;
+    let j = |&:| -> isize {
+        let i: isize;
         i //~ ERROR use of possibly uninitialized variable: `i`
     };
     j();
diff --git a/src/test/compile-fail/borrowck-init-in-fn-expr.rs b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
index 33c284c71b3..31ca39c3f9b 100644
--- a/src/test/compile-fail/borrowck-init-in-fn-expr.rs
+++ b/src/test/compile-fail/borrowck-init-in-fn-expr.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    let f  = |&:| -> int {
-        let i: int;
+    let f  = |&:| -> isize {
+        let i: isize;
         i //~ ERROR use of possibly uninitialized variable: `i`
     };
     println!("{}", f());
diff --git a/src/test/compile-fail/borrowck-init-in-fru.rs b/src/test/compile-fail/borrowck-init-in-fru.rs
index ac90b7cb432..569ddb80c2f 100644
--- a/src/test/compile-fail/borrowck-init-in-fru.rs
+++ b/src/test/compile-fail/borrowck-init-in-fru.rs
@@ -10,8 +10,8 @@
 
 #[derive(Clone)]
 struct point {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-init-op-equal.rs b/src/test/compile-fail/borrowck-init-op-equal.rs
index d6065c81a2d..e0d93fd1d47 100644
--- a/src/test/compile-fail/borrowck-init-op-equal.rs
+++ b/src/test/compile-fail/borrowck-init-op-equal.rs
@@ -10,7 +10,7 @@
 
 
 fn test() {
-    let v: int;
+    let v: isize;
     v += 1; //~ ERROR use of possibly uninitialized variable: `v`
     v.clone();
 }
diff --git a/src/test/compile-fail/borrowck-init-plus-equal.rs b/src/test/compile-fail/borrowck-init-plus-equal.rs
index 6e813809f03..a036286f363 100644
--- a/src/test/compile-fail/borrowck-init-plus-equal.rs
+++ b/src/test/compile-fail/borrowck-init-plus-equal.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn test() {
-    let mut v: int;
+    let mut v: isize;
     v = v + 1; //~ ERROR use of possibly uninitialized variable: `v`
     v.clone();
 }
diff --git a/src/test/compile-fail/borrowck-insert-during-each.rs b/src/test/compile-fail/borrowck-insert-during-each.rs
index 0428ee83065..d729af844cb 100644
--- a/src/test/compile-fail/borrowck-insert-during-each.rs
+++ b/src/test/compile-fail/borrowck-insert-during-each.rs
@@ -12,11 +12,11 @@ extern crate collections;
 use std::collections::HashSet;
 
 struct Foo {
-  n: HashSet<int>,
+  n: HashSet<isize>,
 }
 
 impl Foo {
-    pub fn foo<F>(&mut self, mut fun: F) where F: FnMut(&int) {
+    pub fn foo<F>(&mut self, mut fun: F) where F: FnMut(&isize) {
         for f in self.n.iter() {
             fun(f);
         }
diff --git a/src/test/compile-fail/borrowck-issue-14498.rs b/src/test/compile-fail/borrowck-issue-14498.rs
index 8e46db5eba8..cc562afa9f8 100644
--- a/src/test/compile-fail/borrowck-issue-14498.rs
+++ b/src/test/compile-fail/borrowck-issue-14498.rs
@@ -13,11 +13,11 @@
 
 #![feature(box_syntax)]
 
-struct A { a: int }
-struct B<'a> { a: Box<&'a mut int> }
+struct A { a: isize }
+struct B<'a> { a: Box<&'a mut isize> }
 
 fn borrow_in_var_from_var() {
-    let mut x: int = 1;
+    let mut x: isize = 1;
     let y = box &mut x;
     let p = &y;
     let q = &***p;
@@ -37,7 +37,7 @@ fn borrow_in_var_from_field() {
 }
 
 fn borrow_in_field_from_var() {
-    let mut x: int = 1;
+    let mut x: isize = 1;
     let y = B { a: box &mut x };
     let p = &y.a;
     let q = &***p;
diff --git a/src/test/compile-fail/borrowck-lend-flow-if.rs b/src/test/compile-fail/borrowck-lend-flow-if.rs
index 8a618dfec11..ca8efb5dc96 100644
--- a/src/test/compile-fail/borrowck-lend-flow-if.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-if.rs
@@ -16,13 +16,13 @@
 
 #![feature(box_syntax)]
 
-fn borrow(_v: &int) {}
-fn borrow_mut(_v: &mut int) {}
+fn borrow(_v: &isize) {}
+fn borrow_mut(_v: &mut isize) {}
 fn cond() -> bool { panic!() }
 fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
-fn inc(v: &mut Box<int>) {
+fn inc(v: &mut Box<isize>) {
     *v = box() (**v + 1);
 }
 
diff --git a/src/test/compile-fail/borrowck-lend-flow-loop.rs b/src/test/compile-fail/borrowck-lend-flow-loop.rs
index 954b8010244..83fddcf6964 100644
--- a/src/test/compile-fail/borrowck-lend-flow-loop.rs
+++ b/src/test/compile-fail/borrowck-lend-flow-loop.rs
@@ -16,12 +16,12 @@
 
 #![feature(box_syntax)]
 
-fn borrow(_v: &int) {}
-fn borrow_mut(_v: &mut int) {}
+fn borrow(_v: &isize) {}
+fn borrow_mut(_v: &mut isize) {}
 fn cond() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
-fn inc(v: &mut Box<int>) {
+fn inc(v: &mut Box<isize>) {
     *v = box() (**v + 1);
 }
 
diff --git a/src/test/compile-fail/borrowck-lend-flow.rs b/src/test/compile-fail/borrowck-lend-flow.rs
index d5419b05851..177976c15f0 100644
--- a/src/test/compile-fail/borrowck-lend-flow.rs
+++ b/src/test/compile-fail/borrowck-lend-flow.rs
@@ -16,13 +16,13 @@
 
 #![feature(box_syntax)]
 
-fn borrow(_v: &int) {}
-fn borrow_mut(_v: &mut int) {}
+fn borrow(_v: &isize) {}
+fn borrow_mut(_v: &mut isize) {}
 fn cond() -> bool { panic!() }
 fn for_func<F>(_f: F) where F: FnOnce() -> bool { panic!() }
 fn produce<T>() -> T { panic!(); }
 
-fn inc(v: &mut Box<int>) {
+fn inc(v: &mut Box<isize>) {
     *v = box() (**v + 1);
 }
 
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
index 8b39b6ff661..8906e2d42b2 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move-cc.rs
@@ -12,7 +12,7 @@
 
 use std::thread::Thread;
 
-fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) {
+fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
     f(v);
 }
 
diff --git a/src/test/compile-fail/borrowck-loan-blocks-move.rs b/src/test/compile-fail/borrowck-loan-blocks-move.rs
index f588dbab4fa..f3f18807314 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-move.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-move.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn take(_v: Box<int>) {
+fn take(_v: Box<isize>) {
 }
 
 fn box_imm() {
diff --git a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
index e59baa1e37c..a52a4484b20 100644
--- a/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
+++ b/src/test/compile-fail/borrowck-loan-blocks-mut-uniq.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn borrow<F>(v: &int, f: F) where F: FnOnce(&int) {
+fn borrow<F>(v: &isize, f: F) where F: FnOnce(&isize) {
     f(v);
 }
 
diff --git a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs
index 5aa2deb44f1..b1eb06d16b1 100644
--- a/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs
+++ b/src/test/compile-fail/borrowck-loan-rcvr-overloaded-op.rs
@@ -12,20 +12,20 @@ use std::ops::Add;
 
 #[derive(Copy)]
 struct Point {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-impl Add<int> for Point {
-    type Output = int;
+impl Add<isize> for Point {
+    type Output = isize;
 
-    fn add(self, z: int) -> int {
+    fn add(self, z: isize) -> isize {
         self.x + self.y + z
     }
 }
 
 impl Point {
-    pub fn times(&self, z: int) -> int {
+    pub fn times(&self, z: isize) -> isize {
         self.x * self.y * z
     }
 }
diff --git a/src/test/compile-fail/borrowck-loan-rcvr.rs b/src/test/compile-fail/borrowck-loan-rcvr.rs
index 0ada3db47a4..014b27f9659 100644
--- a/src/test/compile-fail/borrowck-loan-rcvr.rs
+++ b/src/test/compile-fail/borrowck-loan-rcvr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-struct point { x: int, y: int }
+struct point { x: isize, y: isize }
 
 trait methods {
     fn impurem(&self);
diff --git a/src/test/compile-fail/borrowck-loan-vec-content.rs b/src/test/compile-fail/borrowck-loan-vec-content.rs
index efb7a5253ed..21d9dea77b2 100644
--- a/src/test/compile-fail/borrowck-loan-vec-content.rs
+++ b/src/test/compile-fail/borrowck-loan-vec-content.rs
@@ -12,17 +12,17 @@
 // (locally rooted) mutable, unique vector, and that we then prevent
 // modifications to the contents.
 
-fn takes_imm_elt<F>(_v: &int, f: F) where F: FnOnce() {
+fn takes_imm_elt<F>(_v: &isize, f: F) where F: FnOnce() {
     f();
 }
 
 fn has_mut_vec_and_does_not_try_to_change_it() {
-    let mut v: Vec<int> = vec!(1, 2, 3);
+    let mut v: Vec<isize> = vec!(1, 2, 3);
     takes_imm_elt(&v[0], || {})
 }
 
 fn has_mut_vec_but_tries_to_change_it() {
-    let mut v: Vec<int> = vec!(1, 2, 3);
+    let mut v: Vec<isize> = vec!(1, 2, 3);
     takes_imm_elt(
         &v[0],
         || { //~ ERROR cannot borrow `v` as mutable
diff --git a/src/test/compile-fail/borrowck-match-binding-is-assignment.rs b/src/test/compile-fail/borrowck-match-binding-is-assignment.rs
index fe0519b8198..819ff73a580 100644
--- a/src/test/compile-fail/borrowck-match-binding-is-assignment.rs
+++ b/src/test/compile-fail/borrowck-match-binding-is-assignment.rs
@@ -11,11 +11,11 @@
 // Test that immutable pattern bindings cannot be reassigned.
 
 enum E {
-    Foo(int)
+    Foo(isize)
 }
 
 struct S {
-    bar: int,
+    bar: isize,
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/borrowck-move-by-capture.rs b/src/test/compile-fail/borrowck-move-by-capture.rs
index 20212762188..b0d546cd5c8 100644
--- a/src/test/compile-fail/borrowck-move-by-capture.rs
+++ b/src/test/compile-fail/borrowck-move-by-capture.rs
@@ -13,6 +13,6 @@
 pub fn main() {
     let bar = box 3;
     let _g = |&mut:| {
-        let _h = move |:| -> int { *bar }; //~ ERROR cannot move out of captured outer variable
+        let _h = move |:| -> isize { *bar }; //~ ERROR cannot move out of captured outer variable
     };
 }
diff --git a/src/test/compile-fail/borrowck-move-error-with-note.rs b/src/test/compile-fail/borrowck-move-error-with-note.rs
index 4984987c5ca..2d82c8be519 100644
--- a/src/test/compile-fail/borrowck-move-error-with-note.rs
+++ b/src/test/compile-fail/borrowck-move-error-with-note.rs
@@ -45,7 +45,7 @@ fn move_in_match() {
 
 // from issue-8064
 struct A {
-    a: Box<int>,
+    a: Box<isize>,
 }
 
 fn free<T>(_: T) {}
diff --git a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
index 87bb8ef7a58..8310d4ba144 100644
--- a/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
+++ b/src/test/compile-fail/borrowck-move-from-unsafe-ptr.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-fn foo(x: *const Box<int>) -> Box<int> {
+fn foo(x: *const Box<isize>) -> Box<isize> {
     let y = *x; //~ ERROR dereference of unsafe pointer requires unsafe function or block
     return y;
 }
diff --git a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
index 35aef1352d1..43bf3f25d1a 100644
--- a/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
+++ b/src/test/compile-fail/borrowck-move-moved-value-into-closure.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn call_f<F:FnOnce() -> int>(f: F) -> int {
+fn call_f<F:FnOnce() -> isize>(f: F) -> isize {
     f()
 }
 
diff --git a/src/test/compile-fail/borrowck-move-mut-base-ptr.rs b/src/test/compile-fail/borrowck-move-mut-base-ptr.rs
index ce2755dbc0f..5bdea6a2bd9 100644
--- a/src/test/compile-fail/borrowck-move-mut-base-ptr.rs
+++ b/src/test/compile-fail/borrowck-move-mut-base-ptr.rs
@@ -13,8 +13,8 @@
 //
 // Example from src/middle/borrowck/doc.rs
 
-fn foo(t0: &mut int) {
-    let p: &int = &*t0; // Freezes `*t0`
+fn foo(t0: &mut isize) {
+    let p: &isize = &*t0; // Freezes `*t0`
     let t1 = t0;        //~ ERROR cannot move out of `t0`
     *t1 = 22;
 }
diff --git a/src/test/compile-fail/borrowck-move-out-of-static-item.rs b/src/test/compile-fail/borrowck-move-out-of-static-item.rs
index 730a0c3e235..2f81aa8f381 100644
--- a/src/test/compile-fail/borrowck-move-out-of-static-item.rs
+++ b/src/test/compile-fail/borrowck-move-out-of-static-item.rs
@@ -13,7 +13,7 @@
 use std::marker;
 
 struct Foo {
-    foo: int,
+    foo: isize,
     nocopy: marker::NoCopy
 }
 
diff --git a/src/test/compile-fail/borrowck-move-subcomponent.rs b/src/test/compile-fail/borrowck-move-subcomponent.rs
index bdf6fe1f21d..88871dda659 100644
--- a/src/test/compile-fail/borrowck-move-subcomponent.rs
+++ b/src/test/compile-fail/borrowck-move-subcomponent.rs
@@ -14,7 +14,7 @@
 #![feature(box_syntax)]
 
 struct S {
-  x : Box<int>
+  x : Box<isize>
 }
 
 fn f<T>(_: T) {}
diff --git a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
index 0c0377e7411..b6626a835e4 100644
--- a/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
+++ b/src/test/compile-fail/borrowck-mut-addr-of-imm-var.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 fn main() {
-    let x: int = 3;
-    let y: &mut int = &mut x; //~ ERROR cannot borrow
+    let x: isize = 3;
+    let y: &mut isize = &mut x; //~ ERROR cannot borrow
     *y = 5;
     println!("{}", *y);
 }
diff --git a/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs b/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs
index fb018f3d4bc..71dc61abb64 100644
--- a/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs
+++ b/src/test/compile-fail/borrowck-mut-borrow-of-mut-base-ptr.rs
@@ -13,16 +13,16 @@
 //
 // Example from src/middle/borrowck/doc.rs
 
-fn foo<'a>(mut t0: &'a mut int,
-           mut t1: &'a mut int) {
-    let p: &int = &*t0;     // Freezes `*t0`
+fn foo<'a>(mut t0: &'a mut isize,
+           mut t1: &'a mut isize) {
+    let p: &isize = &*t0;     // Freezes `*t0`
     let mut t2 = &mut t0;   //~ ERROR cannot borrow `t0`
     **t2 += 1;              // Mutates `*t0`
 }
 
-fn bar<'a>(mut t0: &'a mut int,
-           mut t1: &'a mut int) {
-    let p: &mut int = &mut *t0; // Claims `*t0`
+fn bar<'a>(mut t0: &'a mut isize,
+           mut t1: &'a mut isize) {
+    let p: &mut isize = &mut *t0; // Claims `*t0`
     let mut t2 = &mut t0;       //~ ERROR cannot borrow `t0`
     **t2 += 1;                  // Mutates `*t0` but not through `*p`
 }
diff --git a/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs b/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs
index 283d6398e9a..b8a92db4e42 100644
--- a/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs
+++ b/src/test/compile-fail/borrowck-mut-slice-of-imm-vec.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn write(v: &mut [int]) {
+fn write(v: &mut [isize]) {
     v[0] += 1;
 }
 
diff --git a/src/test/compile-fail/borrowck-mutate-in-guard.rs b/src/test/compile-fail/borrowck-mutate-in-guard.rs
index 464e42df8aa..44353ab5d96 100644
--- a/src/test/compile-fail/borrowck-mutate-in-guard.rs
+++ b/src/test/compile-fail/borrowck-mutate-in-guard.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 enum Enum<'a> {
-    A(&'a int),
+    A(&'a isize),
     B(bool),
 }
 
-fn foo() -> int {
+fn foo() -> isize {
     let mut n = 42;
     let mut x = Enum::A(&mut n);
     match x {
diff --git a/src/test/compile-fail/borrowck-or-init.rs b/src/test/compile-fail/borrowck-or-init.rs
index 270eeca4c4b..27871a6ab16 100644
--- a/src/test/compile-fail/borrowck-or-init.rs
+++ b/src/test/compile-fail/borrowck-or-init.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let i: int;
+    let i: isize;
 
     println!("{}", false || { i = 5; true });
     println!("{}", i); //~ ERROR use of possibly uninitialized variable: `i`
diff --git a/src/test/compile-fail/borrowck-overloaded-call.rs b/src/test/compile-fail/borrowck-overloaded-call.rs
index 938fc53d610..de959521514 100644
--- a/src/test/compile-fail/borrowck-overloaded-call.rs
+++ b/src/test/compile-fail/borrowck-overloaded-call.rs
@@ -13,23 +13,23 @@
 use std::ops::{Fn, FnMut, FnOnce};
 
 struct SFn {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-impl Fn<(int,),int> for SFn {
-    extern "rust-call" fn call(&self, (z,): (int,)) -> int {
+impl Fn<(isize,),isize> for SFn {
+    extern "rust-call" fn call(&self, (z,): (isize,)) -> isize {
         self.x * self.y * z
     }
 }
 
 struct SFnMut {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-impl FnMut<(int,),int> for SFnMut {
-    extern "rust-call" fn call_mut(&mut self, (z,): (int,)) -> int {
+impl FnMut<(isize,),isize> for SFnMut {
+    extern "rust-call" fn call_mut(&mut self, (z,): (isize,)) -> isize {
         self.x * self.y * z
     }
 }
diff --git a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs
index 416e67dac0c..9193a28511e 100644
--- a/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs
+++ b/src/test/compile-fail/borrowck-overloaded-index-autoderef.rs
@@ -14,14 +14,14 @@
 use std::ops::{Index, IndexMut};
 
 struct Foo {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 impl Index<String> for Foo {
-    type Output = int;
+    type Output = isize;
 
-    fn index<'a>(&'a self, z: &String) -> &'a int {
+    fn index<'a>(&'a self, z: &String) -> &'a isize {
         if z.as_slice() == "x" {
             &self.x
         } else {
@@ -31,9 +31,9 @@ impl Index<String> for Foo {
 }
 
 impl IndexMut<String> for Foo {
-    type Output = int;
+    type Output = isize;
 
-    fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut int {
+    fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize {
         if z.as_slice() == "x" {
             &mut self.x
         } else {
diff --git a/src/test/compile-fail/borrowck-overloaded-index.rs b/src/test/compile-fail/borrowck-overloaded-index.rs
index 80b68dbf519..ec317277e40 100644
--- a/src/test/compile-fail/borrowck-overloaded-index.rs
+++ b/src/test/compile-fail/borrowck-overloaded-index.rs
@@ -11,14 +11,14 @@
 use std::ops::{Index, IndexMut};
 
 struct Foo {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 impl Index<String> for Foo {
-    type Output = int;
+    type Output = isize;
 
-    fn index<'a>(&'a self, z: &String) -> &'a int {
+    fn index<'a>(&'a self, z: &String) -> &'a isize {
         if z.as_slice() == "x" {
             &self.x
         } else {
@@ -28,9 +28,9 @@ impl Index<String> for Foo {
 }
 
 impl IndexMut<String> for Foo {
-    type Output = int;
+    type Output = isize;
 
-    fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut int {
+    fn index_mut<'a>(&'a mut self, z: &String) -> &'a mut isize {
         if z.as_slice() == "x" {
             &mut self.x
         } else {
@@ -40,13 +40,13 @@ impl IndexMut<String> for Foo {
 }
 
 struct Bar {
-    x: int,
+    x: isize,
 }
 
-impl Index<int> for Bar {
-    type Output = int;
+impl Index<isize> for Bar {
+    type Output = isize;
 
-    fn index<'a>(&'a self, z: &int) -> &'a int {
+    fn index<'a>(&'a self, z: &isize) -> &'a isize {
         &self.x
     }
 }
diff --git a/src/test/compile-fail/borrowck-pat-reassign-binding.rs b/src/test/compile-fail/borrowck-pat-reassign-binding.rs
index f33e5e9b02d..d176245823e 100644
--- a/src/test/compile-fail/borrowck-pat-reassign-binding.rs
+++ b/src/test/compile-fail/borrowck-pat-reassign-binding.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let mut x: Option<int> = None;
+    let mut x: Option<isize> = None;
     match x {
       None => {
           // Note: on this branch, no borrow has occurred.
diff --git a/src/test/compile-fail/borrowck-reborrow-from-mut.rs b/src/test/compile-fail/borrowck-reborrow-from-mut.rs
index b4bd64f2135..6f5dfa67be5 100644
--- a/src/test/compile-fail/borrowck-reborrow-from-mut.rs
+++ b/src/test/compile-fail/borrowck-reborrow-from-mut.rs
@@ -14,8 +14,8 @@ struct Foo {
 }
 
 struct Bar {
-  int1: int,
-  int2: int,
+  int1: isize,
+  int2: isize,
 }
 
 fn borrow_same_field_twice_mut_mut(foo: &mut Foo) {
diff --git a/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs b/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs
index 05cadfd5365..eee407472bf 100644
--- a/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs
+++ b/src/test/compile-fail/borrowck-reborrow-from-shorter-lived-andmut.rs
@@ -12,7 +12,7 @@
 // borrowed (but otherwise non-aliasable) location is illegal.
 
 struct S<'a> {
-    pointer: &'a mut int
+    pointer: &'a mut isize
 }
 
 fn copy_borrowed_ptr<'a,'b>(p: &'a mut S<'b>) -> S<'b> {
diff --git a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
index 4a34b85c3ed..1784b72a699 100644
--- a/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
+++ b/src/test/compile-fail/borrowck-ref-mut-of-imm.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn destructure(x: Option<int>) -> int {
+fn destructure(x: Option<isize>) -> isize {
     match x {
       None => 0,
       Some(ref mut v) => *v //~ ERROR cannot borrow
diff --git a/src/test/compile-fail/borrowck-return.rs b/src/test/compile-fail/borrowck-return.rs
index 6558bc57968..74d435b35e7 100644
--- a/src/test/compile-fail/borrowck-return.rs
+++ b/src/test/compile-fail/borrowck-return.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f() -> int {
-    let x: int;
+fn f() -> isize {
+    let x: isize;
     return x; //~ ERROR use of possibly uninitialized variable: `x`
 }
 
diff --git a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
index 98a29f01faf..bbfc5f89a8d 100644
--- a/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
+++ b/src/test/compile-fail/borrowck-struct-update-with-dtor.rs
@@ -15,10 +15,10 @@
 use std::marker::NoCopy as NP;
 
 
-struct S { a: int, np: NP }
+struct S { a: isize, np: NP }
 impl Drop for S { fn drop(&mut self) { } }
 
-struct T { a: int, mv: Box<int> }
+struct T { a: isize, mv: Box<isize> }
 impl Drop for T { fn drop(&mut self) { } }
 
 fn f(s0:S) {
diff --git a/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs b/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs
index 3e8a0f87659..0102a909188 100644
--- a/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs
+++ b/src/test/compile-fail/borrowck-swap-mut-base-ptr.rs
@@ -15,9 +15,9 @@
 
 use std::mem::swap;
 
-fn foo<'a>(mut t0: &'a mut int,
-           mut t1: &'a mut int) {
-    let p: &int = &*t0;     // Freezes `*t0`
+fn foo<'a>(mut t0: &'a mut isize,
+           mut t1: &'a mut isize) {
+    let p: &isize = &*t0;     // Freezes `*t0`
     swap(&mut t0, &mut t1); //~ ERROR cannot borrow `t0`
     *t1 = 22;
 }
diff --git a/src/test/compile-fail/borrowck-unary-move.rs b/src/test/compile-fail/borrowck-unary-move.rs
index 72941f77210..5b5c5f4da91 100644
--- a/src/test/compile-fail/borrowck-unary-move.rs
+++ b/src/test/compile-fail/borrowck-unary-move.rs
@@ -9,13 +9,13 @@
 // except according to those terms.
 
 
-fn foo(x: Box<int>) -> int {
+fn foo(x: Box<isize>) -> isize {
     let y = &*x;
     free(x); //~ ERROR cannot move out of `x` because it is borrowed
     *y
 }
 
-fn free(_x: Box<int>) {
+fn free(_x: Box<isize>) {
 }
 
 fn main() {
diff --git a/src/test/compile-fail/borrowck-unboxed-closures.rs b/src/test/compile-fail/borrowck-unboxed-closures.rs
index cca3dcb8b34..8e7e2e3e777 100644
--- a/src/test/compile-fail/borrowck-unboxed-closures.rs
+++ b/src/test/compile-fail/borrowck-unboxed-closures.rs
@@ -10,17 +10,17 @@
 
 #![feature(overloaded_calls, unboxed_closures)]
 
-fn a<F:Fn(int, int) -> int>(mut f: F) {
+fn a<F:Fn(isize, isize) -> isize>(mut f: F) {
     let g = &mut f;
     f(1, 2);    //~ ERROR cannot borrow `f` as immutable
     //~^ ERROR cannot borrow `f` as immutable
 }
 
-fn b<F:FnMut(int, int) -> int>(f: F) {
+fn b<F:FnMut(isize, isize) -> isize>(f: F) {
     f(1, 2);    //~ ERROR cannot borrow immutable local variable
 }
 
-fn c<F:FnOnce(int, int) -> int>(f: F) {
+fn c<F:FnOnce(isize, isize) -> isize>(f: F) {
     f(1, 2);
     f(1, 2);    //~ ERROR use of moved value
 }
diff --git a/src/test/compile-fail/borrowck-uninit-after-item.rs b/src/test/compile-fail/borrowck-uninit-after-item.rs
index a828b1d6b9f..acd827d6c62 100644
--- a/src/test/compile-fail/borrowck-uninit-after-item.rs
+++ b/src/test/compile-fail/borrowck-uninit-after-item.rs
@@ -10,6 +10,6 @@
 
 fn main() {
     let bar;
-    fn baz(_x: int) { }
+    fn baz(_x: isize) { }
     baz(bar); //~ ERROR use of possibly uninitialized variable: `bar`
 }
diff --git a/src/test/compile-fail/borrowck-uninit-in-assignop.rs b/src/test/compile-fail/borrowck-uninit-in-assignop.rs
index b5e462e592a..e253ecc74b9 100644
--- a/src/test/compile-fail/borrowck-uninit-in-assignop.rs
+++ b/src/test/compile-fail/borrowck-uninit-in-assignop.rs
@@ -12,33 +12,33 @@
 // expression is detected.
 
 pub fn main() {
-    let x: int;
+    let x: isize;
     x += 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x -= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x *= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x /= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x %= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x ^= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x &= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x |= 1; //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x <<= 1;    //~ ERROR use of possibly uninitialized variable: `x`
 
-    let x: int;
+    let x: isize;
     x >>= 1;    //~ ERROR use of possibly uninitialized variable: `x`
 }
diff --git a/src/test/compile-fail/borrowck-uninit.rs b/src/test/compile-fail/borrowck-uninit.rs
index a64216df6c7..f4b73bc889f 100644
--- a/src/test/compile-fail/borrowck-uninit.rs
+++ b/src/test/compile-fail/borrowck-uninit.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int) { println!("{}", x); }
+fn foo(x: isize) { println!("{}", x); }
 
 fn main() {
-    let x: int;
+    let x: isize;
     foo(x); //~ ERROR use of possibly uninitialized variable: `x`
 }
diff --git a/src/test/compile-fail/borrowck-uniq-via-lend.rs b/src/test/compile-fail/borrowck-uniq-via-lend.rs
index b0e8b2a523b..9c14a699032 100644
--- a/src/test/compile-fail/borrowck-uniq-via-lend.rs
+++ b/src/test/compile-fail/borrowck-uniq-via-lend.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn borrow(_v: &int) {}
+fn borrow(_v: &isize) {}
 
 fn local() {
     let mut v = box 3i;
@@ -18,7 +18,7 @@ fn local() {
 }
 
 fn local_rec() {
-    struct F { f: Box<int> }
+    struct F { f: Box<isize> }
     let mut v = F {f: box 3};
     borrow(&*v.f);
 }
@@ -26,7 +26,7 @@ fn local_rec() {
 fn local_recs() {
     struct F { f: G }
     struct G { g: H }
-    struct H { h: Box<int> }
+    struct H { h: Box<isize> }
     let mut v = F {f: G {g: H {h: box 3}}};
     borrow(&*v.f.g.h);
 }
diff --git a/src/test/compile-fail/borrowck-use-in-index-lvalue.rs b/src/test/compile-fail/borrowck-use-in-index-lvalue.rs
index 3cd582ca0b8..94c1d3a6a45 100644
--- a/src/test/compile-fail/borrowck-use-in-index-lvalue.rs
+++ b/src/test/compile-fail/borrowck-use-in-index-lvalue.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 fn test() {
-    let w: &mut [int];
+    let w: &mut [isize];
     w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w`
 
-    let mut w: &mut [int];
+    let mut w: &mut [isize];
     w[5] = 0; //~ ERROR use of possibly uninitialized variable: `w`
 }
 
diff --git a/src/test/compile-fail/borrowck-use-mut-borrow.rs b/src/test/compile-fail/borrowck-use-mut-borrow.rs
index 45813c45f03..42e12622b69 100644
--- a/src/test/compile-fail/borrowck-use-mut-borrow.rs
+++ b/src/test/compile-fail/borrowck-use-mut-borrow.rs
@@ -10,14 +10,14 @@
 
 #![feature(box_syntax)]
 
-struct A { a: int, b: int }
+struct A { a: isize, b: isize }
 
 impl Copy for A {}
 
-struct B { a: int, b: Box<int> }
+struct B { a: isize, b: Box<isize> }
 
 fn var_copy_after_var_borrow() {
-    let mut x: int = 1;
+    let mut x: isize = 1;
     let p = &mut x;
     drop(x); //~ ERROR cannot use `x` because it was mutably borrowed
     *p = 2;
@@ -61,7 +61,7 @@ fn fu_field_copy_after_field_borrow() {
 }
 
 fn var_deref_after_var_borrow() {
-    let mut x: Box<int> = box 1;
+    let mut x: Box<isize> = box 1;
     let p = &mut x;
     drop(*x); //~ ERROR cannot use `*x` because it was mutably borrowed
     **p = 2;
diff --git a/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs b/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs
index 4a5418a4f20..577334cce95 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-element-loan.rs
@@ -10,9 +10,9 @@
 
 #![feature(advanced_slice_patterns)]
 
-fn a<'a>() -> &'a [int] {
+fn a<'a>() -> &'a [isize] {
     let vec = vec!(1, 2, 3, 4);
-    let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
+    let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough
     let tail = match vec {
         [_, tail..] => tail,
         _ => panic!("a")
@@ -20,9 +20,9 @@ fn a<'a>() -> &'a [int] {
     tail
 }
 
-fn b<'a>() -> &'a [int] {
+fn b<'a>() -> &'a [isize] {
     let vec = vec!(1, 2, 3, 4);
-    let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
+    let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough
     let init = match vec {
         [init.., _] => init,
         _ => panic!("b")
@@ -30,9 +30,9 @@ fn b<'a>() -> &'a [int] {
     init
 }
 
-fn c<'a>() -> &'a [int] {
+fn c<'a>() -> &'a [isize] {
     let vec = vec!(1, 2, 3, 4);
-    let vec: &[int] = vec.as_slice(); //~ ERROR does not live long enough
+    let vec: &[isize] = vec.as_slice(); //~ ERROR does not live long enough
     let slice = match vec {
         [_, slice.., _] => slice,
         _ => panic!("c")
diff --git a/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs b/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs
index cc1dbc81955..565b8ca2f68 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-loan-from-mut.rs
@@ -10,7 +10,7 @@
 
 fn a() {
     let mut v = vec!(1, 2, 3);
-    let vb: &mut [int] = v.as_mut_slice();
+    let vb: &mut [isize] = v.as_mut_slice();
     match vb {
         [_a, tail..] => {
             v.push(tail[0] + tail[1]); //~ ERROR cannot borrow
diff --git a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
index c0abc3a2560..98a511f0900 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-nesting.rs
@@ -22,7 +22,7 @@ fn a() {
 
 fn b() {
     let mut vec = vec!(box 1i, box 2, box 3);
-    let vec: &mut [Box<int>] = vec.as_mut_slice();
+    let vec: &mut [Box<isize>] = vec.as_mut_slice();
     match vec {
         [_b..] => {
             vec[0] = box 4; //~ ERROR cannot assign
@@ -32,7 +32,7 @@ fn b() {
 
 fn c() {
     let mut vec = vec!(box 1i, box 2, box 3);
-    let vec: &mut [Box<int>] = vec.as_mut_slice();
+    let vec: &mut [Box<isize>] = vec.as_mut_slice();
     match vec {
         [_a,         //~ ERROR cannot move out
          _b..] => {  //~^ NOTE attempting to move value to here
@@ -50,7 +50,7 @@ fn c() {
 
 fn d() {
     let mut vec = vec!(box 1i, box 2, box 3);
-    let vec: &mut [Box<int>] = vec.as_mut_slice();
+    let vec: &mut [Box<isize>] = vec.as_mut_slice();
     match vec {
         [_a..,     //~ ERROR cannot move out
          _b] => {} //~ NOTE attempting to move value to here
@@ -61,7 +61,7 @@ fn d() {
 
 fn e() {
     let mut vec = vec!(box 1i, box 2, box 3);
-    let vec: &mut [Box<int>] = vec.as_mut_slice();
+    let vec: &mut [Box<isize>] = vec.as_mut_slice();
     match vec {
         [_a, _b, _c] => {}  //~ ERROR cannot move out
         //~^ NOTE attempting to move value to here
diff --git a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs
index 852eb172c59..bcd1aa81d4c 100644
--- a/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs
+++ b/src/test/compile-fail/borrowck-vec-pattern-tail-element-loan.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn a<'a>() -> &'a int {
+fn a<'a>() -> &'a isize {
     let vec = vec!(1, 2, 3, 4);
-    let vec: &[int] = vec.as_slice(); //~ ERROR `vec` does not live long enough
+    let vec: &[isize] = vec.as_slice(); //~ ERROR `vec` does not live long enough
     let tail = match vec {
         [_a, tail..] => &tail[0],
         _ => panic!("foo")
diff --git a/src/test/compile-fail/borrowck-while.rs b/src/test/compile-fail/borrowck-while.rs
index b5703e56642..17eb19a44e6 100644
--- a/src/test/compile-fail/borrowck-while.rs
+++ b/src/test/compile-fail/borrowck-while.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f() -> int {
-    let mut x: int;
+fn f() -> isize {
+    let mut x: isize;
     while 1i == 1 { x = 10; }
     return x; //~ ERROR use of possibly uninitialized variable: `x`
 }
diff --git a/src/test/compile-fail/capture1.rs b/src/test/compile-fail/capture1.rs
index 7d590ca49dd..fd50918a313 100644
--- a/src/test/compile-fail/capture1.rs
+++ b/src/test/compile-fail/capture1.rs
@@ -12,6 +12,6 @@
 // error-pattern: can't capture dynamic environment in a fn item;
 
 fn main() {
-    let bar: int = 5;
-    fn foo() -> int { return bar; }
+    let bar: isize = 5;
+    fn foo() -> isize { return bar; }
 }
diff --git a/src/test/compile-fail/cast-to-bare-fn.rs b/src/test/compile-fail/cast-to-bare-fn.rs
index 1db813292b0..a7f0917ed86 100644
--- a/src/test/compile-fail/cast-to-bare-fn.rs
+++ b/src/test/compile-fail/cast-to-bare-fn.rs
@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(_x: int) { }
+fn foo(_x: isize) { }
 
 fn main() {
     let v: u64 = 5;
-    let x = foo as extern "C" fn() -> int;
+    let x = foo as extern "C" fn() -> isize;
     //~^ ERROR mismatched types
-    let y = v as extern "Rust" fn(int) -> (int, int);
+    let y = v as extern "Rust" fn(isize) -> (isize, isize);
     //~^ ERROR non-scalar cast
     y(x());
 }
diff --git a/src/test/compile-fail/check-static-immutable-mut-slices.rs b/src/test/compile-fail/check-static-immutable-mut-slices.rs
index 2945a050247..d1e3fe25253 100644
--- a/src/test/compile-fail/check-static-immutable-mut-slices.rs
+++ b/src/test/compile-fail/check-static-immutable-mut-slices.rs
@@ -10,7 +10,7 @@
 
 // Checks that immutable static items can't have mutable slices
 
-static TEST: &'static mut [int] = &mut [];
+static TEST: &'static mut [isize] = &mut [];
 //~^ ERROR statics are not allowed to have mutable references
 
 pub fn main() { }
diff --git a/src/test/compile-fail/check-static-values-constraints.rs b/src/test/compile-fail/check-static-values-constraints.rs
index c13faacfee4..7c4f9ada2d3 100644
--- a/src/test/compile-fail/check-static-values-constraints.rs
+++ b/src/test/compile-fail/check-static-values-constraints.rs
@@ -26,7 +26,7 @@ impl Drop for WithDtor {
 // 3. Expr calls with unsafe arguments for statics are rejected
 enum SafeEnum {
     Variant1,
-    Variant2(int),
+    Variant2(isize),
     Variant3(WithDtor),
     Variant4(String)
 }
@@ -45,7 +45,7 @@ static STATIC3: SafeEnum = SafeEnum::Variant3(WithDtor);
 // a destructor.
 enum UnsafeEnum {
     Variant5,
-    Variant6(int)
+    Variant6(isize)
 }
 
 impl Drop for UnsafeEnum {
@@ -132,11 +132,11 @@ static STATIC16: (&'static Box<MyOwned>, &'static Box<MyOwned>) = (
 static mut STATIC17: SafeEnum = SafeEnum::Variant1;
 //~^ ERROR mutable statics are not allowed to have destructors
 
-static STATIC19: Box<int> =
+static STATIC19: Box<isize> =
     box 3;
 //~^ ERROR statics are not allowed to have custom pointers
 
 pub fn main() {
-    let y = { static x: Box<int> = box 3; x };
+    let y = { static x: Box<isize> = box 3; x };
     //~^ ERROR statics are not allowed to have custom pointers
 }
diff --git a/src/test/compile-fail/class-cast-to-trait.rs b/src/test/compile-fail/class-cast-to-trait.rs
index 25abd904d21..c64112d5dfd 100644
--- a/src/test/compile-fail/class-cast-to-trait.rs
+++ b/src/test/compile-fail/class-cast-to-trait.rs
@@ -17,7 +17,7 @@ trait noisy {
 struct cat {
   meows : uint,
 
-  how_hungry : int,
+  how_hungry : isize,
   name : String,
 }
 
@@ -50,7 +50,7 @@ impl cat {
     }
 }
 
-fn cat(in_x : uint, in_y : int, in_name: String) -> cat {
+fn cat(in_x : uint, in_y : isize, in_name: String) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y,
diff --git a/src/test/compile-fail/coherence-all-remote.rs b/src/test/compile-fail/coherence-all-remote.rs
index d86256a7776..f8ddf83c9c6 100644
--- a/src/test/compile-fail/coherence-all-remote.rs
+++ b/src/test/compile-fail/coherence-all-remote.rs
@@ -13,7 +13,7 @@
 extern crate "coherence-lib" as lib;
 use lib::Remote1;
 
-impl<T> Remote1<T> for int { }
+impl<T> Remote1<T> for isize { }
 //~^ ERROR E0117
 
 fn main() { }
diff --git a/src/test/compile-fail/coherence-bigint-int.rs b/src/test/compile-fail/coherence-bigint-int.rs
index b4917d0c29f..684773098cd 100644
--- a/src/test/compile-fail/coherence-bigint-int.rs
+++ b/src/test/compile-fail/coherence-bigint-int.rs
@@ -15,6 +15,6 @@ use lib::Remote1;
 
 pub struct BigInt;
 
-impl Remote1<BigInt> for int { } //~ ERROR E0117
+impl Remote1<BigInt> for isize { } //~ ERROR E0117
 
 fn main() { }
diff --git a/src/test/compile-fail/coherence-bigint-vecint.rs b/src/test/compile-fail/coherence-bigint-vecint.rs
index de4e656110f..28747674b8b 100644
--- a/src/test/compile-fail/coherence-bigint-vecint.rs
+++ b/src/test/compile-fail/coherence-bigint-vecint.rs
@@ -15,6 +15,6 @@ use lib::Remote1;
 
 pub struct BigInt;
 
-impl Remote1<BigInt> for Vec<int> { } //~ ERROR E0117
+impl Remote1<BigInt> for Vec<isize> { } //~ ERROR E0117
 
 fn main() { }
diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs
index c0d82d35e30..1372d9930ee 100644
--- a/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs
+++ b/src/test/compile-fail/coherence-blanket-conflicts-with-blanket-implemented.rs
@@ -23,7 +23,7 @@ trait Even { }
 
 trait Odd { }
 
-impl Even for int { }
+impl Even for isize { }
 
 impl Odd for uint { }
 
diff --git a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs
index 2e163bc11a8..1f6bb08871c 100644
--- a/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs
+++ b/src/test/compile-fail/coherence-blanket-conflicts-with-specific-cross-crate.rs
@@ -19,11 +19,11 @@ use std::default::Default;
 struct MyThingy;
 
 impl Go for MyThingy {
-    fn go(&self, arg: int) { }
+    fn go(&self, arg: isize) { }
 }
 
 impl GoMut for MyThingy { //~ ERROR conflicting implementations
-    fn go_mut(&mut self, arg: int) { }
+    fn go_mut(&mut self, arg: isize) { }
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/coherence-orphan.rs b/src/test/compile-fail/coherence-orphan.rs
index 30a382c143d..568a35cc589 100644
--- a/src/test/compile-fail/coherence-orphan.rs
+++ b/src/test/compile-fail/coherence-orphan.rs
@@ -16,10 +16,10 @@ use lib::TheTrait;
 
 struct TheType;
 
-impl TheTrait<uint> for int { } //~ ERROR E0117
+impl TheTrait<uint> for isize { } //~ ERROR E0117
 
-impl TheTrait<TheType> for int { } //~ ERROR E0117
+impl TheTrait<TheType> for isize { } //~ ERROR E0117
 
-impl TheTrait<int> for TheType { }
+impl TheTrait<isize> for TheType { }
 
 fn main() { }
diff --git a/src/test/compile-fail/comm-not-freeze-receiver.rs b/src/test/compile-fail/comm-not-freeze-receiver.rs
index a7962c09fb3..305acfec401 100644
--- a/src/test/compile-fail/comm-not-freeze-receiver.rs
+++ b/src/test/compile-fail/comm-not-freeze-receiver.rs
@@ -13,5 +13,5 @@ use std::sync::mpsc::Receiver;
 fn test<T: Sync>() {}
 
 fn main() {
-    test::<Receiver<int>>();   //~ ERROR: `core::marker::Sync` is not implemented
+    test::<Receiver<isize>>();   //~ ERROR: `core::marker::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/comm-not-freeze.rs b/src/test/compile-fail/comm-not-freeze.rs
index 1977438d423..de2c96920c3 100644
--- a/src/test/compile-fail/comm-not-freeze.rs
+++ b/src/test/compile-fail/comm-not-freeze.rs
@@ -13,5 +13,5 @@ use std::sync::mpsc::Sender;
 fn test<T: Sync>() {}
 
 fn main() {
-    test::<Sender<int>>();     //~ ERROR: `core::marker::Sync` is not implemented
+    test::<Sender<isize>>();     //~ ERROR: `core::marker::Sync` is not implemented
 }
diff --git a/src/test/compile-fail/const-recursive.rs b/src/test/compile-fail/const-recursive.rs
index 9c633e082b1..ad05c7c423f 100644
--- a/src/test/compile-fail/const-recursive.rs
+++ b/src/test/compile-fail/const-recursive.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 // error-pattern: recursive constant
-static a: int = b;
-static b: int = a;
+static a: isize = b;
+static b: isize = a;
 
 fn main() {
 }
diff --git a/src/test/compile-fail/copy-a-resource.rs b/src/test/compile-fail/copy-a-resource.rs
index 01c6970506c..1201db437b9 100644
--- a/src/test/compile-fail/copy-a-resource.rs
+++ b/src/test/compile-fail/copy-a-resource.rs
@@ -10,14 +10,14 @@
 
 #[derive(Show)]
 struct foo {
-  i: int,
+  i: isize,
 }
 
 impl Drop for foo {
     fn drop(&mut self) {}
 }
 
-fn foo(i:int) -> foo {
+fn foo(i:isize) -> foo {
     foo {
         i: i
     }
diff --git a/src/test/compile-fail/deriving-primitive.rs b/src/test/compile-fail/deriving-primitive.rs
index a3c6c8672c8..901f0c58f45 100644
--- a/src/test/compile-fail/deriving-primitive.rs
+++ b/src/test/compile-fail/deriving-primitive.rs
@@ -9,25 +9,25 @@
 // except according to those terms.
 
 use std::num::FromPrimitive;
-use std::int;
+use std::isize;
 
 #[derive(FromPrimitive)]
-struct A { x: int }
+struct A { x: isize }
 //~^^ ERROR `FromPrimitive` cannot be derived for structs
 //~^^^ ERROR `FromPrimitive` cannot be derived for structs
 
 #[derive(FromPrimitive)]
-struct B(int);
+struct B(isize);
 //~^^ ERROR `FromPrimitive` cannot be derived for structs
 //~^^^ ERROR `FromPrimitive` cannot be derived for structs
 
 #[derive(FromPrimitive)]
-enum C { Foo(int), Bar(uint) }
+enum C { Foo(isize), Bar(uint) }
 //~^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments
 //~^^^ ERROR `FromPrimitive` cannot be derived for enum variants with arguments
 
 #[derive(FromPrimitive)]
-enum D { Baz { x: int } }
+enum D { Baz { x: isize } }
 //~^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants
 //~^^^ ERROR `FromPrimitive` cannot be derived for enums with struct variants
 
diff --git a/src/test/compile-fail/destructure-trait-ref.rs b/src/test/compile-fail/destructure-trait-ref.rs
index 0351040d329..89062576a50 100644
--- a/src/test/compile-fail/destructure-trait-ref.rs
+++ b/src/test/compile-fail/destructure-trait-ref.rs
@@ -14,7 +14,7 @@
 #![feature(box_syntax)]
 
 trait T {}
-impl T for int {}
+impl T for isize {}
 
 fn main() {
     // For an expression of the form:
diff --git a/src/test/compile-fail/drop-on-non-struct.rs b/src/test/compile-fail/drop-on-non-struct.rs
index 8d2ca0b0a6b..26b247d0d0f 100644
--- a/src/test/compile-fail/drop-on-non-struct.rs
+++ b/src/test/compile-fail/drop-on-non-struct.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-impl<'a> Drop for &'a mut int {
+impl<'a> Drop for &'a mut isize {
     //~^ ERROR the Drop trait may only be implemented on structures
     //~^^ ERROR E0117
     fn drop(&mut self) {
diff --git a/src/test/compile-fail/dst-bad-assign-2.rs b/src/test/compile-fail/dst-bad-assign-2.rs
index 6c40ca558de..7dbb8fc92e3 100644
--- a/src/test/compile-fail/dst-bad-assign-2.rs
+++ b/src/test/compile-fail/dst-bad-assign-2.rs
@@ -13,7 +13,7 @@
 #![feature(box_syntax)]
 
 struct Fat<T: ?Sized> {
-    f1: int,
+    f1: isize,
     f2: &'static str,
     ptr: T
 }
@@ -23,19 +23,19 @@ struct Bar;
 
 #[derive(PartialEq,Eq)]
 struct Bar1 {
-    f: int
+    f: isize
 }
 
 trait ToBar {
     fn to_bar(&self) -> Bar;
-    fn to_val(&self) -> int;
+    fn to_val(&self) -> isize;
 }
 
 impl ToBar for Bar1 {
     fn to_bar(&self) -> Bar {
         Bar
     }
-    fn to_val(&self) -> int {
+    fn to_val(&self) -> isize {
         self.f
     }
 }
diff --git a/src/test/compile-fail/dst-bad-assign.rs b/src/test/compile-fail/dst-bad-assign.rs
index 78f70b9add0..634b5999e9e 100644
--- a/src/test/compile-fail/dst-bad-assign.rs
+++ b/src/test/compile-fail/dst-bad-assign.rs
@@ -13,7 +13,7 @@
 #![feature(box_syntax)]
 
 struct Fat<T: ?Sized> {
-    f1: int,
+    f1: isize,
     f2: &'static str,
     ptr: T
 }
@@ -23,19 +23,19 @@ struct Bar;
 
 #[derive(PartialEq,Eq)]
 struct Bar1 {
-    f: int
+    f: isize
 }
 
 trait ToBar {
     fn to_bar(&self) -> Bar;
-    fn to_val(&self) -> int;
+    fn to_val(&self) -> isize;
 }
 
 impl ToBar for Bar1 {
     fn to_bar(&self) -> Bar {
         Bar
     }
-    fn to_val(&self) -> int {
+    fn to_val(&self) -> isize {
         self.f
     }
 }
diff --git a/src/test/compile-fail/dst-bad-coerce2.rs b/src/test/compile-fail/dst-bad-coerce2.rs
index 54c625221ba..160197368d6 100644
--- a/src/test/compile-fail/dst-bad-coerce2.rs
+++ b/src/test/compile-fail/dst-bad-coerce2.rs
@@ -21,8 +21,8 @@ impl Bar for Foo {}
 pub fn main() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int; 3]> = &f1;
-    let f3: &mut Fat<[int]> = f2; //~ ERROR mismatched types
+    let f2: &Fat<[isize; 3]> = &f1;
+    let f3: &mut Fat<[isize]> = f2; //~ ERROR mismatched types
 
     // With a trait.
     let f1 = Fat { ptr: Foo };
diff --git a/src/test/compile-fail/dst-bad-coerce3.rs b/src/test/compile-fail/dst-bad-coerce3.rs
index 192d43e32fd..347a2d2ecbe 100644
--- a/src/test/compile-fail/dst-bad-coerce3.rs
+++ b/src/test/compile-fail/dst-bad-coerce3.rs
@@ -21,8 +21,8 @@ impl Bar for Foo {}
 fn baz<'a>() {
     // With a vec of ints.
     let f1 = Fat { ptr: [1, 2, 3] };
-    let f2: &Fat<[int; 3]> = &f1; //~ ERROR `f1` does not live long enough
-    let f3: &'a Fat<[int]> = f2;
+    let f2: &Fat<[isize; 3]> = &f1; //~ ERROR `f1` does not live long enough
+    let f3: &'a Fat<[isize]> = f2;
 
     // With a trait.
     let f1 = Fat { ptr: Foo };
diff --git a/src/test/compile-fail/dst-bad-deep.rs b/src/test/compile-fail/dst-bad-deep.rs
index 0276e2e418d..354898f6cf0 100644
--- a/src/test/compile-fail/dst-bad-deep.rs
+++ b/src/test/compile-fail/dst-bad-deep.rs
@@ -18,8 +18,8 @@ struct Fat<T: ?Sized> {
 }
 
 pub fn main() {
-    let f: Fat<[int; 3]> = Fat { ptr: [5i, 6, 7] };
-    let g: &Fat<[int]> = &f;
-    let h: &Fat<Fat<[int]>> = &Fat { ptr: *g };
+    let f: Fat<[isize; 3]> = Fat { ptr: [5i, 6, 7] };
+    let g: &Fat<[isize]> = &f;
+    let h: &Fat<Fat<[isize]>> = &Fat { ptr: *g };
     //~^ ERROR the trait `core::marker::Sized` is not implemented
 }
diff --git a/src/test/compile-fail/dst-rvalue.rs b/src/test/compile-fail/dst-rvalue.rs
index 74e952364cd..6e33fdf3f7b 100644
--- a/src/test/compile-fail/dst-rvalue.rs
+++ b/src/test/compile-fail/dst-rvalue.rs
@@ -17,8 +17,8 @@ pub fn main() {
     //~^ ERROR E0161
     //~^^ ERROR cannot move out of dereference
 
-    let array: &[int] = &[1, 2, 3];
-    let _x: Box<[int]> = box *array;
+    let array: &[isize] = &[1, 2, 3];
+    let _x: Box<[isize]> = box *array;
     //~^ ERROR E0161
     //~^^ ERROR cannot move out of dereference
 }
diff --git a/src/test/compile-fail/duplicate-parameter.rs b/src/test/compile-fail/duplicate-parameter.rs
index c1c0f974de9..18ec55e10bb 100644
--- a/src/test/compile-fail/duplicate-parameter.rs
+++ b/src/test/compile-fail/duplicate-parameter.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(a: int, a: int) {}
+fn f(a: isize, a: isize) {}
 //~^ ERROR identifier `a` is bound more than once in this parameter list
 
 fn main() {
diff --git a/src/test/compile-fail/enum-and-module-in-same-scope.rs b/src/test/compile-fail/enum-and-module-in-same-scope.rs
index 7526c6753e6..f3d8fcf31d7 100644
--- a/src/test/compile-fail/enum-and-module-in-same-scope.rs
+++ b/src/test/compile-fail/enum-and-module-in-same-scope.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 mod Foo {
-    pub static X: int = 42;
+    pub static X: isize = 42;
 }
 
 enum Foo {  //~ ERROR duplicate definition of type or module `Foo`
diff --git a/src/test/compile-fail/enum-discrim-too-small.rs b/src/test/compile-fail/enum-discrim-too-small.rs
index 2de50ad1d1d..55e9b6d6ece 100644
--- a/src/test/compile-fail/enum-discrim-too-small.rs
+++ b/src/test/compile-fail/enum-discrim-too-small.rs
@@ -53,6 +53,6 @@ enum Ei32 {
 // u64 currently allows negative numbers, and i64 allows numbers greater than `1<<63`.  This is a
 // little counterintuitive, but since the discriminant can store all the bits, and extracting it
 // with a cast requires specifying the signedness, there is no loss of information in those cases.
-// This also applies to int and uint on 64-bit targets.
+// This also applies to isize and uint on 64-bit targets.
 
 pub fn main() { }
diff --git a/src/test/compile-fail/enum-in-scope.rs b/src/test/compile-fail/enum-in-scope.rs
index cccf66ef2d5..7be06ec7de8 100644
--- a/src/test/compile-fail/enum-in-scope.rs
+++ b/src/test/compile-fail/enum-in-scope.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct hello(int);
+struct hello(isize);
 
 fn main() {
     let hello = 0; //~ERROR declaration of `hello` shadows
diff --git a/src/test/compile-fail/explicit-call-to-dtor.rs b/src/test/compile-fail/explicit-call-to-dtor.rs
index 6b334dd6ecd..90030488dd6 100644
--- a/src/test/compile-fail/explicit-call-to-dtor.rs
+++ b/src/test/compile-fail/explicit-call-to-dtor.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int
+    x: isize
 }
 
 impl Drop for Foo {
diff --git a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs
index d0dd0e68da6..63ed74dfa49 100644
--- a/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs
+++ b/src/test/compile-fail/explicit-call-to-supertrait-dtor.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int
+    x: isize
 }
 
 trait Bar : Drop {
diff --git a/src/test/compile-fail/explicit-self-lifetime-mismatch.rs b/src/test/compile-fail/explicit-self-lifetime-mismatch.rs
index 9b2264b8902..fbc5263d82d 100644
--- a/src/test/compile-fail/explicit-self-lifetime-mismatch.rs
+++ b/src/test/compile-fail/explicit-self-lifetime-mismatch.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 struct Foo<'a,'b> {
-    x: &'a int,
-    y: &'b int,
+    x: &'a isize,
+    y: &'b isize,
 }
 
 impl<'a,'b> Foo<'a,'b> {
diff --git a/src/test/compile-fail/export.rs b/src/test/compile-fail/export.rs
index dec65d4b4f8..3a391e7c609 100644
--- a/src/test/compile-fail/export.rs
+++ b/src/test/compile-fail/export.rs
@@ -10,8 +10,8 @@
 
 // error-pattern: unresolved name
 mod foo {
-    pub fn x(y: int) { log(debug, y); }
-    fn z(y: int) { log(debug, y); }
+    pub fn x(y: isize) { log(debug, y); }
+    fn z(y: isize) { log(debug, y); }
 }
 
 fn main() { foo::z(10); }
diff --git a/src/test/compile-fail/feature-gate-int-uint.rs b/src/test/compile-fail/feature-gate-int-uint.rs
index 78b931b383f..668c9980a2e 100644
--- a/src/test/compile-fail/feature-gate-int-uint.rs
+++ b/src/test/compile-fail/feature-gate-int-uint.rs
@@ -20,11 +20,11 @@ mod u {
     }
 }
 mod i {
-    type X = int; //~ WARN the `int` type is deprecated
+    type X = isize; //~ WARN the `isize` type is deprecated
     struct Foo {
-        x: int //~ WARN the `int` type is deprecated
+        x: isize //~ WARN the `isize` type is deprecated
     }
-    fn bar(x: int) { //~ WARN the `int` type is deprecated
+    fn bar(x: isize) { //~ WARN the `isize` type is deprecated
         1i; //~ WARN the `u` suffix on integers is deprecated
     }
 }
diff --git a/src/test/compile-fail/fn-bad-block-type.rs b/src/test/compile-fail/fn-bad-block-type.rs
index ba568ef5f84..c5c355cfbce 100644
--- a/src/test/compile-fail/fn-bad-block-type.rs
+++ b/src/test/compile-fail/fn-bad-block-type.rs
@@ -10,6 +10,6 @@
 
 // error-pattern:mismatched types
 
-fn f() -> int { true }
+fn f() -> isize { true }
 
 fn main() { }
diff --git a/src/test/compile-fail/fn-item-type.rs b/src/test/compile-fail/fn-item-type.rs
index dd4a24bfb2f..b2394a29899 100644
--- a/src/test/compile-fail/fn-item-type.rs
+++ b/src/test/compile-fail/fn-item-type.rs
@@ -11,8 +11,8 @@
 // Test that the types of distinct fn items are not compatible by
 // default. See also `run-pass/fn-item-type-*.rs`.
 
-fn foo(x: int) -> int { x * 2 }
-fn bar(x: int) -> int { x * 4 }
+fn foo(x: isize) -> isize { x * 2 }
+fn bar(x: isize) -> isize { x * 4 }
 
 fn eq<T>(x: T, y: T) { }
 
diff --git a/src/test/compile-fail/fn-variance-1.rs b/src/test/compile-fail/fn-variance-1.rs
index 039628b6752..838e65e1d05 100644
--- a/src/test/compile-fail/fn-variance-1.rs
+++ b/src/test/compile-fail/fn-variance-1.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn takes_imm(x: &int) { }
+fn takes_imm(x: &isize) { }
 
-fn takes_mut(x: &mut int) { }
+fn takes_mut(x: &mut isize) { }
 
 fn apply<T, F>(t: T, f: F) where F: FnOnce(T) {
     f(t)
diff --git a/src/test/compile-fail/for-loop-bogosity.rs b/src/test/compile-fail/for-loop-bogosity.rs
index 67d07ca4bd1..fd920f92394 100644
--- a/src/test/compile-fail/for-loop-bogosity.rs
+++ b/src/test/compile-fail/for-loop-bogosity.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 struct MyStruct {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 impl MyStruct {
-    fn next(&mut self) -> Option<int> {
+    fn next(&mut self) -> Option<isize> {
         Some(self.x)
     }
 }
diff --git a/src/test/compile-fail/forget-init-unsafe.rs b/src/test/compile-fail/forget-init-unsafe.rs
index 12df0c71cc5..46a18c98183 100644
--- a/src/test/compile-fail/forget-init-unsafe.rs
+++ b/src/test/compile-fail/forget-init-unsafe.rs
@@ -12,6 +12,6 @@ use std::intrinsics::{init, forget};
 
 // Test that the `forget` and `init` intrinsics are really unsafe
 pub fn main() {
-    let stuff = init::<int>(); //~ ERROR call to unsafe function requires unsafe
+    let stuff = init::<isize>(); //~ ERROR call to unsafe function requires unsafe
     forget(stuff);             //~ ERROR call to unsafe function requires unsafe
 }
diff --git a/src/test/compile-fail/fully-qualified-type-name3.rs b/src/test/compile-fail/fully-qualified-type-name3.rs
index 0a5a54b9a27..c69c30216f9 100644
--- a/src/test/compile-fail/fully-qualified-type-name3.rs
+++ b/src/test/compile-fail/fully-qualified-type-name3.rs
@@ -13,7 +13,7 @@
 // ignore-test
 
 type T1 = uint;
-type T2 = int;
+type T2 = isize;
 
 fn bar(x: T1) -> T2 {
     return x;
diff --git a/src/test/compile-fail/functional-struct-update-noncopyable.rs b/src/test/compile-fail/functional-struct-update-noncopyable.rs
index da246f85c43..7ce32bbc975 100644
--- a/src/test/compile-fail/functional-struct-update-noncopyable.rs
+++ b/src/test/compile-fail/functional-struct-update-noncopyable.rs
@@ -12,7 +12,7 @@
 
 use std::sync::Arc;
 
-struct A { y: Arc<int>, x: Arc<int> }
+struct A { y: Arc<isize>, x: Arc<isize> }
 
 impl Drop for A {
     fn drop(&mut self) { println!("x={}", *self.x); }
diff --git a/src/test/compile-fail/gated-non-ascii-idents.rs b/src/test/compile-fail/gated-non-ascii-idents.rs
index 4cbb61d9853..f4b9830d579 100644
--- a/src/test/compile-fail/gated-non-ascii-idents.rs
+++ b/src/test/compile-fail/gated-non-ascii-idents.rs
@@ -17,9 +17,9 @@ mod föö { //~ ERROR non-ascii idents
 }
 
 fn bär( //~ ERROR non-ascii idents
-    bäz: int //~ ERROR non-ascii idents
+    bäz: isize //~ ERROR non-ascii idents
     ) {
-    let _ö: int; //~ ERROR non-ascii idents
+    let _ö: isize; //~ ERROR non-ascii idents
 
     match (1, 2) {
         (_ä, _) => {} //~ ERROR non-ascii idents
@@ -27,12 +27,12 @@ fn bär( //~ ERROR non-ascii idents
 }
 
 struct Föö { //~ ERROR non-ascii idents
-    föö: int //~ ERROR non-ascii idents
+    föö: isize //~ ERROR non-ascii idents
 }
 
 enum Bär { //~ ERROR non-ascii idents
     Bäz { //~ ERROR non-ascii idents
-        qüx: int //~ ERROR non-ascii idents
+        qüx: isize //~ ERROR non-ascii idents
     }
 }
 
diff --git a/src/test/compile-fail/generic-impl-less-params-with-defaults.rs b/src/test/compile-fail/generic-impl-less-params-with-defaults.rs
index a8b1911426c..02f09749d61 100644
--- a/src/test/compile-fail/generic-impl-less-params-with-defaults.rs
+++ b/src/test/compile-fail/generic-impl-less-params-with-defaults.rs
@@ -15,6 +15,6 @@ impl<A, B, C = (A, B)> Foo<A, B, C> {
 }
 
 fn main() {
-    Foo::<int>::new();
+    Foo::<isize>::new();
     //~^ ERROR too few type parameters provided
 }
diff --git a/src/test/compile-fail/generic-impl-more-params-with-defaults.rs b/src/test/compile-fail/generic-impl-more-params-with-defaults.rs
index 696235333a1..d88da2625c1 100644
--- a/src/test/compile-fail/generic-impl-more-params-with-defaults.rs
+++ b/src/test/compile-fail/generic-impl-more-params-with-defaults.rs
@@ -17,6 +17,6 @@ impl<T, A = Heap> Vec<T, A> {
 }
 
 fn main() {
-    Vec::<int, Heap, bool>::new();
+    Vec::<isize, Heap, bool>::new();
     //~^ ERROR too many type parameters provided
 }
diff --git a/src/test/compile-fail/generic-type-more-params-with-defaults.rs b/src/test/compile-fail/generic-type-more-params-with-defaults.rs
index ee3e1818779..19d303488ac 100644
--- a/src/test/compile-fail/generic-type-more-params-with-defaults.rs
+++ b/src/test/compile-fail/generic-type-more-params-with-defaults.rs
@@ -13,6 +13,6 @@ struct Heap;
 struct Vec<T, A = Heap>;
 
 fn main() {
-    let _: Vec<int, Heap, bool>;
+    let _: Vec<isize, Heap, bool>;
     //~^ ERROR wrong number of type arguments: expected at most 2, found 3
 }
diff --git a/src/test/compile-fail/glob-resolve1.rs b/src/test/compile-fail/glob-resolve1.rs
index d8258a72ce3..fce8a07d727 100644
--- a/src/test/compile-fail/glob-resolve1.rs
+++ b/src/test/compile-fail/glob-resolve1.rs
@@ -23,7 +23,7 @@ mod bar {
 
     struct C;
 
-    type D = int;
+    type D = isize;
 }
 
 fn foo<T>() {}
diff --git a/src/test/compile-fail/hrtb-conflate-regions.rs b/src/test/compile-fail/hrtb-conflate-regions.rs
index 5eb8fd69312..3efe0501267 100644
--- a/src/test/compile-fail/hrtb-conflate-regions.rs
+++ b/src/test/compile-fail/hrtb-conflate-regions.rs
@@ -16,12 +16,12 @@ trait Foo<X> {
 }
 
 fn want_foo2<T>()
-    where T : for<'a,'b> Foo<(&'a int, &'b int)>
+    where T : for<'a,'b> Foo<(&'a isize, &'b isize)>
 {
 }
 
 fn want_foo1<T>()
-    where T : for<'z> Foo<(&'z int, &'z int)>
+    where T : for<'z> Foo<(&'z isize, &'z isize)>
 {
 }
 
@@ -30,7 +30,7 @@ fn want_foo1<T>()
 
 struct SomeStruct;
 
-impl<'a> Foo<(&'a int, &'a int)> for SomeStruct
+impl<'a> Foo<(&'a isize, &'a isize)> for SomeStruct
 {
 }
 
diff --git a/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs b/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs
index 4199deee7b8..249256f8e01 100644
--- a/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs
+++ b/src/test/compile-fail/hrtb-higher-ranker-supertraits-transitive.rs
@@ -12,13 +12,13 @@
 
 trait Foo<'tcx>
 {
-    fn foo(&'tcx self) -> &'tcx int;
+    fn foo(&'tcx self) -> &'tcx isize;
 }
 
 trait Bar<'ccx>
     : for<'tcx> Foo<'tcx>
 {
-    fn bar(&'ccx self) -> &'ccx int;
+    fn bar(&'ccx self) -> &'ccx isize;
 }
 
 trait Baz
diff --git a/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs b/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs
index 108ca1b82e0..441ad76b602 100644
--- a/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs
+++ b/src/test/compile-fail/hrtb-higher-ranker-supertraits.rs
@@ -12,13 +12,13 @@
 
 trait Foo<'tcx>
 {
-    fn foo(&'tcx self) -> &'tcx int;
+    fn foo(&'tcx self) -> &'tcx isize;
 }
 
 trait Bar<'ccx>
     : for<'tcx> Foo<'tcx>
 {
-    fn bar(&'ccx self) -> &'ccx int;
+    fn bar(&'ccx self) -> &'ccx isize;
 }
 
 fn want_foo_for_some_tcx<'x,F>(f: &'x F)
diff --git a/src/test/compile-fail/hrtb-identity-fn-borrows.rs b/src/test/compile-fail/hrtb-identity-fn-borrows.rs
index 733a5b2a85a..17939cf9fe0 100644
--- a/src/test/compile-fail/hrtb-identity-fn-borrows.rs
+++ b/src/test/compile-fail/hrtb-identity-fn-borrows.rs
@@ -16,7 +16,7 @@ trait FnLike<A,R> {
 }
 
 fn call_repeatedly<F>(f: F)
-    where F : for<'a> FnLike<&'a int, &'a int>
+    where F : for<'a> FnLike<&'a isize, &'a isize>
 {
     // Result is stored: cannot re-assign `x`
     let mut x = 3;
diff --git a/src/test/compile-fail/immut-function-arguments.rs b/src/test/compile-fail/immut-function-arguments.rs
index 827e648cca8..99927d8b9bf 100644
--- a/src/test/compile-fail/immut-function-arguments.rs
+++ b/src/test/compile-fail/immut-function-arguments.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 
-fn f(y: Box<int>) {
+fn f(y: Box<isize>) {
     *y = 5; //~ ERROR cannot assign
 }
 
 fn g() {
-    let _frob = |&: q: Box<int>| { *q = 2; }; //~ ERROR cannot assign
+    let _frob = |&: q: Box<isize>| { *q = 2; }; //~ ERROR cannot assign
 
 }
 
diff --git a/src/test/compile-fail/impl-bounds-checking.rs b/src/test/compile-fail/impl-bounds-checking.rs
index 69a35bcbd7b..8c8f67e40ab 100644
--- a/src/test/compile-fail/impl-bounds-checking.rs
+++ b/src/test/compile-fail/impl-bounds-checking.rs
@@ -17,8 +17,8 @@ trait Getter<T: Clone2> {
     fn get(&self) -> T;
 }
 
-impl Getter<int> for int { //~ ERROR the trait `Clone2` is not implemented
-    fn get(&self) -> int { *self }
+impl Getter<isize> for isize { //~ ERROR the trait `Clone2` is not implemented
+    fn get(&self) -> isize { *self }
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/impl-not-adjacent-to-type.rs b/src/test/compile-fail/impl-not-adjacent-to-type.rs
index 7a5428d63e8..7a7673d871d 100644
--- a/src/test/compile-fail/impl-not-adjacent-to-type.rs
+++ b/src/test/compile-fail/impl-not-adjacent-to-type.rs
@@ -10,8 +10,8 @@
 
 mod foo {
     pub struct Foo {
-        x: int,
-        y: int,
+        x: isize,
+        y: isize,
     }
 }
 
diff --git a/src/test/compile-fail/impl-unused-tps.rs b/src/test/compile-fail/impl-unused-tps.rs
index 99c6c6b8985..c9399afbb93 100644
--- a/src/test/compile-fail/impl-unused-tps.rs
+++ b/src/test/compile-fail/impl-unused-tps.rs
@@ -16,19 +16,19 @@ trait Bar {
     type Out;
 }
 
-impl<T> Foo<T> for [int;0] {
+impl<T> Foo<T> for [isize;0] {
     // OK, T is used in `Foo<T>`.
 }
 
-impl<T,U> Foo<T> for [int;1] {
+impl<T,U> Foo<T> for [isize;1] {
     //~^ ERROR the type parameter `U` is not constrained
 }
 
-impl<T,U> Foo<T> for [int;2] where T : Bar<Out=U> {
+impl<T,U> Foo<T> for [isize;2] where T : Bar<Out=U> {
     // OK, `U` is now constrained by the output type parameter.
 }
 
-impl<T:Bar<Out=U>,U> Foo<T> for [int;3] {
+impl<T:Bar<Out=U>,U> Foo<T> for [isize;3] {
     // OK, same as above but written differently.
 }
 
diff --git a/src/test/compile-fail/import-shadow-1.rs b/src/test/compile-fail/import-shadow-1.rs
index eac5a98140f..503fa4eca52 100644
--- a/src/test/compile-fail/import-shadow-1.rs
+++ b/src/test/compile-fail/import-shadow-1.rs
@@ -16,11 +16,11 @@ use foo::*;
 use bar::*; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-2.rs b/src/test/compile-fail/import-shadow-2.rs
index 8b0809fd55a..0c107cf27f5 100644
--- a/src/test/compile-fail/import-shadow-2.rs
+++ b/src/test/compile-fail/import-shadow-2.rs
@@ -16,11 +16,11 @@ use foo::*;
 use foo::*; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-3.rs b/src/test/compile-fail/import-shadow-3.rs
index cef481af6ba..bf90973c285 100644
--- a/src/test/compile-fail/import-shadow-3.rs
+++ b/src/test/compile-fail/import-shadow-3.rs
@@ -16,11 +16,11 @@ use foo::Baz;
 use bar::*; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-4.rs b/src/test/compile-fail/import-shadow-4.rs
index 919eea0e046..f21fdaae47b 100644
--- a/src/test/compile-fail/import-shadow-4.rs
+++ b/src/test/compile-fail/import-shadow-4.rs
@@ -16,11 +16,11 @@ use foo::*;
 use bar::Baz; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-5.rs b/src/test/compile-fail/import-shadow-5.rs
index df17b7f0a20..dc300bc7baa 100644
--- a/src/test/compile-fail/import-shadow-5.rs
+++ b/src/test/compile-fail/import-shadow-5.rs
@@ -16,11 +16,11 @@ use foo::Baz;
 use bar::Baz; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-6.rs b/src/test/compile-fail/import-shadow-6.rs
index 94269043b02..fa3b75c70f0 100644
--- a/src/test/compile-fail/import-shadow-6.rs
+++ b/src/test/compile-fail/import-shadow-6.rs
@@ -16,11 +16,11 @@ use qux::*;
 use foo::*; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/import-shadow-7.rs b/src/test/compile-fail/import-shadow-7.rs
index b3bac380710..34aba15b392 100644
--- a/src/test/compile-fail/import-shadow-7.rs
+++ b/src/test/compile-fail/import-shadow-7.rs
@@ -16,11 +16,11 @@ use foo::*;
 use qux::*; //~ERROR a type named `Baz` has already been imported in this module
 
 mod foo {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod bar {
-    pub type Baz = int;
+    pub type Baz = isize;
 }
 
 mod qux {
diff --git a/src/test/compile-fail/indexing-requires-a-uint.rs b/src/test/compile-fail/indexing-requires-a-uint.rs
index e5edb2358f8..e40457a86c9 100644
--- a/src/test/compile-fail/indexing-requires-a-uint.rs
+++ b/src/test/compile-fail/indexing-requires-a-uint.rs
@@ -20,7 +20,7 @@ fn main() {
 
     let i = 0;      // i is an IntVar
     [0][i];         // i should be locked to uint
-    bar::<int>(i);  // i should not be re-coerced back to an int
+    bar::<isize>(i);  // i should not be re-coerced back to an isize
     //~^ ERROR: mismatched types
 }
 
diff --git a/src/test/compile-fail/infinite-tag-type-recursion.rs b/src/test/compile-fail/infinite-tag-type-recursion.rs
index f8d89a8269d..a57c015d684 100644
--- a/src/test/compile-fail/infinite-tag-type-recursion.rs
+++ b/src/test/compile-fail/infinite-tag-type-recursion.rs
@@ -11,6 +11,6 @@
 
 // error-pattern: illegal recursive enum type; wrap the inner value in a box
 
-enum mlist { cons(int, mlist), nil, }
+enum mlist { cons(isize, mlist), nil, }
 
 fn main() { let a = mlist::cons(10, mlist::cons(11, mlist::nil)); }
diff --git a/src/test/compile-fail/int-literal-too-large-span.rs b/src/test/compile-fail/int-literal-too-large-span.rs
index 8a496c934b9..2eb66816cba 100644
--- a/src/test/compile-fail/int-literal-too-large-span.rs
+++ b/src/test/compile-fail/int-literal-too-large-span.rs
@@ -11,7 +11,7 @@
 // issue #17123
 
 fn main() {
-    100000000000000000000000000000000 //~ ERROR int literal is too large
+    100000000000000000000000000000000 //~ ERROR isize literal is too large
 
         ; // the span shouldn't point to this.
 }
diff --git a/src/test/compile-fail/integral-indexing.rs b/src/test/compile-fail/integral-indexing.rs
index bbceb00abd3..08a8f72a668 100644
--- a/src/test/compile-fail/integral-indexing.rs
+++ b/src/test/compile-fail/integral-indexing.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    let v: Vec<int> = vec!(0, 1, 2, 3, 4, 5);
+    let v: Vec<isize> = vec!(0, 1, 2, 3, 4, 5);
     let s: String = "abcdef".to_string();
     v.as_slice()[3u];
     v.as_slice()[3];
diff --git a/src/test/compile-fail/intrinsic-return-address.rs b/src/test/compile-fail/intrinsic-return-address.rs
index 9c1db4057c6..a80d3931555 100644
--- a/src/test/compile-fail/intrinsic-return-address.rs
+++ b/src/test/compile-fail/intrinsic-return-address.rs
@@ -20,7 +20,7 @@ unsafe fn f() {
     //~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer
 }
 
-unsafe fn g() -> int {
+unsafe fn g() -> isize {
     let _ = return_address();
     //~^ ERROR invalid use of `return_address` intrinsic: function does not use out pointer
     0
diff --git a/src/test/compile-fail/issue-10291.rs b/src/test/compile-fail/issue-10291.rs
index 453746ffd6a..45f6e55914a 100644
--- a/src/test/compile-fail/issue-10291.rs
+++ b/src/test/compile-fail/issue-10291.rs
@@ -10,8 +10,8 @@
 
 #![feature(box_syntax)]
 
-fn test<'x>(x: &'x int) {
-    drop::<Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| {
+fn test<'x>(x: &'x isize) {
+    drop::<Box<for<'z> FnMut(&'z isize) -> &'z isize>>(box |z| {
         x
         //~^ ERROR cannot infer an appropriate lifetime
     });
diff --git a/src/test/compile-fail/issue-10392-2.rs b/src/test/compile-fail/issue-10392-2.rs
index 2cbb59cc15a..b077081c5b0 100644
--- a/src/test/compile-fail/issue-10392-2.rs
+++ b/src/test/compile-fail/issue-10392-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct A { foo: int }
+struct A { foo: isize }
 
 fn a() -> A { panic!() }
 
diff --git a/src/test/compile-fail/issue-10392.rs b/src/test/compile-fail/issue-10392.rs
index 4d0e02c6310..3f8d26bfec0 100644
--- a/src/test/compile-fail/issue-10392.rs
+++ b/src/test/compile-fail/issue-10392.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct A { foo: int }
+struct A { foo: isize }
 
 fn a() -> A { panic!() }
 
diff --git a/src/test/compile-fail/issue-10636-2.rs b/src/test/compile-fail/issue-10636-2.rs
index 2303f858fcc..a92ef248924 100644
--- a/src/test/compile-fail/issue-10636-2.rs
+++ b/src/test/compile-fail/issue-10636-2.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-pub fn trace_option(option: Option<int>) {
+pub fn trace_option(option: Option<isize>) {
     option.map(|some| 42; //~ NOTE: unclosed delimiter
 } //~ ERROR: incorrect close delimiter
diff --git a/src/test/compile-fail/issue-10877.rs b/src/test/compile-fail/issue-10877.rs
index 2a9cadf1f33..132298eba99 100644
--- a/src/test/compile-fail/issue-10877.rs
+++ b/src/test/compile-fail/issue-10877.rs
@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Foo { x: int }
+struct Foo { x: isize }
 extern {
     fn foo(1: ());
     //~^ ERROR: patterns aren't allowed in foreign function declarations
-    fn bar((): int);
+    fn bar((): isize);
     //~^ ERROR: patterns aren't allowed in foreign function declarations
-    fn baz(Foo { x }: int);
+    fn baz(Foo { x }: isize);
     //~^ ERROR: patterns aren't allowed in foreign function declarations
     fn qux((x,y): ());
     //~^ ERROR: patterns aren't allowed in foreign function declarations
diff --git a/src/test/compile-fail/issue-11192.rs b/src/test/compile-fail/issue-11192.rs
index 3784d3d6437..0d7a846bff6 100644
--- a/src/test/compile-fail/issue-11192.rs
+++ b/src/test/compile-fail/issue-11192.rs
@@ -11,7 +11,7 @@
 #![feature(box_syntax)]
 
 struct Foo {
-    x: int
+    x: isize
 }
 
 impl Drop for Foo {
diff --git a/src/test/compile-fail/issue-11714.rs b/src/test/compile-fail/issue-11714.rs
index ed00d4131db..dd3fad978eb 100644
--- a/src/test/compile-fail/issue-11714.rs
+++ b/src/test/compile-fail/issue-11714.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn blah() -> int { //~ ERROR not all control paths return a value
+fn blah() -> isize { //~ ERROR not all control paths return a value
     1i
 
     ; //~ HELP consider removing this semicolon:
diff --git a/src/test/compile-fail/issue-12116.rs b/src/test/compile-fail/issue-12116.rs
index 8a5e8c27259..6f75909fada 100644
--- a/src/test/compile-fail/issue-12116.rs
+++ b/src/test/compile-fail/issue-12116.rs
@@ -11,7 +11,7 @@
 #![feature(box_syntax)]
 
 enum IntList {
-    Cons(int, Box<IntList>),
+    Cons(isize, Box<IntList>),
     Nil
 }
 
diff --git a/src/test/compile-fail/issue-12127.rs b/src/test/compile-fail/issue-12127.rs
index 2d87bdaf524..c06082de3cd 100644
--- a/src/test/compile-fail/issue-12127.rs
+++ b/src/test/compile-fail/issue-12127.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn do_it(x: &int) { }
+fn do_it(x: &isize) { }
 
 fn main() {
     let x = box 22;
diff --git a/src/test/compile-fail/issue-12369.rs b/src/test/compile-fail/issue-12369.rs
index 4522b536ffd..0587bdf6136 100644
--- a/src/test/compile-fail/issue-12369.rs
+++ b/src/test/compile-fail/issue-12369.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     let sl = vec![1,2,3];
-    let v: int = match sl.as_slice() {
+    let v: isize = match sl.as_slice() {
         [] => 0,
         [a,b,c] => 3,
         [a, rest..] => a,
diff --git a/src/test/compile-fail/issue-12470.rs b/src/test/compile-fail/issue-12470.rs
index 31874655302..93785817e14 100644
--- a/src/test/compile-fail/issue-12470.rs
+++ b/src/test/compile-fail/issue-12470.rs
@@ -11,16 +11,16 @@
 #![feature(box_syntax)]
 
 trait X {
-    fn get_i(&self) -> int;
+    fn get_i(&self) -> isize;
 }
 
 
 struct B {
-    i: int
+    i: isize
 }
 
 impl X for B {
-    fn get_i(&self) -> int {
+    fn get_i(&self) -> isize {
         self.i
     }
 }
diff --git a/src/test/compile-fail/issue-12997-1.rs b/src/test/compile-fail/issue-12997-1.rs
index 193cbcb25b7..2d8d7857c99 100644
--- a/src/test/compile-fail/issue-12997-1.rs
+++ b/src/test/compile-fail/issue-12997-1.rs
@@ -16,4 +16,4 @@
 fn foo() { } //~ ERROR functions used as benches
 
 #[bench]
-fn bar(x: int, y: int) { } //~ ERROR functions used as benches
+fn bar(x: isize, y: isize) { } //~ ERROR functions used as benches
diff --git a/src/test/compile-fail/issue-13359.rs b/src/test/compile-fail/issue-13359.rs
index 25e64e070f4..607874de49d 100644
--- a/src/test/compile-fail/issue-13359.rs
+++ b/src/test/compile-fail/issue-13359.rs
@@ -13,7 +13,7 @@ fn foo(_s: i16) { }
 fn bar(_s: u32) { }
 
 fn main() {
-    foo(1*(1 as int));
+    foo(1*(1 as isize));
     //~^ ERROR: mismatched types: expected `i16`, found `isize` (expected i16, found isize)
 
     bar(1*(1 as uint));
diff --git a/src/test/compile-fail/issue-13853-4.rs b/src/test/compile-fail/issue-13853-4.rs
index 7d653f5ab9e..b0db9e58dba 100644
--- a/src/test/compile-fail/issue-13853-4.rs
+++ b/src/test/compile-fail/issue-13853-4.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct AutoBuilder<'a> {
-    context: &'a int
+    context: &'a isize
 }
 
 impl<'a> Drop for AutoBuilder<'a> {
diff --git a/src/test/compile-fail/issue-14182.rs b/src/test/compile-fail/issue-14182.rs
index 5033576a234..364951a4fea 100644
--- a/src/test/compile-fail/issue-14182.rs
+++ b/src/test/compile-fail/issue-14182.rs
@@ -11,8 +11,8 @@
 // ignore-test FIXME(japari) remove test
 
 struct Foo {
-    f: for <'b> |&'b int|:
-      'b -> &'b int //~ ERROR use of undeclared lifetime name `'b`
+    f: for <'b> |&'b isize|:
+      'b -> &'b isize //~ ERROR use of undeclared lifetime name `'b`
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-14254.rs b/src/test/compile-fail/issue-14254.rs
index dc19b9d51c8..74eea0c57a0 100644
--- a/src/test/compile-fail/issue-14254.rs
+++ b/src/test/compile-fail/issue-14254.rs
@@ -15,7 +15,7 @@ trait Foo {
 }
 
 struct BarTy {
-    x : int,
+    x : isize,
     y : f64,
 }
 
@@ -76,7 +76,7 @@ impl Foo for Box<BarTy> {
     }
 }
 
-impl Foo for *const int {
+impl Foo for *const isize {
     fn bar(&self) {
         baz();
         //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`?
@@ -85,7 +85,7 @@ impl Foo for *const int {
     }
 }
 
-impl<'a> Foo for &'a int {
+impl<'a> Foo for &'a isize {
     fn bar(&self) {
         baz();
         //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`?
@@ -94,7 +94,7 @@ impl<'a> Foo for &'a int {
     }
 }
 
-impl<'a> Foo for &'a mut int {
+impl<'a> Foo for &'a mut isize {
     fn bar(&self) {
         baz();
         //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`?
@@ -103,7 +103,7 @@ impl<'a> Foo for &'a mut int {
     }
 }
 
-impl Foo for Box<int> {
+impl Foo for Box<isize> {
     fn bar(&self) {
         baz();
         //~^ ERROR: unresolved name `baz`. Did you mean to call `self.baz`?
diff --git a/src/test/compile-fail/issue-14303-impl.rs b/src/test/compile-fail/issue-14303-impl.rs
index 46d0219da81..c4a00581274 100644
--- a/src/test/compile-fail/issue-14303-impl.rs
+++ b/src/test/compile-fail/issue-14303-impl.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct X { x: int }
+struct X { x: isize }
 
 impl<'a, T, 'b> X {}
 //~^ ERROR lifetime parameters must be declared prior to type parameters
diff --git a/src/test/compile-fail/issue-15129.rs b/src/test/compile-fail/issue-15129.rs
index f56430f4228..7a7ba46de74 100644
--- a/src/test/compile-fail/issue-15129.rs
+++ b/src/test/compile-fail/issue-15129.rs
@@ -14,7 +14,7 @@ pub enum T {
 }
 
 pub enum V {
-    V1(int),
+    V1(isize),
     V2(bool)
 }
 
diff --git a/src/test/compile-fail/issue-15524.rs b/src/test/compile-fail/issue-15524.rs
index 6d9657ab289..b378d2f885e 100644
--- a/src/test/compile-fail/issue-15524.rs
+++ b/src/test/compile-fail/issue-15524.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-const N: int = 1;
+const N: isize = 1;
 
 enum Foo {
     A = 1,
diff --git a/src/test/compile-fail/issue-16149.rs b/src/test/compile-fail/issue-16149.rs
index aa586e58f70..a924cc9f9bb 100644
--- a/src/test/compile-fail/issue-16149.rs
+++ b/src/test/compile-fail/issue-16149.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 extern {
-    static externalValue: int;
+    static externalValue: isize;
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-16465.rs b/src/test/compile-fail/issue-16465.rs
index 280f19cfe9c..825b40cb322 100644
--- a/src/test/compile-fail/issue-16465.rs
+++ b/src/test/compile-fail/issue-16465.rs
@@ -14,7 +14,7 @@ struct Foo<T>{
     x : T
 }
 
-type FooInt = Foo<int>;
+type FooInt = Foo<isize>;
 
 impl Drop for FooInt {
 //~^ ERROR cannot implement a destructor on a structure with type parameters
diff --git a/src/test/compile-fail/issue-17263.rs b/src/test/compile-fail/issue-17263.rs
index ba993259216..543063b3fc9 100644
--- a/src/test/compile-fail/issue-17263.rs
+++ b/src/test/compile-fail/issue-17263.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-struct Foo { a: int, b: int }
+struct Foo { a: isize, b: isize }
 
 fn main() {
     let mut x = box Foo { a: 1, b: 2 };
diff --git a/src/test/compile-fail/issue-17383.rs b/src/test/compile-fail/issue-17383.rs
index 24007364550..c71e0ecd494 100644
--- a/src/test/compile-fail/issue-17383.rs
+++ b/src/test/compile-fail/issue-17383.rs
@@ -12,7 +12,7 @@ enum X {
     A =
         b'a' //~ ERROR discriminator values can only be used with a c-like enum
     ,
-    B(int)
+    B(isize)
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-17385.rs b/src/test/compile-fail/issue-17385.rs
index 62a5c7318b9..e7cab292ea7 100644
--- a/src/test/compile-fail/issue-17385.rs
+++ b/src/test/compile-fail/issue-17385.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct X(int);
+struct X(isize);
 
 enum Enum {
     Variant1,
diff --git a/src/test/compile-fail/issue-17405.rs b/src/test/compile-fail/issue-17405.rs
index c956f00c8e7..cb541835fbb 100644
--- a/src/test/compile-fail/issue-17405.rs
+++ b/src/test/compile-fail/issue-17405.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 enum Foo {
-    Bar(int)
+    Bar(isize)
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-17450.rs b/src/test/compile-fail/issue-17450.rs
index ca611c62577..5471d8522df 100644
--- a/src/test/compile-fail/issue-17450.rs
+++ b/src/test/compile-fail/issue-17450.rs
@@ -10,8 +10,8 @@
 
 #![allow(dead_code)]
 
-static mut x: int = 3;
-static mut y: int = unsafe {
+static mut x: isize = 3;
+static mut y: isize = unsafe {
     x
 //~^ ERROR cannot refer to other statics by value, use the address-of operator or a constant instea
 };
diff --git a/src/test/compile-fail/issue-17718-const-naming.rs b/src/test/compile-fail/issue-17718-const-naming.rs
index 0cfee6daf3f..15f66493f88 100644
--- a/src/test/compile-fail/issue-17718-const-naming.rs
+++ b/src/test/compile-fail/issue-17718-const-naming.rs
@@ -10,7 +10,7 @@
 
 #[deny(warnings)]
 
-const foo: int = 3;
+const foo: isize = 3;
 //~^ ERROR: should have an uppercase name such as
 //~^^ ERROR: constant item is never used
 
diff --git a/src/test/compile-fail/issue-18118.rs b/src/test/compile-fail/issue-18118.rs
index 4497c8088c3..129f28f1d89 100644
--- a/src/test/compile-fail/issue-18118.rs
+++ b/src/test/compile-fail/issue-18118.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 pub fn main() {
-    static z: &'static int = {
+    static z: &'static isize = {
         let p = 3;
         &p
 //~^ ERROR cannot borrow a local variable inside a static block, define a separate static instead
diff --git a/src/test/compile-fail/issue-18423.rs b/src/test/compile-fail/issue-18423.rs
index 63b110b5579..5945a7a1c9a 100644
--- a/src/test/compile-fail/issue-18423.rs
+++ b/src/test/compile-fail/issue-18423.rs
@@ -11,7 +11,7 @@
 // Test that `Box` cannot be used with a lifetime parameter.
 
 struct Foo<'a> {
-    x: Box<'a, int> //~ ERROR wrong number of lifetime parameters
+    x: Box<'a, isize> //~ ERROR wrong number of lifetime parameters
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/issue-19096.rs b/src/test/compile-fail/issue-19096.rs
index 5d915d6a59b..1e68de1f923 100644
--- a/src/test/compile-fail/issue-19096.rs
+++ b/src/test/compile-fail/issue-19096.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let t = (42i, 42i);
-    t.0::<int>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::`
+    t.0::<isize>; //~ ERROR expected one of `.`, `;`, `}`, or an operator, found `::`
 }
diff --git a/src/test/compile-fail/issue-19244-1.rs b/src/test/compile-fail/issue-19244-1.rs
index fafe6377397..c3700f2f90a 100644
--- a/src/test/compile-fail/issue-19244-1.rs
+++ b/src/test/compile-fail/issue-19244-1.rs
@@ -11,6 +11,6 @@
 const TUP: (uint,) = (42,);
 
 fn main() {
-    let a: [int; TUP.1];
+    let a: [isize; TUP.1];
     //~^ ERROR expected constant expr for array length: tuple index out of bounds
 }
diff --git a/src/test/compile-fail/issue-19244-2.rs b/src/test/compile-fail/issue-19244-2.rs
index 95965ca35f9..7c7271552d2 100644
--- a/src/test/compile-fail/issue-19244-2.rs
+++ b/src/test/compile-fail/issue-19244-2.rs
@@ -12,6 +12,6 @@ struct MyStruct { field: uint }
 const STRUCT: MyStruct = MyStruct { field: 42 };
 
 fn main() {
-    let a: [int; STRUCT.nonexistent_field];
+    let a: [isize; STRUCT.nonexistent_field];
     //~^ ERROR expected constant expr for array length: nonexistent struct field
 }
diff --git a/src/test/compile-fail/issue-2150.rs b/src/test/compile-fail/issue-2150.rs
index 455cde63f27..90b5ff8475e 100644
--- a/src/test/compile-fail/issue-2150.rs
+++ b/src/test/compile-fail/issue-2150.rs
@@ -12,7 +12,7 @@
 #![allow(unused_variables)]
 #![allow(dead_code)]
 
-fn fail_len(v: Vec<int> ) -> uint {
+fn fail_len(v: Vec<isize> ) -> uint {
     let mut i = 3;
     panic!();
     for x in v.iter() { i += 1u; }
diff --git a/src/test/compile-fail/issue-2330.rs b/src/test/compile-fail/issue-2330.rs
index 6291b024053..63f146a21d9 100644
--- a/src/test/compile-fail/issue-2330.rs
+++ b/src/test/compile-fail/issue-2330.rs
@@ -15,8 +15,8 @@ trait channel<T> {
 }
 
 // `chan` is not a trait, it's an enum
-impl chan for int { //~ ERROR `chan` is not a trait
-    fn send(&self, v: int) { panic!() }
+impl chan for isize { //~ ERROR `chan` is not a trait
+    fn send(&self, v: isize) { panic!() }
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-2354-1.rs b/src/test/compile-fail/issue-2354-1.rs
index 67b5c6becc7..d37837b9714 100644
--- a/src/test/compile-fail/issue-2354-1.rs
+++ b/src/test/compile-fail/issue-2354-1.rs
@@ -8,5 +8,5 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static foo: int = 2; } //~ ERROR incorrect close delimiter:
+static foo: isize = 2; } //~ ERROR incorrect close delimiter:
 
diff --git a/src/test/compile-fail/issue-2356.rs b/src/test/compile-fail/issue-2356.rs
index 850edd05781..d6acc13c289 100644
--- a/src/test/compile-fail/issue-2356.rs
+++ b/src/test/compile-fail/issue-2356.rs
@@ -13,7 +13,7 @@ trait Groom {
 }
 
 pub struct cat {
-  whiskers: int,
+  whiskers: isize,
 }
 
 pub enum MaybeDog {
diff --git a/src/test/compile-fail/issue-2478.rs b/src/test/compile-fail/issue-2478.rs
index 860192ba3e5..3aea9c32e3a 100644
--- a/src/test/compile-fail/issue-2478.rs
+++ b/src/test/compile-fail/issue-2478.rs
@@ -10,8 +10,8 @@
 
 // ignore-test
 
-fn foo<'a>() -> &'a int {  //~ ERROR unconstrained region
+fn foo<'a>() -> &'a isize {  //~ ERROR unconstrained region
     return &x;
 }
-static x: int = 5;
+static x: isize = 5;
 fn main() {}
diff --git a/src/test/compile-fail/issue-2590.rs b/src/test/compile-fail/issue-2590.rs
index 79a66e30fdb..60a270b2c94 100644
--- a/src/test/compile-fail/issue-2590.rs
+++ b/src/test/compile-fail/issue-2590.rs
@@ -10,15 +10,15 @@
 
 
 struct parser {
-    tokens: Vec<int> ,
+    tokens: Vec<isize> ,
 }
 
 trait parse {
-    fn parse(&self) -> Vec<int> ;
+    fn parse(&self) -> Vec<isize> ;
 }
 
 impl parse for parser {
-    fn parse(&self) -> Vec<int> {
+    fn parse(&self) -> Vec<isize> {
         self.tokens //~ ERROR cannot move out of dereference of `&`-pointer
     }
 }
diff --git a/src/test/compile-fail/issue-2611-4.rs b/src/test/compile-fail/issue-2611-4.rs
index 70ffa86359d..b141c1f441a 100644
--- a/src/test/compile-fail/issue-2611-4.rs
+++ b/src/test/compile-fail/issue-2611-4.rs
@@ -16,7 +16,7 @@ trait A {
 }
 
 struct E {
- f: int
+ f: isize
 }
 
 impl A for E {
diff --git a/src/test/compile-fail/issue-2611-5.rs b/src/test/compile-fail/issue-2611-5.rs
index 2eda5d67edd..440294f38ae 100644
--- a/src/test/compile-fail/issue-2611-5.rs
+++ b/src/test/compile-fail/issue-2611-5.rs
@@ -16,7 +16,7 @@ trait A {
 }
 
 struct E {
- f: int
+ f: isize
 }
 
 impl A for E {
diff --git a/src/test/compile-fail/issue-2823.rs b/src/test/compile-fail/issue-2823.rs
index b6820a1d8e4..1996cb737fc 100644
--- a/src/test/compile-fail/issue-2823.rs
+++ b/src/test/compile-fail/issue-2823.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct C {
-    x: int,
+    x: isize,
 }
 
 impl Drop for C {
diff --git a/src/test/compile-fail/issue-2849.rs b/src/test/compile-fail/issue-2849.rs
index 5aaeb7e8c6d..48f4cac9711 100644
--- a/src/test/compile-fail/issue-2849.rs
+++ b/src/test/compile-fail/issue-2849.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum foo { alpha, beta(int) }
+enum foo { alpha, beta(isize) }
 
 fn main() {
     match foo::alpha {
diff --git a/src/test/compile-fail/issue-2995.rs b/src/test/compile-fail/issue-2995.rs
index 920897e6828..8fbf97411cc 100644
--- a/src/test/compile-fail/issue-2995.rs
+++ b/src/test/compile-fail/issue-2995.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn bad (p: *const int) {
-    let _q: &int = p as &int; //~ ERROR non-scalar cast
+fn bad (p: *const isize) {
+    let _q: &isize = p as &isize; //~ ERROR non-scalar cast
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/issue-3038.rs b/src/test/compile-fail/issue-3038.rs
index d9fe3550c9e..1eec62df788 100644
--- a/src/test/compile-fail/issue-3038.rs
+++ b/src/test/compile-fail/issue-3038.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum f { g(int, int) }
+enum f { g(isize, isize) }
 
 enum h { i(j, k) }
 
-enum j { l(int, int) }
-enum k { m(int, int) }
+enum j { l(isize, isize) }
+enum k { m(isize, isize) }
 
 fn main()
 {
diff --git a/src/test/compile-fail/issue-3521-2.rs b/src/test/compile-fail/issue-3521-2.rs
index cdfc9906776..678618d7216 100644
--- a/src/test/compile-fail/issue-3521-2.rs
+++ b/src/test/compile-fail/issue-3521-2.rs
@@ -11,7 +11,7 @@
 fn main() {
     let foo = 100;
 
-    static y: int = foo + 1; //~ ERROR: attempt to use a non-constant value in a constant
+    static y: isize = foo + 1; //~ ERROR: attempt to use a non-constant value in a constant
 
     println!("{}", y);
 }
diff --git a/src/test/compile-fail/issue-3668-2.rs b/src/test/compile-fail/issue-3668-2.rs
index f7637f684be..0577b152723 100644
--- a/src/test/compile-fail/issue-3668-2.rs
+++ b/src/test/compile-fail/issue-3668-2.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(x:int) {
-    static child: int = x + 1; //~ ERROR attempt to use a non-constant value in a constant
+fn f(x:isize) {
+    static child: isize = x + 1; //~ ERROR attempt to use a non-constant value in a constant
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-3702-2.rs b/src/test/compile-fail/issue-3702-2.rs
index 1e80fd7a7e9..2b732899ea4 100644
--- a/src/test/compile-fail/issue-3702-2.rs
+++ b/src/test/compile-fail/issue-3702-2.rs
@@ -11,13 +11,13 @@
 use std::num::ToPrimitive;
 
 trait Add {
-    fn to_int(&self) -> int;
-    fn add_dynamic(&self, other: &Add) -> int;
+    fn to_int(&self) -> isize;
+    fn add_dynamic(&self, other: &Add) -> isize;
 }
 
-impl Add for int {
-    fn to_int(&self) -> int { *self }
-    fn add_dynamic(&self, other: &Add) -> int {
+impl Add for isize {
+    fn to_int(&self) -> isize { *self }
+    fn add_dynamic(&self, other: &Add) -> isize {
         self.to_int() + other.to_int() //~ ERROR multiple applicable methods in scope
     }
 }
diff --git a/src/test/compile-fail/issue-3763.rs b/src/test/compile-fail/issue-3763.rs
index 06939d8f358..6e6c19a5bf6 100644
--- a/src/test/compile-fail/issue-3763.rs
+++ b/src/test/compile-fail/issue-3763.rs
@@ -12,7 +12,7 @@
 
 mod my_mod {
     pub struct MyStruct {
-        priv_field: int
+        priv_field: isize
     }
     pub fn MyStruct () -> MyStruct {
         MyStruct {priv_field: 4}
diff --git a/src/test/compile-fail/issue-3820.rs b/src/test/compile-fail/issue-3820.rs
index 06577afa6dd..28de76f18da 100644
--- a/src/test/compile-fail/issue-3820.rs
+++ b/src/test/compile-fail/issue-3820.rs
@@ -9,11 +9,11 @@
 // except according to those terms.
 
 struct Thing {
-    x: int
+    x: isize
 }
 
 impl Thing {
-    fn mul(&self, c: &int) -> Thing {
+    fn mul(&self, c: &isize) -> Thing {
         Thing {x: self.x * *c}
     }
 }
diff --git a/src/test/compile-fail/issue-3907-2.rs b/src/test/compile-fail/issue-3907-2.rs
index 546b808a38f..9a166a6752b 100644
--- a/src/test/compile-fail/issue-3907-2.rs
+++ b/src/test/compile-fail/issue-3907-2.rs
@@ -14,7 +14,7 @@ extern crate issue_3907;
 type Foo = issue_3907::Foo+'static;
 
 struct S {
-    name: int
+    name: isize
 }
 
 fn bar(_x: Foo) {} //~ ERROR the trait `core::marker::Sized` is not implemented
diff --git a/src/test/compile-fail/issue-3907.rs b/src/test/compile-fail/issue-3907.rs
index a2faef59fd8..001de796b4a 100644
--- a/src/test/compile-fail/issue-3907.rs
+++ b/src/test/compile-fail/issue-3907.rs
@@ -14,7 +14,7 @@ extern crate issue_3907;
 type Foo = issue_3907::Foo;
 
 struct S {
-    name: int
+    name: isize
 }
 
 impl Foo for S { //~ ERROR: `Foo` is not a trait
diff --git a/src/test/compile-fail/issue-3953.rs b/src/test/compile-fail/issue-3953.rs
index ab2018af999..0f1dd2d7fd6 100644
--- a/src/test/compile-fail/issue-3953.rs
+++ b/src/test/compile-fail/issue-3953.rs
@@ -16,7 +16,7 @@ trait Hahaha: PartialEq + PartialEq {
     //~^ ERROR trait `PartialEq` already appears in the list of bounds
 }
 
-struct Lol(int);
+struct Lol(isize);
 
 impl Hahaha for Lol { }
 
diff --git a/src/test/compile-fail/issue-4366-2.rs b/src/test/compile-fail/issue-4366-2.rs
index 289e9855525..e8dfac45447 100644
--- a/src/test/compile-fail/issue-4366-2.rs
+++ b/src/test/compile-fail/issue-4366-2.rs
@@ -18,7 +18,7 @@ mod foo {
 mod a {
     pub mod b {
         use foo::foo;
-        type bar = int;
+        type bar = isize;
     }
     pub mod sub {
         use a::b::*;
diff --git a/src/test/compile-fail/issue-4366.rs b/src/test/compile-fail/issue-4366.rs
index 289aa21e1cb..5625ac00c85 100644
--- a/src/test/compile-fail/issue-4366.rs
+++ b/src/test/compile-fail/issue-4366.rs
@@ -21,11 +21,11 @@ mod foo {
 mod a {
     pub mod b {
         use foo::foo;
-        type bar = int;
+        type bar = isize;
     }
     pub mod sub {
         use a::b::*;
-        fn sub() -> int { foo(); 1 } //~ ERROR: unresolved name `foo`
+        fn sub() -> isize { foo(); 1 } //~ ERROR: unresolved name `foo`
     }
 }
 
diff --git a/src/test/compile-fail/issue-5035.rs b/src/test/compile-fail/issue-5035.rs
index 8ffe308a669..cdf9d3bd36e 100644
--- a/src/test/compile-fail/issue-5035.rs
+++ b/src/test/compile-fail/issue-5035.rs
@@ -10,6 +10,6 @@
 
 trait I {}
 type K = I;
-impl K for int {} //~ ERROR: `K` is not a trait
+impl K for isize {} //~ ERROR: `K` is not a trait
 //~^ NOTE: `type` aliases cannot be used for traits
 fn main() {}
diff --git a/src/test/compile-fail/issue-5153.rs b/src/test/compile-fail/issue-5153.rs
index 57a158d2438..c10c7cba455 100644
--- a/src/test/compile-fail/issue-5153.rs
+++ b/src/test/compile-fail/issue-5153.rs
@@ -14,8 +14,8 @@ trait Foo {
     fn foo(self: Box<Self>);
 }
 
-impl Foo for int {
-    fn foo(self: Box<int>) { }
+impl Foo for isize {
+    fn foo(self: Box<isize>) { }
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-5439.rs b/src/test/compile-fail/issue-5439.rs
index 72074d64edc..4e618f3d858 100644
--- a/src/test/compile-fail/issue-5439.rs
+++ b/src/test/compile-fail/issue-5439.rs
@@ -11,15 +11,15 @@
 #![feature(box_syntax)]
 
 struct Foo {
-    foo: int,
+    foo: isize,
 }
 
 struct Bar {
-    bar: int,
+    bar: isize,
 }
 
 impl Bar {
-    fn make_foo (&self, i: int) -> Box<Foo> {
+    fn make_foo (&self, i: isize) -> Box<Foo> {
         return box Foo { nonexistent: self, foo: i }; //~ ERROR: no field named
     }
 }
diff --git a/src/test/compile-fail/issue-5544-a.rs b/src/test/compile-fail/issue-5544-a.rs
index 42a18ba5fb7..6db126f403a 100644
--- a/src/test/compile-fail/issue-5544-a.rs
+++ b/src/test/compile-fail/issue-5544-a.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let _i = 18446744073709551616; // 2^64
-    //~^ ERROR int literal is too large
+    //~^ ERROR isize literal is too large
 }
diff --git a/src/test/compile-fail/issue-5544-b.rs b/src/test/compile-fail/issue-5544-b.rs
index bbe43e652a8..4b04fe1a36a 100644
--- a/src/test/compile-fail/issue-5544-b.rs
+++ b/src/test/compile-fail/issue-5544-b.rs
@@ -10,5 +10,5 @@
 
 fn main() {
     let _i = 0xff_ffff_ffff_ffff_ffff;
-    //~^ ERROR int literal is too large
+    //~^ ERROR isize literal is too large
 }
diff --git a/src/test/compile-fail/issue-5997-enum.rs b/src/test/compile-fail/issue-5997-enum.rs
index 39e1e117cd0..ad485f2d330 100644
--- a/src/test/compile-fail/issue-5997-enum.rs
+++ b/src/test/compile-fail/issue-5997-enum.rs
@@ -16,6 +16,6 @@ fn f<Z>() -> bool {
 }
 
 fn main() {
-    let b = f::<int>();
+    let b = f::<isize>();
     assert!(b);
 }
diff --git a/src/test/compile-fail/issue-5997-struct.rs b/src/test/compile-fail/issue-5997-struct.rs
index b2a63ed1c7b..587c7c63f4c 100644
--- a/src/test/compile-fail/issue-5997-struct.rs
+++ b/src/test/compile-fail/issue-5997-struct.rs
@@ -16,6 +16,6 @@ fn f<T>() -> bool {
 }
 
 fn main() {
-    let b = f::<int>();
+    let b = f::<isize>();
     assert!(b);
 }
diff --git a/src/test/compile-fail/issue-6702.rs b/src/test/compile-fail/issue-6702.rs
index 3e35e4a659d..d035c615ec3 100644
--- a/src/test/compile-fail/issue-6702.rs
+++ b/src/test/compile-fail/issue-6702.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Monster {
-    damage: int
+    damage: isize
 }
 
 
diff --git a/src/test/compile-fail/issue-7044.rs b/src/test/compile-fail/issue-7044.rs
index ee332789b0e..6f9fb2e61f2 100644
--- a/src/test/compile-fail/issue-7044.rs
+++ b/src/test/compile-fail/issue-7044.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static X: int = 0;
+static X: isize = 0;
 struct X; //~ ERROR error: duplicate definition of value `X`
 
 fn main() {}
diff --git a/src/test/compile-fail/issue-7364.rs b/src/test/compile-fail/issue-7364.rs
index b4df38a6aac..2e644b65402 100644
--- a/src/test/compile-fail/issue-7364.rs
+++ b/src/test/compile-fail/issue-7364.rs
@@ -13,7 +13,7 @@
 use std::cell::RefCell;
 
 // Regresion test for issue 7364
-static boxed: Box<RefCell<int>> = box RefCell::new(0);
+static boxed: Box<RefCell<isize>> = box RefCell::new(0);
 //~^ ERROR statics are not allowed to have custom pointers
 //~| ERROR: the trait `core::marker::Sync` is not implemented for the type
 //~| ERROR: the trait `core::marker::Sync` is not implemented for the type
diff --git a/src/test/compile-fail/issue-7607-1.rs b/src/test/compile-fail/issue-7607-1.rs
index 9bf1bd2e011..48fc393d0da 100644
--- a/src/test/compile-fail/issue-7607-1.rs
+++ b/src/test/compile-fail/issue-7607-1.rs
@@ -11,7 +11,7 @@
 // ignore-tidy-linelength
 
 struct Foo {
-    x: int
+    x: isize
 }
 
 impl Fo { //~ERROR inherent implementations are not allowed for types not defined in the current module
diff --git a/src/test/compile-fail/issue-8153.rs b/src/test/compile-fail/issue-8153.rs
index 2af531135ec..ea7224939ce 100644
--- a/src/test/compile-fail/issue-8153.rs
+++ b/src/test/compile-fail/issue-8153.rs
@@ -13,12 +13,12 @@
 struct Foo;
 
 trait Bar {
-    fn bar(&self) -> int;
+    fn bar(&self) -> isize;
 }
 
 impl Bar for Foo {
-    fn bar(&self) -> int {1}
-    fn bar(&self) -> int {2} //~ ERROR duplicate method
+    fn bar(&self) -> isize {1}
+    fn bar(&self) -> isize {2} //~ ERROR duplicate method
 }
 
 fn main() {
diff --git a/src/test/compile-fail/issue-9243.rs b/src/test/compile-fail/issue-9243.rs
index eb3618c9f04..808aa098c5a 100644
--- a/src/test/compile-fail/issue-9243.rs
+++ b/src/test/compile-fail/issue-9243.rs
@@ -11,7 +11,7 @@
 // Regresion test for issue 9243
 
 struct Test {
-    mem: int,
+    mem: isize,
 }
 
 pub static g_test: Test = Test {mem: 0}; //~ ERROR statics are not allowed to have destructors
diff --git a/src/test/compile-fail/issue-9725.rs b/src/test/compile-fail/issue-9725.rs
index 9545ad43ff8..1a3c926ba38 100644
--- a/src/test/compile-fail/issue-9725.rs
+++ b/src/test/compile-fail/issue-9725.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct A { foo: int }
+struct A { foo: isize }
 
 fn main() {
     let A { foo, foo } = A { foo: 3 };
diff --git a/src/test/compile-fail/issue-9814.rs b/src/test/compile-fail/issue-9814.rs
index d6cc493e936..8aefc5919d1 100644
--- a/src/test/compile-fail/issue-9814.rs
+++ b/src/test/compile-fail/issue-9814.rs
@@ -11,7 +11,7 @@
 // Verify that single-variant enums cant be de-referenced
 // Regression test for issue #9814
 
-enum Foo { Bar(int) }
+enum Foo { Bar(isize) }
 
 fn main() {
     let _ = *Foo::Bar(2); //~ ERROR type `Foo` cannot be dereferenced
diff --git a/src/test/compile-fail/keyword-super.rs b/src/test/compile-fail/keyword-super.rs
index 6cbc8aa1ea6..0c94f76f1f6 100644
--- a/src/test/compile-fail/keyword-super.rs
+++ b/src/test/compile-fail/keyword-super.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    let super: int; //~ ERROR expected identifier, found keyword `super`
+    let super: isize; //~ ERROR expected identifier, found keyword `super`
 }
diff --git a/src/test/compile-fail/kindck-copy.rs b/src/test/compile-fail/kindck-copy.rs
index ac088e69a28..4398be4b212 100644
--- a/src/test/compile-fail/kindck-copy.rs
+++ b/src/test/compile-fail/kindck-copy.rs
@@ -18,8 +18,8 @@ fn assert_copy<T:Copy>() { }
 trait Dummy { }
 
 struct MyStruct {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 impl Copy for MyStruct {}
@@ -28,22 +28,22 @@ struct MyNoncopyStruct {
     x: Box<char>,
 }
 
-fn test<'a,T,U:Copy>(_: &'a int) {
+fn test<'a,T,U:Copy>(_: &'a isize) {
     // lifetime pointers are ok...
-    assert_copy::<&'static int>();
-    assert_copy::<&'a int>();
+    assert_copy::<&'static isize>();
+    assert_copy::<&'a isize>();
     assert_copy::<&'a str>();
-    assert_copy::<&'a [int]>();
+    assert_copy::<&'a [isize]>();
 
     // ...unless they are mutable
-    assert_copy::<&'static mut int>(); //~ ERROR `core::marker::Copy` is not implemented
-    assert_copy::<&'a mut int>();  //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<&'static mut isize>(); //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<&'a mut isize>();  //~ ERROR `core::marker::Copy` is not implemented
 
     // ~ pointers are not ok
-    assert_copy::<Box<int>>();   //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<Box<isize>>();   //~ ERROR `core::marker::Copy` is not implemented
     assert_copy::<String>();   //~ ERROR `core::marker::Copy` is not implemented
-    assert_copy::<Vec<int> >(); //~ ERROR `core::marker::Copy` is not implemented
-    assert_copy::<Box<&'a mut int>>(); //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<Vec<isize> >(); //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<Box<&'a mut isize>>(); //~ ERROR `core::marker::Copy` is not implemented
 
     // borrowed object types are generally ok
     assert_copy::<&'a Dummy>();
@@ -58,16 +58,16 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<&'a mut (Dummy+Copy)>();  //~ ERROR `core::marker::Copy` is not implemented
 
     // unsafe ptrs are ok
-    assert_copy::<*const int>();
-    assert_copy::<*const &'a mut int>();
+    assert_copy::<*const isize>();
+    assert_copy::<*const &'a mut isize>();
 
     // regular old ints and such are ok
-    assert_copy::<int>();
+    assert_copy::<isize>();
     assert_copy::<bool>();
     assert_copy::<()>();
 
     // tuples are ok
-    assert_copy::<(int,int)>();
+    assert_copy::<(isize,isize)>();
 
     // structs of POD are ok
     assert_copy::<MyStruct>();
@@ -76,7 +76,7 @@ fn test<'a,T,U:Copy>(_: &'a int) {
     assert_copy::<MyNoncopyStruct>(); //~ ERROR `core::marker::Copy` is not implemented
 
     // ref counted types are not ok
-    assert_copy::<Rc<int>>();   //~ ERROR `core::marker::Copy` is not implemented
+    assert_copy::<Rc<isize>>();   //~ ERROR `core::marker::Copy` is not implemented
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/kindck-destructor-owned.rs b/src/test/compile-fail/kindck-destructor-owned.rs
index 803da617abd..7f3704144be 100644
--- a/src/test/compile-fail/kindck-destructor-owned.rs
+++ b/src/test/compile-fail/kindck-destructor-owned.rs
@@ -10,7 +10,7 @@
 
 
 struct Bar<'a> {
-    f: &'a int,
+    f: &'a isize,
 }
 
 impl<'a> Drop for Bar<'a> {
@@ -20,7 +20,7 @@ impl<'a> Drop for Bar<'a> {
 }
 
 struct Baz {
-    f: &'static int,
+    f: &'static isize,
 }
 
 impl Drop for Baz {
diff --git a/src/test/compile-fail/kindck-impl-type-params.rs b/src/test/compile-fail/kindck-impl-type-params.rs
index 34e77353463..5d090689415 100644
--- a/src/test/compile-fail/kindck-impl-type-params.rs
+++ b/src/test/compile-fail/kindck-impl-type-params.rs
@@ -34,8 +34,8 @@ fn g<T>(val: T) {
 }
 
 fn foo<'a>() {
-    let t: S<&'a int> = S;
-    let a = &t as &Gettable<&'a int>;
+    let t: S<&'a isize> = S;
+    let a = &t as &Gettable<&'a isize>;
     //~^ ERROR declared lifetime bound not satisfied
 }
 
diff --git a/src/test/compile-fail/kindck-send-owned.rs b/src/test/compile-fail/kindck-send-owned.rs
index 11148d2846c..7025249fafb 100644
--- a/src/test/compile-fail/kindck-send-owned.rs
+++ b/src/test/compile-fail/kindck-send-owned.rs
@@ -13,13 +13,13 @@
 fn assert_send<T:Send>() { }
 
 // owned content are ok
-fn test30() { assert_send::<Box<int>>(); }
+fn test30() { assert_send::<Box<isize>>(); }
 fn test31() { assert_send::<String>(); }
-fn test32() { assert_send::<Vec<int> >(); }
+fn test32() { assert_send::<Vec<isize> >(); }
 
 // but not if they own a bad thing
-fn test40<'a>(_: &'a int) {
-    assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied
+fn test40<'a>(_: &'a isize) {
+    assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-send-region-pointers.rs b/src/test/compile-fail/kindck-send-region-pointers.rs
index 04172932cfe..c6987e89e3a 100644
--- a/src/test/compile-fail/kindck-send-region-pointers.rs
+++ b/src/test/compile-fail/kindck-send-region-pointers.rs
@@ -13,22 +13,22 @@
 fn assert_send<T:Send>() { }
 
 // lifetime pointers with 'static lifetime are ok
-fn test01() { assert_send::<&'static int>(); }
+fn test01() { assert_send::<&'static isize>(); }
 fn test02() { assert_send::<&'static str>(); }
-fn test03() { assert_send::<&'static [int]>(); }
+fn test03() { assert_send::<&'static [isize]>(); }
 
 // whether or not they are mutable
-fn test10() { assert_send::<&'static mut int>(); }
+fn test10() { assert_send::<&'static mut isize>(); }
 
 // otherwise lifetime pointers are not ok
-fn test20<'a>(_: &'a int) {
-    assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied
+fn test20<'a>(_: &'a isize) {
+    assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied
 }
-fn test21<'a>(_: &'a int) {
+fn test21<'a>(_: &'a isize) {
     assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied
 }
-fn test22<'a>(_: &'a int) {
-    assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied
+fn test22<'a>(_: &'a isize) {
+    assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/kindck-send-unsafe.rs b/src/test/compile-fail/kindck-send-unsafe.rs
index 1bfd0d4a11f..bce765a986a 100644
--- a/src/test/compile-fail/kindck-send-unsafe.rs
+++ b/src/test/compile-fail/kindck-send-unsafe.rs
@@ -13,7 +13,7 @@ extern crate core;
 fn assert_send<T:Send>() { }
 
 fn test71<'a>() {
-    assert_send::<*mut &'a int>();
+    assert_send::<*mut &'a isize>();
     //~^ ERROR the trait `core::marker::Send` is not implemented for the type
 }
 
diff --git a/src/test/compile-fail/lang-item-missing.rs b/src/test/compile-fail/lang-item-missing.rs
index bcde10a0b22..793d9c77c3b 100644
--- a/src/test/compile-fail/lang-item-missing.rs
+++ b/src/test/compile-fail/lang-item-missing.rs
@@ -16,6 +16,6 @@
 #![no_std]
 
 #[start]
-fn start(argc: int, argv: *const *const u8) -> int {
+fn start(argc: isize, argv: *const *const u8) -> isize {
     0
 }
diff --git a/src/test/compile-fail/lex-bad-numeric-literals.rs b/src/test/compile-fail/lex-bad-numeric-literals.rs
index 9a490be6a01..273a7627d73 100644
--- a/src/test/compile-fail/lex-bad-numeric-literals.rs
+++ b/src/test/compile-fail/lex-bad-numeric-literals.rs
@@ -21,8 +21,8 @@ fn main() {
     0o; //~ ERROR: no valid digits
     1e+; //~ ERROR: expected at least one digit in exponent
     0x539.0; //~ ERROR: hexadecimal float literal is not supported
-    99999999999999999999999999999999; //~ ERROR: int literal is too large
-    99999999999999999999999999999999u32; //~ ERROR: int literal is too large
+    99999999999999999999999999999999; //~ ERROR: isize literal is too large
+    99999999999999999999999999999999u32; //~ ERROR: isize literal is too large
     0x; //~ ERROR: no valid digits
     0xu32; //~ ERROR: no valid digits
     0ou32; //~ ERROR: no valid digits
diff --git a/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs b/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs
index 817582a877f..55cce016335 100644
--- a/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs
+++ b/src/test/compile-fail/lifetime-elision-return-type-requires-explicit-lifetime.rs
@@ -9,29 +9,29 @@
 // except according to those terms.
 
 // Lifetime annotation needed because we have no arguments.
-fn f() -> &int {    //~ ERROR missing lifetime specifier
+fn f() -> &isize {    //~ ERROR missing lifetime specifier
 //~^ HELP there is no value for it to be borrowed from
     panic!()
 }
 
 // Lifetime annotation needed because we have two by-reference parameters.
-fn g(_x: &int, _y: &int) -> &int {    //~ ERROR missing lifetime specifier
+fn g(_x: &isize, _y: &isize) -> &isize {    //~ ERROR missing lifetime specifier
 //~^ HELP the signature does not say whether it is borrowed from `_x` or `_y`
     panic!()
 }
 
 struct Foo<'a> {
-    x: &'a int,
+    x: &'a isize,
 }
 
 // Lifetime annotation needed because we have two lifetimes: one as a parameter
 // and one on the reference.
-fn h(_x: &Foo) -> &int { //~ ERROR missing lifetime specifier
+fn h(_x: &Foo) -> &isize { //~ ERROR missing lifetime specifier
 //~^ HELP the signature does not say which one of `_x`'s 2 elided lifetimes it is borrowed from
     panic!()
 }
 
-fn i(_x: int) -> &int { //~ ERROR missing lifetime specifier
+fn i(_x: isize) -> &isize { //~ ERROR missing lifetime specifier
 //~^ HELP this function's return type contains a borrowed value
     panic!()
 }
diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs
index 29265b8750c..18ef30f5b28 100644
--- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs
+++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param-3.rs
@@ -10,17 +10,17 @@
 
 // ignore-tidy-linelength
 
-struct Bar<'x, 'y, 'z> { bar: &'y int, baz: int }
-fn bar1<'a>(x: &Bar) -> (&'a int, &'a int, &'a int) {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar1<'b, 'c, 'a>(x: &'a Bar<'b, 'a, 'c>) -> (&'a int, &'a int, &'a int)
+struct Bar<'x, 'y, 'z> { bar: &'y isize, baz: isize }
+fn bar1<'a>(x: &Bar) -> (&'a isize, &'a isize, &'a isize) {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar1<'b, 'c, 'a>(x: &'a Bar<'b, 'a, 'c>) -> (&'a isize, &'a isize, &'a isize)
     (x.bar, &x.baz, &x.baz)
     //~^ ERROR: cannot infer
     //~^^ ERROR: cannot infer
     //~^^^ ERROR: cannot infer
 }
 
-fn bar2<'a, 'b, 'c>(x: &Bar<'a, 'b, 'c>) -> (&'a int, &'a int, &'a int) {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar2<'a, 'c>(x: &'a Bar<'a, 'a, 'c>) -> (&'a int, &'a int, &'a int)
+fn bar2<'a, 'b, 'c>(x: &Bar<'a, 'b, 'c>) -> (&'a isize, &'a isize, &'a isize) {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn bar2<'a, 'c>(x: &'a Bar<'a, 'a, 'c>) -> (&'a isize, &'a isize, &'a isize)
     (x.bar, &x.baz, &x.baz)
     //~^ ERROR: cannot infer
     //~^^ ERROR: cannot infer
diff --git a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs
index 4abf045501c..c60e321219b 100644
--- a/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs
+++ b/src/test/compile-fail/lifetime-inference-give-expl-lifetime-param.rs
@@ -10,43 +10,43 @@
 
 // ignore-tidy-linelength
 
-struct Foo<'x> { bar: int }
-fn foo1<'a>(x: &Foo) -> &'a int {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo1<'a>(x: &'a Foo) -> &'a int
+struct Foo<'x> { bar: isize }
+fn foo1<'a>(x: &Foo) -> &'a isize {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo1<'a>(x: &'a Foo) -> &'a isize
     &x.bar //~ ERROR: cannot infer
 }
 
-fn foo2<'a, 'b>(x: &'a Foo) -> &'b int {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo2<'a>(x: &'a Foo) -> &'a int
+fn foo2<'a, 'b>(x: &'a Foo) -> &'b isize {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo2<'a>(x: &'a Foo) -> &'a isize
     &x.bar //~ ERROR: cannot infer
 }
 
-fn foo3<'a>(x: &Foo) -> (&'a int, &'a int) {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo3<'a>(x: &'a Foo) -> (&'a int, &'a int)
+fn foo3<'a>(x: &Foo) -> (&'a isize, &'a isize) {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo3<'a>(x: &'a Foo) -> (&'a isize, &'a isize)
     (&x.bar, &x.bar) //~ ERROR: cannot infer
     //~^ ERROR: cannot infer
 }
 
-fn foo4<'a, 'b>(x: &'a Foo) -> (&'b int, &'a int, &'b int) {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo4<'a>(x: &'a Foo) -> (&'a int, &'a int, &'a int)
+fn foo4<'a, 'b>(x: &'a Foo) -> (&'b isize, &'a isize, &'b isize) {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn foo4<'a>(x: &'a Foo) -> (&'a isize, &'a isize, &'a isize)
     (&x.bar, &x.bar, &x.bar) //~ ERROR: cannot infer
     //~^ ERROR: cannot infer
 }
 
-struct Cat<'x, T> { cat: &'x int, t: T }
-struct Dog<'y> { dog: &'y int }
+struct Cat<'x, T> { cat: &'x isize, t: T }
+struct Dog<'y> { dog: &'y isize }
 
-fn cat2<'x, 'y>(x: Cat<'x, Dog<'y>>) -> &'x int {
-//~^ HELP: consider using an explicit lifetime parameter as shown: fn cat2<'x>(x: Cat<'x, Dog<'x>>) -> &'x int
+fn cat2<'x, 'y>(x: Cat<'x, Dog<'y>>) -> &'x isize {
+//~^ HELP: consider using an explicit lifetime parameter as shown: fn cat2<'x>(x: Cat<'x, Dog<'x>>) -> &'x isize
     x.t.dog //~ ERROR: cannot infer
 }
 
 struct Baz<'x> {
-    bar: &'x int
+    bar: &'x isize
 }
 
 impl<'a> Baz<'a> {
-    fn baz2<'b>(&self, x: &int) -> (&'b int, &'b int) {
+    fn baz2<'b>(&self, x: &isize) -> (&'b isize, &'b isize) {
         // The lifetime that gets assigned to `x` seems somewhat random.
         // I have disabled this test for the time being. --pcwalton
         (self.bar, x) //~ ERROR: cannot infer
diff --git a/src/test/compile-fail/lifetime-no-keyword.rs b/src/test/compile-fail/lifetime-no-keyword.rs
index 0ef13d73fab..8ffbcd90df8 100644
--- a/src/test/compile-fail/lifetime-no-keyword.rs
+++ b/src/test/compile-fail/lifetime-no-keyword.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo<'a>(a: &'a int) { }
-fn bar(a: &'static int) { }
-fn baz(a: &'let int) { } //~ ERROR invalid lifetime name
+fn foo<'a>(a: &'a isize) { }
+fn bar(a: &'static isize) { }
+fn baz(a: &'let isize) { } //~ ERROR invalid lifetime name
 
 fn main() { }
diff --git a/src/test/compile-fail/lifetime-obsoleted-self.rs b/src/test/compile-fail/lifetime-obsoleted-self.rs
index a99daaab249..766922f2f88 100644
--- a/src/test/compile-fail/lifetime-obsoleted-self.rs
+++ b/src/test/compile-fail/lifetime-obsoleted-self.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn baz(a: &'self int) { } //~ ERROR invalid lifetime name: 'self is no longer a special lifetime
+fn baz(a: &'self isize) { } //~ ERROR invalid lifetime name: 'self is no longer a special lifetime
 
 fn main() { }
diff --git a/src/test/compile-fail/linkage1.rs b/src/test/compile-fail/linkage1.rs
index a045b838d51..555cc2b9a7a 100644
--- a/src/test/compile-fail/linkage1.rs
+++ b/src/test/compile-fail/linkage1.rs
@@ -9,6 +9,6 @@
 // except according to those terms.
 
 extern {
-    #[linkage = "extern_weak"] static foo: int;
+    #[linkage = "extern_weak"] static foo: isize;
     //~^ ERROR: the `linkage` attribute is experimental and not portable
 }
diff --git a/src/test/compile-fail/linkage4.rs b/src/test/compile-fail/linkage4.rs
index 8f68f3e553c..635d58e04c7 100644
--- a/src/test/compile-fail/linkage4.rs
+++ b/src/test/compile-fail/linkage4.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #[linkage = "external"]
-static foo: int = 0;
+static foo: isize = 0;
 //~^ ERROR: the `linkage` attribute is experimental and not portable
 
 fn main() {}
diff --git a/src/test/compile-fail/lint-ctypes.rs b/src/test/compile-fail/lint-ctypes.rs
index 1755a9a2481..e0ed095b1a1 100644
--- a/src/test/compile-fail/lint-ctypes.rs
+++ b/src/test/compile-fail/lint-ctypes.rs
@@ -13,9 +13,9 @@
 extern crate libc;
 
 extern {
-    pub fn bare_type1(size: int); //~ ERROR: found rust type
+    pub fn bare_type1(size: isize); //~ ERROR: found rust type
     pub fn bare_type2(size: uint); //~ ERROR: found rust type
-    pub fn ptr_type1(size: *const int); //~ ERROR: found rust type
+    pub fn ptr_type1(size: *const isize); //~ ERROR: found rust type
     pub fn ptr_type2(size: *const uint); //~ ERROR: found rust type
 
     pub fn good1(size: *const libc::c_int);
diff --git a/src/test/compile-fail/lint-dead-code-1.rs b/src/test/compile-fail/lint-dead-code-1.rs
index 9e5f15c2721..e55922db3d5 100644
--- a/src/test/compile-fail/lint-dead-code-1.rs
+++ b/src/test/compile-fail/lint-dead-code-1.rs
@@ -29,28 +29,28 @@ mod foo2 {
     pub struct Bar2;
 }
 
-pub static pub_static: int = 0;
-static priv_static: int = 0; //~ ERROR: static item is never used
-const used_static: int = 0;
-pub static used_static2: int = used_static;
-const USED_STATIC: int = 0;
-const STATIC_USED_IN_ENUM_DISCRIMINANT: int = 10;
+pub static pub_static: isize = 0;
+static priv_static: isize = 0; //~ ERROR: static item is never used
+const used_static: isize = 0;
+pub static used_static2: isize = used_static;
+const USED_STATIC: isize = 0;
+const STATIC_USED_IN_ENUM_DISCRIMINANT: isize = 10;
 
-pub const pub_const: int = 0;
-const priv_const: int = 0; //~ ERROR: constant item is never used
-const used_const: int = 0;
-pub const used_const2: int = used_const;
-const USED_CONST: int = 1;
-const CONST_USED_IN_ENUM_DISCRIMINANT: int = 11;
+pub const pub_const: isize = 0;
+const priv_const: isize = 0; //~ ERROR: constant item is never used
+const used_const: isize = 0;
+pub const used_const2: isize = used_const;
+const USED_CONST: isize = 1;
+const CONST_USED_IN_ENUM_DISCRIMINANT: isize = 11;
 
 pub type typ = *const UsedStruct4;
 pub struct PubStruct;
 struct PrivStruct; //~ ERROR: struct is never used
 struct UsedStruct1 {
     #[allow(dead_code)]
-    x: int
+    x: isize
 }
-struct UsedStruct2(int);
+struct UsedStruct2(isize);
 struct UsedStruct3;
 struct UsedStruct4;
 // this struct is never used directly, but its method is, so we don't want
diff --git a/src/test/compile-fail/lint-dead-code-2.rs b/src/test/compile-fail/lint-dead-code-2.rs
index c7199eec8a3..e8b85ffd69a 100644
--- a/src/test/compile-fail/lint-dead-code-2.rs
+++ b/src/test/compile-fail/lint-dead-code-2.rs
@@ -36,7 +36,7 @@ fn dead_fn2() {} //~ ERROR: function is never used
 fn used_fn() {}
 
 #[start]
-fn start(_: int, _: *const *const u8) -> int {
+fn start(_: isize, _: *const *const u8) -> isize {
     used_fn();
     let foo = Foo;
     foo.bar2();
diff --git a/src/test/compile-fail/lint-dead-code-3.rs b/src/test/compile-fail/lint-dead-code-3.rs
index 4ef76030bcc..3662855a720 100644
--- a/src/test/compile-fail/lint-dead-code-3.rs
+++ b/src/test/compile-fail/lint-dead-code-3.rs
@@ -79,7 +79,7 @@ mod inner {
         fn f(&self) { f(); }
     }
 
-    impl Trait for int {}
+    impl Trait for isize {}
 
     fn f() {}
 }
diff --git a/src/test/compile-fail/lint-dead-code-4.rs b/src/test/compile-fail/lint-dead-code-4.rs
index 21e1ab4c33e..2653c1d5b24 100644
--- a/src/test/compile-fail/lint-dead-code-4.rs
+++ b/src/test/compile-fail/lint-dead-code-4.rs
@@ -30,7 +30,7 @@ enum XYZ {
     X, //~ ERROR variant is never used
     Y { //~ ERROR variant is never used
         a: String,
-        b: int //~ ERROR: struct field is never used
+        b: isize //~ ERROR: struct field is never used
     },
     Z
 }
diff --git a/src/test/compile-fail/lint-dead-code-5.rs b/src/test/compile-fail/lint-dead-code-5.rs
index d6a31c96100..04d6547d938 100644
--- a/src/test/compile-fail/lint-dead-code-5.rs
+++ b/src/test/compile-fail/lint-dead-code-5.rs
@@ -12,16 +12,16 @@
 #![deny(dead_code)]
 
 enum Enum1 {
-    Variant1(int),
+    Variant1(isize),
     Variant2 //~ ERROR: variant is never used
 }
 
 enum Enum2 {
     Variant3(bool),
     #[allow(dead_code)]
-    Variant4(int),
-    Variant5 { _x: int }, //~ ERROR: variant is never used: `Variant5`
-    Variant6(int), //~ ERROR: variant is never used: `Variant6`
+    Variant4(isize),
+    Variant5 { _x: isize }, //~ ERROR: variant is never used: `Variant5`
+    Variant6(isize), //~ ERROR: variant is never used: `Variant6`
     _Variant7,
 }
 
diff --git a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs
index efb28449564..18159aec708 100644
--- a/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs
+++ b/src/test/compile-fail/lint-directives-on-use-items-issue-10534.rs
@@ -16,7 +16,7 @@
 // ignored.
 
 #[allow(dead_code)]
-mod a { pub static x: int = 3; pub static y: int = 4; }
+mod a { pub static x: isize = 3; pub static y: isize = 4; }
 
 mod b {
     use a::x; //~ ERROR: unused import
diff --git a/src/test/compile-fail/lint-exceeding-bitshifts.rs b/src/test/compile-fail/lint-exceeding-bitshifts.rs
index dbb65d8b7ce..cbb416b62a6 100644
--- a/src/test/compile-fail/lint-exceeding-bitshifts.rs
+++ b/src/test/compile-fail/lint-exceeding-bitshifts.rs
@@ -56,7 +56,7 @@ fn main() {
       let n = 1u8 << (4+3);
       let n = 1u8 << (4+4); //~ ERROR: bitshift exceeds the type's number of bits
 
-      let n = 1i << std::int::BITS; //~ ERROR: bitshift exceeds the type's number of bits
+      let n = 1i << std::isize::BITS; //~ ERROR: bitshift exceeds the type's number of bits
       let n = 1u << std::uint::BITS; //~ ERROR: bitshift exceeds the type's number of bits
 }
 
diff --git a/src/test/compile-fail/lint-group-style.rs b/src/test/compile-fail/lint-group-style.rs
index 63d65fc06aa..24d16bcaafc 100644
--- a/src/test/compile-fail/lint-group-style.rs
+++ b/src/test/compile-fail/lint-group-style.rs
@@ -24,7 +24,7 @@ mod test {
     mod bad {
         fn CamelCase() {} //~ ERROR function `CamelCase` should have a snake case name
 
-        static bad: int = 1; //~ ERROR static constant `bad` should have an uppercase name
+        static bad: isize = 1; //~ ERROR static constant `bad` should have an uppercase name
     }
 
     mod warn {
diff --git a/src/test/compile-fail/lint-impl-fn.rs b/src/test/compile-fail/lint-impl-fn.rs
index eaef43a9083..608aec327b6 100644
--- a/src/test/compile-fail/lint-impl-fn.rs
+++ b/src/test/compile-fail/lint-impl-fn.rs
@@ -11,7 +11,7 @@
 #![allow(while_true)]
 #![allow(dead_code)]
 
-struct A(int);
+struct A(isize);
 
 impl A {
     fn foo(&self) { while true {} }
@@ -22,7 +22,7 @@ impl A {
 
 #[deny(while_true)]
 mod foo {
-    struct B(int);
+    struct B(isize);
 
     impl B {
         fn foo(&self) { while true {} } //~ ERROR: infinite loops
diff --git a/src/test/compile-fail/lint-missing-doc.rs b/src/test/compile-fail/lint-missing-doc.rs
index e50f636050c..55103f10f2c 100644
--- a/src/test/compile-fail/lint-missing-doc.rs
+++ b/src/test/compile-fail/lint-missing-doc.rs
@@ -21,19 +21,19 @@ type Typedef = String;
 pub type PubTypedef = String; //~ ERROR: missing documentation
 
 struct Foo {
-    a: int,
-    b: int,
+    a: isize,
+    b: isize,
 }
 
 pub struct PubFoo { //~ ERROR: missing documentation
-    pub a: int,      //~ ERROR: missing documentation
-    b: int,
+    pub a: isize,      //~ ERROR: missing documentation
+    b: isize,
 }
 
 #[allow(missing_docs)]
 pub struct PubFoo2 {
-    pub a: int,
-    pub c: int,
+    pub a: isize,
+    pub c: isize,
 }
 
 mod module_no_dox {}
@@ -100,15 +100,15 @@ mod a {
 
 enum Baz {
     BazA {
-        a: int,
-        b: int
+        a: isize,
+        b: isize
     },
     BarB
 }
 
 pub enum PubBaz { //~ ERROR: missing documentation
     PubBazA { //~ ERROR: missing documentation
-        a: int, //~ ERROR: missing documentation
+        a: isize, //~ ERROR: missing documentation
     },
 }
 
@@ -117,14 +117,14 @@ pub enum PubBaz2 {
     /// dox
     PubBaz2A {
         /// dox
-        a: int,
+        a: isize,
     },
 }
 
 #[allow(missing_docs)]
 pub enum PubBaz3 {
     PubBaz3A {
-        b: int
+        b: isize
     },
 }
 
diff --git a/src/test/compile-fail/lint-non-camel-case-types.rs b/src/test/compile-fail/lint-non-camel-case-types.rs
index 6ce63e2ecdb..70d6b240985 100644
--- a/src/test/compile-fail/lint-non-camel-case-types.rs
+++ b/src/test/compile-fail/lint-non-camel-case-types.rs
@@ -12,7 +12,7 @@
 #![allow(dead_code)]
 
 struct foo { //~ ERROR type `foo` should have a camel case name such as `Foo`
-    bar: int,
+    bar: isize,
 }
 
 enum foo2 { //~ ERROR type `foo2` should have a camel case name such as `Foo2`
@@ -20,10 +20,10 @@ enum foo2 { //~ ERROR type `foo2` should have a camel case name such as `Foo2`
 }
 
 struct foo3 { //~ ERROR type `foo3` should have a camel case name such as `Foo3`
-    bar: int
+    bar: isize
 }
 
-type foo4 = int; //~ ERROR type `foo4` should have a camel case name such as `Foo4`
+type foo4 = isize; //~ ERROR type `foo4` should have a camel case name such as `Foo4`
 
 enum Foo5 {
     bar //~ ERROR variant `bar` should have a camel case name such as `Bar`
@@ -36,9 +36,9 @@ fn f<ty>(_: ty) {} //~ ERROR type parameter `ty` should have a camel case name s
 
 #[repr(C)]
 struct foo7 {
-    bar: int,
+    bar: isize,
 }
 
-type __ = int; //~ ERROR type `__` should have a camel case name such as `CamelCase`
+type __ = isize; //~ ERROR type `__` should have a camel case name such as `CamelCase`
 
 fn main() { }
diff --git a/src/test/compile-fail/lint-non-uppercase-statics.rs b/src/test/compile-fail/lint-non-uppercase-statics.rs
index 7ff5cafd097..10475f967d7 100644
--- a/src/test/compile-fail/lint-non-uppercase-statics.rs
+++ b/src/test/compile-fail/lint-non-uppercase-statics.rs
@@ -11,6 +11,6 @@
 #![forbid(non_upper_case_globals)]
 #![allow(dead_code)]
 
-static foo: int = 1; //~ ERROR static constant `foo` should have an uppercase name such as `FOO`
+static foo: isize = 1; //~ ERROR static constant `foo` should have an uppercase name such as `FOO`
 
 fn main() { }
diff --git a/src/test/compile-fail/lint-owned-heap-memory.rs b/src/test/compile-fail/lint-owned-heap-memory.rs
index 1702cefec6d..9c68da8beaf 100644
--- a/src/test/compile-fail/lint-owned-heap-memory.rs
+++ b/src/test/compile-fail/lint-owned-heap-memory.rs
@@ -13,7 +13,7 @@
 #![feature(box_syntax)]
 
 struct Foo {
-    x: Box<int> //~ ERROR type uses owned
+    x: Box<isize> //~ ERROR type uses owned
 }
 
 fn main() {
diff --git a/src/test/compile-fail/lint-raw-ptr-derive.rs b/src/test/compile-fail/lint-raw-ptr-derive.rs
index 3198e782df8..9fcd6b33c9d 100644
--- a/src/test/compile-fail/lint-raw-ptr-derive.rs
+++ b/src/test/compile-fail/lint-raw-ptr-derive.rs
@@ -13,21 +13,21 @@
 
 #[derive(Clone)]
 struct Foo {
-    x: *const int //~ ERROR use of `#[derive]` with a raw pointer
+    x: *const isize //~ ERROR use of `#[derive]` with a raw pointer
 }
 
 #[derive(Clone)]
-struct Bar(*mut int); //~ ERROR use of `#[derive]` with a raw pointer
+struct Bar(*mut isize); //~ ERROR use of `#[derive]` with a raw pointer
 
 #[derive(Clone)]
 enum Baz {
-    A(*const int), //~ ERROR use of `#[derive]` with a raw pointer
-    B { x: *mut int } //~ ERROR use of `#[derive]` with a raw pointer
+    A(*const isize), //~ ERROR use of `#[derive]` with a raw pointer
+    B { x: *mut isize } //~ ERROR use of `#[derive]` with a raw pointer
 }
 
 #[derive(Clone)]
 struct Buzz {
-    x: (*const int, //~ ERROR use of `#[derive]` with a raw pointer
+    x: (*const isize, //~ ERROR use of `#[derive]` with a raw pointer
         *const uint) //~ ERROR use of `#[derive]` with a raw pointer
 }
 
diff --git a/src/test/compile-fail/lint-shorthand-field.rs b/src/test/compile-fail/lint-shorthand-field.rs
index eb4da4d66f3..97a976a493f 100644
--- a/src/test/compile-fail/lint-shorthand-field.rs
+++ b/src/test/compile-fail/lint-shorthand-field.rs
@@ -12,8 +12,8 @@
 #![deny(non_shorthand_field_patterns)]
 
 struct Foo {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 fn main() {
@@ -30,7 +30,7 @@ fn main() {
     }
 
     {
-        const x: int = 1;
+        const x: isize = 1;
 
         match (Foo { x: 1, y: 1 }) {
             Foo { x: x, ..} => {},
diff --git a/src/test/compile-fail/lint-stability.rs b/src/test/compile-fail/lint-stability.rs
index 0e24269ec44..b0a3a6bd10e 100644
--- a/src/test/compile-fail/lint-stability.rs
+++ b/src/test/compile-fail/lint-stability.rs
@@ -287,18 +287,18 @@ mod this_crate {
     impl Trait for MethodTester {}
 
     #[deprecated]
-    pub struct DeprecatedStruct { i: int }
+    pub struct DeprecatedStruct { i: isize }
     #[experimental]
-    pub struct ExperimentalStruct { i: int }
+    pub struct ExperimentalStruct { i: isize }
     #[unstable]
-    pub struct UnstableStruct { i: int }
-    pub struct UnmarkedStruct { i: int }
+    pub struct UnstableStruct { i: isize }
+    pub struct UnmarkedStruct { i: isize }
     #[stable]
-    pub struct StableStruct { i: int }
+    pub struct StableStruct { i: isize }
     #[frozen]
-    pub struct FrozenStruct { i: int }
+    pub struct FrozenStruct { i: isize }
     #[locked]
-    pub struct LockedStruct { i: int }
+    pub struct LockedStruct { i: isize }
 
     #[deprecated]
     pub struct DeprecatedUnitStruct;
@@ -332,18 +332,18 @@ mod this_crate {
     }
 
     #[deprecated]
-    pub struct DeprecatedTupleStruct(int);
+    pub struct DeprecatedTupleStruct(isize);
     #[experimental]
-    pub struct ExperimentalTupleStruct(int);
+    pub struct ExperimentalTupleStruct(isize);
     #[unstable]
-    pub struct UnstableTupleStruct(int);
-    pub struct UnmarkedTupleStruct(int);
+    pub struct UnstableTupleStruct(isize);
+    pub struct UnmarkedTupleStruct(isize);
     #[stable]
-    pub struct StableTupleStruct(int);
+    pub struct StableTupleStruct(isize);
     #[frozen]
-    pub struct FrozenTupleStruct(int);
+    pub struct FrozenTupleStruct(isize);
     #[locked]
-    pub struct LockedTupleStruct(int);
+    pub struct LockedTupleStruct(isize);
 
     fn test() {
         // Only the deprecated cases of the following should generate
diff --git a/src/test/compile-fail/lint-type-limits.rs b/src/test/compile-fail/lint-type-limits.rs
index 67ef9cd0680..d5ea092617d 100644
--- a/src/test/compile-fail/lint-type-limits.rs
+++ b/src/test/compile-fail/lint-type-limits.rs
@@ -50,12 +50,12 @@ fn qux() {
 }
 
 fn quy() {
-    let i = -23u; //~ WARNING negation of unsigned int literal may be unintentional
+    let i = -23u; //~ WARNING negation of unsigned isize literal may be unintentional
                   //~^ WARNING unused variable
 }
 
 fn quz() {
     let i = 23u;
-    let j = -i;   //~ WARNING negation of unsigned int variable may be unintentional
+    let j = -i;   //~ WARNING negation of unsigned isize variable may be unintentional
                   //~^ WARNING unused variable
 }
diff --git a/src/test/compile-fail/lint-unnecessary-parens.rs b/src/test/compile-fail/lint-unnecessary-parens.rs
index 1c7a2d7e9d5..158f13bf3f1 100644
--- a/src/test/compile-fail/lint-unnecessary-parens.rs
+++ b/src/test/compile-fail/lint-unnecessary-parens.rs
@@ -16,7 +16,7 @@ impl X {
     fn foo(&self) -> bool { self.y }
 }
 
-fn foo() -> int {
+fn foo() -> isize {
     return (1i); //~ ERROR unnecessary parentheses around `return` value
 }
 fn bar() -> X {
diff --git a/src/test/compile-fail/lint-unused-imports.rs b/src/test/compile-fail/lint-unused-imports.rs
index b5c0dce6e53..44579bb55e0 100644
--- a/src/test/compile-fail/lint-unused-imports.rs
+++ b/src/test/compile-fail/lint-unused-imports.rs
@@ -43,7 +43,7 @@ mod test {
 }
 
 mod foo {
-    pub struct Point{pub x: int, pub y: int}
+    pub struct Point{pub x: isize, pub y: isize}
     pub struct Square{pub p: Point, pub h: uint, pub w: uint}
 }
 
@@ -54,7 +54,7 @@ mod bar {
     pub mod c {
         use foo::Point;
         use foo::Square; //~ ERROR unused import
-        pub fn cc(p: Point) -> int { return 2i * (p.x + p.y); }
+        pub fn cc(p: Point) -> isize { return 2i * (p.x + p.y); }
     }
 
     #[allow(unused_imports)]
diff --git a/src/test/compile-fail/lint-unused-mut-variables.rs b/src/test/compile-fail/lint-unused-mut-variables.rs
index 7513e1bc21a..4c1a01aac64 100644
--- a/src/test/compile-fail/lint-unused-mut-variables.rs
+++ b/src/test/compile-fail/lint-unused-mut-variables.rs
@@ -35,8 +35,8 @@ fn main() {
       _ => {}
     }
 
-    let x = |&: mut y: int| 10i; //~ ERROR: variable does not need to be mutable
-    fn what(mut foo: int) {} //~ ERROR: variable does not need to be mutable
+    let x = |&: mut y: isize| 10i; //~ ERROR: variable does not need to be mutable
+    fn what(mut foo: isize) {} //~ ERROR: variable does not need to be mutable
 
     // positive cases
     let mut a = 2i;
@@ -65,8 +65,8 @@ fn main() {
       _ => {}
     }
 
-    let x = |&mut: mut y: int| y = 32i;
-    fn nothing(mut foo: int) { foo = 37i; }
+    let x = |&mut: mut y: isize| y = 32i;
+    fn nothing(mut foo: isize) { foo = 37i; }
 
     // leading underscore should avoid the warning, just like the
     // unused variable lint.
@@ -77,7 +77,7 @@ fn callback<F>(f: F) where F: FnOnce() {}
 
 // make sure the lint attribute can be turned off
 #[allow(unused_mut)]
-fn foo(mut a: int) {
+fn foo(mut a: isize) {
     let mut a = 3i;
     let mut b = vec!(2i);
 }
diff --git a/src/test/compile-fail/lint-visible-private-types.rs b/src/test/compile-fail/lint-visible-private-types.rs
index 373bcb1f859..8cf375f80fb 100644
--- a/src/test/compile-fail/lint-visible-private-types.rs
+++ b/src/test/compile-fail/lint-visible-private-types.rs
@@ -15,108 +15,108 @@
 struct Private<T>;
 pub struct Public<T>;
 
-impl Private<Public<int>> {
-    pub fn a(&self) -> Private<int> { panic!() }
-    fn b(&self) -> Private<int> { panic!() }
+impl Private<Public<isize>> {
+    pub fn a(&self) -> Private<isize> { panic!() }
+    fn b(&self) -> Private<isize> { panic!() }
 
-    pub fn c() -> Private<int> { panic!() }
-    fn d() -> Private<int> { panic!() }
+    pub fn c() -> Private<isize> { panic!() }
+    fn d() -> Private<isize> { panic!() }
 }
-impl Private<int> {
-    pub fn e(&self) -> Private<int> { panic!() }
-    fn f(&self) -> Private<int> { panic!() }
+impl Private<isize> {
+    pub fn e(&self) -> Private<isize> { panic!() }
+    fn f(&self) -> Private<isize> { panic!() }
 }
 
-impl Public<Private<int>> {
-    pub fn a(&self) -> Private<int> { panic!() }
-    fn b(&self) -> Private<int> { panic!() }
+impl Public<Private<isize>> {
+    pub fn a(&self) -> Private<isize> { panic!() }
+    fn b(&self) -> Private<isize> { panic!() }
 
-    pub fn c() -> Private<int> { panic!() } //~ ERROR private type in exported type signature
-    fn d() -> Private<int> { panic!() }
+    pub fn c() -> Private<isize> { panic!() } //~ ERROR private type in exported type signature
+    fn d() -> Private<isize> { panic!() }
 }
-impl Public<int> {
-    pub fn e(&self) -> Private<int> { panic!() } //~ ERROR private type in exported type signature
-    fn f(&self) -> Private<int> { panic!() }
+impl Public<isize> {
+    pub fn e(&self) -> Private<isize> { panic!() } //~ ERROR private type in exported type signature
+    fn f(&self) -> Private<isize> { panic!() }
 }
 
-pub fn x(_: Private<int>) {} //~ ERROR private type in exported type signature
+pub fn x(_: Private<isize>) {} //~ ERROR private type in exported type signature
 
-fn y(_: Private<int>) {}
+fn y(_: Private<isize>) {}
 
 
 pub struct Foo {
-    pub x: Private<int>, //~ ERROR private type in exported type signature
-    y: Private<int>
+    pub x: Private<isize>, //~ ERROR private type in exported type signature
+    y: Private<isize>
 }
 
 struct Bar {
-    x: Private<int>,
+    x: Private<isize>,
 }
 
 pub enum Baz {
-    Baz1(Private<int>), //~ ERROR private type in exported type signature
+    Baz1(Private<isize>), //~ ERROR private type in exported type signature
     Baz2 {
-        y: Private<int> //~ ERROR private type in exported type signature
+        y: Private<isize> //~ ERROR private type in exported type signature
     },
 }
 
 enum Qux {
-    Qux1(Private<int>),
+    Qux1(Private<isize>),
     Qux2 {
-        x: Private<int>,
+        x: Private<isize>,
     }
 }
 
 pub trait PubTrait {
-    fn foo(&self) -> Private<int> { panic!( )} //~ ERROR private type in exported type signature
-    fn bar(&self) -> Private<int>; //~ ERROR private type in exported type signature
-    fn baz() -> Private<int>; //~ ERROR private type in exported type signature
+    fn foo(&self) -> Private<isize> { panic!( )} //~ ERROR private type in exported type signature
+    fn bar(&self) -> Private<isize>; //~ ERROR private type in exported type signature
+    fn baz() -> Private<isize>; //~ ERROR private type in exported type signature
 }
 
-impl PubTrait for Public<int> {
-    fn bar(&self) -> Private<int> { panic!() }
-    fn baz() -> Private<int> { panic!() }
+impl PubTrait for Public<isize> {
+    fn bar(&self) -> Private<isize> { panic!() }
+    fn baz() -> Private<isize> { panic!() }
 }
-impl PubTrait for Public<Private<int>> {
-    fn bar(&self) -> Private<int> { panic!() }
-    fn baz() -> Private<int> { panic!() }
+impl PubTrait for Public<Private<isize>> {
+    fn bar(&self) -> Private<isize> { panic!() }
+    fn baz() -> Private<isize> { panic!() }
 }
 
-impl PubTrait for Private<int> {
-    fn bar(&self) -> Private<int> { panic!() }
-    fn baz() -> Private<int> { panic!() }
+impl PubTrait for Private<isize> {
+    fn bar(&self) -> Private<isize> { panic!() }
+    fn baz() -> Private<isize> { panic!() }
 }
-impl PubTrait for (Private<int>,) {
-    fn bar(&self) -> Private<int> { panic!() }
-    fn baz() -> Private<int> { panic!() }
+impl PubTrait for (Private<isize>,) {
+    fn bar(&self) -> Private<isize> { panic!() }
+    fn baz() -> Private<isize> { panic!() }
 }
 
 
 trait PrivTrait {
-    fn foo(&self) -> Private<int> { panic!( )}
-    fn bar(&self) -> Private<int>;
+    fn foo(&self) -> Private<isize> { panic!( )}
+    fn bar(&self) -> Private<isize>;
 }
-impl PrivTrait for Private<int> {
-    fn bar(&self) -> Private<int> { panic!() }
+impl PrivTrait for Private<isize> {
+    fn bar(&self) -> Private<isize> { panic!() }
 }
-impl PrivTrait for (Private<int>,) {
-    fn bar(&self) -> Private<int> { panic!() }
+impl PrivTrait for (Private<isize>,) {
+    fn bar(&self) -> Private<isize> { panic!() }
 }
 
 pub trait ParamTrait<T> {
     fn foo() -> T;
 }
 
-impl ParamTrait<Private<int>> //~ ERROR private type in exported type signature
-   for Public<int> {
-    fn foo() -> Private<int> { panic!() }
+impl ParamTrait<Private<isize>> //~ ERROR private type in exported type signature
+   for Public<isize> {
+    fn foo() -> Private<isize> { panic!() }
 }
 
-impl ParamTrait<Private<int>> for Private<int> {
-    fn foo() -> Private<int> { panic!( )}
+impl ParamTrait<Private<isize>> for Private<isize> {
+    fn foo() -> Private<isize> { panic!( )}
 }
 
-impl<T: ParamTrait<Private<int>>>  //~ ERROR private type in exported type signature
+impl<T: ParamTrait<Private<isize>>>  //~ ERROR private type in exported type signature
      ParamTrait<T> for Public<i8> {
     fn foo() -> T { panic!() }
 }
diff --git a/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs b/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs
index f8afc10c49b..f50a9345106 100644
--- a/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs
+++ b/src/test/compile-fail/liveness-assign-imm-local-in-loop.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn test() {
-    let v: int;
+    let v: isize;
     loop {
         v = 1; //~ ERROR re-assignment of immutable variable
         //~^ NOTE prior assignment occurs here
diff --git a/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs b/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs
index 43d7ca83753..df57bb9e441 100644
--- a/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs
+++ b/src/test/compile-fail/liveness-assign-imm-local-in-op-eq.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn test() {
-    let v: int;
+    let v: isize;
     v = 2;  //~ NOTE prior assignment occurs here
     v += 1; //~ ERROR re-assignment of immutable variable
     v.clone();
diff --git a/src/test/compile-fail/liveness-assign-imm-local-with-init.rs b/src/test/compile-fail/liveness-assign-imm-local-with-init.rs
index 8eb84525b83..28218bff60d 100644
--- a/src/test/compile-fail/liveness-assign-imm-local-with-init.rs
+++ b/src/test/compile-fail/liveness-assign-imm-local-with-init.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn test() {
-    let v: int = 1; //~ NOTE prior assignment occurs here
+    let v: isize = 1; //~ NOTE prior assignment occurs here
     v.clone();
     v = 2; //~ ERROR re-assignment of immutable variable
     v.clone();
diff --git a/src/test/compile-fail/liveness-closure-require-ret.rs b/src/test/compile-fail/liveness-closure-require-ret.rs
index 82de02f0981..17cd8231222 100644
--- a/src/test/compile-fail/liveness-closure-require-ret.rs
+++ b/src/test/compile-fail/liveness-closure-require-ret.rs
@@ -8,5 +8,5 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn force<F>(f: F) -> int where F: FnOnce() -> int { f() }
+fn force<F>(f: F) -> isize where F: FnOnce() -> isize { f() }
 fn main() { println!("{}", force(|| {})); } //~ ERROR mismatched types
diff --git a/src/test/compile-fail/liveness-dead.rs b/src/test/compile-fail/liveness-dead.rs
index 18baf7a9c3f..dc7b0fc4fd0 100644
--- a/src/test/compile-fail/liveness-dead.rs
+++ b/src/test/compile-fail/liveness-dead.rs
@@ -11,18 +11,18 @@
 #![allow(dead_code)]
 #![deny(unused_assignments)]
 
-fn f1(x: &mut int) {
+fn f1(x: &mut isize) {
     *x = 1; // no error
 }
 
 fn f2() {
-    let mut x: int = 3; //~ ERROR: value assigned to `x` is never read
+    let mut x: isize = 3; //~ ERROR: value assigned to `x` is never read
     x = 4;
     x.clone();
 }
 
 fn f3() {
-    let mut x: int = 3;
+    let mut x: isize = 3;
     x.clone();
     x = 4; //~ ERROR: value assigned to `x` is never read
 }
diff --git a/src/test/compile-fail/liveness-forgot-ret.rs b/src/test/compile-fail/liveness-forgot-ret.rs
index 305cbcad738..e08515e40af 100644
--- a/src/test/compile-fail/liveness-forgot-ret.rs
+++ b/src/test/compile-fail/liveness-forgot-ret.rs
@@ -10,8 +10,8 @@
 
 // error-pattern: not all control paths return a value
 
-fn god_exists(a: int) -> bool { return god_exists(a); }
+fn god_exists(a: isize) -> bool { return god_exists(a); }
 
-fn f(a: int) -> int { if god_exists(a) { return 5; }; }
+fn f(a: isize) -> isize { if god_exists(a) { return 5; }; }
 
 fn main() { f(12); }
diff --git a/src/test/compile-fail/liveness-issue-2163.rs b/src/test/compile-fail/liveness-issue-2163.rs
index e46d00c4ab9..69bceec8c32 100644
--- a/src/test/compile-fail/liveness-issue-2163.rs
+++ b/src/test/compile-fail/liveness-issue-2163.rs
@@ -11,7 +11,7 @@
 use std::vec::Vec;
 
 fn main() {
-    let a: Vec<int> = Vec::new();
+    let a: Vec<isize> = Vec::new();
     a.iter().all(|_| -> bool {
         //~^ ERROR mismatched types
     });
diff --git a/src/test/compile-fail/liveness-missing-ret2.rs b/src/test/compile-fail/liveness-missing-ret2.rs
index 541e8ec97fa..b53bb6159e8 100644
--- a/src/test/compile-fail/liveness-missing-ret2.rs
+++ b/src/test/compile-fail/liveness-missing-ret2.rs
@@ -10,7 +10,7 @@
 
 // error-pattern: not all control paths return a value
 
-fn f() -> int {
+fn f() -> isize {
     // Make sure typestate doesn't interpret this match expression as
     // the function result
    match true { true => { } _ => {} };
diff --git a/src/test/compile-fail/liveness-move-call-arg.rs b/src/test/compile-fail/liveness-move-call-arg.rs
index 08a523fb8ff..9340964c1fb 100644
--- a/src/test/compile-fail/liveness-move-call-arg.rs
+++ b/src/test/compile-fail/liveness-move-call-arg.rs
@@ -10,11 +10,11 @@
 
 #![feature(box_syntax)]
 
-fn take(_x: Box<int>) {}
+fn take(_x: Box<isize>) {}
 
 fn main() {
 
-    let x: Box<int> = box 25;
+    let x: Box<isize> = box 25;
     loop {
         take(x); //~ ERROR use of moved value: `x`
     }
diff --git a/src/test/compile-fail/liveness-move-in-loop.rs b/src/test/compile-fail/liveness-move-in-loop.rs
index b2142258fb0..65ccaceac08 100644
--- a/src/test/compile-fail/liveness-move-in-loop.rs
+++ b/src/test/compile-fail/liveness-move-in-loop.rs
@@ -11,8 +11,8 @@
 #![feature(box_syntax)]
 
 fn main() {
-    let y: Box<int> = box 42;
-    let mut x: Box<int>;
+    let y: Box<isize> = box 42;
+    let mut x: Box<isize>;
     loop {
         println!("{}", y);
         loop {
diff --git a/src/test/compile-fail/liveness-move-in-while.rs b/src/test/compile-fail/liveness-move-in-while.rs
index 549cf523d03..cadfd487121 100644
--- a/src/test/compile-fail/liveness-move-in-while.rs
+++ b/src/test/compile-fail/liveness-move-in-while.rs
@@ -11,8 +11,8 @@
 #![feature(box_syntax)]
 
 fn main() {
-    let y: Box<int> = box 42;
-    let mut x: Box<int>;
+    let y: Box<isize> = box 42;
+    let mut x: Box<isize>;
     loop {
         println!("{}", y); //~ ERROR use of moved value: `y`
         while true { while true { while true { x = y; x.clone(); } } }
diff --git a/src/test/compile-fail/liveness-return-last-stmt-semi.rs b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
index 9cfffb5fa6b..b274ad9f3d4 100644
--- a/src/test/compile-fail/liveness-return-last-stmt-semi.rs
+++ b/src/test/compile-fail/liveness-return-last-stmt-semi.rs
@@ -10,11 +10,11 @@
 //
 // regression test for #8005
 
-macro_rules! test { () => { fn foo() -> int { 1i; } } }
+macro_rules! test { () => { fn foo() -> isize { 1i; } } }
                                              //~^ ERROR not all control paths return a value
                                              //~^^ HELP consider removing this semicolon
 
-fn no_return() -> int {} //~ ERROR  not all control paths return a value
+fn no_return() -> isize {} //~ ERROR  not all control paths return a value
 
 fn bar(x: u32) -> u32 { //~ ERROR  not all control paths return a value
     x * 2; //~ HELP consider removing this semicolon
diff --git a/src/test/compile-fail/liveness-unused.rs b/src/test/compile-fail/liveness-unused.rs
index e93872eba0c..0971709229b 100644
--- a/src/test/compile-fail/liveness-unused.rs
+++ b/src/test/compile-fail/liveness-unused.rs
@@ -12,19 +12,19 @@
 #![deny(unused_assignments)]
 #![allow(dead_code, non_camel_case_types)]
 
-fn f1(x: int) {
+fn f1(x: isize) {
     //~^ ERROR unused variable: `x`
 }
 
-fn f1b(x: &mut int) {
+fn f1b(x: &mut isize) {
     //~^ ERROR unused variable: `x`
 }
 
 #[allow(unused_variables)]
-fn f1c(x: int) {}
+fn f1c(x: isize) {}
 
 fn f1d() {
-    let x: int;
+    let x: isize;
     //~^ ERROR unused variable: `x`
 }
 
@@ -71,10 +71,10 @@ fn f4() {
 }
 
 enum tri {
-    a(int), b(int), c(int)
+    a(isize), b(isize), c(isize)
 }
 
-fn f4b() -> int {
+fn f4b() -> isize {
     match tri::a(3i) {
       tri::a(i) | tri::b(i) | tri::c(i) => {
         i
diff --git a/src/test/compile-fail/liveness-use-after-send.rs b/src/test/compile-fail/liveness-use-after-send.rs
index 44d45463f19..4ba24800f5d 100644
--- a/src/test/compile-fail/liveness-use-after-send.rs
+++ b/src/test/compile-fail/liveness-use-after-send.rs
@@ -15,11 +15,11 @@ fn send<T:Send + std::fmt::Show>(ch: _chan<T>, data: T) {
 }
 
 #[derive(Show)]
-struct _chan<T>(int);
+struct _chan<T>(isize);
 
 // Tests that "log(debug, message);" is flagged as using
 // message after the send deinitializes it
-fn test00_start(ch: _chan<Box<int>>, message: Box<int>, _count: Box<int>) {
+fn test00_start(ch: _chan<Box<isize>>, message: Box<isize>, _count: Box<isize>) {
     send(ch, message);
     println!("{}", message); //~ ERROR use of moved value: `message`
 }
diff --git a/src/test/compile-fail/main-wrong-type.rs b/src/test/compile-fail/main-wrong-type.rs
index ae990880523..d9c617a7172 100644
--- a/src/test/compile-fail/main-wrong-type.rs
+++ b/src/test/compile-fail/main-wrong-type.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 struct S {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 fn main(foo: S) {
diff --git a/src/test/compile-fail/match-join.rs b/src/test/compile-fail/match-join.rs
index e78561b9fdb..4ec426fd3aa 100644
--- a/src/test/compile-fail/match-join.rs
+++ b/src/test/compile-fail/match-join.rs
@@ -17,5 +17,5 @@ fn main() {
     match true { false => { my_panic(); } true => { } }
 
     println!("{}", x); //~ ERROR unresolved name `x`
-    let x: int;
+    let x: isize;
 }
diff --git a/src/test/compile-fail/match-static-const-lc.rs b/src/test/compile-fail/match-static-const-lc.rs
index 15a832aad89..345c4aa69a7 100644
--- a/src/test/compile-fail/match-static-const-lc.rs
+++ b/src/test/compile-fail/match-static-const-lc.rs
@@ -14,7 +14,7 @@
 #![deny(non_upper_case_globals)]
 
 #[allow(non_upper_case_globals)]
-pub const a : int = 97;
+pub const a : isize = 97;
 
 fn f() {
     let r = match (0,0) {
@@ -27,7 +27,7 @@ fn f() {
 
 mod m {
     #[allow(non_upper_case_globals)]
-    pub const aha : int = 7;
+    pub const aha : isize = 7;
 }
 
 fn g() {
@@ -41,7 +41,7 @@ fn g() {
 }
 
 mod n {
-    pub const OKAY : int = 8;
+    pub const OKAY : isize = 8;
 }
 
 fn h() {
diff --git a/src/test/compile-fail/match-struct.rs b/src/test/compile-fail/match-struct.rs
index 65082f93d35..e3b47372a4f 100644
--- a/src/test/compile-fail/match-struct.rs
+++ b/src/test/compile-fail/match-struct.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 
-struct S { a: int }
-enum E { C(int) }
+struct S { a: isize }
+enum E { C(isize) }
 
 fn main() {
     match (S { a: 1 }) {
diff --git a/src/test/compile-fail/match-tag-unary.rs b/src/test/compile-fail/match-tag-unary.rs
index 89012e42bdc..48733fd423d 100644
--- a/src/test/compile-fail/match-tag-unary.rs
+++ b/src/test/compile-fail/match-tag-unary.rs
@@ -10,7 +10,7 @@
 
 // error-pattern: mismatched types
 
-enum a { A(int), }
-enum b { B(int), }
+enum a { A(isize), }
+enum b { B(isize), }
 
 fn main() { let x: a = a::A(0); match x { b::B(y) => { } } }
diff --git a/src/test/compile-fail/match-vec-unreachable.rs b/src/test/compile-fail/match-vec-unreachable.rs
index a85ce660e8b..e2671552b43 100644
--- a/src/test/compile-fail/match-vec-unreachable.rs
+++ b/src/test/compile-fail/match-vec-unreachable.rs
@@ -10,8 +10,8 @@
 
 
 fn main() {
-    let x: Vec<(int, int)> = Vec::new();
-    let x: &[(int, int)] = x.as_slice();
+    let x: Vec<(isize, isize)> = Vec::new();
+    let x: &[(isize, isize)] = x.as_slice();
     match x {
         [a, (2, 3), _] => (),
         [(1, 2), (2, 3), b] => (), //~ ERROR unreachable pattern
diff --git a/src/test/compile-fail/method-ambig-one-trait-coerce.rs b/src/test/compile-fail/method-ambig-one-trait-coerce.rs
index 5e3206ea516..cb5da4bb547 100644
--- a/src/test/compile-fail/method-ambig-one-trait-coerce.rs
+++ b/src/test/compile-fail/method-ambig-one-trait-coerce.rs
@@ -15,15 +15,15 @@
 trait Object { }
 
 trait foo {
-    fn foo(self) -> int;
+    fn foo(self) -> isize;
 }
 
 impl foo for Box<Object+'static> {
-    fn foo(self) -> int {1}
+    fn foo(self) -> isize {1}
 }
 
 impl foo for Box<Object+Send> {
-    fn foo(self) -> int {2}
+    fn foo(self) -> isize {2}
 }
 
 fn test1(x: Box<Object+Send+Sync>) {
diff --git a/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs b/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs
index e211db2dcd2..f0cc7c80417 100644
--- a/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs
+++ b/src/test/compile-fail/method-ambig-one-trait-unknown-int-type.rs
@@ -13,15 +13,15 @@
 // of what kind of `Vec` we have, eventually leading to a type error.
 
 trait foo {
-    fn foo(&self) -> int;
+    fn foo(&self) -> isize;
 }
 
 impl foo for Vec<uint> {
-    fn foo(&self) -> int {1}
+    fn foo(&self) -> isize {1}
 }
 
-impl foo for Vec<int> {
-    fn foo(&self) -> int {2}
+impl foo for Vec<isize> {
+    fn foo(&self) -> isize {2}
 }
 
 // This is very hokey: we have heuristics to suppress messages about
diff --git a/src/test/compile-fail/method-call-err-msg.rs b/src/test/compile-fail/method-call-err-msg.rs
index 3610a0e2e9d..2f82441762f 100644
--- a/src/test/compile-fail/method-call-err-msg.rs
+++ b/src/test/compile-fail/method-call-err-msg.rs
@@ -13,8 +13,8 @@
 pub struct Foo;
 impl Foo {
     fn zero(self) -> Foo { self }
-    fn one(self, _: int) -> Foo { self }
-    fn two(self, _: int, _: int) -> Foo { self }
+    fn one(self, _: isize) -> Foo { self }
+    fn two(self, _: isize, _: isize) -> Foo { self }
 }
 
 fn main() {
diff --git a/src/test/compile-fail/method-missing-call.rs b/src/test/compile-fail/method-missing-call.rs
index ddfa447f60e..83418cbc104 100644
--- a/src/test/compile-fail/method-missing-call.rs
+++ b/src/test/compile-fail/method-missing-call.rs
@@ -14,21 +14,21 @@
 
 
 struct Point {
-    x: int,
-    y: int
+    x: isize,
+    y: isize
 }
 impl Point {
     fn new() -> Point {
         Point{x:0, y:0}
     }
-    fn get_x(&self) -> int {
+    fn get_x(&self) -> isize {
         self.x
     }
 }
 
 fn main() {
     let point: Point = Point::new();
-    let px: int =  point
+    let px: isize =  point
                         .get_x;//~ ERROR attempted to take value of method `get_x` on type `Point`
                         //~^ HELP maybe a `()` to call it is missing
 
diff --git a/src/test/compile-fail/missing-derivable-attr.rs b/src/test/compile-fail/missing-derivable-attr.rs
index db960ac3409..7eee51e4076 100644
--- a/src/test/compile-fail/missing-derivable-attr.rs
+++ b/src/test/compile-fail/missing-derivable-attr.rs
@@ -13,11 +13,11 @@ trait MyEq {
 }
 
 struct A {
-    x: int
+    x: isize
 }
 
-impl MyEq for int {
-    fn eq(&self, other: &int) -> bool { *self == *other }
+impl MyEq for isize {
+    fn eq(&self, other: &isize) -> bool { *self == *other }
 }
 
 impl MyEq for A {}  //~ ERROR not all trait items implemented, missing: `eq`
diff --git a/src/test/compile-fail/missing-return.rs b/src/test/compile-fail/missing-return.rs
index 1dc817cc6e6..efd0c827a35 100644
--- a/src/test/compile-fail/missing-return.rs
+++ b/src/test/compile-fail/missing-return.rs
@@ -10,6 +10,6 @@
 
 // error-pattern: return
 
-fn f() -> int { }
+fn f() -> isize { }
 
 fn main() { f(); }
diff --git a/src/test/compile-fail/mod_file_aux.rs b/src/test/compile-fail/mod_file_aux.rs
index 4d18decdc13..b7470811f60 100644
--- a/src/test/compile-fail/mod_file_aux.rs
+++ b/src/test/compile-fail/mod_file_aux.rs
@@ -10,4 +10,4 @@
 
 // ignore-test Not a test. Used by other tests
 
-pub fn foo() -> int { 10 }
+pub fn foo() -> isize { 10 }
diff --git a/src/test/compile-fail/move-fragments-1.rs b/src/test/compile-fail/move-fragments-1.rs
index e45862a7fc6..3f14be2da10 100644
--- a/src/test/compile-fail/move-fragments-1.rs
+++ b/src/test/compile-fail/move-fragments-1.rs
@@ -18,7 +18,7 @@
 // These are all fairly trivial cases: unused variables or direct
 // drops of substructure.
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 #[rustc_move_fragments]
diff --git a/src/test/compile-fail/move-fragments-2.rs b/src/test/compile-fail/move-fragments-2.rs
index ceb1d5a0f09..6c0635d6be9 100644
--- a/src/test/compile-fail/move-fragments-2.rs
+++ b/src/test/compile-fail/move-fragments-2.rs
@@ -20,7 +20,7 @@
 
 use self::Lonely::{Zero, One, Two};
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub enum Lonely<X,Y> { Zero, One(X), Two(X, Y) }
diff --git a/src/test/compile-fail/move-fragments-3.rs b/src/test/compile-fail/move-fragments-3.rs
index 4540b0c5a91..24d73ec2274 100644
--- a/src/test/compile-fail/move-fragments-3.rs
+++ b/src/test/compile-fail/move-fragments-3.rs
@@ -20,7 +20,7 @@
 
 use self::Lonely::{Zero, One, Two};
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub enum Lonely<X,Y> { Zero, One(X), Two(X, Y) }
diff --git a/src/test/compile-fail/move-fragments-4.rs b/src/test/compile-fail/move-fragments-4.rs
index dc43dcb9b0e..97e8e45ed06 100644
--- a/src/test/compile-fail/move-fragments-4.rs
+++ b/src/test/compile-fail/move-fragments-4.rs
@@ -19,7 +19,7 @@
 // early draft of the code did not properly traverse up through all of
 // the parents of the leaf fragment.)
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub struct Pair<X,Y> { x: X, y: Y }
diff --git a/src/test/compile-fail/move-fragments-5.rs b/src/test/compile-fail/move-fragments-5.rs
index bef2f12d642..9f70421fa84 100644
--- a/src/test/compile-fail/move-fragments-5.rs
+++ b/src/test/compile-fail/move-fragments-5.rs
@@ -17,7 +17,7 @@
 
 // This is the first test that checks moving into local variables.
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub struct Pair<X,Y> { x: X, y: Y }
diff --git a/src/test/compile-fail/move-fragments-7.rs b/src/test/compile-fail/move-fragments-7.rs
index 6b2c77bcac1..2af2b2957f8 100644
--- a/src/test/compile-fail/move-fragments-7.rs
+++ b/src/test/compile-fail/move-fragments-7.rs
@@ -19,7 +19,7 @@
 // both moving out of the structure (i.e. reading `*p.x`) and writing
 // into the container (i.e. writing `*p.x`).
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub struct Pair<X,Y> { x: X, y: Y }
diff --git a/src/test/compile-fail/move-fragments-8.rs b/src/test/compile-fail/move-fragments-8.rs
index 40ab541128c..18bf4066076 100644
--- a/src/test/compile-fail/move-fragments-8.rs
+++ b/src/test/compile-fail/move-fragments-8.rs
@@ -22,7 +22,7 @@
 // also that in this case we cannot do a move out of `&T`, so we only
 // test writing `*p.x` here.
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 pub struct Pair<X,Y> { x: X, y: Y }
diff --git a/src/test/compile-fail/move-fragments-9.rs b/src/test/compile-fail/move-fragments-9.rs
index 0b095ff6f82..4dd6c5eb4e6 100644
--- a/src/test/compile-fail/move-fragments-9.rs
+++ b/src/test/compile-fail/move-fragments-9.rs
@@ -14,7 +14,7 @@
 // Note also that the `test_move_array_then_overwrite` tests represent
 // cases that we probably should make illegal.
 
-pub struct D { d: int }
+pub struct D { d: isize }
 impl Drop for D { fn drop(&mut self) { } }
 
 #[rustc_move_fragments]
diff --git a/src/test/compile-fail/move-out-of-tuple-field.rs b/src/test/compile-fail/move-out-of-tuple-field.rs
index 78b6736c1c8..ca09d43d79c 100644
--- a/src/test/compile-fail/move-out-of-tuple-field.rs
+++ b/src/test/compile-fail/move-out-of-tuple-field.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-struct Foo(Box<int>);
+struct Foo(Box<isize>);
 
 fn main() {
     let x = (box 1i,);
diff --git a/src/test/compile-fail/moves-based-on-type-access-to-field.rs b/src/test/compile-fail/moves-based-on-type-access-to-field.rs
index c9efce0d684..b8572fbd215 100644
--- a/src/test/compile-fail/moves-based-on-type-access-to-field.rs
+++ b/src/test/compile-fail/moves-based-on-type-access-to-field.rs
@@ -11,7 +11,7 @@
 // Tests that if you move from `x.f` or `x[0]`, `x` is inaccessible.
 // Also tests that we give a more specific error message.
 
-struct Foo { f: String, y: int }
+struct Foo { f: String, y: isize }
 fn consume(_s: String) {}
 fn touch<A>(_a: &A) {}
 
diff --git a/src/test/compile-fail/moves-based-on-type-block-bad.rs b/src/test/compile-fail/moves-based-on-type-block-bad.rs
index 379397f22bd..179c71d3659 100644
--- a/src/test/compile-fail/moves-based-on-type-block-bad.rs
+++ b/src/test/compile-fail/moves-based-on-type-block-bad.rs
@@ -18,7 +18,7 @@ struct S {
 
 enum E {
     Foo(Box<S>),
-    Bar(Box<int>),
+    Bar(Box<isize>),
     Baz
 }
 
diff --git a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
index 805c82f03f9..865784c2f1e 100644
--- a/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
+++ b/src/test/compile-fail/moves-based-on-type-cyclic-types-issue-4821.rs
@@ -13,9 +13,9 @@
 // See middle::ty::type_contents() for more information.
 
 
-struct List { key: int, next: Option<Box<List>> }
+struct List { key: isize, next: Option<Box<List>> }
 
-fn foo(node: Box<List>) -> int {
+fn foo(node: Box<List>) -> isize {
     let r = match node.next {
         Some(right) => consume(right),
         None => 0
@@ -23,7 +23,7 @@ fn foo(node: Box<List>) -> int {
     consume(node) + r //~ ERROR use of partially moved value: `node`
 }
 
-fn consume(v: Box<List>) -> int {
+fn consume(v: Box<List>) -> isize {
     v.key
 }
 
diff --git a/src/test/compile-fail/moves-based-on-type-tuple.rs b/src/test/compile-fail/moves-based-on-type-tuple.rs
index 397b22c486e..30388f9d2f7 100644
--- a/src/test/compile-fail/moves-based-on-type-tuple.rs
+++ b/src/test/compile-fail/moves-based-on-type-tuple.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn dup(x: Box<int>) -> Box<(Box<int>,Box<int>)> { box() (x, x) } //~ ERROR use of moved value
+fn dup(x: Box<isize>) -> Box<(Box<isize>,Box<isize>)> { box() (x, x) } //~ ERROR use of moved value
 fn main() {
     dup(box 3);
 }
diff --git a/src/test/compile-fail/moves-sru-moved-field.rs b/src/test/compile-fail/moves-sru-moved-field.rs
index 6c351f88713..15977fbeb73 100644
--- a/src/test/compile-fail/moves-sru-moved-field.rs
+++ b/src/test/compile-fail/moves-sru-moved-field.rs
@@ -10,11 +10,11 @@
 
 #![feature(box_syntax)]
 
-type Noncopyable = Box<int>;
+type Noncopyable = Box<isize>;
 
 struct Foo {
-    copied: int,
-    moved: Box<int>,
+    copied: isize,
+    moved: Box<isize>,
     noncopyable: Noncopyable
 }
 
diff --git a/src/test/compile-fail/multitrait.rs b/src/test/compile-fail/multitrait.rs
index 7add747fbfa..a0e210aed40 100644
--- a/src/test/compile-fail/multitrait.rs
+++ b/src/test/compile-fail/multitrait.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct S {
- y: int
+ y: isize
 }
 
 impl Cmp, ToString for S { //~ ERROR: expected one of `(`, `+`, `::`, or `{`, found `,`
diff --git a/src/test/compile-fail/mut-cross-borrowing.rs b/src/test/compile-fail/mut-cross-borrowing.rs
index 90bc0019531..ee4d11c96ca 100644
--- a/src/test/compile-fail/mut-cross-borrowing.rs
+++ b/src/test/compile-fail/mut-cross-borrowing.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-fn f(_: &mut int) {}
+fn f(_: &mut isize) {}
 
 fn main() {
     let mut x = box 3i;
diff --git a/src/test/compile-fail/mut-patterns.rs b/src/test/compile-fail/mut-patterns.rs
index a78e82bb73c..cde05bc1d52 100644
--- a/src/test/compile-fail/mut-patterns.rs
+++ b/src/test/compile-fail/mut-patterns.rs
@@ -11,6 +11,6 @@
 // Can't put mut in non-ident pattern
 
 pub fn main() {
-    struct Foo { x: int }
+    struct Foo { x: isize }
     let mut Foo { x: x } = Foo { x: 3 }; //~ ERROR: expected one of `:`, `;`, `=`, or `@`, found `{`
 }
diff --git a/src/test/compile-fail/mutable-class-fields-2.rs b/src/test/compile-fail/mutable-class-fields-2.rs
index 377c745acf3..3d8b095cb4e 100644
--- a/src/test/compile-fail/mutable-class-fields-2.rs
+++ b/src/test/compile-fail/mutable-class-fields-2.rs
@@ -11,7 +11,7 @@
 struct cat {
   meows : uint,
 
-  how_hungry : int,
+  how_hungry : isize,
 }
 
 impl cat {
@@ -21,7 +21,7 @@ impl cat {
 
 }
 
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : uint, in_y : isize) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y
diff --git a/src/test/compile-fail/mutable-class-fields.rs b/src/test/compile-fail/mutable-class-fields.rs
index 4d77d1824ab..b2a76d8fd37 100644
--- a/src/test/compile-fail/mutable-class-fields.rs
+++ b/src/test/compile-fail/mutable-class-fields.rs
@@ -10,10 +10,10 @@
 
 struct cat {
   meows : uint,
-  how_hungry : int,
+  how_hungry : isize,
 }
 
-fn cat(in_x : uint, in_y : int) -> cat {
+fn cat(in_x : uint, in_y : isize) -> cat {
     cat {
         meows: in_x,
         how_hungry: in_y
diff --git a/src/test/compile-fail/name-clash-nullary.rs b/src/test/compile-fail/name-clash-nullary.rs
index 2f0588b261e..1250318a729 100644
--- a/src/test/compile-fail/name-clash-nullary.rs
+++ b/src/test/compile-fail/name-clash-nullary.rs
@@ -12,6 +12,6 @@
 use std::option::*;
 
 fn main() {
-  let None: int = 42;
+  let None: isize = 42;
   log(debug, None);
 }
diff --git a/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs b/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs
index 602ec9ba762..4437482fb67 100644
--- a/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs
+++ b/src/test/compile-fail/namespaced-enum-glob-import-no-impls.rs
@@ -11,8 +11,8 @@
 mod m2 {
     pub enum Foo {
         A,
-        B(int),
-        C { a: int },
+        B(isize),
+        C { a: isize },
     }
 
     impl Foo {
diff --git a/src/test/compile-fail/no_send-struct.rs b/src/test/compile-fail/no_send-struct.rs
index c2d6f04c7d4..bef70523787 100644
--- a/src/test/compile-fail/no_send-struct.rs
+++ b/src/test/compile-fail/no_send-struct.rs
@@ -11,7 +11,7 @@
 use std::marker;
 
 struct Foo {
-    a: int,
+    a: isize,
     ns: marker::NoSend
 }
 
diff --git a/src/test/compile-fail/no_share-struct.rs b/src/test/compile-fail/no_share-struct.rs
index 59864b63b04..c7028ce9786 100644
--- a/src/test/compile-fail/no_share-struct.rs
+++ b/src/test/compile-fail/no_share-struct.rs
@@ -10,7 +10,7 @@
 
 use std::marker;
 
-struct Foo { a: int, m: marker::NoSync }
+struct Foo { a: isize, m: marker::NoSync }
 
 fn bar<T: Sync>(_: T) {}
 
diff --git a/src/test/compile-fail/noexporttypeexe.rs b/src/test/compile-fail/noexporttypeexe.rs
index 4081792b654..8fa4e81c889 100644
--- a/src/test/compile-fail/noexporttypeexe.rs
+++ b/src/test/compile-fail/noexporttypeexe.rs
@@ -17,6 +17,6 @@ fn main() {
     // This used to cause internal errors when serializing
     // because the def_id associated with the type was
     // not convertible to a path.
-  let x: int = noexporttypelib::foo();
+  let x: isize = noexporttypelib::foo();
     //~^ ERROR expected `isize`, found `core::option::Option<isize>`
 }
diff --git a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
index 85d734ddaf2..14d2c8d0326 100644
--- a/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
+++ b/src/test/compile-fail/non-constant-expr-for-fixed-len-vec.rs
@@ -11,8 +11,8 @@
 // Check that non-constant exprs do fail as count in fixed length vec type
 
 fn main() {
-    fn bar(n: int) {
-        let _x: [int; n];
+    fn bar(n: isize) {
+        let _x: [isize; n];
         //~^ ERROR expected constant expr for array length: non-constant path in constant expr
     }
 }
diff --git a/src/test/compile-fail/non-copyable-void.rs b/src/test/compile-fail/non-copyable-void.rs
index cd134ccf71d..40b641519b0 100644
--- a/src/test/compile-fail/non-copyable-void.rs
+++ b/src/test/compile-fail/non-copyable-void.rs
@@ -11,7 +11,7 @@
 extern crate libc;
 
 fn main() {
-    let x : *const Vec<int> = &vec!(1,2,3);
+    let x : *const Vec<isize> = &vec!(1,2,3);
     let y : *const libc::c_void = x as *const libc::c_void;
     unsafe {
         let _z = (*y).clone();
diff --git a/src/test/compile-fail/non-exhaustive-match.rs b/src/test/compile-fail/non-exhaustive-match.rs
index 8fcf10f1c35..4c421a689ee 100644
--- a/src/test/compile-fail/non-exhaustive-match.rs
+++ b/src/test/compile-fail/non-exhaustive-match.rs
@@ -36,14 +36,14 @@ fn main() {
       (t::b, t::b) => {}
     }
     let vec = vec!(Some(42i), None, Some(21i));
-    let vec: &[Option<int>] = vec.as_slice();
+    let vec: &[Option<isize>] = vec.as_slice();
     match vec { //~ ERROR non-exhaustive patterns: `[]` not covered
         [Some(..), None, tail..] => {}
         [Some(..), Some(..), tail..] => {}
         [None] => {}
     }
     let vec = vec!(1i);
-    let vec: &[int] = vec.as_slice();
+    let vec: &[isize] = vec.as_slice();
     match vec {
         [_, tail..] => (),
         [] => ()
@@ -57,7 +57,7 @@ fn main() {
         [] => ()
     }
     let vec = vec!(Some(42i), None, Some(21i));
-    let vec: &[Option<int>] = vec.as_slice();
+    let vec: &[Option<isize>] = vec.as_slice();
     match vec {
         [Some(..), None, tail..] => {}
         [Some(..), Some(..), tail..] => {}
diff --git a/src/test/compile-fail/noncopyable-class.rs b/src/test/compile-fail/noncopyable-class.rs
index ec8369d6736..029b8485993 100644
--- a/src/test/compile-fail/noncopyable-class.rs
+++ b/src/test/compile-fail/noncopyable-class.rs
@@ -13,14 +13,14 @@
 
 #[derive(Show)]
 struct bar {
-  x: int,
+  x: isize,
 }
 
 impl Drop for bar {
     fn drop(&mut self) {}
 }
 
-fn bar(x:int) -> bar {
+fn bar(x:isize) -> bar {
     bar {
         x: x
     }
@@ -28,11 +28,11 @@ fn bar(x:int) -> bar {
 
 #[derive(Show)]
 struct foo {
-  i: int,
+  i: isize,
   j: bar,
 }
 
-fn foo(i:int) -> foo {
+fn foo(i:isize) -> foo {
     foo {
         i: i,
         j: bar(5)
diff --git a/src/test/compile-fail/nonscalar-cast.rs b/src/test/compile-fail/nonscalar-cast.rs
index 728f66a6aa7..f32c96b7b64 100644
--- a/src/test/compile-fail/nonscalar-cast.rs
+++ b/src/test/compile-fail/nonscalar-cast.rs
@@ -12,9 +12,9 @@
 
 #[derive(Show)]
 struct foo {
-    x: int
+    x: isize
 }
 
 fn main() {
-    println!("{}", foo{ x: 1 } as int);
+    println!("{}", foo{ x: 1 } as isize);
 }
diff --git a/src/test/compile-fail/not-a-pred.rs b/src/test/compile-fail/not-a-pred.rs
index 2e16c58eaad..782c90a6c26 100644
--- a/src/test/compile-fail/not-a-pred.rs
+++ b/src/test/compile-fail/not-a-pred.rs
@@ -10,8 +10,8 @@
 
 // error-pattern: lt
 
-fn f(a: int, b: int) : lt(a, b) { }
+fn f(a: isize, b: isize) : lt(a, b) { }
 
-fn lt(a: int, b: int) { }
+fn lt(a: isize, b: isize) { }
 
-fn main() { let a: int = 10; let b: int = 23; check (lt(a, b)); f(a, b); }
+fn main() { let a: isize = 10; let b: isize = 23; check (lt(a, b)); f(a, b); }
diff --git a/src/test/compile-fail/not-enough-arguments.rs b/src/test/compile-fail/not-enough-arguments.rs
index 2deb9591a83..c952906e5e8 100644
--- a/src/test/compile-fail/not-enough-arguments.rs
+++ b/src/test/compile-fail/not-enough-arguments.rs
@@ -12,7 +12,7 @@
 // mismatch between the # of params, and not other
 // unrelated errors.
 
-fn foo(a: int, b: int, c: int, d:int) {
+fn foo(a: isize, b: isize, c: isize, d:isize) {
   panic!();
 }
 
diff --git a/src/test/compile-fail/obsolete-tilde.rs b/src/test/compile-fail/obsolete-tilde.rs
index fa59798c1d5..9c395406f03 100644
--- a/src/test/compile-fail/obsolete-tilde.rs
+++ b/src/test/compile-fail/obsolete-tilde.rs
@@ -10,9 +10,9 @@
 
 // Test that ~ pointers give an obsolescence message.
 
-fn foo(x: ~int) {} //~ ERROR obsolete syntax: `~` notation for owned pointers
+fn foo(x: ~isize) {} //~ ERROR obsolete syntax: `~` notation for owned pointers
 fn bar(x: ~str) {} //~ ERROR obsolete syntax: `~` notation for owned pointers
-fn baz(x: ~[int]) {} //~ ERROR obsolete syntax: `~[T]` is no longer a type
+fn baz(x: ~[isize]) {} //~ ERROR obsolete syntax: `~[T]` is no longer a type
 
 fn main() {
     let x = ~4i; //~ ERROR obsolete syntax: `~` notation for owned pointer allocation
diff --git a/src/test/compile-fail/obsolete-tuple-struct-deref.rs b/src/test/compile-fail/obsolete-tuple-struct-deref.rs
index 9ea7d960da9..ad5fac3e21e 100644
--- a/src/test/compile-fail/obsolete-tuple-struct-deref.rs
+++ b/src/test/compile-fail/obsolete-tuple-struct-deref.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    struct S(int);
+    struct S(isize);
     let s = S(0);
     let x = *s; //~ ERROR single-field tuple-structs can no longer be dereferenced
 }
diff --git a/src/test/compile-fail/occurs-check-3.rs b/src/test/compile-fail/occurs-check-3.rs
index 4cda97bcb4a..ba7688e8524 100644
--- a/src/test/compile-fail/occurs-check-3.rs
+++ b/src/test/compile-fail/occurs-check-3.rs
@@ -11,4 +11,4 @@
 // error-pattern:mismatched types
 // From Issue #778
 enum clam<T> { a(T), }
-fn main() { let c; c = clam::a(c); match c { clam::a::<int>(_) => { } } }
+fn main() { let c; c = clam::a(c); match c { clam::a::<isize>(_) => { } } }
diff --git a/src/test/compile-fail/or-patter-mismatch.rs b/src/test/compile-fail/or-patter-mismatch.rs
index e79113ceb89..7f30e365609 100644
--- a/src/test/compile-fail/or-patter-mismatch.rs
+++ b/src/test/compile-fail/or-patter-mismatch.rs
@@ -10,6 +10,6 @@
 
 // error-pattern: mismatched types
 
-enum blah { a(int, int, uint), b(int, int), }
+enum blah { a(isize, isize, uint), b(isize, isize), }
 
 fn main() { match blah::a(1, 1, 2u) { blah::a(_, x, y) | blah::b(x, y) => { } } }
diff --git a/src/test/compile-fail/output-type-mismatch.rs b/src/test/compile-fail/output-type-mismatch.rs
index bc77765ebf4..158e99ac200 100644
--- a/src/test/compile-fail/output-type-mismatch.rs
+++ b/src/test/compile-fail/output-type-mismatch.rs
@@ -12,4 +12,4 @@
 
 fn f() { }
 
-fn main() { let i: int; i = f(); }
+fn main() { let i: isize; i = f(); }
diff --git a/src/test/compile-fail/overloaded-calls-bad.rs b/src/test/compile-fail/overloaded-calls-bad.rs
index b3a4c312589..d784ba2d0d6 100644
--- a/src/test/compile-fail/overloaded-calls-bad.rs
+++ b/src/test/compile-fail/overloaded-calls-bad.rs
@@ -13,12 +13,12 @@
 use std::ops::FnMut;
 
 struct S {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-impl FnMut<(int,),int> for S {
-    extern "rust-call" fn call_mut(&mut self, (z,): (int,)) -> int {
+impl FnMut<(isize,),isize> for S {
+    extern "rust-call" fn call_mut(&mut self, (z,): (isize,)) -> isize {
         self.x * self.y * z
     }
 }
diff --git a/src/test/compile-fail/overloaded-calls-nontuple.rs b/src/test/compile-fail/overloaded-calls-nontuple.rs
index 396a809c2e1..c06ab04cd84 100644
--- a/src/test/compile-fail/overloaded-calls-nontuple.rs
+++ b/src/test/compile-fail/overloaded-calls-nontuple.rs
@@ -13,12 +13,12 @@
 use std::ops::FnMut;
 
 struct S {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-impl FnMut<int,int> for S {
-    extern "rust-call" fn call_mut(&mut self, z: int) -> int {
+impl FnMut<isize,isize> for S {
+    extern "rust-call" fn call_mut(&mut self, z: isize) -> isize {
         self.x + self.y + z
     }
 }
diff --git a/src/test/compile-fail/oversized-literal.rs b/src/test/compile-fail/oversized-literal.rs
index 5416bcacf3d..2a70653bd6c 100644
--- a/src/test/compile-fail/oversized-literal.rs
+++ b/src/test/compile-fail/oversized-literal.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 fn main() {
-    println!("{}", 18446744073709551616u64);  //~ error: int literal is too large
+    println!("{}", 18446744073709551616u64);  //~ error: isize literal is too large
 }
diff --git a/src/test/compile-fail/pat-ref-enum.rs b/src/test/compile-fail/pat-ref-enum.rs
index f1f0637a318..062d3308c3d 100644
--- a/src/test/compile-fail/pat-ref-enum.rs
+++ b/src/test/compile-fail/pat-ref-enum.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn matcher(x: Option<int>) {
+fn matcher(x: Option<isize>) {
     match x {
       ref Some(i) => {} //~ ERROR expected identifier, found enum pattern
       None => {}
diff --git a/src/test/compile-fail/pattern-error-continue.rs b/src/test/compile-fail/pattern-error-continue.rs
index 8b65af00fb1..c288429dcda 100644
--- a/src/test/compile-fail/pattern-error-continue.rs
+++ b/src/test/compile-fail/pattern-error-continue.rs
@@ -11,13 +11,13 @@
 // Test that certain pattern-match type errors are non-fatal
 
 enum A {
-    B(int, int),
-    C(int, int, int),
+    B(isize, isize),
+    C(isize, isize, isize),
     D
 }
 
 struct S {
-    a: int
+    a: isize
 }
 
 fn f(_c: char) {}
diff --git a/src/test/compile-fail/pattern-ident-path-generics.rs b/src/test/compile-fail/pattern-ident-path-generics.rs
index ab77e376979..58288fa4842 100644
--- a/src/test/compile-fail/pattern-ident-path-generics.rs
+++ b/src/test/compile-fail/pattern-ident-path-generics.rs
@@ -10,7 +10,7 @@
 
 fn main() {
     match Some("foo") {
-        None::<int> => {}   //~ ERROR mismatched types
+        None::<isize> => {}   //~ ERROR mismatched types
         Some(_) => {}
     }
 }
diff --git a/src/test/compile-fail/pattern-tyvar-2.rs b/src/test/compile-fail/pattern-tyvar-2.rs
index ff898ebd16b..cd4a98835c8 100644
--- a/src/test/compile-fail/pattern-tyvar-2.rs
+++ b/src/test/compile-fail/pattern-tyvar-2.rs
@@ -8,10 +8,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum bar { t1((), Option<Vec<int>>), t2, }
+enum bar { t1((), Option<Vec<isize>>), t2, }
 
 // n.b. my change changes this error message, but I think it's right -- tjc
-fn foo(t: bar) -> int { match t { bar::t1(_, Some(x)) => { return x * 3; } _ => { panic!(); } } }
+fn foo(t: bar) -> isize { match t { bar::t1(_, Some(x)) => { return x * 3; } _ => { panic!(); } } }
 //~^ ERROR binary operation `*` cannot be applied to
 
 fn main() { }
diff --git a/src/test/compile-fail/pattern-tyvar.rs b/src/test/compile-fail/pattern-tyvar.rs
index 01b288fdaad..be8d3e027e7 100644
--- a/src/test/compile-fail/pattern-tyvar.rs
+++ b/src/test/compile-fail/pattern-tyvar.rs
@@ -10,11 +10,11 @@
 
 // error-pattern: mismatched types
 
-enum bar { t1((), Option<Vec<int> >), t2, }
+enum bar { t1((), Option<Vec<isize> >), t2, }
 
 fn foo(t: bar) {
     match t {
-      bar::t1(_, Some::<int>(x)) => {
+      bar::t1(_, Some::<isize>(x)) => {
         println!("{}", x);
       }
       _ => { panic!(); }
diff --git a/src/test/compile-fail/prim-with-args.rs b/src/test/compile-fail/prim-with-args.rs
index 0587e033a97..b4dba4f3a60 100644
--- a/src/test/compile-fail/prim-with-args.rs
+++ b/src/test/compile-fail/prim-with-args.rs
@@ -10,19 +10,19 @@
 
 fn main() {
 
-let x: int<int>; //~ ERROR type parameters are not allowed on this type
-let x: i8<int>; //~ ERROR type parameters are not allowed on this type
-let x: i16<int>; //~ ERROR type parameters are not allowed on this type
-let x: i32<int>; //~ ERROR type parameters are not allowed on this type
-let x: i64<int>; //~ ERROR type parameters are not allowed on this type
-let x: uint<int>; //~ ERROR type parameters are not allowed on this type
-let x: u8<int>; //~ ERROR type parameters are not allowed on this type
-let x: u16<int>; //~ ERROR type parameters are not allowed on this type
-let x: u32<int>; //~ ERROR type parameters are not allowed on this type
-let x: u64<int>; //~ ERROR type parameters are not allowed on this type
-let x: char<int>; //~ ERROR type parameters are not allowed on this type
+let x: isize<isize>; //~ ERROR type parameters are not allowed on this type
+let x: i8<isize>; //~ ERROR type parameters are not allowed on this type
+let x: i16<isize>; //~ ERROR type parameters are not allowed on this type
+let x: i32<isize>; //~ ERROR type parameters are not allowed on this type
+let x: i64<isize>; //~ ERROR type parameters are not allowed on this type
+let x: uint<isize>; //~ ERROR type parameters are not allowed on this type
+let x: u8<isize>; //~ ERROR type parameters are not allowed on this type
+let x: u16<isize>; //~ ERROR type parameters are not allowed on this type
+let x: u32<isize>; //~ ERROR type parameters are not allowed on this type
+let x: u64<isize>; //~ ERROR type parameters are not allowed on this type
+let x: char<isize>; //~ ERROR type parameters are not allowed on this type
 
-let x: int<'static>; //~ ERROR lifetime parameters are not allowed on this type
+let x: isize<'static>; //~ ERROR lifetime parameters are not allowed on this type
 let x: i8<'static>; //~ ERROR lifetime parameters are not allowed on this type
 let x: i16<'static>; //~ ERROR lifetime parameters are not allowed on this type
 let x: i32<'static>; //~ ERROR lifetime parameters are not allowed on this type
diff --git a/src/test/compile-fail/privacy1.rs b/src/test/compile-fail/privacy1.rs
index ffee00642ac..9dafae3d87d 100644
--- a/src/test/compile-fail/privacy1.rs
+++ b/src/test/compile-fail/privacy1.rs
@@ -41,7 +41,7 @@ mod bar {
         fn foo() -> Self;
     }
 
-    impl B for int { fn foo() -> int { 3 } }
+    impl B for isize { fn foo() -> isize { 3 } }
 
     pub enum Enum {
         Pub
@@ -119,7 +119,7 @@ mod foo {
                                 //~^ ERROR: method `bar2` is private
                                 //~^^ NOTE: module `baz` is private
 
-        let _: int =
+        let _: isize =
         ::bar::B::foo();        //~ ERROR: method `foo` is inaccessible
                                 //~^ NOTE: trait `B` is private
         ::lol();
@@ -186,4 +186,4 @@ pub mod mytest {
     }
 }
 
-#[start] fn main(_: int, _: *const *const u8) -> int { 3 }
+#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }
diff --git a/src/test/compile-fail/privacy2.rs b/src/test/compile-fail/privacy2.rs
index b38d7aedf84..b59905776d3 100644
--- a/src/test/compile-fail/privacy2.rs
+++ b/src/test/compile-fail/privacy2.rs
@@ -32,4 +32,4 @@ fn test2() {
     //~^ ERROR unresolved import `bar::glob::foo`. There is no `foo` in `bar::glob`
 }
 
-#[start] fn main(_: int, _: *const *const u8) -> int { 3 }
+#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }
diff --git a/src/test/compile-fail/privacy3.rs b/src/test/compile-fail/privacy3.rs
index 5ec10d5a4ca..80219b70e07 100644
--- a/src/test/compile-fail/privacy3.rs
+++ b/src/test/compile-fail/privacy3.rs
@@ -29,4 +29,4 @@ fn test1() {
     gpriv();
 }
 
-#[start] fn main(_: int, _: *const *const u8) -> int { 3 }
+#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }
diff --git a/src/test/compile-fail/privacy4.rs b/src/test/compile-fail/privacy4.rs
index 92f3a57c69d..3f17d463890 100644
--- a/src/test/compile-fail/privacy4.rs
+++ b/src/test/compile-fail/privacy4.rs
@@ -32,4 +32,4 @@ fn test2() {
     gpriv();
 }
 
-#[start] fn main(_: int, _: *const *const u8) -> int { 3 }
+#[start] fn main(_: isize, _: *const *const u8) -> isize { 3 }
diff --git a/src/test/compile-fail/privacy5.rs b/src/test/compile-fail/privacy5.rs
index 555969b65ff..df570fd4647 100644
--- a/src/test/compile-fail/privacy5.rs
+++ b/src/test/compile-fail/privacy5.rs
@@ -15,9 +15,9 @@ extern crate "privacy-tuple-struct" as other;
 
 mod a {
     pub struct A(());
-    pub struct B(int);
-    pub struct C(pub int, int);
-    pub struct D(pub int);
+    pub struct B(isize);
+    pub struct C(pub isize, isize);
+    pub struct D(pub isize);
 
     fn test() {
         let a = A(());
diff --git a/src/test/compile-fail/private-impl-method.rs b/src/test/compile-fail/private-impl-method.rs
index fe5908b40ab..c6e329aab04 100644
--- a/src/test/compile-fail/private-impl-method.rs
+++ b/src/test/compile-fail/private-impl-method.rs
@@ -10,7 +10,7 @@
 
 mod a {
     pub struct Foo {
-        pub x: int
+        pub x: isize
     }
 
     impl Foo {
diff --git a/src/test/compile-fail/private-method.rs b/src/test/compile-fail/private-method.rs
index 88ab73e1f9d..d09481cfd64 100644
--- a/src/test/compile-fail/private-method.rs
+++ b/src/test/compile-fail/private-method.rs
@@ -14,14 +14,14 @@ mod kitties {
     pub struct cat {
         meows : uint,
 
-        how_hungry : int,
+        how_hungry : isize,
     }
 
     impl cat {
         fn nap(&self) {}
     }
 
-    pub fn cat(in_x : uint, in_y : int) -> cat {
+    pub fn cat(in_x : uint, in_y : isize) -> cat {
         cat {
             meows: in_x,
             how_hungry: in_y
diff --git a/src/test/compile-fail/private-struct-field-ctor.rs b/src/test/compile-fail/private-struct-field-ctor.rs
index ae19c221496..0a0f2d490a8 100644
--- a/src/test/compile-fail/private-struct-field-ctor.rs
+++ b/src/test/compile-fail/private-struct-field-ctor.rs
@@ -10,7 +10,7 @@
 
 mod a {
     pub struct Foo {
-        x: int
+        x: isize
     }
 }
 
diff --git a/src/test/compile-fail/private-struct-field-pattern.rs b/src/test/compile-fail/private-struct-field-pattern.rs
index 991457ef1ce..e9dd6cd1d74 100644
--- a/src/test/compile-fail/private-struct-field-pattern.rs
+++ b/src/test/compile-fail/private-struct-field-pattern.rs
@@ -12,7 +12,7 @@ use a::Foo;
 
 mod a {
     pub struct Foo {
-        x: int
+        x: isize
     }
 
     pub fn make() -> Foo {
diff --git a/src/test/compile-fail/ptr-coercion.rs b/src/test/compile-fail/ptr-coercion.rs
index d9b20748a7a..b7d122cd79d 100644
--- a/src/test/compile-fail/ptr-coercion.rs
+++ b/src/test/compile-fail/ptr-coercion.rs
@@ -13,12 +13,12 @@
 
 pub fn main() {
     // *const -> *mut
-    let x: *const int = &42i;
-    let x: *mut int = x; //~ERROR values differ in mutability
+    let x: *const isize = &42i;
+    let x: *mut isize = x; //~ERROR values differ in mutability
 
     // & -> *mut
-    let x: *mut int = &42; //~ERROR values differ in mutability
+    let x: *mut isize = &42; //~ERROR values differ in mutability
 
-    let x: *const int = &42;
-    let x: *mut int = x; //~ERROR values differ in mutability
+    let x: *const isize = &42;
+    let x: *mut isize = x; //~ERROR values differ in mutability
 }
diff --git a/src/test/compile-fail/qquote-2.rs b/src/test/compile-fail/qquote-2.rs
index 94485dddd13..978287a681e 100644
--- a/src/test/compile-fail/qquote-2.rs
+++ b/src/test/compile-fail/qquote-2.rs
@@ -52,7 +52,7 @@ fn mk_ctxt() -> fake_ext_ctxt {
 fn main() {
     let cx = mk_ctxt();
 
-    let stmt = quote_stmt!(cx, let x int = 20;); //~ ERROR expected end-of-string
+    let stmt = quote_stmt!(cx, let x isize = 20;); //~ ERROR expected end-of-string
     check_pp(*stmt,  pprust::print_stmt, "");
 }
 
diff --git a/src/test/compile-fail/recursion.rs b/src/test/compile-fail/recursion.rs
index da05514f763..ffc21a5ce61 100644
--- a/src/test/compile-fail/recursion.rs
+++ b/src/test/compile-fail/recursion.rs
@@ -16,17 +16,17 @@
 // that is more helpful.
 
 enum Nil {NilValue}
-struct Cons<T> {head:int, tail:T}
-trait Dot {fn dot(&self, other:Self) -> int;}
+struct Cons<T> {head:isize, tail:T}
+trait Dot {fn dot(&self, other:Self) -> isize;}
 impl Dot for Nil {
-  fn dot(&self, _:Nil) -> int {0}
+  fn dot(&self, _:Nil) -> isize {0}
 }
 impl<T:Dot> Dot for Cons<T> {
-  fn dot(&self, other:Cons<T>) -> int {
+  fn dot(&self, other:Cons<T>) -> isize {
     self.head * other.head + self.tail.dot(other.tail)
   }
 }
-fn test<T:Dot> (n:int, i:int, first:T, second:T) ->int {
+fn test<T:Dot> (n:isize, i:isize, first:T, second:T) ->isize {
   match n {    0 => {first.dot(second)}
       //~^ ERROR: reached the recursion limit during monomorphization
       // Error message should be here. It should be a type error
diff --git a/src/test/compile-fail/refutable-pattern-errors.rs b/src/test/compile-fail/refutable-pattern-errors.rs
index 98d616ee3af..54b8c7fe4b9 100644
--- a/src/test/compile-fail/refutable-pattern-errors.rs
+++ b/src/test/compile-fail/refutable-pattern-errors.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 
-fn func((1, (Some(1), 2...3)): (int, (Option<int>, int))) { }
+fn func((1, (Some(1), 2...3)): (isize, (Option<isize>, isize))) { }
 //~^ ERROR refutable pattern in function argument: `(_, _)` not covered
 
 fn main() {
diff --git a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
index 575e9864a92..53f923e5061 100644
--- a/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
+++ b/src/test/compile-fail/refutable-pattern-in-fn-arg.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let f = |&: 3: int| println!("hello");
+    let f = |&: 3: isize| println!("hello");
     //~^ ERROR refutable pattern in function argument: `_` not covered
     f(4);
 }
diff --git a/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs b/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs
index 3e6a95b04f7..ee05ba676ac 100644
--- a/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs
+++ b/src/test/compile-fail/region-lifetime-bounds-on-fns-where-clause.rs
@@ -8,17 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn a<'a, 'b>(x: &mut &'a int, y: &mut &'b int) where 'b: 'a {
+fn a<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) where 'b: 'a {
     // Note: this is legal because of the `'b:'a` declaration.
     *x = *y;
 }
 
-fn b<'a, 'b>(x: &mut &'a int, y: &mut &'b int) {
+fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) {
     // Illegal now because there is no `'b:'a` declaration.
     *x = *y; //~ ERROR cannot infer
 }
 
-fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) {
+fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
     // Here we try to call `foo` but do not know that `'a` and `'b` are
     // related as required.
     a(x, y); //~ ERROR cannot infer
@@ -27,13 +27,13 @@ fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) {
 fn d() {
     // 'a and 'b are early bound in the function `a` because they appear
     // inconstraints:
-    let _: fn(&mut &int, &mut &int) = a; //~ ERROR mismatched types
+    let _: fn(&mut &isize, &mut &isize) = a; //~ ERROR mismatched types
 }
 
 fn e() {
     // 'a and 'b are late bound in the function `b` because there are
     // no constraints:
-    let _: fn(&mut &int, &mut &int) = b;
+    let _: fn(&mut &isize, &mut &isize) = b;
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs b/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs
index 2d635e9fc27..30e6a4e1277 100644
--- a/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs
+++ b/src/test/compile-fail/region-multiple-lifetime-bounds-on-fns-where-clause.rs
@@ -8,19 +8,19 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn a<'a, 'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) where 'b: 'a + 'c {
+fn a<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) where 'b: 'a + 'c {
     // Note: this is legal because of the `'b:'a` declaration.
     *x = *y;
     *z = *y;
 }
 
-fn b<'a, 'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) {
+fn b<'a, 'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
     // Illegal now because there is no `'b:'a` declaration.
     *x = *y; //~ ERROR cannot infer
     *z = *y; //~ ERROR cannot infer
 }
 
-fn c<'a,'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) {
+fn c<'a,'b, 'c>(x: &mut &'a isize, y: &mut &'b isize, z: &mut &'c isize) {
     // Here we try to call `foo` but do not know that `'a` and `'b` are
     // related as required.
     a(x, y, z); //~ ERROR cannot infer
@@ -29,13 +29,13 @@ fn c<'a,'b, 'c>(x: &mut &'a int, y: &mut &'b int, z: &mut &'c int) {
 fn d() {
     // 'a and 'b are early bound in the function `a` because they appear
     // inconstraints:
-    let _: fn(&mut &int, &mut &int, &mut &int) = a; //~ ERROR mismatched types
+    let _: fn(&mut &isize, &mut &isize, &mut &isize) = a; //~ ERROR mismatched types
 }
 
 fn e() {
     // 'a and 'b are late bound in the function `b` because there are
     // no constraints:
-    let _: fn(&mut &int, &mut &int, &mut &int) = b;
+    let _: fn(&mut &isize, &mut &isize, &mut &isize) = b;
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
index 75e9e55138e..cdaa3468a46 100644
--- a/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
+++ b/src/test/compile-fail/regionck-unboxed-closure-lifetimes.rs
@@ -17,7 +17,7 @@ fn main() {
     {
         let c = 1;
         let c_ref = &c; //~ ERROR `c` does not live long enough
-        f = move |&mut: a: int, b: int| { a + b + *c_ref };
+        f = move |&mut: a: isize, b: isize| { a + b + *c_ref };
     }
 }
 
diff --git a/src/test/compile-fail/regions-addr-of-arg.rs b/src/test/compile-fail/regions-addr-of-arg.rs
index 3e568180b53..c54b4aaace5 100644
--- a/src/test/compile-fail/regions-addr-of-arg.rs
+++ b/src/test/compile-fail/regions-addr-of-arg.rs
@@ -11,15 +11,15 @@
 // Check that taking the address of an argument yields a lifetime
 // bounded by the current function call.
 
-fn foo(a: int) {
-    let _p: &'static int = &a; //~ ERROR `a` does not live long enough
+fn foo(a: isize) {
+    let _p: &'static isize = &a; //~ ERROR `a` does not live long enough
 }
 
-fn bar(a: int) {
-    let _q: &int = &a;
+fn bar(a: isize) {
+    let _q: &isize = &a;
 }
 
-fn zed<'a>(a: int) -> &'a int {
+fn zed<'a>(a: isize) -> &'a isize {
     &a //~ ERROR `a` does not live long enough
 }
 
diff --git a/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs b/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs
index c6a9f67cfc6..5028ec89972 100644
--- a/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs
+++ b/src/test/compile-fail/regions-bound-missing-bound-in-impl.rs
@@ -13,7 +13,7 @@
 // checked.
 
 struct Inv<'a> { // invariant w/r/t 'a
-    x: &'a mut &'a int
+    x: &'a mut &'a isize
 }
 
 pub trait Foo<'a> {
@@ -24,7 +24,7 @@ pub trait Foo<'a> {
 }
 
 
-impl<'a> Foo<'a> for &'a int {
+impl<'a> Foo<'a> for &'a isize {
     fn no_bound<'b:'a>(self, b: Inv<'b>) {
         //~^ ERROR lifetime parameters or bounds on method `no_bound` do not match
     }
diff --git a/src/test/compile-fail/regions-bounded-by-send.rs b/src/test/compile-fail/regions-bounded-by-send.rs
index 0628bbb8bb0..e3f0d3bcdb6 100644
--- a/src/test/compile-fail/regions-bounded-by-send.rs
+++ b/src/test/compile-fail/regions-bounded-by-send.rs
@@ -20,41 +20,41 @@ trait Dummy:Send { }
 
 // lifetime pointers with 'static lifetime are ok
 
-fn static_lifime_ok<'a,T,U:Send>(_: &'a int) {
-    assert_send::<&'static int>();
+fn static_lifime_ok<'a,T,U:Send>(_: &'a isize) {
+    assert_send::<&'static isize>();
     assert_send::<&'static str>();
-    assert_send::<&'static [int]>();
+    assert_send::<&'static [isize]>();
 
     // whether or not they are mutable
-    assert_send::<&'static mut int>();
+    assert_send::<&'static mut isize>();
 }
 
 // otherwise lifetime pointers are not ok
 
-fn param_not_ok<'a>(x: &'a int) {
-    assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied
+fn param_not_ok<'a>(x: &'a isize) {
+    assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied
 }
 
-fn param_not_ok1<'a>(_: &'a int) {
+fn param_not_ok1<'a>(_: &'a isize) {
     assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied
 }
 
-fn param_not_ok2<'a>(_: &'a int) {
-    assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied
+fn param_not_ok2<'a>(_: &'a isize) {
+    assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 // boxes are ok
 
 fn box_ok() {
-    assert_send::<Box<int>>();
+    assert_send::<Box<isize>>();
     assert_send::<String>();
-    assert_send::<Vec<int>>();
+    assert_send::<Vec<isize>>();
 }
 
 // but not if they own a bad thing
 
 fn box_with_region_not_ok<'a>() {
-    assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied
+    assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 // objects with insufficient bounds no ok
@@ -71,11 +71,11 @@ fn object_with_send_bound_not_ok<'a>() {
 
 // unsafe pointers are ok unless they point at unsendable things
 
-struct UniqueUnsafePtr(Unique<*const int>);
+struct UniqueUnsafePtr(Unique<*const isize>);
 
 unsafe impl Send for UniqueUnsafePtr {}
 
-fn unsafe_ok1<'a>(_: &'a int) {
+fn unsafe_ok1<'a>(_: &'a isize) {
     assert_send::<UniqueUnsafePtr>();
 }
 
diff --git a/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs b/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs
index e3939a4e390..8194af25d73 100644
--- a/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs
+++ b/src/test/compile-fail/regions-bounded-by-trait-requiring-static.rs
@@ -17,56 +17,56 @@ fn assert_send<T:'static>() { }
 
 // lifetime pointers with 'static lifetime are ok
 
-fn static_lifime_ok<'a,T,U:Send>(_: &'a int) {
-    assert_send::<&'static int>();
+fn static_lifime_ok<'a,T,U:Send>(_: &'a isize) {
+    assert_send::<&'static isize>();
     assert_send::<&'static str>();
-    assert_send::<&'static [int]>();
+    assert_send::<&'static [isize]>();
 
     // whether or not they are mutable
-    assert_send::<&'static mut int>();
+    assert_send::<&'static mut isize>();
 }
 
 // otherwise lifetime pointers are not ok
 
-fn param_not_ok<'a>(x: &'a int) {
-    assert_send::<&'a int>(); //~ ERROR declared lifetime bound not satisfied
+fn param_not_ok<'a>(x: &'a isize) {
+    assert_send::<&'a isize>(); //~ ERROR declared lifetime bound not satisfied
 }
 
-fn param_not_ok1<'a>(_: &'a int) {
+fn param_not_ok1<'a>(_: &'a isize) {
     assert_send::<&'a str>(); //~ ERROR declared lifetime bound not satisfied
 }
 
-fn param_not_ok2<'a>(_: &'a int) {
-    assert_send::<&'a [int]>(); //~ ERROR declared lifetime bound not satisfied
+fn param_not_ok2<'a>(_: &'a isize) {
+    assert_send::<&'a [isize]>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 // boxes are ok
 
 fn box_ok() {
-    assert_send::<Box<int>>();
+    assert_send::<Box<isize>>();
     assert_send::<String>();
-    assert_send::<Vec<int>>();
+    assert_send::<Vec<isize>>();
 }
 
 // but not if they own a bad thing
 
 fn box_with_region_not_ok<'a>() {
-    assert_send::<Box<&'a int>>(); //~ ERROR declared lifetime bound not satisfied
+    assert_send::<Box<&'a isize>>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 // unsafe pointers are ok unless they point at unsendable things
 
-fn unsafe_ok1<'a>(_: &'a int) {
-    assert_send::<*const int>();
-    assert_send::<*mut int>();
+fn unsafe_ok1<'a>(_: &'a isize) {
+    assert_send::<*const isize>();
+    assert_send::<*mut isize>();
 }
 
-fn unsafe_ok2<'a>(_: &'a int) {
-    assert_send::<*const &'a int>(); //~ ERROR declared lifetime bound not satisfied
+fn unsafe_ok2<'a>(_: &'a isize) {
+    assert_send::<*const &'a isize>(); //~ ERROR declared lifetime bound not satisfied
 }
 
-fn unsafe_ok3<'a>(_: &'a int) {
-    assert_send::<*mut &'a int>(); //~ ERROR declared lifetime bound not satisfied
+fn unsafe_ok3<'a>(_: &'a isize) {
+    assert_send::<*mut &'a isize>(); //~ ERROR declared lifetime bound not satisfied
 }
 
 fn main() {
diff --git a/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs b/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs
index e628eb3285a..acc721f26b3 100644
--- a/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs
+++ b/src/test/compile-fail/regions-bounded-method-type-parameters-trait-bound.rs
@@ -19,7 +19,7 @@
 trait Sized { }
 
 struct Inv<'a> { // invariant w/r/t 'a
-    x: &'a mut &'a int
+    x: &'a mut &'a isize
 }
 
 trait Foo<'x> {
diff --git a/src/test/compile-fail/regions-bounded-method-type-parameters.rs b/src/test/compile-fail/regions-bounded-method-type-parameters.rs
index 10484925980..9afacacd662 100644
--- a/src/test/compile-fail/regions-bounded-method-type-parameters.rs
+++ b/src/test/compile-fail/regions-bounded-method-type-parameters.rs
@@ -18,8 +18,8 @@ impl Foo {
     fn some_method<A:'static>(self) { }
 }
 
-fn caller<'a>(x: &int) {
-    Foo.some_method::<&'a int>();
+fn caller<'a>(x: &isize) {
+    Foo.some_method::<&'a isize>();
     //~^ ERROR declared lifetime bound not satisfied
 }
 
diff --git a/src/test/compile-fail/regions-bounds.rs b/src/test/compile-fail/regions-bounds.rs
index e13a6b211a5..c26740c9598 100644
--- a/src/test/compile-fail/regions-bounds.rs
+++ b/src/test/compile-fail/regions-bounds.rs
@@ -12,8 +12,8 @@
 // nominal types (but not on other types) and that they are type
 // checked.
 
-struct an_enum<'a>(&'a int);
-struct a_class<'a> { x:&'a int }
+struct an_enum<'a>(&'a isize);
+struct a_class<'a> { x:&'a isize }
 
 fn a_fn1<'a,'b>(e: an_enum<'a>) -> an_enum<'b> {
     return e; //~ ERROR mismatched types: expected `an_enum<'b>`, found `an_enum<'a>`
diff --git a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
index e17786e6a51..25b8137d29c 100644
--- a/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
+++ b/src/test/compile-fail/regions-close-over-borrowed-ref-in-obj.rs
@@ -12,12 +12,12 @@
 
 trait Foo { }
 
-impl<'a> Foo for &'a int { }
+impl<'a> Foo for &'a isize { }
 
 fn main() {
     let blah;
     {
-        let ss: &int = &1; //~ ERROR borrowed value does not live long enough
+        let ss: &isize = &1; //~ ERROR borrowed value does not live long enough
         blah = box ss as Box<Foo>;
     }
 }
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-1.rs b/src/test/compile-fail/regions-close-over-type-parameter-1.rs
index 985ae6116f0..fc18095fc83 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-1.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-1.rs
@@ -14,7 +14,7 @@
 // an object. This should yield errors unless `A` (and the object)
 // both have suitable bounds.
 
-trait SomeTrait { fn get(&self) -> int; }
+trait SomeTrait { fn get(&self) -> isize; }
 
 fn make_object1<A:SomeTrait>(v: A) -> Box<SomeTrait+'static> {
     box v as Box<SomeTrait+'static>
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-2.rs b/src/test/compile-fail/regions-close-over-type-parameter-2.rs
index 85ff336b4cb..8d9bd92a8de 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-2.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-2.rs
@@ -26,7 +26,7 @@ fn repeater3<'a,A:'a>(v: A) -> Box<Foo+'a> {
 
 fn main() {
     // Error results because the type of is inferred to be
-    // ~Repeat<&'blk int> where blk is the lifetime of the block below.
+    // ~Repeat<&'blk isize> where blk is the lifetime of the block below.
 
     let _ = {
         let tmp0 = 3i;
diff --git a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
index 2aa77b2e53d..0f8bc6d684f 100644
--- a/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
+++ b/src/test/compile-fail/regions-close-over-type-parameter-multiple.rs
@@ -13,7 +13,7 @@
 // Various tests where we over type parameters with multiple lifetime
 // bounds.
 
-trait SomeTrait { fn get(&self) -> int; }
+trait SomeTrait { fn get(&self) -> isize; }
 
 fn make_object_good1<'a,'b,A:SomeTrait+'a+'b>(v: A) -> Box<SomeTrait+'a> {
     // A outlives 'a AND 'b...
diff --git a/src/test/compile-fail/regions-early-bound-error-method.rs b/src/test/compile-fail/regions-early-bound-error-method.rs
index 0cb88b924f8..9de0ed070c7 100644
--- a/src/test/compile-fail/regions-early-bound-error-method.rs
+++ b/src/test/compile-fail/regions-early-bound-error-method.rs
@@ -12,21 +12,21 @@
 // the value for a type parameter in a bound.
 
 trait GetRef<'a> {
-    fn get(&self) -> &'a int;
+    fn get(&self) -> &'a isize;
 }
 
 struct Box<'a> {
-    t: &'a int
+    t: &'a isize
 }
 
 impl<'a> GetRef<'a> for Box<'a> {
-    fn get(&self) -> &'a int {
+    fn get(&self) -> &'a isize {
         self.t
     }
 }
 
 impl<'a> Box<'a> {
-    fn or<'b,G:GetRef<'b>>(&self, g2: G) -> &'a int {
+    fn or<'b,G:GetRef<'b>>(&self, g2: G) -> &'a isize {
         g2.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to
     }
 }
diff --git a/src/test/compile-fail/regions-early-bound-error.rs b/src/test/compile-fail/regions-early-bound-error.rs
index 5da281d93dd..37b74aea539 100644
--- a/src/test/compile-fail/regions-early-bound-error.rs
+++ b/src/test/compile-fail/regions-early-bound-error.rs
@@ -25,7 +25,7 @@ impl<'a,T:Clone> GetRef<'a,T> for Box<'a,T> {
     }
 }
 
-fn get<'a,'b,G:GetRef<'a, int>>(g1: G, b: &'b int) -> &'b int {
+fn get<'a,'b,G:GetRef<'a, isize>>(g1: G, b: &'b isize) -> &'b isize {
     g1.get() //~ ERROR cannot infer an appropriate lifetime for automatic coercion due to
 }
 
diff --git a/src/test/compile-fail/regions-enum-not-wf.rs b/src/test/compile-fail/regions-enum-not-wf.rs
index 0691ad0de73..0165dbdabf3 100644
--- a/src/test/compile-fail/regions-enum-not-wf.rs
+++ b/src/test/compile-fail/regions-enum-not-wf.rs
@@ -18,7 +18,7 @@ enum Ref1<'a, T> { //~ ERROR the parameter type `T` may not live long enough
 
 enum Ref2<'a, T> { //~ ERROR the parameter type `T` may not live long enough
     Ref2Variant1,
-    Ref2Variant2(int, &'a T),
+    Ref2Variant2(isize, &'a T),
 }
 
 enum RefOk<'a, T:'a> {
@@ -26,7 +26,7 @@ enum RefOk<'a, T:'a> {
 }
 
 enum RefIndirect<'a, T> { //~ ERROR the parameter type `T` may not live long enough
-    RefIndirectVariant1(int, RefOk<'a,T>)
+    RefIndirectVariant1(isize, RefOk<'a,T>)
 }
 
 enum RefDouble<'a, 'b, T> { //~ ERROR reference has a longer lifetime than the data
diff --git a/src/test/compile-fail/regions-escape-bound-fn-2.rs b/src/test/compile-fail/regions-escape-bound-fn-2.rs
index 547accbf086..1329d05a0f6 100644
--- a/src/test/compile-fail/regions-escape-bound-fn-2.rs
+++ b/src/test/compile-fail/regions-escape-bound-fn-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn with_int<F>(f: F) where F: FnOnce(&int) {
+fn with_int<F>(f: F) where F: FnOnce(&isize) {
     let x = 3;
     f(&x);
 }
diff --git a/src/test/compile-fail/regions-escape-bound-fn.rs b/src/test/compile-fail/regions-escape-bound-fn.rs
index 6d67bd80650..02e62ffddfd 100644
--- a/src/test/compile-fail/regions-escape-bound-fn.rs
+++ b/src/test/compile-fail/regions-escape-bound-fn.rs
@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn with_int<F>(f: F) where F: FnOnce(&int) {
+fn with_int<F>(f: F) where F: FnOnce(&isize) {
     let x = 3;
     f(&x);
 }
 
 fn main() {
-    let mut x: Option<&int> = None;
+    let mut x: Option<&isize> = None;
     with_int(|y| x = Some(y));   //~ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-escape-unboxed-closure.rs b/src/test/compile-fail/regions-escape-unboxed-closure.rs
index 70f0d61b5ee..06768fa6880 100644
--- a/src/test/compile-fail/regions-escape-unboxed-closure.rs
+++ b/src/test/compile-fail/regions-escape-unboxed-closure.rs
@@ -10,10 +10,10 @@
 
 #![feature(unboxed_closures)]
 
-fn with_int(f: &mut FnMut(&int)) {
+fn with_int(f: &mut FnMut(&isize)) {
 }
 
 fn main() {
-    let mut x: Option<&int> = None;
+    let mut x: Option<&isize> = None;
     with_int(&mut |&mut: y| x = Some(y));   //~ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-escape-via-trait-or-not.rs b/src/test/compile-fail/regions-escape-via-trait-or-not.rs
index 873d4cea039..a4363b00e1c 100644
--- a/src/test/compile-fail/regions-escape-via-trait-or-not.rs
+++ b/src/test/compile-fail/regions-escape-via-trait-or-not.rs
@@ -11,20 +11,20 @@
 #![allow(dead_code)]
 
 trait Deref {
-    fn get(self) -> int;
+    fn get(self) -> isize;
 }
 
-impl<'a> Deref for &'a int {
-    fn get(self) -> int {
+impl<'a> Deref for &'a isize {
+    fn get(self) -> isize {
         *self
     }
 }
 
-fn with<R:Deref, F>(f: F) -> int where F: FnOnce(&int) -> R {
+fn with<R:Deref, F>(f: F) -> isize where F: FnOnce(&isize) -> R {
     f(&3).get()
 }
 
-fn return_it() -> int {
+fn return_it() -> isize {
     with(|o| o) //~ ERROR cannot infer
 }
 
diff --git a/src/test/compile-fail/regions-in-consts.rs b/src/test/compile-fail/regions-in-consts.rs
index 9f2facf4e1f..8d0829a4cff 100644
--- a/src/test/compile-fail/regions-in-consts.rs
+++ b/src/test/compile-fail/regions-in-consts.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static c_y: &int = &22; //~ ERROR missing lifetime specifier
-static c_z: &'static int = &22;
+static c_y: &isize = &22; //~ ERROR missing lifetime specifier
+static c_z: &'static isize = &22;
 
 fn main() {
 }
diff --git a/src/test/compile-fail/regions-in-enums-anon.rs b/src/test/compile-fail/regions-in-enums-anon.rs
index 5c7a37d0359..305bf88c4d5 100644
--- a/src/test/compile-fail/regions-in-enums-anon.rs
+++ b/src/test/compile-fail/regions-in-enums-anon.rs
@@ -11,7 +11,7 @@
 // Test that anonymous lifetimes are not permitted in enum declarations
 
 enum Foo {
-    Bar(&int) //~ ERROR missing lifetime specifier
+    Bar(&isize) //~ ERROR missing lifetime specifier
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-in-structs-anon.rs b/src/test/compile-fail/regions-in-structs-anon.rs
index 0f2036a56cd..b85928b1b9f 100644
--- a/src/test/compile-fail/regions-in-structs-anon.rs
+++ b/src/test/compile-fail/regions-in-structs-anon.rs
@@ -11,7 +11,7 @@
 // Test that anonymous lifetimes are not permitted in struct declarations
 
 struct Foo {
-    x: &int //~ ERROR missing lifetime specifier
+    x: &isize //~ ERROR missing lifetime specifier
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-in-structs.rs b/src/test/compile-fail/regions-in-structs.rs
index 0c5cb98e6a4..f46f73bf26a 100644
--- a/src/test/compile-fail/regions-in-structs.rs
+++ b/src/test/compile-fail/regions-in-structs.rs
@@ -17,8 +17,8 @@ struct yes2<'a> {
 }
 
 struct StructDecl {
-    a: &'a int, //~ ERROR use of undeclared lifetime name `'a`
-    b: &'a int, //~ ERROR use of undeclared lifetime name `'a`
+    a: &'a isize, //~ ERROR use of undeclared lifetime name `'a`
+    b: &'a isize, //~ ERROR use of undeclared lifetime name `'a`
 }
 
 
diff --git a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
index b710578969b..2628e6a1ce2 100644
--- a/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
+++ b/src/test/compile-fail/regions-infer-borrow-scope-too-big.rs
@@ -10,15 +10,15 @@
 
 
 struct point {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
-fn x_coord<'r>(p: &'r point) -> &'r int {
+fn x_coord<'r>(p: &'r point) -> &'r isize {
     return &p.x;
 }
 
-fn foo<'a>(p: Box<point>) -> &'a int {
+fn foo<'a>(p: Box<point>) -> &'a isize {
     let xc = x_coord(&*p); //~ ERROR `*p` does not live long enough
     assert_eq!(*xc, 3);
     return xc;
diff --git a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
index c8edd936bf2..a05658e9e58 100644
--- a/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
+++ b/src/test/compile-fail/regions-infer-borrow-scope-within-loop.rs
@@ -13,9 +13,9 @@ fn borrow<T>(x: &T) -> &T {x}
 
 fn foo<C, M>(mut cond: C, mut make_box: M) where
     C: FnMut() -> bool,
-    M: FnMut() -> Box<int>,
+    M: FnMut() -> Box<isize>,
 {
-    let mut y: &int;
+    let mut y: &isize;
     loop {
         let x = make_box();
 
diff --git a/src/test/compile-fail/regions-infer-bound-from-trait-self.rs b/src/test/compile-fail/regions-infer-bound-from-trait-self.rs
index aeb003ca5d0..23b8ebfe54b 100644
--- a/src/test/compile-fail/regions-infer-bound-from-trait-self.rs
+++ b/src/test/compile-fail/regions-infer-bound-from-trait-self.rs
@@ -16,7 +16,7 @@ trait Static : 'static { }
 trait Is<'a> : 'a { }
 
 struct Inv<'a> {
-    x: Option<&'a mut &'a int>
+    x: Option<&'a mut &'a isize>
 }
 
 fn check_bound<'a,A:'a>(x: Inv<'a>, a: A) { }
diff --git a/src/test/compile-fail/regions-infer-bound-from-trait.rs b/src/test/compile-fail/regions-infer-bound-from-trait.rs
index d1111377f1e..f7a91054766 100644
--- a/src/test/compile-fail/regions-infer-bound-from-trait.rs
+++ b/src/test/compile-fail/regions-infer-bound-from-trait.rs
@@ -16,7 +16,7 @@ trait Static : 'static { }
 trait Is<'a> : 'a { }
 
 struct Inv<'a> {
-    x: Option<&'a mut &'a int>
+    x: Option<&'a mut &'a isize>
 }
 
 fn check_bound<'a,A:'a>(x: Inv<'a>, a: A) { }
diff --git a/src/test/compile-fail/regions-infer-call-3.rs b/src/test/compile-fail/regions-infer-call-3.rs
index ac41f2a5b3e..95783a420b6 100644
--- a/src/test/compile-fail/regions-infer-call-3.rs
+++ b/src/test/compile-fail/regions-infer-call-3.rs
@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn select<'r>(x: &'r int, y: &'r int) -> &'r int { x }
+fn select<'r>(x: &'r isize, y: &'r isize) -> &'r isize { x }
 
-fn with<T, F>(f: F) -> T where F: FnOnce(&int) -> T {
+fn with<T, F>(f: F) -> T where F: FnOnce(&isize) -> T {
     f(&20)
 }
 
-fn manip<'a>(x: &'a int) -> int {
+fn manip<'a>(x: &'a isize) -> isize {
     let z = with(|y| { select(x, y) });
     //~^ ERROR cannot infer
     *z
diff --git a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
index 4d31d2c8e69..6c5e90a54de 100644
--- a/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
+++ b/src/test/compile-fail/regions-infer-contravariance-due-to-decl.rs
@@ -24,8 +24,8 @@ struct Contravariant<'a> {
 }
 
 fn use_<'short,'long>(c: Contravariant<'short>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     // Test whether Contravariant<'short> <: Contravariant<'long>.  Since
diff --git a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
index 1c3b7bb5960..d8e31fa1374 100644
--- a/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
+++ b/src/test/compile-fail/regions-infer-covariance-due-to-decl.rs
@@ -21,8 +21,8 @@ struct Covariant<'a> {
 }
 
 fn use_<'short,'long>(c: Covariant<'long>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     // Test whether Covariant<'long> <: Covariant<'short>.  Since
diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs
index 190e444fe7e..e42aa684e14 100644
--- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs
+++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-3.rs
@@ -10,7 +10,7 @@
 
 
 struct invariant<'a> {
-    f: Box<FnOnce(&mut &'a int) + 'static>,
+    f: Box<FnOnce(&mut &'a isize) + 'static>,
 }
 
 fn to_same_lifetime<'r>(bi: invariant<'r>) {
diff --git a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs
index 71d0c988c5e..2e634dfe3eb 100644
--- a/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs
+++ b/src/test/compile-fail/regions-infer-invariance-due-to-mutability-4.rs
@@ -10,7 +10,7 @@
 
 
 struct invariant<'a> {
-    f: Box<for<'b> FnOnce() -> &'b mut &'a int + 'static>,
+    f: Box<for<'b> FnOnce() -> &'b mut &'a isize + 'static>,
 }
 
 fn to_same_lifetime<'r>(bi: invariant<'r>) {
diff --git a/src/test/compile-fail/regions-infer-not-param.rs b/src/test/compile-fail/regions-infer-not-param.rs
index 323ebc3c20b..5d7a218ca8a 100644
--- a/src/test/compile-fail/regions-infer-not-param.rs
+++ b/src/test/compile-fail/regions-infer-not-param.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct direct<'a> {
-    f: &'a int
+    f: &'a isize
 }
 
 struct indirect1 {
diff --git a/src/test/compile-fail/regions-infer-paramd-method.rs b/src/test/compile-fail/regions-infer-paramd-method.rs
index 772ccadda52..ef331bb0fd7 100644
--- a/src/test/compile-fail/regions-infer-paramd-method.rs
+++ b/src/test/compile-fail/regions-infer-paramd-method.rs
@@ -25,9 +25,9 @@
 // refers to self.
 
 trait foo<'a> {
-    fn self_int(self) -> &'a int;
+    fn self_int(self) -> &'a isize;
 
-    fn any_int(self) -> &int;
+    fn any_int(self) -> &isize;
 }
 
 struct with_foo<'a> {
@@ -47,7 +47,7 @@ impl<'a> set_foo_foo for with_foo<'a> {
 // Bar is not region parameterized.
 
 trait bar {
-    fn any_int(&self) -> &int;
+    fn any_int(&self) -> &isize;
 }
 
 struct with_bar {
diff --git a/src/test/compile-fail/regions-infer-proc-static-upvar.rs b/src/test/compile-fail/regions-infer-proc-static-upvar.rs
index 8b2fdfe7cdd..bf05554e6d0 100644
--- a/src/test/compile-fail/regions-infer-proc-static-upvar.rs
+++ b/src/test/compile-fail/regions-infer-proc-static-upvar.rs
@@ -13,7 +13,7 @@
 
 fn foo<F:FnOnce()+'static>(_p: F) { }
 
-static i: int = 3;
+static i: isize = 3;
 
 fn capture_local() {
     let x = 3i;
diff --git a/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs b/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs
index 4a42728da6f..43940d499d2 100644
--- a/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs
+++ b/src/test/compile-fail/regions-lifetime-bounds-on-fns.rs
@@ -8,17 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn a<'a, 'b:'a>(x: &mut &'a int, y: &mut &'b int) {
+fn a<'a, 'b:'a>(x: &mut &'a isize, y: &mut &'b isize) {
     // Note: this is legal because of the `'b:'a` declaration.
     *x = *y;
 }
 
-fn b<'a, 'b>(x: &mut &'a int, y: &mut &'b int) {
+fn b<'a, 'b>(x: &mut &'a isize, y: &mut &'b isize) {
     // Illegal now because there is no `'b:'a` declaration.
     *x = *y; //~ ERROR cannot infer
 }
 
-fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) {
+fn c<'a,'b>(x: &mut &'a isize, y: &mut &'b isize) {
     // Here we try to call `foo` but do not know that `'a` and `'b` are
     // related as required.
     a(x, y); //~ ERROR cannot infer
@@ -27,13 +27,13 @@ fn c<'a,'b>(x: &mut &'a int, y: &mut &'b int) {
 fn d() {
     // 'a and 'b are early bound in the function `a` because they appear
     // inconstraints:
-    let _: fn(&mut &int, &mut &int) = a; //~ ERROR mismatched types
+    let _: fn(&mut &isize, &mut &isize) = a; //~ ERROR mismatched types
 }
 
 fn e() {
     // 'a and 'b are late bound in the function `b` because there are
     // no constraints:
-    let _: fn(&mut &int, &mut &int) = b;
+    let _: fn(&mut &isize, &mut &isize) = b;
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/regions-name-duplicated.rs b/src/test/compile-fail/regions-name-duplicated.rs
index 518fe0b00b6..b4b9cfd75cb 100644
--- a/src/test/compile-fail/regions-name-duplicated.rs
+++ b/src/test/compile-fail/regions-name-duplicated.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo<'a, 'a> { //~ ERROR lifetime name `'a` declared twice
-    x: &'a int
+    x: &'a isize
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-name-static.rs b/src/test/compile-fail/regions-name-static.rs
index 9f50ad36660..29896aa486b 100644
--- a/src/test/compile-fail/regions-name-static.rs
+++ b/src/test/compile-fail/regions-name-static.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo<'static> { //~ ERROR illegal lifetime parameter name: `'static`
-    x: &'static int
+    x: &'static isize
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/regions-name-undeclared.rs b/src/test/compile-fail/regions-name-undeclared.rs
index b9c721159f2..a61d3094933 100644
--- a/src/test/compile-fail/regions-name-undeclared.rs
+++ b/src/test/compile-fail/regions-name-undeclared.rs
@@ -12,48 +12,48 @@
 // rules correctly in various scenarios.
 
 struct Foo<'a> {
-    x: &'a int
+    x: &'a isize
 }
 
 impl<'a> Foo<'a> {
     // &'a is inherited:
-    fn m1(&self, arg: &'a int) { }
+    fn m1(&self, arg: &'a isize) { }
     fn m2(&'a self) { }
     fn m3(&self, arg: Foo<'a>) { }
 
     // &'b is not:
-    fn m4(&self, arg: &'b int) { } //~ ERROR undeclared lifetime
+    fn m4(&self, arg: &'b isize) { } //~ ERROR undeclared lifetime
     fn m5(&'b self) { } //~ ERROR undeclared lifetime
     fn m6(&self, arg: Foo<'b>) { } //~ ERROR undeclared lifetime
 }
 
-fn bar<'a>(x: &'a int) {
+fn bar<'a>(x: &'a isize) {
     // &'a is visible to code:
-    let y: &'a int = x;
+    let y: &'a isize = x;
 
     // &'a is not visible to *items*:
-    type X = Option<&'a int>; //~ ERROR undeclared lifetime
+    type X = Option<&'a isize>; //~ ERROR undeclared lifetime
     enum E {
-        E1(&'a int) //~ ERROR undeclared lifetime
+        E1(&'a isize) //~ ERROR undeclared lifetime
     }
     struct S {
-        f: &'a int //~ ERROR undeclared lifetime
+        f: &'a isize //~ ERROR undeclared lifetime
     }
-    fn f(a: &'a int) { } //~ ERROR undeclared lifetime
+    fn f(a: &'a isize) { } //~ ERROR undeclared lifetime
 
     // &'a CAN be declared on functions and used then:
-    fn g<'a>(a: &'a int) { } // OK
-    fn h(a: Box<for<'a> FnOnce(&'a int)>) { } // OK
+    fn g<'a>(a: &'a isize) { } // OK
+    fn h(a: Box<for<'a> FnOnce(&'a isize)>) { } // OK
 }
 
 // Test nesting of lifetimes in fn type declarations
-fn fn_types(a: &'a int, //~ ERROR undeclared lifetime
-            b: Box<for<'a> FnOnce(&'a int,
-                                  &'b int, //~ ERROR undeclared lifetime
-                                  Box<for<'b> FnOnce(&'a int,
-                                                     &'b int)>,
-                                  &'b int)>, //~ ERROR undeclared lifetime
-            c: &'a int) //~ ERROR undeclared lifetime
+fn fn_types(a: &'a isize, //~ ERROR undeclared lifetime
+            b: Box<for<'a> FnOnce(&'a isize,
+                                  &'b isize, //~ ERROR undeclared lifetime
+                                  Box<for<'b> FnOnce(&'a isize,
+                                                     &'b isize)>,
+                                  &'b isize)>, //~ ERROR undeclared lifetime
+            c: &'a isize) //~ ERROR undeclared lifetime
 {
 }
 
diff --git a/src/test/compile-fail/regions-nested-fns-2.rs b/src/test/compile-fail/regions-nested-fns-2.rs
index b7fe893a1f5..bdebadb2832 100644
--- a/src/test/compile-fail/regions-nested-fns-2.rs
+++ b/src/test/compile-fail/regions-nested-fns-2.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn ignore<F>(_f: F) where F: for<'z> FnOnce(&'z int) -> &'z int {}
+fn ignore<F>(_f: F) where F: for<'z> FnOnce(&'z isize) -> &'z isize {}
 
 fn nested() {
     let y = 3;
diff --git a/src/test/compile-fail/regions-nested-fns.rs b/src/test/compile-fail/regions-nested-fns.rs
index e8054779774..58386c319f8 100644
--- a/src/test/compile-fail/regions-nested-fns.rs
+++ b/src/test/compile-fail/regions-nested-fns.rs
@@ -12,17 +12,17 @@
 
 fn ignore<T>(t: T) {}
 
-fn nested<'x>(x: &'x int) {
+fn nested<'x>(x: &'x isize) {
     let y = 3;
     let mut ay = &y;
 
-    ignore::<Box<for<'z> FnMut(&'z int)>>(box |z| {
+    ignore::<Box<for<'z> FnMut(&'z isize)>>(box |z| {
         ay = x; //~ ERROR cannot infer
         ay = &y;
         ay = z;
     });
 
-    ignore::< Box<for<'z> FnMut(&'z int) -> &'z int>>(box |z| {
+    ignore::< Box<for<'z> FnMut(&'z isize) -> &'z isize>>(box |z| {
         if false { return x; }  //~ ERROR cannot infer an appropriate lifetime for automatic
         if false { return ay; }
         return z;
diff --git a/src/test/compile-fail/regions-proc-bound-capture.rs b/src/test/compile-fail/regions-proc-bound-capture.rs
index b849ddf7b82..7ea4d1c7507 100644
--- a/src/test/compile-fail/regions-proc-bound-capture.rs
+++ b/src/test/compile-fail/regions-proc-bound-capture.rs
@@ -10,13 +10,13 @@
 
 #![feature(box_syntax)]
 
-fn borrowed_proc<'a>(x: &'a int) -> Box<FnMut()->(int) + 'a> {
+fn borrowed_proc<'a>(x: &'a isize) -> Box<FnMut()->(isize) + 'a> {
     // This is legal, because the region bound on `proc`
     // states that it captures `x`.
     box move|| { *x }
 }
 
-fn static_proc(x: &int) -> Box<FnMut()->(int) + 'static> {
+fn static_proc(x: &isize) -> Box<FnMut()->(isize) + 'static> {
     // This is illegal, because the region bound on `proc` is 'static.
     box move|| { *x } //~ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs
index 783009f6dcb..9743f11c966 100644
--- a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs
+++ b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref-mut-ref.rs
@@ -10,7 +10,7 @@
 
 // Issue #8624. Test for reborrowing with 3 levels, not just two.
 
-fn copy_borrowed_ptr<'a, 'b, 'c>(p: &'a mut &'b mut &'c mut int) -> &'b mut int {
+fn copy_borrowed_ptr<'a, 'b, 'c>(p: &'a mut &'b mut &'c mut isize) -> &'b mut isize {
     &mut ***p //~ ERROR cannot infer
 }
 
diff --git a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs
index 4b1c7a2928b..399ebd6a2a7 100644
--- a/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs
+++ b/src/test/compile-fail/regions-reborrow-from-shorter-mut-ref.rs
@@ -12,7 +12,7 @@
 // pointer which is backed by another `&'a mut` can only be done
 // for `'a` (which must be a sublifetime of `'b`).
 
-fn copy_borrowed_ptr<'a, 'b>(p: &'a mut &'b mut int) -> &'b mut int {
+fn copy_borrowed_ptr<'a, 'b>(p: &'a mut &'b mut isize) -> &'b mut isize {
     &mut **p //~ ERROR cannot infer
 }
 
diff --git a/src/test/compile-fail/regions-ref-in-fn-arg.rs b/src/test/compile-fail/regions-ref-in-fn-arg.rs
index e47fddbdc36..13a903bf2b5 100644
--- a/src/test/compile-fail/regions-ref-in-fn-arg.rs
+++ b/src/test/compile-fail/regions-ref-in-fn-arg.rs
@@ -10,13 +10,13 @@
 
 #![feature(box_syntax)]
 
-fn arg_item(box ref x: Box<int>) -> &'static int {
+fn arg_item(box ref x: Box<isize>) -> &'static isize {
     x //~^ ERROR borrowed value does not live long enough
 }
 
-fn with<R, F>(f: F) -> R where F: FnOnce(Box<int>) -> R { f(box 3) }
+fn with<R, F>(f: F) -> R where F: FnOnce(Box<isize>) -> R { f(box 3) }
 
-fn arg_closure() -> &'static int {
+fn arg_closure() -> &'static isize {
     with(|box ref x| x) //~ ERROR borrowed value does not live long enough
 }
 
diff --git a/src/test/compile-fail/regions-ret-borrowed-1.rs b/src/test/compile-fail/regions-ret-borrowed-1.rs
index bd14d31217e..b8cebe66518 100644
--- a/src/test/compile-fail/regions-ret-borrowed-1.rs
+++ b/src/test/compile-fail/regions-ret-borrowed-1.rs
@@ -12,11 +12,11 @@
 // some point regions-ret-borrowed reported an error but this file did
 // not, due to special hardcoding around the anonymous region.
 
-fn with<R, F>(f: F) -> R where F: for<'a> FnOnce(&'a int) -> R {
+fn with<R, F>(f: F) -> R where F: for<'a> FnOnce(&'a isize) -> R {
     f(&3)
 }
 
-fn return_it<'a>() -> &'a int {
+fn return_it<'a>() -> &'a isize {
     with(|o| o)
         //~^ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-ret-borrowed.rs b/src/test/compile-fail/regions-ret-borrowed.rs
index 4dfd4f1709a..40909ddd4ad 100644
--- a/src/test/compile-fail/regions-ret-borrowed.rs
+++ b/src/test/compile-fail/regions-ret-borrowed.rs
@@ -10,16 +10,16 @@
 
 // Ensure that you cannot use generic types to return a region outside
 // of its bound.  Here, in the `return_it()` fn, we call with() but
-// with R bound to &int from the return_it.  Meanwhile, with()
+// with R bound to &isize from the return_it.  Meanwhile, with()
 // provides a value that is only good within its own stack frame. This
 // used to successfully compile because we failed to account for the
-// fact that fn(x: &int) rebound the region &.
+// fact that fn(x: &isize) rebound the region &.
 
-fn with<R, F>(f: F) -> R where F: FnOnce(&int) -> R {
+fn with<R, F>(f: F) -> R where F: FnOnce(&isize) -> R {
     f(&3)
 }
 
-fn return_it<'a>() -> &'a int {
+fn return_it<'a>() -> &'a isize {
     with(|o| o)
         //~^ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/regions-ret.rs b/src/test/compile-fail/regions-ret.rs
index 4986771c793..61c98d69d80 100644
--- a/src/test/compile-fail/regions-ret.rs
+++ b/src/test/compile-fail/regions-ret.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(_x: &int) -> &int {
+fn f(_x: &isize) -> &isize {
     return &3; //~ ERROR borrowed value does not live long enough
 }
 
diff --git a/src/test/compile-fail/regions-return-stack-allocated-vec.rs b/src/test/compile-fail/regions-return-stack-allocated-vec.rs
index 3c5423c44d0..b5d4e07d04b 100644
--- a/src/test/compile-fail/regions-return-stack-allocated-vec.rs
+++ b/src/test/compile-fail/regions-return-stack-allocated-vec.rs
@@ -10,7 +10,7 @@
 
 // Test that we cannot return a stack allocated slice
 
-fn function(x: int) -> &'static [int] {
+fn function(x: isize) -> &'static [isize] {
     &[x] //~ ERROR borrowed value does not live long enough
 }
 
diff --git a/src/test/compile-fail/regions-trait-variance.rs b/src/test/compile-fail/regions-trait-variance.rs
index 22e43c0bf89..9ba4ef4e358 100644
--- a/src/test/compile-fail/regions-trait-variance.rs
+++ b/src/test/compile-fail/regions-trait-variance.rs
@@ -13,15 +13,15 @@
 // Issue #12470.
 
 trait X {
-    fn get_i(&self) -> int;
+    fn get_i(&self) -> isize;
 }
 
 struct B {
-    i: int
+    i: isize
 }
 
 impl X for B {
-    fn get_i(&self) -> int {
+    fn get_i(&self) -> isize {
         self.i
     }
 }
diff --git a/src/test/compile-fail/regions-undeclared.rs b/src/test/compile-fail/regions-undeclared.rs
index 2d1de23616b..31908751580 100644
--- a/src/test/compile-fail/regions-undeclared.rs
+++ b/src/test/compile-fail/regions-undeclared.rs
@@ -8,15 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static c_x: &'blk int = &22; //~ ERROR use of undeclared lifetime name `'blk`
+static c_x: &'blk isize = &22; //~ ERROR use of undeclared lifetime name `'blk`
 
 enum EnumDecl {
-    Foo(&'a int), //~ ERROR use of undeclared lifetime name `'a`
-    Bar(&'a int), //~ ERROR use of undeclared lifetime name `'a`
+    Foo(&'a isize), //~ ERROR use of undeclared lifetime name `'a`
+    Bar(&'a isize), //~ ERROR use of undeclared lifetime name `'a`
 }
 
-fn fnDecl(x: &'a int, //~ ERROR use of undeclared lifetime name `'a`
-          y: &'a int) //~ ERROR use of undeclared lifetime name `'a`
+fn fnDecl(x: &'a isize, //~ ERROR use of undeclared lifetime name `'a`
+          y: &'a isize) //~ ERROR use of undeclared lifetime name `'a`
 {}
 
 fn main() {
diff --git a/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs b/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs
index 14ead8da158..a7ef3ec9ac1 100644
--- a/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs
+++ b/src/test/compile-fail/regions-variance-contravariant-use-covariant-in-second-position.rs
@@ -16,13 +16,13 @@
 
 // `S` is contravariant with respect to both parameters.
 struct S<'a, 'b> {
-    f: &'a int,
-    g: &'b int,
+    f: &'a isize,
+    g: &'b isize,
 }
 
 fn use_<'short,'long>(c: S<'long, 'short>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     let _: S<'long, 'short> = c; // OK
diff --git a/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs b/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs
index 3fc58071d2c..a79249ade4f 100644
--- a/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs
+++ b/src/test/compile-fail/regions-variance-contravariant-use-covariant.rs
@@ -18,12 +18,12 @@
 // Contravariant<'long> <: Contravariant<'short> iff
 // 'short <= 'long
 struct Contravariant<'a> {
-    f: &'a int
+    f: &'a isize
 }
 
 fn use_<'short,'long>(c: Contravariant<'short>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     // Test whether Contravariant<'short> <: Contravariant<'long>.  Since
diff --git a/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs b/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs
index 844c8151a64..f42b7027d9e 100644
--- a/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs
+++ b/src/test/compile-fail/regions-variance-covariant-use-contravariant.rs
@@ -18,12 +18,12 @@
 // Covariant<'foo> <: Covariant<'static> because
 // 'foo <= 'static
 struct Covariant<'a> {
-    f: extern "Rust" fn(&'a int)
+    f: extern "Rust" fn(&'a isize)
 }
 
 fn use_<'short,'long>(c: Covariant<'long>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     // Test whether Covariant<'long> <: Covariant<'short>.  Since
diff --git a/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs b/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs
index d09e6babe09..71023b26c27 100644
--- a/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs
+++ b/src/test/compile-fail/regions-variance-invariant-use-contravariant.rs
@@ -15,12 +15,12 @@
 // variance inference works in the first place.
 
 struct Invariant<'a> {
-    f: &'a mut &'a int
+    f: &'a mut &'a isize
 }
 
 fn use_<'short,'long>(c: Invariant<'long>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
 
     // Test whether Invariant<'long> <: Invariant<'short>.  Since
diff --git a/src/test/compile-fail/regions-variance-invariant-use-covariant.rs b/src/test/compile-fail/regions-variance-invariant-use-covariant.rs
index 861668ad50d..bd944a8b52c 100644
--- a/src/test/compile-fail/regions-variance-invariant-use-covariant.rs
+++ b/src/test/compile-fail/regions-variance-invariant-use-covariant.rs
@@ -15,7 +15,7 @@
 // variance inference works in the first place.
 
 struct Invariant<'a> {
-    f: &'a mut &'a int
+    f: &'a mut &'a isize
 }
 
 fn use_<'b>(c: Invariant<'b>) {
diff --git a/src/test/compile-fail/removed-syntax-enum-newtype.rs b/src/test/compile-fail/removed-syntax-enum-newtype.rs
index ba1b5a616df..3b45fd81288 100644
--- a/src/test/compile-fail/removed-syntax-enum-newtype.rs
+++ b/src/test/compile-fail/removed-syntax-enum-newtype.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-enum e = int; //~ ERROR expected one of `<` or `{`, found `=`
+enum e = isize; //~ ERROR expected one of `<` or `{`, found `=`
diff --git a/src/test/compile-fail/removed-syntax-extern-const.rs b/src/test/compile-fail/removed-syntax-extern-const.rs
index 2f98552a953..98eec0977e0 100644
--- a/src/test/compile-fail/removed-syntax-extern-const.rs
+++ b/src/test/compile-fail/removed-syntax-extern-const.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 extern {
-    const i: int; //~ ERROR unexpected token: `const`
+    const i: isize; //~ ERROR unexpected token: `const`
 }
diff --git a/src/test/compile-fail/removed-syntax-fixed-vec.rs b/src/test/compile-fail/removed-syntax-fixed-vec.rs
index 6537e3ddd27..0ca2380ef68 100644
--- a/src/test/compile-fail/removed-syntax-fixed-vec.rs
+++ b/src/test/compile-fail/removed-syntax-fixed-vec.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type v = [int * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `*`
+type v = [isize * 3]; //~ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `*`
diff --git a/src/test/compile-fail/removed-syntax-mode.rs b/src/test/compile-fail/removed-syntax-mode.rs
index d2ab1881b1a..b02de5ce08e 100644
--- a/src/test/compile-fail/removed-syntax-mode.rs
+++ b/src/test/compile-fail/removed-syntax-mode.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn f(+x: int) {} //~ ERROR unexpected token: `+`
+fn f(+x: isize) {} //~ ERROR unexpected token: `+`
diff --git a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs
index efde1f1b24d..0f67a1d04ee 100644
--- a/src/test/compile-fail/removed-syntax-mut-vec-ty.rs
+++ b/src/test/compile-fail/removed-syntax-mut-vec-ty.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type v = [mut int];
+type v = [mut isize];
     //~^  ERROR expected identifier, found keyword `mut`
-    //~^^ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `int`
+    //~^^ ERROR expected one of `(`, `+`, `::`, `;`, or `]`, found `isize`
diff --git a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs
index 1a1c4c9b40a..d94f2ec1e07 100644
--- a/src/test/compile-fail/removed-syntax-ptr-lifetime.rs
+++ b/src/test/compile-fail/removed-syntax-ptr-lifetime.rs
@@ -8,4 +8,4 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type bptr = &lifetime/int; //~ ERROR expected one of `(`, `+`, `::`, or `;`, found `/`
+type bptr = &lifetime/isize; //~ ERROR expected one of `(`, `+`, `::`, or `;`, found `/`
diff --git a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
index 8c3db89bad2..c051059aee6 100644
--- a/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
+++ b/src/test/compile-fail/removed-syntax-uniq-mut-ty.rs
@@ -8,6 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-type mut_box = Box<mut int>;
+type mut_box = Box<mut isize>;
     //~^  ERROR expected identifier, found keyword `mut`
-    //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `int`
+    //~^^ ERROR expected one of `(`, `+`, `,`, `::`, or `>`, found `isize`
diff --git a/src/test/compile-fail/repeat-to-run-dtor-twice.rs b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
index 762c976a943..c8457adb8d6 100644
--- a/src/test/compile-fail/repeat-to-run-dtor-twice.rs
+++ b/src/test/compile-fail/repeat-to-run-dtor-twice.rs
@@ -12,7 +12,7 @@
 // literal syntax.
 
 struct Foo {
-    x: int,
+    x: isize,
 
 }
 
diff --git a/src/test/compile-fail/resolve-inconsistent-binding-mode.rs b/src/test/compile-fail/resolve-inconsistent-binding-mode.rs
index df54a66f0a2..cdb81279048 100644
--- a/src/test/compile-fail/resolve-inconsistent-binding-mode.rs
+++ b/src/test/compile-fail/resolve-inconsistent-binding-mode.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 enum opts {
-    a(int), b(int), c(int)
+    a(isize), b(isize), c(isize)
 }
 
 fn matcher1(x: opts) {
diff --git a/src/test/compile-fail/resolve-unknown-trait.rs b/src/test/compile-fail/resolve-unknown-trait.rs
index 699a30ad4eb..0d0dc0a05d1 100644
--- a/src/test/compile-fail/resolve-unknown-trait.rs
+++ b/src/test/compile-fail/resolve-unknown-trait.rs
@@ -12,7 +12,7 @@
 trait NewTrait : SomeNonExistentTrait {}
 //~^ ERROR attempt to derive a nonexistent trait `SomeNonExistentTrait`
 
-impl SomeNonExistentTrait for int {}
+impl SomeNonExistentTrait for isize {}
 //~^ ERROR attempt to implement a nonexistent trait `SomeNonExistentTrait`
 
 fn f<T:SomeNonExistentTrait>() {}
diff --git a/src/test/compile-fail/ret-non-nil.rs b/src/test/compile-fail/ret-non-nil.rs
index d0cb2d4e812..4ee3cf4abac 100644
--- a/src/test/compile-fail/ret-non-nil.rs
+++ b/src/test/compile-fail/ret-non-nil.rs
@@ -12,6 +12,6 @@
 
 fn f() { return; }
 
-fn g() -> int { return; }
+fn g() -> isize { return; }
 
 fn main() { f(); g(); }
diff --git a/src/test/compile-fail/shadowed-lifetime.rs b/src/test/compile-fail/shadowed-lifetime.rs
index ff8ce7769d7..a2a603a4b6a 100644
--- a/src/test/compile-fail/shadowed-lifetime.rs
+++ b/src/test/compile-fail/shadowed-lifetime.rs
@@ -10,27 +10,27 @@
 
 // Test that shadowed lifetimes generate an error.
 
-struct Foo<'a>(&'a int);
+struct Foo<'a>(&'a isize);
 
 impl<'a> Foo<'a> {
     //~^ HELP shadowed lifetime `'a` declared here
-    fn shadow_in_method<'a>(&'a self) -> &'a int {
+    fn shadow_in_method<'a>(&'a self) -> &'a isize {
         //~^ WARNING lifetime name `'a` shadows another lifetime name that is already in scope
         //~| HELP deprecated
         self.0
     }
 
-    fn shadow_in_type<'b>(&'b self) -> &'b int {
+    fn shadow_in_type<'b>(&'b self) -> &'b isize {
         //~^ HELP shadowed lifetime `'b` declared here
-        let x: for<'b> fn(&'b int) = panic!();
+        let x: for<'b> fn(&'b isize) = panic!();
         //~^ WARNING lifetime name `'b` shadows another lifetime name that is already in scope
         //~| HELP deprecated
         self.0
     }
 
     fn not_shadow_in_item<'b>(&'b self) {
-        struct Bar<'a, 'b>(&'a int, &'b int); // not a shadow, separate item
-        fn foo<'a, 'b>(x: &'a int, y: &'b int) { } // same
+        struct Bar<'a, 'b>(&'a isize, &'b isize); // not a shadow, separate item
+        fn foo<'a, 'b>(x: &'a isize, y: &'b isize) { } // same
     }
 }
 
@@ -39,5 +39,5 @@ fn main() {
     // just to ensure that this test fails to compile; when shadowed
     // lifetimes become either an error or a proper lint, this will
     // not be needed.
-    let x: int = 3u; //~ ERROR mismatched types
+    let x: isize = 3u; //~ ERROR mismatched types
 }
diff --git a/src/test/compile-fail/shadowing-in-the-same-pattern.rs b/src/test/compile-fail/shadowing-in-the-same-pattern.rs
index 0b78023d318..c29534128ae 100644
--- a/src/test/compile-fail/shadowing-in-the-same-pattern.rs
+++ b/src/test/compile-fail/shadowing-in-the-same-pattern.rs
@@ -10,7 +10,7 @@
 
 // Test for issue #14581.
 
-fn f((a, a): (int, int)) {} //~ ERROR identifier `a` is bound more than once
+fn f((a, a): (isize, isize)) {} //~ ERROR identifier `a` is bound more than once
 
 fn main() {
     let (a, a) = (1, 1);    //~ ERROR identifier `a` is bound more than once
diff --git a/src/test/compile-fail/simd-type.rs b/src/test/compile-fail/simd-type.rs
index 16be3941298..c47bc1747de 100644
--- a/src/test/compile-fail/simd-type.rs
+++ b/src/test/compile-fail/simd-type.rs
@@ -20,6 +20,6 @@ struct empty; //~ ERROR SIMD vector cannot be empty
 struct i64f64(i64, f64); //~ ERROR SIMD vector should be homogeneous
 
 #[simd]
-struct int4(int, int, int, int); //~ ERROR SIMD vector element type should be machine type
+struct int4(isize, isize, isize, isize); //~ ERROR SIMD vector element type should be machine type
 
 fn main() {}
diff --git a/src/test/compile-fail/slice-borrow.rs b/src/test/compile-fail/slice-borrow.rs
index 43c4326628d..0062f66ae22 100644
--- a/src/test/compile-fail/slice-borrow.rs
+++ b/src/test/compile-fail/slice-borrow.rs
@@ -13,7 +13,7 @@
 fn main() {
     let y;
     {
-        let x: &[int] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough
+        let x: &[isize] = &[1, 2, 3, 4, 5]; //~ ERROR borrowed value does not live long enough
         y = &x[1..];
     }
 }
diff --git a/src/test/compile-fail/slice-mut-2.rs b/src/test/compile-fail/slice-mut-2.rs
index 12f184d410c..ecbd360e14e 100644
--- a/src/test/compile-fail/slice-mut-2.rs
+++ b/src/test/compile-fail/slice-mut-2.rs
@@ -11,8 +11,8 @@
 // Test mutability and slicing syntax.
 
 fn main() {
-    let x: &[int] = &[1, 2, 3, 4, 5];
+    let x: &[isize] = &[1, 2, 3, 4, 5];
     // Can't mutably slice an immutable slice
-    let slice: &mut [int] = &mut [0, 1];
+    let slice: &mut [isize] = &mut [0, 1];
     let _ = &mut x[2..4]; //~ERROR cannot borrow immutable dereference of `&`-pointer `*x` as mutabl
 }
diff --git a/src/test/compile-fail/slice-mut.rs b/src/test/compile-fail/slice-mut.rs
index 9bd9a752e4e..6de1bdd3eab 100644
--- a/src/test/compile-fail/slice-mut.rs
+++ b/src/test/compile-fail/slice-mut.rs
@@ -11,7 +11,7 @@
 // Test mutability and slicing syntax.
 
 fn main() {
-    let x: &[int] = &[1, 2, 3, 4, 5];
+    let x: &[isize] = &[1, 2, 3, 4, 5];
     // Immutable slices are not mutable.
     let y: &mut[_] = &x[2..4]; //~ ERROR cannot borrow immutable dereference of `&`-pointer as mutab
 }
diff --git a/src/test/compile-fail/static-items-cant-move.rs b/src/test/compile-fail/static-items-cant-move.rs
index 14ad1b3041f..422e95338ed 100644
--- a/src/test/compile-fail/static-items-cant-move.rs
+++ b/src/test/compile-fail/static-items-cant-move.rs
@@ -13,7 +13,7 @@
 use std::marker;
 
 struct Foo {
-    foo: int,
+    foo: isize,
     nocopy: marker::NoCopy
 }
 
diff --git a/src/test/compile-fail/static-mut-bad-types.rs b/src/test/compile-fail/static-mut-bad-types.rs
index 7aed3ce30bc..088c8ef3ab8 100644
--- a/src/test/compile-fail/static-mut-bad-types.rs
+++ b/src/test/compile-fail/static-mut-bad-types.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static mut a: int = 3;
+static mut a: isize = 3;
 
 fn main() {
     unsafe {
diff --git a/src/test/compile-fail/static-mut-not-constant.rs b/src/test/compile-fail/static-mut-not-constant.rs
index fd05f05502e..7c228ce413f 100644
--- a/src/test/compile-fail/static-mut-not-constant.rs
+++ b/src/test/compile-fail/static-mut-not-constant.rs
@@ -10,7 +10,7 @@
 
 #![feature(box_syntax)]
 
-static mut a: Box<int> = box 3;
+static mut a: Box<isize> = box 3;
 //~^ ERROR statics are not allowed to have custom pointers
 //~^^ ERROR mutable statics are not allowed to have owned pointers
 
diff --git a/src/test/compile-fail/static-mut-not-pat.rs b/src/test/compile-fail/static-mut-not-pat.rs
index de93422cd7a..d4170608559 100644
--- a/src/test/compile-fail/static-mut-not-pat.rs
+++ b/src/test/compile-fail/static-mut-not-pat.rs
@@ -12,7 +12,7 @@
 // statics cannot. This ensures that there's some form of error if this is
 // attempted.
 
-static mut a: int = 3;
+static mut a: isize = 3;
 
 fn main() {
     // If they can't be matched against, then it's possible to capture the same
diff --git a/src/test/compile-fail/static-mut-requires-unsafe.rs b/src/test/compile-fail/static-mut-requires-unsafe.rs
index 7337920cce6..f6ad46a0527 100644
--- a/src/test/compile-fail/static-mut-requires-unsafe.rs
+++ b/src/test/compile-fail/static-mut-requires-unsafe.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-static mut a: int = 3;
+static mut a: isize = 3;
 
 fn main() {
     a += 3;         //~ ERROR: requires unsafe
diff --git a/src/test/compile-fail/static-priv-by-default.rs b/src/test/compile-fail/static-priv-by-default.rs
index 98b37242c03..14299a9b639 100644
--- a/src/test/compile-fail/static-priv-by-default.rs
+++ b/src/test/compile-fail/static-priv-by-default.rs
@@ -14,12 +14,12 @@ extern crate static_priv_by_default;
 
 mod child {
     pub mod childs_child {
-        static private: int = 0;
-        pub static public: int = 0;
+        static private: isize = 0;
+        pub static public: isize = 0;
     }
 }
 
-fn foo(_: int) {}
+fn foo(_: isize) {}
 
 fn full_ref() {
     foo(static_priv_by_default::private); //~ ERROR: static `private` is private
diff --git a/src/test/compile-fail/static-priv-by-default2.rs b/src/test/compile-fail/static-priv-by-default2.rs
index 2141099c7aa..577e4f7542d 100644
--- a/src/test/compile-fail/static-priv-by-default2.rs
+++ b/src/test/compile-fail/static-priv-by-default2.rs
@@ -14,8 +14,8 @@ extern crate static_priv_by_default;
 
 mod child {
     pub mod childs_child {
-        static private: int = 0;
-        pub static public: int = 0;
+        static private: isize = 0;
+        pub static public: isize = 0;
     }
 }
 
diff --git a/src/test/compile-fail/static-reference-to-fn-1.rs b/src/test/compile-fail/static-reference-to-fn-1.rs
index bce397c4793..cf8ee1ecb41 100644
--- a/src/test/compile-fail/static-reference-to-fn-1.rs
+++ b/src/test/compile-fail/static-reference-to-fn-1.rs
@@ -9,16 +9,16 @@
 // except according to those terms.
 
 struct A<'a> {
-    func: &'a fn() -> Option<int>
+    func: &'a fn() -> Option<isize>
 }
 
 impl<'a> A<'a> {
-    fn call(&self) -> Option<int> {
+    fn call(&self) -> Option<isize> {
         (*self.func)()
     }
 }
 
-fn foo() -> Option<int> {
+fn foo() -> Option<isize> {
     None
 }
 
diff --git a/src/test/compile-fail/static-vec-repeat-not-constant.rs b/src/test/compile-fail/static-vec-repeat-not-constant.rs
index ff84ed5bf0c..7cb7615526a 100644
--- a/src/test/compile-fail/static-vec-repeat-not-constant.rs
+++ b/src/test/compile-fail/static-vec-repeat-not-constant.rs
@@ -8,9 +8,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo() -> int { 23 }
+fn foo() -> isize { 23 }
 
-static a: [int; 2] = [foo(); 2];
+static a: [isize; 2] = [foo(); 2];
 //~^ ERROR: function calls in constants are limited to struct and enum constructors
 
 fn main() {}
diff --git a/src/test/compile-fail/staticness-mismatch.rs b/src/test/compile-fail/staticness-mismatch.rs
index a6082d31480..bf4e46cace3 100644
--- a/src/test/compile-fail/staticness-mismatch.rs
+++ b/src/test/compile-fail/staticness-mismatch.rs
@@ -13,7 +13,7 @@ trait foo {
     fn bar();
 }
 
-impl foo for int {
+impl foo for isize {
     fn bar(&self) {}
     //~^ ERROR method `bar` has a `&self` declaration in the impl, but not in the trait
 }
diff --git a/src/test/compile-fail/struct-base-wrong-type.rs b/src/test/compile-fail/struct-base-wrong-type.rs
index af6fc645351..2bb8d32a7e3 100644
--- a/src/test/compile-fail/struct-base-wrong-type.rs
+++ b/src/test/compile-fail/struct-base-wrong-type.rs
@@ -8,8 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Foo { a: int, b: int }
-struct Bar { x: int }
+struct Foo { a: isize, b: isize }
+struct Bar { x: isize }
 
 static bar: Bar = Bar { x: 5 };
 static foo: Foo = Foo { a: 2, ..bar }; //~ ERROR mismatched types: expected `Foo`, found `Bar`
diff --git a/src/test/compile-fail/struct-field-assignability.rs b/src/test/compile-fail/struct-field-assignability.rs
index 2c3d48e9bf7..685ce28d510 100644
--- a/src/test/compile-fail/struct-field-assignability.rs
+++ b/src/test/compile-fail/struct-field-assignability.rs
@@ -12,7 +12,7 @@
 
 
 struct Foo<'a> {
-    x: &'a int
+    x: &'a isize
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/struct-field-privacy.rs b/src/test/compile-fail/struct-field-privacy.rs
index ae421815e4d..667e944f92c 100644
--- a/src/test/compile-fail/struct-field-privacy.rs
+++ b/src/test/compile-fail/struct-field-privacy.rs
@@ -13,17 +13,17 @@
 extern crate "struct-field-privacy" as xc;
 
 struct A {
-    a: int,
+    a: isize,
 }
 
 mod inner {
     struct A {
-        a: int,
-        pub b: int,
+        a: isize,
+        pub b: isize,
     }
     pub struct B {
-        pub a: int,
-        b: int,
+        pub a: isize,
+        b: isize,
     }
 }
 
diff --git a/src/test/compile-fail/struct-fields-decl-dupe.rs b/src/test/compile-fail/struct-fields-decl-dupe.rs
index 78216d5f4af..049569e8a18 100644
--- a/src/test/compile-fail/struct-fields-decl-dupe.rs
+++ b/src/test/compile-fail/struct-fields-decl-dupe.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 struct BuildData {
-    foo: int,
-    foo: int, //~ ERROR field `foo` is already declared
+    foo: isize,
+    foo: isize, //~ ERROR field `foo` is already declared
 }
 
 fn main() {
diff --git a/src/test/compile-fail/struct-fields-dupe.rs b/src/test/compile-fail/struct-fields-dupe.rs
index ffbfecdc48c..578091f5e9a 100644
--- a/src/test/compile-fail/struct-fields-dupe.rs
+++ b/src/test/compile-fail/struct-fields-dupe.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct BuildData {
-    foo: int,
+    foo: isize,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/struct-fields-missing.rs b/src/test/compile-fail/struct-fields-missing.rs
index 0afc84ee1b3..1fd9357cf2d 100644
--- a/src/test/compile-fail/struct-fields-missing.rs
+++ b/src/test/compile-fail/struct-fields-missing.rs
@@ -10,8 +10,8 @@
 
 
 struct BuildData {
-    foo: int,
-    bar: Box<int>,
+    foo: isize,
+    bar: Box<isize>,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/struct-fields-too-many.rs b/src/test/compile-fail/struct-fields-too-many.rs
index de58b5d110e..9244a9d4f9d 100644
--- a/src/test/compile-fail/struct-fields-too-many.rs
+++ b/src/test/compile-fail/struct-fields-too-many.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct BuildData {
-    foo: int,
+    foo: isize,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/struct-like-enum-nonexhaustive.rs b/src/test/compile-fail/struct-like-enum-nonexhaustive.rs
index 1115d78e560..a14e43f4c94 100644
--- a/src/test/compile-fail/struct-like-enum-nonexhaustive.rs
+++ b/src/test/compile-fail/struct-like-enum-nonexhaustive.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 enum A {
-    B { x: Option<int> },
+    B { x: Option<isize> },
     C
 }
 
diff --git a/src/test/compile-fail/struct-literal-in-for.rs b/src/test/compile-fail/struct-literal-in-for.rs
index a37197b889d..4bb5d5e6aa1 100644
--- a/src/test/compile-fail/struct-literal-in-for.rs
+++ b/src/test/compile-fail/struct-literal-in-for.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 impl Foo {
diff --git a/src/test/compile-fail/struct-literal-in-if.rs b/src/test/compile-fail/struct-literal-in-if.rs
index 9759e4f7bda..b2bc8a4901f 100644
--- a/src/test/compile-fail/struct-literal-in-if.rs
+++ b/src/test/compile-fail/struct-literal-in-if.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 impl Foo {
diff --git a/src/test/compile-fail/struct-literal-in-match-discriminant.rs b/src/test/compile-fail/struct-literal-in-match-discriminant.rs
index 297d3f7347f..8f50940806a 100644
--- a/src/test/compile-fail/struct-literal-in-match-discriminant.rs
+++ b/src/test/compile-fail/struct-literal-in-match-discriminant.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 fn main() {
diff --git a/src/test/compile-fail/struct-literal-in-while.rs b/src/test/compile-fail/struct-literal-in-while.rs
index 5b1679cf9a1..05fa3a8dd5f 100644
--- a/src/test/compile-fail/struct-literal-in-while.rs
+++ b/src/test/compile-fail/struct-literal-in-while.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
+    x: isize,
 }
 
 impl Foo {
diff --git a/src/test/compile-fail/struct-pattern-match-useless.rs b/src/test/compile-fail/struct-pattern-match-useless.rs
index b9c0be9276d..9f7ebc261ad 100644
--- a/src/test/compile-fail/struct-pattern-match-useless.rs
+++ b/src/test/compile-fail/struct-pattern-match-useless.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/struct-variant-no-pub.rs b/src/test/compile-fail/struct-variant-no-pub.rs
index 15ed69083e0..e62b39ad5aa 100644
--- a/src/test/compile-fail/struct-variant-no-pub.rs
+++ b/src/test/compile-fail/struct-variant-no-pub.rs
@@ -10,7 +10,7 @@
 
 enum Foo {
     Bar {
-        pub a: int //~ ERROR: `pub` is not allowed here
+        pub a: isize //~ ERROR: `pub` is not allowed here
     }
 }
 
diff --git a/src/test/compile-fail/struct-variant-privacy.rs b/src/test/compile-fail/struct-variant-privacy.rs
index bf404c27648..f36862364e7 100644
--- a/src/test/compile-fail/struct-variant-privacy.rs
+++ b/src/test/compile-fail/struct-variant-privacy.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 mod foo {
     enum Bar {
-        Baz { a: int }
+        Baz { a: isize }
     }
 }
 
diff --git a/src/test/compile-fail/tag-variant-cast-non-nullary.rs b/src/test/compile-fail/tag-variant-cast-non-nullary.rs
index 1d05c5d181d..b0106329126 100644
--- a/src/test/compile-fail/tag-variant-cast-non-nullary.rs
+++ b/src/test/compile-fail/tag-variant-cast-non-nullary.rs
@@ -12,10 +12,10 @@
 
 enum non_nullary {
     nullary,
-    other(int),
+    other(isize),
 }
 
 fn main() {
     let v = non_nullary::nullary;
-    let val = v as int;
+    let val = v as isize;
 }
diff --git a/src/test/compile-fail/tail-typeck.rs b/src/test/compile-fail/tail-typeck.rs
index 786d1e12137..aeb01c93ed0 100644
--- a/src/test/compile-fail/tail-typeck.rs
+++ b/src/test/compile-fail/tail-typeck.rs
@@ -10,7 +10,7 @@
 
 // error-pattern: mismatched types
 
-fn f() -> int { return g(); }
+fn f() -> isize { return g(); }
 
 fn g() -> uint { return 0u; }
 
diff --git a/src/test/compile-fail/terr-in-field.rs b/src/test/compile-fail/terr-in-field.rs
index 88da7bc8542..975c7e7de1f 100644
--- a/src/test/compile-fail/terr-in-field.rs
+++ b/src/test/compile-fail/terr-in-field.rs
@@ -9,12 +9,12 @@
 // except according to those terms.
 
 struct foo {
-    a: int,
-    b: int,
+    a: isize,
+    b: isize,
 }
 
 struct bar {
-    a: int,
+    a: isize,
     b: uint,
 }
 
diff --git a/src/test/compile-fail/terr-sorts.rs b/src/test/compile-fail/terr-sorts.rs
index 53ebe1f9b5b..d1a37c99c47 100644
--- a/src/test/compile-fail/terr-sorts.rs
+++ b/src/test/compile-fail/terr-sorts.rs
@@ -10,8 +10,8 @@
 
 
 struct foo {
-    a: int,
-    b: int,
+    a: isize,
+    b: isize,
 }
 
 type bar = Box<foo>;
diff --git a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs
index c11b5d22878..87d32a0041d 100644
--- a/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs
+++ b/src/test/compile-fail/trait-bounds-on-structs-and-enums.rs
@@ -15,7 +15,7 @@ struct Foo<T:Trait> {
 }
 
 enum Bar<T:Trait> {
-    ABar(int),
+    ABar(isize),
     BBar(T),
     CBar(uint),
 }
@@ -33,7 +33,7 @@ impl<T> Foo<T> {
 
 struct Baz {
 //~^ ERROR not implemented
-    a: Foo<int>,
+    a: Foo<isize>,
 }
 
 enum Boo {
diff --git a/src/test/compile-fail/trait-impl-1.rs b/src/test/compile-fail/trait-impl-1.rs
index 44b478bfb15..1c7fa1e4263 100644
--- a/src/test/compile-fail/trait-impl-1.rs
+++ b/src/test/compile-fail/trait-impl-1.rs
@@ -18,7 +18,7 @@ impl<'a> T+'a {
     fn foo(&self) {}
 }
 
-impl T for int {}
+impl T for isize {}
 
 fn main() {
     let x = &42is;
diff --git a/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs b/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs
index 1471d9232b2..3538c7f1289 100644
--- a/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs
+++ b/src/test/compile-fail/trait-impl-can-not-have-untraitful-methods.rs
@@ -10,7 +10,7 @@
 
 trait A { }
 
-impl A for int {
+impl A for isize {
     fn foo(&self) { } //~ ERROR method `foo` is not a member of trait `A`
 }
 
diff --git a/src/test/compile-fail/trait-impl-different-num-params.rs b/src/test/compile-fail/trait-impl-different-num-params.rs
index ea2062dd272..6c3e9879441 100644
--- a/src/test/compile-fail/trait-impl-different-num-params.rs
+++ b/src/test/compile-fail/trait-impl-different-num-params.rs
@@ -11,8 +11,8 @@
 trait foo {
     fn bar(&self, x: uint) -> Self;
 }
-impl foo for int {
-    fn bar(&self) -> int {
+impl foo for isize {
+    fn bar(&self) -> isize {
         //~^ ERROR method `bar` has 1 parameter but the declaration in trait `foo::bar` has 2
         *self
     }
diff --git a/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs b/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs
index 716362415a6..44c53e70f86 100644
--- a/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs
+++ b/src/test/compile-fail/trait-impl-of-supertrait-has-wrong-lifetime-parameters.rs
@@ -13,26 +13,26 @@
 // an impl of T1<'a>, but we have an impl of T1<'b>.
 
 trait T1<'x> {
-    fn x(&self) -> &'x int;
+    fn x(&self) -> &'x isize;
 }
 
 trait T2<'x, 'y> : T1<'x> {
-    fn y(&self) -> &'y int;
+    fn y(&self) -> &'y isize;
 }
 
 struct S<'a, 'b> {
-    a: &'a int,
-    b: &'b int
+    a: &'a isize,
+    b: &'b isize
 }
 
 impl<'a,'b> T1<'b> for S<'a, 'b> {
-    fn x(&self) -> &'b int {
+    fn x(&self) -> &'b isize {
         self.b
     }
 }
 
 impl<'a,'b> T2<'a, 'b> for S<'a, 'b> { //~ ERROR cannot infer an appropriate lifetime
-    fn y(&self) -> &'b int {
+    fn y(&self) -> &'b isize {
         self.b
     }
 }
diff --git a/src/test/compile-fail/trait-matching-lifetimes.rs b/src/test/compile-fail/trait-matching-lifetimes.rs
index 333730e0c4b..5ab80065572 100644
--- a/src/test/compile-fail/trait-matching-lifetimes.rs
+++ b/src/test/compile-fail/trait-matching-lifetimes.rs
@@ -12,8 +12,8 @@
 // (Issue #15517.)
 
 struct Foo<'a,'b> {
-    x: &'a int,
-    y: &'b int,
+    x: &'a isize,
+    y: &'b isize,
 }
 
 trait Tr : Sized {
diff --git a/src/test/compile-fail/trait-safety-fn-body.rs b/src/test/compile-fail/trait-safety-fn-body.rs
index f894e2ee28e..499b58f70d7 100644
--- a/src/test/compile-fail/trait-safety-fn-body.rs
+++ b/src/test/compile-fail/trait-safety-fn-body.rs
@@ -15,7 +15,7 @@ unsafe trait UnsafeTrait : Sized {
     fn foo(self) { }
 }
 
-unsafe impl UnsafeTrait for *mut int {
+unsafe impl UnsafeTrait for *mut isize {
     fn foo(self) {
         // Unsafe actions are not made legal by taking place in an unsafe trait:
         *self += 1; //~ ERROR E0133
diff --git a/src/test/compile-fail/trait-safety-trait-impl-cc.rs b/src/test/compile-fail/trait-safety-trait-impl-cc.rs
index 21dd5a237c5..032deb2e017 100644
--- a/src/test/compile-fail/trait-safety-trait-impl-cc.rs
+++ b/src/test/compile-fail/trait-safety-trait-impl-cc.rs
@@ -17,8 +17,8 @@ extern crate "trait-safety-lib" as lib;
 
 struct Bar;
 impl lib::Foo for Bar { //~ ERROR requires an `unsafe impl` declaration
-    fn foo(&self) -> int {
-        *self as int
+    fn foo(&self) -> isize {
+        *self as isize
     }
 }
 
diff --git a/src/test/compile-fail/trait-test-2.rs b/src/test/compile-fail/trait-test-2.rs
index f66034e395c..f1ff82662b9 100644
--- a/src/test/compile-fail/trait-test-2.rs
+++ b/src/test/compile-fail/trait-test-2.rs
@@ -11,11 +11,11 @@
 #![feature(box_syntax)]
 
 trait bar { fn dup(&self) -> Self; fn blah<X>(&self); }
-impl bar for int { fn dup(&self) -> int { *self } fn blah<X>(&self) {} }
+impl bar for isize { fn dup(&self) -> isize { *self } fn blah<X>(&self) {} }
 impl bar for uint { fn dup(&self) -> uint { *self } fn blah<X>(&self) {} }
 
 fn main() {
-    10i.dup::<int>(); //~ ERROR does not take type parameters
-    10i.blah::<int, int>(); //~ ERROR incorrect number of type parameters
+    10i.dup::<isize>(); //~ ERROR does not take type parameters
+    10i.blah::<isize, isize>(); //~ ERROR incorrect number of type parameters
     (box 10i as Box<bar>).dup(); //~ ERROR cannot convert to a trait object
 }
diff --git a/src/test/compile-fail/trait-test.rs b/src/test/compile-fail/trait-test.rs
index 1682e98fb23..6039e646407 100644
--- a/src/test/compile-fail/trait-test.rs
+++ b/src/test/compile-fail/trait-test.rs
@@ -10,6 +10,6 @@
 
 trait foo { fn foo(&self); }
 
-impl int for uint { fn foo(&self) {} } //~ ERROR trait
+impl isize for uint { fn foo(&self) {} } //~ ERROR trait
 
 fn main() {}
diff --git a/src/test/compile-fail/traits-multidispatch-bad.rs b/src/test/compile-fail/traits-multidispatch-bad.rs
index f5ce904a4bb..d155735d69c 100644
--- a/src/test/compile-fail/traits-multidispatch-bad.rs
+++ b/src/test/compile-fail/traits-multidispatch-bad.rs
@@ -14,7 +14,7 @@ trait Convert<Target> {
     fn convert(&self) -> Target;
 }
 
-impl Convert<uint> for int {
+impl Convert<uint> for isize {
     fn convert(&self) -> uint {
         *self as uint
     }
diff --git a/src/test/compile-fail/transmute-impl.rs b/src/test/compile-fail/transmute-impl.rs
index a68bba285df..a77a37a77e1 100644
--- a/src/test/compile-fail/transmute-impl.rs
+++ b/src/test/compile-fail/transmute-impl.rs
@@ -19,12 +19,12 @@ struct Foo<T: ?Sized> {
 }
 
 impl<T: ?Sized> Foo<T> {
-    fn m(x: &T) -> &int where T : Sized {
+    fn m(x: &T) -> &isize where T : Sized {
         // OK here, because T : Sized is in scope.
         unsafe { transmute(x) }
     }
 
-    fn n(x: &T) -> &int {
+    fn n(x: &T) -> &isize {
         // Not OK here, because T : Sized is not in scope.
         unsafe { transmute(x) } //~ ERROR transmute called on types with potentially different sizes
     }
diff --git a/src/test/compile-fail/transmute-type-parameters.rs b/src/test/compile-fail/transmute-type-parameters.rs
index 2286c0e75bd..b06966bd867 100644
--- a/src/test/compile-fail/transmute-type-parameters.rs
+++ b/src/test/compile-fail/transmute-type-parameters.rs
@@ -13,15 +13,15 @@
 use std::mem::transmute;
 
 unsafe fn f<T>(x: T) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
-unsafe fn g<T>(x: (T, int)) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+unsafe fn g<T>(x: (T, isize)) {
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
 unsafe fn h<T>(x: [T; 10]) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
 struct Bad<T> {
@@ -29,7 +29,7 @@ struct Bad<T> {
 }
 
 unsafe fn i<T>(x: Bad<T>) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
 enum Worse<T> {
@@ -38,11 +38,11 @@ enum Worse<T> {
 }
 
 unsafe fn j<T>(x: Worse<T>) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
 unsafe fn k<T>(x: Option<T>) {
-    let _: int = transmute(x);  //~ ERROR cannot transmute
+    let _: isize = transmute(x);  //~ ERROR cannot transmute
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/tuple-index-not-tuple.rs b/src/test/compile-fail/tuple-index-not-tuple.rs
index 33aeebb3691..bf2a63abbfd 100644
--- a/src/test/compile-fail/tuple-index-not-tuple.rs
+++ b/src/test/compile-fail/tuple-index-not-tuple.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Point { x: int, y: int }
+struct Point { x: isize, y: isize }
 struct Empty;
 
 fn main() {
diff --git a/src/test/compile-fail/tuple-struct-nonexhaustive.rs b/src/test/compile-fail/tuple-struct-nonexhaustive.rs
index 1f14fbb27ad..e4fda6dd534 100644
--- a/src/test/compile-fail/tuple-struct-nonexhaustive.rs
+++ b/src/test/compile-fail/tuple-struct-nonexhaustive.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct Foo(int, int);
+struct Foo(isize, isize);
 
 fn main() {
     let x = Foo(1, 2);
diff --git a/src/test/compile-fail/tutorial-suffix-inference-test.rs b/src/test/compile-fail/tutorial-suffix-inference-test.rs
index 85ad302f3ed..1b44c7e8128 100644
--- a/src/test/compile-fail/tutorial-suffix-inference-test.rs
+++ b/src/test/compile-fail/tutorial-suffix-inference-test.rs
@@ -23,7 +23,7 @@ fn main() {
 
     let a = 3is;
 
-    fn identity_i(n: isize) -> int { n }
+    fn identity_i(n: isize) -> isize { n }
 
     identity_i(a); // ok
     identity_u16(a);
diff --git a/src/test/compile-fail/type-parameters-in-field-exprs.rs b/src/test/compile-fail/type-parameters-in-field-exprs.rs
index 023f7d1c29f..54ddb3e19fa 100644
--- a/src/test/compile-fail/type-parameters-in-field-exprs.rs
+++ b/src/test/compile-fail/type-parameters-in-field-exprs.rs
@@ -9,8 +9,8 @@
 // except according to those terms.
 
 struct Foo {
-    x: int,
-    y: int,
+    x: isize,
+    y: isize,
 }
 
 fn main() {
@@ -18,7 +18,7 @@ fn main() {
         x: 1,
         y: 2,
     };
-    f.x::<int>;
+    f.x::<isize>;
     //~^ ERROR field expressions may not have type parameters
 }
 
diff --git a/src/test/compile-fail/type-recursive.rs b/src/test/compile-fail/type-recursive.rs
index a2b4e8d9782..9dcb60628a9 100644
--- a/src/test/compile-fail/type-recursive.rs
+++ b/src/test/compile-fail/type-recursive.rs
@@ -10,7 +10,7 @@
 
 // error-pattern:this type cannot be instantiated
 struct t1 {
-    foo: int,
+    foo: isize,
     foolish: t1
 }
 
diff --git a/src/test/compile-fail/type-shadow.rs b/src/test/compile-fail/type-shadow.rs
index 50c8cf99d3c..6d8c0fe22bd 100644
--- a/src/test/compile-fail/type-shadow.rs
+++ b/src/test/compile-fail/type-shadow.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    type X = int;
+    type X = isize;
     type Y = X;
     if true {
         type X = &'static str;
diff --git a/src/test/compile-fail/ufcs-explicit-self-bad.rs b/src/test/compile-fail/ufcs-explicit-self-bad.rs
index 5ba660495f7..60b2002ae97 100644
--- a/src/test/compile-fail/ufcs-explicit-self-bad.rs
+++ b/src/test/compile-fail/ufcs-explicit-self-bad.rs
@@ -11,11 +11,11 @@
 #![feature(box_syntax)]
 
 struct Foo {
-    f: int,
+    f: isize,
 }
 
 impl Foo {
-    fn foo(self: int, x: int) -> int {  //~ ERROR mismatched self type
+    fn foo(self: isize, x: isize) -> isize {  //~ ERROR mismatched self type
         self.f + x
     }
 }
@@ -25,10 +25,10 @@ struct Bar<T> {
 }
 
 impl<T> Bar<T> {
-    fn foo(self: Bar<int>, x: int) -> int { //~ ERROR mismatched self type
+    fn foo(self: Bar<isize>, x: isize) -> isize { //~ ERROR mismatched self type
         x
     }
-    fn bar(self: &Bar<uint>, x: int) -> int {   //~ ERROR mismatched self type
+    fn bar(self: &Bar<uint>, x: isize) -> isize {   //~ ERROR mismatched self type
         x
     }
 }
diff --git a/src/test/compile-fail/unboxed-closure-feature-gate.rs b/src/test/compile-fail/unboxed-closure-feature-gate.rs
index 9bb8037e2c3..5eb67a9bb71 100644
--- a/src/test/compile-fail/unboxed-closure-feature-gate.rs
+++ b/src/test/compile-fail/unboxed-closure-feature-gate.rs
@@ -15,11 +15,11 @@ trait Foo<A,R> {
 }
 
 fn main() {
-    let x: Box<Foo(int)>;
+    let x: Box<Foo(isize)>;
     //~^ ERROR parenthetical notation is only stable when used with the `Fn` family
 
     // No errors with these:
-    let x: Box<Fn(int)>;
-    let x: Box<FnMut(int)>;
-    let x: Box<FnOnce(int)>;
+    let x: Box<Fn(isize)>;
+    let x: Box<FnMut(isize)>;
+    let x: Box<FnOnce(isize)>;
 }
diff --git a/src/test/compile-fail/unboxed-closure-sugar-default.rs b/src/test/compile-fail/unboxed-closure-sugar-default.rs
index 82355ddf681..0d9e406b086 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-default.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-default.rs
@@ -24,14 +24,14 @@ fn eq<A: ?Sized,B: ?Sized>() where A : Eq<B> { }
 
 fn test<'a,'b>() {
     // Parens are equivalent to omitting default in angle.
-    eq::< Foo<(int,),()>,               Foo(int)                      >();
+    eq::< Foo<(isize,),()>,               Foo(isize)                      >();
 
     // In angle version, we supply something other than the default
-    eq::< Foo<(int,),(),int>,           Foo(int)                      >();
+    eq::< Foo<(isize,),(),isize>,           Foo(isize)                      >();
     //~^ ERROR not implemented
 
     // Supply default explicitly.
-    eq::< Foo<(int,),(),(int,)>,        Foo(int)                      >();
+    eq::< Foo<(isize,),(),(isize,)>,        Foo(isize)                      >();
 }
 
 fn main() { }
diff --git a/src/test/compile-fail/unboxed-closure-sugar-equiv.rs b/src/test/compile-fail/unboxed-closure-sugar-equiv.rs
index f36fad30670..f37dcfb7745 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-equiv.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-equiv.rs
@@ -27,26 +27,26 @@ fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
 fn test<'a,'b>() {
     // No errors expected:
     eq::< Foo<(),()>,                   Foo()                         >();
-    eq::< Foo<(int,),()>,               Foo(int)                      >();
-    eq::< Foo<(int,uint),()>,           Foo(int,uint)                 >();
-    eq::< Foo<(int,uint),uint>,         Foo(int,uint) -> uint         >();
-    eq::< Foo<(&'a int,&'b uint),uint>, Foo(&'a int,&'b uint) -> uint >();
+    eq::< Foo<(isize,),()>,               Foo(isize)                      >();
+    eq::< Foo<(isize,uint),()>,           Foo(isize,uint)                 >();
+    eq::< Foo<(isize,uint),uint>,         Foo(isize,uint) -> uint         >();
+    eq::< Foo<(&'a isize,&'b uint),uint>, Foo(&'a isize,&'b uint) -> uint >();
 
     // Test that anonymous regions in `()` form are equivalent
     // to fresh bound regions, and that we can intermingle
     // named and anonymous as we choose:
-    eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>,
-          for<'x,'y> Foo(&'x int,&'y uint) -> uint            >();
-    eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>,
-          for<'x> Foo(&'x int,&uint) -> uint                  >();
-    eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>,
-          for<'y> Foo(&int,&'y uint) -> uint                  >();
-    eq::< for<'x,'y> Foo<(&'x int,&'y uint),uint>,
-          Foo(&int,&uint) -> uint                             >();
+    eq::< for<'x,'y> Foo<(&'x isize,&'y uint),uint>,
+          for<'x,'y> Foo(&'x isize,&'y uint) -> uint            >();
+    eq::< for<'x,'y> Foo<(&'x isize,&'y uint),uint>,
+          for<'x> Foo(&'x isize,&uint) -> uint                  >();
+    eq::< for<'x,'y> Foo<(&'x isize,&'y uint),uint>,
+          for<'y> Foo(&isize,&'y uint) -> uint                  >();
+    eq::< for<'x,'y> Foo<(&'x isize,&'y uint),uint>,
+          Foo(&isize,&uint) -> uint                             >();
 
     // lifetime elision
-    eq::< for<'x> Foo<(&'x int,), &'x int>,
-          Foo(&int) -> &int                                   >();
+    eq::< for<'x> Foo<(&'x isize,), &'x isize>,
+          Foo(&isize) -> &isize                                   >();
 
     // Errors expected:
     eq::< Foo<(),()>,                   Foo(char)                     >();
diff --git a/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs b/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs
index 2617be295cd..176970703c5 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-lifetime-elision.rs
@@ -25,10 +25,10 @@ impl<X: ?Sized> Eq<X> for X { }
 fn eq<A: ?Sized,B: ?Sized +Eq<A>>() { }
 
 fn main() {
-    eq::< for<'a> Foo<(&'a int,), &'a int>,
-          Foo(&int) -> &int                                   >();
-    eq::< for<'a> Foo<(&'a int,), (&'a int, &'a int)>,
-          Foo(&int) -> (&int, &int)                           >();
+    eq::< for<'a> Foo<(&'a isize,), &'a isize>,
+          Foo(&isize) -> &isize                                   >();
+    eq::< for<'a> Foo<(&'a isize,), (&'a isize, &'a isize)>,
+          Foo(&isize) -> (&isize, &isize)                           >();
 
-    let _: Foo(&int, &uint) -> &uint; //~ ERROR missing lifetime specifier
+    let _: Foo(&isize, &uint) -> &uint; //~ ERROR missing lifetime specifier
 }
diff --git a/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs b/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs
index 23e2d2f4365..12f62d805e1 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-nonexistent-trait.rs
@@ -10,11 +10,11 @@
 
 #![feature(unboxed_closures)]
 
-fn f<F:Nonexist(int) -> int>(x: F) {} //~ ERROR nonexistent trait `Nonexist`
+fn f<F:Nonexist(isize) -> isize>(x: F) {} //~ ERROR nonexistent trait `Nonexist`
 
-type Typedef = int;
+type Typedef = isize;
 
-fn g<F:Typedef(int) -> int>(x: F) {} //~ ERROR `Typedef` is not a trait
+fn g<F:Typedef(isize) -> isize>(x: F) {} //~ ERROR `Typedef` is not a trait
 
 fn main() {}
 
diff --git a/src/test/compile-fail/unboxed-closure-sugar-region.rs b/src/test/compile-fail/unboxed-closure-sugar-region.rs
index e0783b09cbd..c8dd33c11fd 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-region.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-region.rs
@@ -29,14 +29,14 @@ fn same_type<A,B:Eq<A>>(a: A, b: B) { }
 
 fn test<'a,'b>() {
     // Parens are equivalent to omitting default in angle.
-    eq::< Foo<(int,),()>,               Foo(int)                      >();
+    eq::< Foo<(isize,),()>,               Foo(isize)                      >();
 
     // Here we specify 'static explicitly in angle-bracket version.
     // Parenthesized winds up getting inferred.
-    eq::< Foo<'static, (int,),()>,      Foo(int)                      >();
+    eq::< Foo<'static, (isize,),()>,      Foo(isize)                      >();
 }
 
-fn test2(x: &Foo<(int,),()>, y: &Foo(int)) {
+fn test2(x: &Foo<(isize,),()>, y: &Foo(isize)) {
     // Here, the omitted lifetimes are expanded to distinct things.
     same_type(x, y) //~ ERROR cannot infer
 }
diff --git a/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs b/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs
index 5e16adc4e42..b2bd030f3c4 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-used-on-struct-3.rs
@@ -19,7 +19,7 @@ impl<A,B> Bar<A,B> {
 }
 
 fn bar() {
-    let b = Box::Bar::<int,uint>::new(); // OK
+    let b = Box::Bar::<isize,uint>::new(); // OK
 
     let b = Box::Bar::()::new();
     //~^ ERROR expected ident, found `(`
diff --git a/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs b/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs
index ba1e931ac64..b58e08355c1 100644
--- a/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs
+++ b/src/test/compile-fail/unboxed-closure-sugar-wrong-trait.rs
@@ -12,7 +12,7 @@
 
 trait Trait {}
 
-fn f<F:Trait(int) -> int>(x: F) {}
+fn f<F:Trait(isize) -> isize>(x: F) {}
 //~^ ERROR wrong number of type arguments: expected 0, found 2
 
 fn main() {}
diff --git a/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs b/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs
index 9fbb8a18ae9..fc87ec9f959 100644
--- a/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs
+++ b/src/test/compile-fail/unboxed-closures-fnmut-as-fn.rs
@@ -18,13 +18,13 @@ use std::ops::{Fn,FnMut,FnOnce};
 
 struct S;
 
-impl FnMut<(int,),int> for S {
-    extern "rust-call" fn call_mut(&mut self, (x,): (int,)) -> int {
+impl FnMut<(isize,),isize> for S {
+    extern "rust-call" fn call_mut(&mut self, (x,): (isize,)) -> isize {
         x * x
     }
 }
 
-fn call_it<F:Fn(int)->int>(f: &F, x: int) -> int {
+fn call_it<F:Fn(isize)->isize>(f: &F, x: isize) -> isize {
     f.call((x,))
 }
 
diff --git a/src/test/compile-fail/unboxed-closures-type-mismatch.rs b/src/test/compile-fail/unboxed-closures-type-mismatch.rs
index 61f13172832..6c2e9f431fe 100644
--- a/src/test/compile-fail/unboxed-closures-type-mismatch.rs
+++ b/src/test/compile-fail/unboxed-closures-type-mismatch.rs
@@ -13,7 +13,7 @@
 use std::ops::FnMut;
 
 pub fn main() {
-    let mut f = |&mut: x: int, y: int| -> int { x + y };
+    let mut f = |&mut: x: isize, y: isize| -> isize { x + y };
     let z = f(1u, 2);    //~ ERROR mismatched types
     println!("{}", z);
 }
diff --git a/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs b/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs
index b0b37d077c1..ab909717cab 100644
--- a/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs
+++ b/src/test/compile-fail/unboxed-closures-unsafe-extern-fn.rs
@@ -14,11 +14,11 @@
 
 use std::ops::{Fn,FnMut,FnOnce};
 
-unsafe fn square(x: &int) -> int { (*x) * (*x) }
+unsafe fn square(x: &isize) -> isize { (*x) * (*x) }
 
-fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 }
-fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 }
-fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 }
+fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 }
+fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 }
+fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 }
 
 fn a() {
     let x = call_it(&square, 22); //~ ERROR not implemented
diff --git a/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs b/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs
index 85b33f73bbc..ca641e39aed 100644
--- a/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs
+++ b/src/test/compile-fail/unboxed-closures-vtable-mismatch.rs
@@ -12,12 +12,12 @@
 
 use std::ops::FnMut;
 
-fn call_it<F:FnMut<(int,int),int>>(y: int, mut f: F) -> int {
+fn call_it<F:FnMut<(isize,isize),isize>>(y: isize, mut f: F) -> isize {
     f(2, y)
 }
 
 pub fn main() {
-    let f = |&mut: x: uint, y: int| -> int { (x as int) + y };
+    let f = |&mut: x: uint, y: isize| -> isize { (x as isize) + y };
     let z = call_it(3, f);  //~ ERROR type mismatch
     println!("{}", z);
 }
diff --git a/src/test/compile-fail/unboxed-closures-wrong-abi.rs b/src/test/compile-fail/unboxed-closures-wrong-abi.rs
index 20a4ab85d7b..4a0b55558c0 100644
--- a/src/test/compile-fail/unboxed-closures-wrong-abi.rs
+++ b/src/test/compile-fail/unboxed-closures-wrong-abi.rs
@@ -14,11 +14,11 @@
 
 use std::ops::{Fn,FnMut,FnOnce};
 
-extern "C" fn square(x: &int) -> int { (*x) * (*x) }
+extern "C" fn square(x: &isize) -> isize { (*x) * (*x) }
 
-fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 }
-fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 }
-fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 }
+fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 }
+fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 }
+fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 }
 
 fn a() {
     let x = call_it(&square, 22); //~ ERROR not implemented
diff --git a/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs b/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs
index f08cff3cd68..b2fdf792630 100644
--- a/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs
+++ b/src/test/compile-fail/unboxed-closures-wrong-arg-type-extern-fn.rs
@@ -14,12 +14,12 @@
 
 use std::ops::{Fn,FnMut,FnOnce};
 
-unsafe fn square(x: int) -> int { x * x }
-// note: argument type here is `int`, not `&int`
+unsafe fn square(x: isize) -> isize { x * x }
+// note: argument type here is `isize`, not `&isize`
 
-fn call_it<F:Fn(&int)->int>(_: &F, _: int) -> int { 0 }
-fn call_it_mut<F:FnMut(&int)->int>(_: &mut F, _: int) -> int { 0 }
-fn call_it_once<F:FnOnce(&int)->int>(_: F, _: int) -> int { 0 }
+fn call_it<F:Fn(&isize)->isize>(_: &F, _: isize) -> isize { 0 }
+fn call_it_mut<F:FnMut(&isize)->isize>(_: &mut F, _: isize) -> isize { 0 }
+fn call_it_once<F:FnOnce(&isize)->isize>(_: F, _: isize) -> isize { 0 }
 
 fn a() {
     let x = call_it(&square, 22); //~ ERROR not implemented
diff --git a/src/test/compile-fail/unboxed-closures-wrong-trait.rs b/src/test/compile-fail/unboxed-closures-wrong-trait.rs
index e15fe8ad049..e4255d0024f 100644
--- a/src/test/compile-fail/unboxed-closures-wrong-trait.rs
+++ b/src/test/compile-fail/unboxed-closures-wrong-trait.rs
@@ -10,13 +10,13 @@
 
 #![feature(lang_items, overloaded_calls, unboxed_closures)]
 
-fn c<F:Fn(int, int) -> int>(f: F) -> int {
+fn c<F:Fn(isize, isize) -> isize>(f: F) -> isize {
     f(5, 6)
 }
 
 fn main() {
-    let z: int = 7;
-    assert_eq!(c(|&mut: x: int, y| x + y + z), 10);
+    let z: isize = 7;
+    assert_eq!(c(|&mut: x: isize, y| x + y + z), 10);
     //~^ ERROR not implemented
 }
 
diff --git a/src/test/compile-fail/uninhabited-enum-cast.rs b/src/test/compile-fail/uninhabited-enum-cast.rs
index 9f91337db9f..b4df5fb1e2a 100644
--- a/src/test/compile-fail/uninhabited-enum-cast.rs
+++ b/src/test/compile-fail/uninhabited-enum-cast.rs
@@ -11,7 +11,7 @@
 enum E {}
 
 fn f(e: E) {
-    println!("{}", (e as int).to_string());   //~ ERROR non-scalar cast
+    println!("{}", (e as isize).to_string());   //~ ERROR non-scalar cast
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/unique-object-noncopyable.rs b/src/test/compile-fail/unique-object-noncopyable.rs
index 2dde11ada28..5074d00ca15 100644
--- a/src/test/compile-fail/unique-object-noncopyable.rs
+++ b/src/test/compile-fail/unique-object-noncopyable.rs
@@ -15,7 +15,7 @@ trait Foo {
 }
 
 struct Bar {
-    x: int,
+    x: isize,
 }
 
 impl Drop for Bar {
diff --git a/src/test/compile-fail/unique-vec-res.rs b/src/test/compile-fail/unique-vec-res.rs
index b558989304f..4a84bb4c5ab 100644
--- a/src/test/compile-fail/unique-vec-res.rs
+++ b/src/test/compile-fail/unique-vec-res.rs
@@ -16,7 +16,7 @@ use std::cell::Cell;
 
 #[derive(Show)]
 struct r<'a> {
-  i: &'a Cell<int>,
+  i: &'a Cell<isize>,
 }
 
 #[unsafe_destructor]
diff --git a/src/test/compile-fail/unnecessary-private.rs b/src/test/compile-fail/unnecessary-private.rs
index abbb084dbc0..6e6ffd23c4a 100644
--- a/src/test/compile-fail/unnecessary-private.rs
+++ b/src/test/compile-fail/unnecessary-private.rs
@@ -19,7 +19,7 @@ fn main() {
     }
 
     struct D {
-        pub foo: int, //~ ERROR: visibility has no effect
+        pub foo: isize, //~ ERROR: visibility has no effect
     }
     pub fn foo() {} //~ ERROR: visibility has no effect
     pub mod bar {} //~ ERROR: visibility has no effect
diff --git a/src/test/compile-fail/unreachable-arm.rs b/src/test/compile-fail/unreachable-arm.rs
index 934ddb5f80b..c4c0e648f34 100644
--- a/src/test/compile-fail/unreachable-arm.rs
+++ b/src/test/compile-fail/unreachable-arm.rs
@@ -12,6 +12,6 @@
 
 #![feature(box_syntax)]
 
-enum foo { a(Box<foo>, int), b(uint), }
+enum foo { a(Box<foo>, isize), b(uint), }
 
 fn main() { match foo::b(1u) { foo::b(_) | foo::a(box _, 1) => { } foo::a(_, 1) => { } } }
diff --git a/src/test/compile-fail/unsafe-fn-autoderef.rs b/src/test/compile-fail/unsafe-fn-autoderef.rs
index 464abd57872..97a7bf14710 100644
--- a/src/test/compile-fail/unsafe-fn-autoderef.rs
+++ b/src/test/compile-fail/unsafe-fn-autoderef.rs
@@ -9,10 +9,10 @@
 // except according to those terms.
 
 struct Rec {
-    f: int
+    f: isize
 }
 
-fn f(p: *const Rec) -> int {
+fn f(p: *const Rec) -> isize {
 
     // Test that * ptrs do not autoderef.  There is a deeper reason for
     // prohibiting this, beyond making unsafe things annoying (which doesn't
diff --git a/src/test/compile-fail/unsendable-class.rs b/src/test/compile-fail/unsendable-class.rs
index 96f36af53aa..abd93fdfc6c 100644
--- a/src/test/compile-fail/unsendable-class.rs
+++ b/src/test/compile-fail/unsendable-class.rs
@@ -16,11 +16,11 @@ use std::sync::mpsc::channel;
 use std::rc::Rc;
 
 struct foo {
-  i: int,
+  i: isize,
   j: Rc<String>,
 }
 
-fn foo(i:int, j: Rc<String>) -> foo {
+fn foo(i:isize, j: Rc<String>) -> foo {
     foo {
         i: i,
         j: j
diff --git a/src/test/compile-fail/unsized5.rs b/src/test/compile-fail/unsized5.rs
index 026d496aa43..02a8b5899d7 100644
--- a/src/test/compile-fail/unsized5.rs
+++ b/src/test/compile-fail/unsized5.rs
@@ -12,12 +12,12 @@
 
 struct S1<X: ?Sized> {
     f1: X, //~ ERROR `core::marker::Sized` is not implemented
-    f2: int,
+    f2: isize,
 }
 struct S2<X: ?Sized> {
-    f: int,
+    f: isize,
     g: X, //~ ERROR `core::marker::Sized` is not implemented
-    h: int,
+    h: isize,
 }
 struct S3 {
     f: str, //~ ERROR `core::marker::Sized` is not implemented
@@ -28,10 +28,10 @@ struct S4 {
     g: uint
 }
 enum E<X: ?Sized> {
-    V1(X, int), //~ERROR `core::marker::Sized` is not implemented
+    V1(X, isize), //~ERROR `core::marker::Sized` is not implemented
 }
 enum F<X: ?Sized> {
-    V2{f1: X, f: int}, //~ERROR `core::marker::Sized` is not implemented
+    V2{f1: X, f: isize}, //~ERROR `core::marker::Sized` is not implemented
 }
 
 pub fn main() {
diff --git a/src/test/compile-fail/unsized6.rs b/src/test/compile-fail/unsized6.rs
index 02f3404b72b..2129f075a81 100644
--- a/src/test/compile-fail/unsized6.rs
+++ b/src/test/compile-fail/unsized6.rs
@@ -15,13 +15,13 @@ trait T {}
 
 fn f1<X: ?Sized>(x: &X) {
     let _: X; // <-- this is OK, no bindings created, no initializer.
-    let _: (int, (X, int)); // same
+    let _: (isize, (X, isize)); // same
     let y: X; //~ERROR the trait `core::marker::Sized` is not implemented
-    let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented
+    let y: (isize, (X, isize)); //~ERROR the trait `core::marker::Sized` is not implemented
 }
 fn f2<X: ?Sized + T>(x: &X) {
     let y: X; //~ERROR the trait `core::marker::Sized` is not implemented
-    let y: (int, (X, int)); //~ERROR the trait `core::marker::Sized` is not implemented
+    let y: (isize, (X, isize)); //~ERROR the trait `core::marker::Sized` is not implemented
 }
 
 fn f3<X: ?Sized>(x1: Box<X>, x2: Box<X>, x3: Box<X>) {
diff --git a/src/test/compile-fail/unused-attr.rs b/src/test/compile-fail/unused-attr.rs
index 786421c4ef9..635ceec73a3 100644
--- a/src/test/compile-fail/unused-attr.rs
+++ b/src/test/compile-fail/unused-attr.rs
@@ -44,7 +44,7 @@ fn bar(f: foo::Foo) {
 #[foo] //~ ERROR unused attribute
 struct Foo {
     #[foo] //~ ERROR unused attribute
-    a: int
+    a: isize
 }
 
 #[foo] //~ ERROR unused attribute
diff --git a/src/test/compile-fail/unused-result.rs b/src/test/compile-fail/unused-result.rs
index 1263d7c5710..6ed3b081c97 100644
--- a/src/test/compile-fail/unused-result.rs
+++ b/src/test/compile-fail/unused-result.rs
@@ -19,30 +19,30 @@ enum MustUseMsg { Test2 }
 
 fn foo<T>() -> T { panic!() }
 
-fn bar() -> int { return foo::<int>(); }
+fn bar() -> isize { return foo::<isize>(); }
 fn baz() -> MustUse { return foo::<MustUse>(); }
 fn qux() -> MustUseMsg { return foo::<MustUseMsg>(); }
 
 #[allow(unused_results)]
 fn test() {
-    foo::<int>();
+    foo::<isize>();
     foo::<MustUse>(); //~ ERROR: unused result which must be used
     foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message
 }
 
 #[allow(unused_results, unused_must_use)]
 fn test2() {
-    foo::<int>();
+    foo::<isize>();
     foo::<MustUse>();
     foo::<MustUseMsg>();
 }
 
 fn main() {
-    foo::<int>(); //~ ERROR: unused result
+    foo::<isize>(); //~ ERROR: unused result
     foo::<MustUse>(); //~ ERROR: unused result which must be used
     foo::<MustUseMsg>(); //~ ERROR: unused result which must be used: some message
 
-    let _ = foo::<int>();
+    let _ = foo::<isize>();
     let _ = foo::<MustUse>();
     let _ = foo::<MustUseMsg>();
 }
diff --git a/src/test/compile-fail/use-after-move-self-based-on-type.rs b/src/test/compile-fail/use-after-move-self-based-on-type.rs
index a1b7f83da2f..810fc68a0f4 100644
--- a/src/test/compile-fail/use-after-move-self-based-on-type.rs
+++ b/src/test/compile-fail/use-after-move-self-based-on-type.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 struct S {
-    x: int,
+    x: isize,
 }
 
 impl Drop for S {
@@ -17,7 +17,7 @@ impl Drop for S {
 }
 
 impl S {
-    pub fn foo(self) -> int {
+    pub fn foo(self) -> isize {
         self.bar();
         return self.x;  //~ ERROR use of moved value: `self.x`
     }
diff --git a/src/test/compile-fail/use-after-move-self.rs b/src/test/compile-fail/use-after-move-self.rs
index ce0f2808e33..e9ffb26aba5 100644
--- a/src/test/compile-fail/use-after-move-self.rs
+++ b/src/test/compile-fail/use-after-move-self.rs
@@ -11,11 +11,11 @@
 #![feature(box_syntax)]
 
 struct S {
-    x: Box<int>,
+    x: Box<isize>,
 }
 
 impl S {
-    pub fn foo(self) -> int {
+    pub fn foo(self) -> isize {
         self.bar();
         return *self.x;  //~ ERROR use of moved value: `*self.x`
     }
diff --git a/src/test/compile-fail/use-mod-3.rs b/src/test/compile-fail/use-mod-3.rs
index 040674fd6d9..bd954272fcc 100644
--- a/src/test/compile-fail/use-mod-3.rs
+++ b/src/test/compile-fail/use-mod-3.rs
@@ -17,7 +17,7 @@ use foo::bar::{
 };
 
 mod foo {
-    mod bar { pub type Bar = int; }
+    mod bar { pub type Bar = isize; }
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/useless-priv.rs b/src/test/compile-fail/useless-priv.rs
index bb39107463e..d8531f4543d 100644
--- a/src/test/compile-fail/useless-priv.rs
+++ b/src/test/compile-fail/useless-priv.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-struct A { pub i: int }
+struct A { pub i: isize }
 pub enum C { pub Variant }      //~ ERROR: unnecessary `pub`
 
 pub trait E {
diff --git a/src/test/compile-fail/variadic-ffi-1.rs b/src/test/compile-fail/variadic-ffi-1.rs
index 93f702d8052..34846ab496d 100644
--- a/src/test/compile-fail/variadic-ffi-1.rs
+++ b/src/test/compile-fail/variadic-ffi-1.rs
@@ -10,7 +10,7 @@
 
 extern {
     fn printf(...); //~ ERROR: variadic function must be declared with at least one named argument
-    fn printf(..., foo: int); //~ ERROR: `...` must be last in argument list for variadic function
+    fn printf(..., foo: isize); //~ ERROR: `...` must be last in argument list for variadic function
 }
 
 fn main() {}
diff --git a/src/test/compile-fail/variadic-ffi-3.rs b/src/test/compile-fail/variadic-ffi-3.rs
index f143e715450..331a4523934 100644
--- a/src/test/compile-fail/variadic-ffi-3.rs
+++ b/src/test/compile-fail/variadic-ffi-3.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-fn foo(x: int, ...) {
+fn foo(x: isize, ...) {
     //~^ ERROR: only foreign functions are allowed to be variadic
 }
 
diff --git a/src/test/compile-fail/variadic-ffi-4.rs b/src/test/compile-fail/variadic-ffi-4.rs
index d4c54dfffe0..62e985f44f7 100644
--- a/src/test/compile-fail/variadic-ffi-4.rs
+++ b/src/test/compile-fail/variadic-ffi-4.rs
@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-extern "C" fn foo(x: int, ...) {
+extern "C" fn foo(x: isize, ...) {
     //~^ ERROR: only foreign functions are allowed to be variadic
 }
 
diff --git a/src/test/compile-fail/variance-cell-is-invariant.rs b/src/test/compile-fail/variance-cell-is-invariant.rs
index 0efca74f3ce..b8a8f9ad91c 100644
--- a/src/test/compile-fail/variance-cell-is-invariant.rs
+++ b/src/test/compile-fail/variance-cell-is-invariant.rs
@@ -14,12 +14,12 @@
 use std::cell::Cell;
 
 struct Foo<'a> {
-    x: Cell<Option<&'a int>>,
+    x: Cell<Option<&'a isize>>,
 }
 
 fn use_<'short,'long>(c: Foo<'short>,
-                      s: &'short int,
-                      l: &'long int,
+                      s: &'short isize,
+                      l: &'long isize,
                       _where:Option<&'short &'long ()>) {
     let _: Foo<'long> = c; //~ ERROR mismatched types
 }
diff --git a/src/test/compile-fail/variance-regions-direct.rs b/src/test/compile-fail/variance-regions-direct.rs
index fa38482b21c..04389b67dba 100644
--- a/src/test/compile-fail/variance-regions-direct.rs
+++ b/src/test/compile-fail/variance-regions-direct.rs
@@ -15,8 +15,8 @@
 
 #[rustc_variance]
 struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]]
-    x: &'a int,
-    y: &'b [int],
+    x: &'a isize,
+    y: &'b [isize],
     c: &'c str
 }
 
@@ -24,8 +24,8 @@ struct Test2<'a, 'b, 'c> { //~ ERROR regions=[[-, -, -];[];[]]
 
 #[rustc_variance]
 struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]]
-    x: extern "Rust" fn(&'a int),
-    y: extern "Rust" fn(&'b [int]),
+    x: extern "Rust" fn(&'a isize),
+    y: extern "Rust" fn(&'b [isize]),
     c: extern "Rust" fn(&'c str),
 }
 
@@ -33,7 +33,7 @@ struct Test3<'a, 'b, 'c> { //~ ERROR regions=[[+, +, +];[];[]]
 
 #[rustc_variance]
 struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]]
-    x: &'a mut &'b int,
+    x: &'a mut &'b isize,
 }
 
 // Mutability induces invariance, even when in a
@@ -41,32 +41,32 @@ struct Test4<'a, 'b:'a> { //~ ERROR regions=[[-, o];[];[]]
 
 #[rustc_variance]
 struct Test5<'a, 'b> { //~ ERROR regions=[[+, o];[];[]]
-    x: extern "Rust" fn(&'a mut &'b int),
+    x: extern "Rust" fn(&'a mut &'b isize),
 }
 
 // Invariance is a trap from which NO ONE CAN ESCAPE.
-// In other words, even though the `&'b int` occurs in
+// In other words, even though the `&'b isize` occurs in
 // a argument list (which is contravariant), that
 // argument list occurs in an invariant context.
 
 #[rustc_variance]
 struct Test6<'a, 'b> { //~ ERROR regions=[[-, o];[];[]]
-    x: &'a mut extern "Rust" fn(&'b int),
+    x: &'a mut extern "Rust" fn(&'b isize),
 }
 
 // No uses at all is bivariant:
 
 #[rustc_variance]
 struct Test7<'a> { //~ ERROR regions=[[*];[];[]]
-    x: int
+    x: isize
 }
 
 // Try enums too.
 
 #[rustc_variance]
 enum Test8<'a, 'b, 'c:'b> { //~ ERROR regions=[[+, -, o];[];[]]
-    Test8A(extern "Rust" fn(&'a int)),
-    Test8B(&'b [int]),
+    Test8A(extern "Rust" fn(&'a isize)),
+    Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),
 }
 
diff --git a/src/test/compile-fail/variance-regions-indirect.rs b/src/test/compile-fail/variance-regions-indirect.rs
index c049fbc0fed..e2c7958b31d 100644
--- a/src/test/compile-fail/variance-regions-indirect.rs
+++ b/src/test/compile-fail/variance-regions-indirect.rs
@@ -14,8 +14,8 @@
 
 #[rustc_variance]
 enum Base<'a, 'b, 'c:'b, 'd> { //~ ERROR regions=[[+, -, o, *];[];[]]
-    Test8A(extern "Rust" fn(&'a int)),
-    Test8B(&'b [int]),
+    Test8A(extern "Rust" fn(&'a isize)),
+    Test8B(&'b [isize]),
     Test8C(&'b mut &'c str),
 }
 
diff --git a/src/test/compile-fail/variance-trait-matching.rs b/src/test/compile-fail/variance-trait-matching.rs
index 1644705222f..d4dab5f0ed0 100644
--- a/src/test/compile-fail/variance-trait-matching.rs
+++ b/src/test/compile-fail/variance-trait-matching.rs
@@ -11,18 +11,18 @@
 // Issue #5781. Tests that subtyping is handled properly in trait matching.
 
 trait Make<'a> {
-    fn make(x: &'a mut int) -> Self;
+    fn make(x: &'a mut isize) -> Self;
 }
 
-impl<'a> Make<'a> for &'a mut int {
-    fn make(x: &'a mut int) -> &'a mut int {
+impl<'a> Make<'a> for &'a mut isize {
+    fn make(x: &'a mut isize) -> &'a mut isize {
         x
     }
 }
 
-fn f() -> &'static mut int {
+fn f() -> &'static mut isize {
     let mut x = 1;
-    let y: &'static mut int = Make::make(&mut x);   //~ ERROR `x` does not live long enough
+    let y: &'static mut isize = Make::make(&mut x);   //~ ERROR `x` does not live long enough
     y
 }
 
diff --git a/src/test/compile-fail/vec-mut-iter-borrow.rs b/src/test/compile-fail/vec-mut-iter-borrow.rs
index c03956c42cb..b60d1799f77 100644
--- a/src/test/compile-fail/vec-mut-iter-borrow.rs
+++ b/src/test/compile-fail/vec-mut-iter-borrow.rs
@@ -9,7 +9,7 @@
 // except according to those terms.
 
 fn main() {
-    let mut xs: Vec<int> = vec!();
+    let mut xs: Vec<isize> = vec!();
 
     for x in xs.iter_mut() {
         xs.push(1i) //~ ERROR cannot borrow `xs`
diff --git a/src/test/compile-fail/vec-res-add.rs b/src/test/compile-fail/vec-res-add.rs
index dc166f9fd9d..97a684b2459 100644
--- a/src/test/compile-fail/vec-res-add.rs
+++ b/src/test/compile-fail/vec-res-add.rs
@@ -10,10 +10,10 @@
 
 #[derive(Show)]
 struct r {
-  i:int
+  i:isize
 }
 
-fn r(i:int) -> r { r { i: i } }
+fn r(i:isize) -> r { r { i: i } }
 
 impl Drop for r {
     fn drop(&mut self) {}
diff --git a/src/test/compile-fail/virtual-structs.rs b/src/test/compile-fail/virtual-structs.rs
index 69125bab2ce..3b3c7d5a30f 100644
--- a/src/test/compile-fail/virtual-structs.rs
+++ b/src/test/compile-fail/virtual-structs.rs
@@ -12,7 +12,7 @@
 #![feature(struct_inherit)]
 
 virtual struct SuperStruct { //~ ERROR `virtual` structs have been removed from the language
-    f1: int,
+    f1: isize,
 }
 
 struct Struct : SuperStruct; //~ ERROR `virtual` structs have been removed from the language
diff --git a/src/test/compile-fail/vtable-res-trait-param.rs b/src/test/compile-fail/vtable-res-trait-param.rs
index 12cfe9c20fa..32a6c65b133 100644
--- a/src/test/compile-fail/vtable-res-trait-param.rs
+++ b/src/test/compile-fail/vtable-res-trait-param.rs
@@ -9,20 +9,20 @@
 // except according to those terms.
 
 trait TraitA {
-    fn method_a(&self) -> int;
+    fn method_a(&self) -> isize;
 }
 
 trait TraitB {
-    fn gimme_an_a<A:TraitA>(&self, a: A) -> int;
+    fn gimme_an_a<A:TraitA>(&self, a: A) -> isize;
 }
 
-impl TraitB for int {
-    fn gimme_an_a<A:TraitA>(&self, a: A) -> int {
+impl TraitB for isize {
+    fn gimme_an_a<A:TraitA>(&self, a: A) -> isize {
         a.method_a() + *self
     }
 }
 
-fn call_it<B:TraitB>(b: B)  -> int {
+fn call_it<B:TraitB>(b: B)  -> isize {
     let y = 4u;
     b.gimme_an_a(y) //~ ERROR the trait `TraitA` is not implemented
 }
diff --git a/src/test/compile-fail/walk-struct-literal-with.rs b/src/test/compile-fail/walk-struct-literal-with.rs
index bb3b310a68f..0f3754e09e4 100644
--- a/src/test/compile-fail/walk-struct-literal-with.rs
+++ b/src/test/compile-fail/walk-struct-literal-with.rs
@@ -10,7 +10,7 @@
 
 struct Mine{
     test: String,
-    other_val: int
+    other_val: isize
 }
 
 impl Mine{
diff --git a/src/test/compile-fail/where-clause-method-substituion.rs b/src/test/compile-fail/where-clause-method-substituion.rs
index 40d2df45488..a5108f005dc 100644
--- a/src/test/compile-fail/where-clause-method-substituion.rs
+++ b/src/test/compile-fail/where-clause-method-substituion.rs
@@ -19,7 +19,7 @@ struct X;
 
 // Remove this impl causing the below resolution to fail // impl Foo<S> for X {}
 
-impl Bar<X> for int {
+impl Bar<X> for isize {
     fn method<U>(&self) where X: Foo<U> {
     }
 }
diff --git a/src/test/compile-fail/where-clauses-not-parameter.rs b/src/test/compile-fail/where-clauses-not-parameter.rs
index d8af859c081..65205cc72ee 100644
--- a/src/test/compile-fail/where-clauses-not-parameter.rs
+++ b/src/test/compile-fail/where-clauses-not-parameter.rs
@@ -35,7 +35,7 @@ trait Baz<T> where isize : Eq {
     //~^ ERROR cannot bound type `isize`, where clause
 }
 
-impl Baz<int> for int where isize : Eq {
+impl Baz<isize> for isize where isize : Eq {
     //~^ ERROR cannot bound type `isize`, where clause bounds
     fn baz() where String : Eq {}
 }
diff --git a/src/test/compile-fail/writing-to-immutable-vec.rs b/src/test/compile-fail/writing-to-immutable-vec.rs
index 4e9f1545f3a..09c9439b464 100644
--- a/src/test/compile-fail/writing-to-immutable-vec.rs
+++ b/src/test/compile-fail/writing-to-immutable-vec.rs
@@ -10,6 +10,6 @@
 
 
 fn main() {
-    let v: Vec<int> = vec!(1, 2, 3);
+    let v: Vec<isize> = vec!(1, 2, 3);
     v[1] = 4; //~ ERROR cannot borrow immutable local variable `v` as mutable
 }
diff --git a/src/test/compile-fail/wrong-ret-type.rs b/src/test/compile-fail/wrong-ret-type.rs
index ba3f3df7990..d744ad804e7 100644
--- a/src/test/compile-fail/wrong-ret-type.rs
+++ b/src/test/compile-fail/wrong-ret-type.rs
@@ -9,5 +9,5 @@
 // except according to those terms.
 
 // error-pattern: mismatched types
-fn mk_int() -> uint { let i: int = 3; return i; }
+fn mk_int() -> uint { let i: isize = 3; return i; }
 fn main() { }