Mass rename uint/int to usize/isize

Now that support has been removed, all lingering use cases are renamed.

41 files changed, 128 insertions, 127 deletions

diff --git a/src/test/debuginfo/basic-types-globals-metadata.rs b/src/test/debuginfo/basic-types-globals-metadata.rs
index 30a70fe0b37..2c44afa4b8a 100644
--- a/src/test/debuginfo/basic-types-globals-metadata.rs
+++ b/src/test/debuginfo/basic-types-globals-metadata.rs
@@ -48,13 +48,13 @@
 
 // N.B. These are `mut` only so they don't constant fold away.
 static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
 static mut C: char = 'a';
 static mut I8: i8 = 68;
 static mut I16: i16 = -16;
 static mut I32: i32 = -32;
 static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
 static mut U8: u8 = 100;
 static mut U16: u16 = 16;
 static mut U32: u32 = 32;
diff --git a/src/test/debuginfo/basic-types-globals.rs b/src/test/debuginfo/basic-types-globals.rs
index cb89879481b..745beab17be 100644
--- a/src/test/debuginfo/basic-types-globals.rs
+++ b/src/test/debuginfo/basic-types-globals.rs
@@ -53,13 +53,13 @@
 
 // N.B. These are `mut` only so they don't constant fold away.
 static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
 static mut C: char = 'a';
 static mut I8: i8 = 68;
 static mut I16: i16 = -16;
 static mut I32: i32 = -32;
 static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
 static mut U8: u8 = 100;
 static mut U16: u16 = 16;
 static mut U32: u32 = 32;
diff --git a/src/test/debuginfo/basic-types-mut-globals.rs b/src/test/debuginfo/basic-types-mut-globals.rs
index 7f82878e080..6540f268220 100644
--- a/src/test/debuginfo/basic-types-mut-globals.rs
+++ b/src/test/debuginfo/basic-types-mut-globals.rs
@@ -85,13 +85,13 @@
 #![omit_gdb_pretty_printer_section]
 
 static mut B: bool = false;
-static mut I: int = -1;
+static mut I: isize = -1;
 static mut C: char = 'a';
 static mut I8: i8 = 68;
 static mut I16: i16 = -16;
 static mut I32: i32 = -32;
 static mut I64: i64 = -64;
-static mut U: uint = 1;
+static mut U: usize = 1;
 static mut U8: u8 = 100;
 static mut U16: u16 = 16;
 static mut U32: u32 = 32;
diff --git a/src/test/debuginfo/basic-types.rs b/src/test/debuginfo/basic-types.rs
index 95483c16783..c9144b18b2f 100644
--- a/src/test/debuginfo/basic-types.rs
+++ b/src/test/debuginfo/basic-types.rs
@@ -60,7 +60,7 @@
 // lldb-check:[...]$1 = -1
 
 // NOTE: LLDB does not support 32bit chars
-// d ebugger:print (uint)(c)
+// d ebugger:print (usize)(c)
 // c heck:$3 = 97
 
 // lldb-command:print i8
@@ -91,13 +91,13 @@
 
 fn main() {
     let b: bool = false;
-    let i: int = -1;
+    let i: isize = -1;
     let c: char = 'a';
     let i8: i8 = 68;
     let i16: i16 = -16;
     let i32: i32 = -32;
     let i64: i64 = -64;
-    let u: uint = 1;
+    let u: usize = 1;
     let u8: u8 = 100;
     let u16: u16 = 16;
     let u32: u32 = 32;
diff --git a/src/test/debuginfo/borrowed-basic.rs b/src/test/debuginfo/borrowed-basic.rs
index 52e81b7e046..b0f06bb8a75 100644
--- a/src/test/debuginfo/borrowed-basic.rs
+++ b/src/test/debuginfo/borrowed-basic.rs
@@ -114,8 +114,8 @@ fn main() {
     let bool_val: bool = true;
     let bool_ref: &bool = &bool_val;
 
-    let int_val: int = -1;
-    let int_ref: &int = &int_val;
+    let int_val: isize = -1;
+    let int_ref: &isize = &int_val;
 
     let char_val: char = 'a';
     let char_ref: &char = &char_val;
@@ -132,8 +132,8 @@ fn main() {
     let i64_val: i64 = -64;
     let i64_ref: &i64 = &i64_val;
 
-    let uint_val: uint = 1;
-    let uint_ref: &uint = &uint_val;
+    let uint_val: usize = 1;
+    let uint_ref: &usize = &uint_val;
 
     let u8_val: u8 = 100;
     let u8_ref: &u8 = &u8_val;
diff --git a/src/test/debuginfo/borrowed-struct.rs b/src/test/debuginfo/borrowed-struct.rs
index 4430ea9380d..70c24fc2ab0 100644
--- a/src/test/debuginfo/borrowed-struct.rs
+++ b/src/test/debuginfo/borrowed-struct.rs
@@ -67,20 +67,20 @@
 #![omit_gdb_pretty_printer_section]
 
 struct SomeStruct {
-    x: int,
+    x: isize,
     y: f64
 }
 
 fn main() {
     let stack_val: SomeStruct = SomeStruct { x: 10, y: 23.5 };
     let stack_val_ref: &SomeStruct = &stack_val;
-    let stack_val_interior_ref_1: &int = &stack_val.x;
+    let stack_val_interior_ref_1: &isize = &stack_val.x;
     let stack_val_interior_ref_2: &f64 = &stack_val.y;
     let ref_to_unnamed: &SomeStruct = &SomeStruct { x: 11, y: 24.5 };
 
     let unique_val: Box<_> = box SomeStruct { x: 13, y: 26.5 };
     let unique_val_ref: &SomeStruct = &*unique_val;
-    let unique_val_interior_ref_1: &int = &unique_val.x;
+    let unique_val_interior_ref_1: &isize = &unique_val.x;
     let unique_val_interior_ref_2: &f64 = &unique_val.y;
 
     zzz(); // #break
diff --git a/src/test/debuginfo/borrowed-unique-basic.rs b/src/test/debuginfo/borrowed-unique-basic.rs
index 14a3d008f42..d8ce3af4789 100644
--- a/src/test/debuginfo/borrowed-unique-basic.rs
+++ b/src/test/debuginfo/borrowed-unique-basic.rs
@@ -118,8 +118,8 @@ fn main() {
     let bool_box: Box<bool> = box true;
     let bool_ref: &bool = &*bool_box;
 
-    let int_box: Box<int> = box -1;
-    let int_ref: &int = &*int_box;
+    let int_box: Box<isize> = box -1;
+    let int_ref: &isize = &*int_box;
 
     let char_box: Box<char> = box 'a';
     let char_ref: &char = &*char_box;
@@ -136,8 +136,8 @@ fn main() {
     let i64_box: Box<i64> = box -64;
     let i64_ref: &i64 = &*i64_box;
 
-    let uint_box: Box<uint> = box 1;
-    let uint_ref: &uint = &*uint_box;
+    let uint_box: Box<usize> = box 1;
+    let uint_ref: &usize = &*uint_box;
 
     let u8_box: Box<u8> = box 100;
     let u8_ref: &u8 = &*u8_box;
diff --git a/src/test/debuginfo/by-value-non-immediate-argument.rs b/src/test/debuginfo/by-value-non-immediate-argument.rs
index 3efda1e2f6a..bc1116b0641 100644
--- a/src/test/debuginfo/by-value-non-immediate-argument.rs
+++ b/src/test/debuginfo/by-value-non-immediate-argument.rs
@@ -74,7 +74,7 @@
 
 #[derive(Clone)]
 struct Struct {
-    a: int,
+    a: isize,
     b: f64
 }
 
@@ -92,11 +92,11 @@ fn fun_fun(StructStruct { a: x, b: Struct { a: y, b: z } }: StructStruct) {
     zzz(); // #break
 }
 
-fn tup(a: (int, uint, f64, f64)) {
+fn tup(a: (isize, usize, f64, f64)) {
     zzz(); // #break
 }
 
-struct Newtype(f64, f64, int, uint);
+struct Newtype(f64, f64, isize, usize);
 
 fn new_type(a: Newtype) {
     zzz(); // #break
diff --git a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
index 2b2a9bf83f1..5bd872f9faf 100644
--- a/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
+++ b/src/test/debuginfo/by-value-self-argument-in-trait-impl.rs
@@ -51,16 +51,16 @@ trait Trait {
     fn method(self) -> Self;
 }
 
-impl Trait for int {
-    fn method(self) -> int {
+impl Trait for isize {
+    fn method(self) -> isize {
         zzz(); // #break
         self
     }
 }
 
 struct Struct {
-    x: uint,
-    y: uint,
+    x: usize,
+    y: usize,
 }
 
 impl Trait for Struct {
@@ -70,15 +70,15 @@ impl Trait for Struct {
     }
 }
 
-impl Trait for (f64, int, int, f64) {
-    fn method(self) -> (f64, int, int, f64) {
+impl Trait for (f64, isize, isize, f64) {
+    fn method(self) -> (f64, isize, isize, f64) {
         zzz(); // #break
         self
     }
 }
 
 fn main() {
-    let _ = (1111 as int).method();
+    let _ = (1111 as isize).method();
     let _ = Struct { x: 2222, y: 3333 }.method();
     let _ = (4444.5, 5555, 6666, 7777.5).method();
 }
diff --git a/src/test/debuginfo/destructured-fn-argument.rs b/src/test/debuginfo/destructured-fn-argument.rs
index 51cced20439..d7ec5673258 100644
--- a/src/test/debuginfo/destructured-fn-argument.rs
+++ b/src/test/debuginfo/destructured-fn-argument.rs
@@ -325,18 +325,18 @@ enum Univariant {
     Unit(i32)
 }
 
-struct TupleStruct (f64, int);
+struct TupleStruct (f64, isize);
 
 
-fn simple_tuple((a, b): (int, bool)) {
+fn simple_tuple((a, b): (isize, bool)) {
     zzz(); // #break
 }
 
-fn nested_tuple((a, (b, c)): (int, (u16, u16))) {
+fn nested_tuple((a, (b, c)): (isize, (u16, u16))) {
     zzz(); // #break
 }
 
-fn destructure_only_first_level((a, b): (int, (u32, u32))) {
+fn destructure_only_first_level((a, b): (isize, (u32, u32))) {
     zzz(); // #break
 }
 
@@ -348,7 +348,7 @@ fn struct_pattern(Struct { a: k, b: l }: Struct) {
     zzz(); // #break
 }
 
-fn ignored_tuple_element((m, _, n): (int, u16, i32)) {
+fn ignored_tuple_element((m, _, n): (isize, u16, i32)) {
     zzz(); // #break
 }
 
@@ -370,27 +370,27 @@ fn complex_nesting(((u,   v  ), ((w,   (x,   Struct { a: y, b: z})), Struct { a:
     zzz(); // #break
 }
 
-fn managed_box(&aa: &(int, int)) {
+fn managed_box(&aa: &(isize, isize)) {
     zzz(); // #break
 }
 
-fn borrowed_pointer(&bb: &(int, int)) {
+fn borrowed_pointer(&bb: &(isize, isize)) {
     zzz(); // #break
 }
 
-fn contained_borrowed_pointer((&cc, _): (&int, int)) {
+fn contained_borrowed_pointer((&cc, _): (&isize, isize)) {
     zzz(); // #break
 }
 
-fn unique_pointer(box dd: Box<(int, int, int)>) {
+fn unique_pointer(box dd: Box<(isize, isize, isize)>) {
     zzz(); // #break
 }
 
-fn ref_binding(ref ee: (int, int, int)) {
+fn ref_binding(ref ee: (isize, isize, isize)) {
     zzz(); // #break
 }
 
-fn ref_binding_in_tuple((ref ff, gg): (int, (int, int))) {
+fn ref_binding_in_tuple((ref ff, gg): (isize, (isize, isize))) {
     zzz(); // #break
 }
 
@@ -414,7 +414,7 @@ fn tuple_struct_with_ref_binding(TupleStruct(mm, ref nn): TupleStruct) {
     zzz(); // #break
 }
 
-fn multiple_arguments((oo, pp): (int, int), qq : int) {
+fn multiple_arguments((oo, pp): (isize, isize), qq : isize) {
     zzz(); // #break
 }
 
@@ -442,7 +442,7 @@ fn main() {
     tuple_struct_with_ref_binding(TupleStruct(55.0, 56));
     multiple_arguments((57, 58), 59);
 
-    fn nested_function(rr: int, (ss, tt): (int, int)) {
+    fn nested_function(rr: isize, (ss, tt): (isize, isize)) {
         zzz(); // #break
     }
 
diff --git a/src/test/debuginfo/destructured-local.rs b/src/test/debuginfo/destructured-local.rs
index cf0ca0b67a7..4b1c57e0afb 100644
--- a/src/test/debuginfo/destructured-local.rs
+++ b/src/test/debuginfo/destructured-local.rs
@@ -258,18 +258,18 @@ enum Univariant {
     Unit(i32)
 }
 
-struct TupleStruct (f64, int);
+struct TupleStruct (f64, isize);
 
 
 fn main() {
     // simple tuple
-    let (a, b) : (int, bool) = (1, false);
+    let (a, b) : (isize, bool) = (1, false);
 
     // nested tuple
-    let (c, (d, e)) : (int, (u16, u16)) = (2, (3, 4));
+    let (c, (d, e)) : (isize, (u16, u16)) = (2, (3, 4));
 
     // bind tuple-typed value to one name (destructure only first level)
-    let (f, g) : (int, (u32, u32)) = (5, (6, 7));
+    let (f, g) : (isize, (u32, u32)) = (5, (6, 7));
 
     // struct as tuple element
     let (h, i, j) : (i16, Struct, i16) = (8, Struct { a: 9, b: 10 }, 11);
diff --git a/src/test/debuginfo/function-arg-initialization.rs b/src/test/debuginfo/function-arg-initialization.rs
index c161600f2c3..d611e4a65a6 100644
--- a/src/test/debuginfo/function-arg-initialization.rs
+++ b/src/test/debuginfo/function-arg-initialization.rs
@@ -226,7 +226,7 @@
 #![allow(unused_variables)]
 #![omit_gdb_pretty_printer_section]
 
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
     ::std::old_io::print("") // #break
 }
 
diff --git a/src/test/debuginfo/function-arguments.rs b/src/test/debuginfo/function-arguments.rs
index 2ab3668abb9..21c2cc09a9f 100644
--- a/src/test/debuginfo/function-arguments.rs
+++ b/src/test/debuginfo/function-arguments.rs
@@ -58,7 +58,7 @@ fn main() {
     }
 }
 
-fn fun(x: int, y: bool) -> (int, bool) {
+fn fun(x: isize, y: bool) -> (isize, bool) {
     zzz(); // #break
 
     (x, y)
diff --git a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
index 99e31ab2302..0608e49b28c 100644
--- a/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
+++ b/src/test/debuginfo/function-prologue-stepping-no-stack-check.rs
@@ -250,7 +250,7 @@
 #![omit_gdb_pretty_printer_section]
 
 #[no_stack_check]
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
     ::std::old_io::print("");
 }
 
diff --git a/src/test/debuginfo/function-prologue-stepping-regular.rs b/src/test/debuginfo/function-prologue-stepping-regular.rs
index 8312d16bcac..e1a77b34e7f 100644
--- a/src/test/debuginfo/function-prologue-stepping-regular.rs
+++ b/src/test/debuginfo/function-prologue-stepping-regular.rs
@@ -129,7 +129,7 @@
 #![feature(old_io)]
 #![omit_gdb_pretty_printer_section]
 
-fn immediate_args(a: int, b: bool, c: f64) {
+fn immediate_args(a: isize, b: bool, c: f64) {
     ()
 }
 
diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs
index aa902a9b2d4..aa6051d7922 100644
--- a/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs
+++ b/src/test/debuginfo/gdb-pretty-struct-and-enums-pre-gdb-7-7.rs
@@ -37,7 +37,7 @@
 // gdb-check:$5 = CStyleEnumVar3
 
 struct RegularStruct {
-    the_first_field: int,
+    the_first_field: isize,
     the_second_field: f64,
     the_third_field: bool,
 }
diff --git a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs
index d47dee14f55..81af9c213a3 100644
--- a/src/test/debuginfo/gdb-pretty-struct-and-enums.rs
+++ b/src/test/debuginfo/gdb-pretty-struct-and-enums.rs
@@ -81,7 +81,7 @@ use self::MixedEnum::{MixedEnumCStyleVar, MixedEnumTupleVar, MixedEnumStructVar}
 use self::NestedEnum::{NestedVariant1, NestedVariant2};
 
 struct RegularStruct {
-    the_first_field: int,
+    the_first_field: isize,
     the_second_field: f64,
     the_third_field: bool,
     the_fourth_field: &'static str,
@@ -140,7 +140,7 @@ fn main() {
     let mixed_enum_struct_var = MixedEnumStructVar { field1: 108.5, field2: 109 };
 
     let some = Some(110_usize);
-    let none: Option<int> = None;
+    let none: Option<isize> = None;
     let some_fat = Some("abc");
     let none_fat: Option<&'static str> = None;
 
@@ -177,7 +177,7 @@ fn main() {
         }
     };
 
-    let none_check1: Option<(uint, Vec<uint>)> = None;
+    let none_check1: Option<(usize, Vec<usize>)> = None;
     let none_check2: Option<String> = None;
 
     zzz(); // #break
diff --git a/src/test/debuginfo/generic-function.rs b/src/test/debuginfo/generic-function.rs
index 76b7a3e729d..1748083b2ba 100644
--- a/src/test/debuginfo/generic-function.rs
+++ b/src/test/debuginfo/generic-function.rs
@@ -73,7 +73,7 @@
 
 #[derive(Clone)]
 struct Struct {
-    a: int,
+    a: isize,
     b: f64
 }
 
diff --git a/src/test/debuginfo/generic-method-on-generic-struct.rs b/src/test/debuginfo/generic-method-on-generic-struct.rs
index 07b6d745544..06053965ca7 100644
--- a/src/test/debuginfo/generic-method-on-generic-struct.rs
+++ b/src/test/debuginfo/generic-method-on-generic-struct.rs
@@ -121,17 +121,17 @@ struct Struct<T> {
 
 impl<T1> Struct<T1> {
 
-    fn self_by_ref<T2>(&self, arg1: int, arg2: T2) -> int {
+    fn self_by_ref<T2>(&self, arg1: isize, arg2: T2) -> isize {
         zzz(); // #break
         arg1
     }
 
-    fn self_by_val<T2>(self, arg1: int, arg2: T2) -> int {
+    fn self_by_val<T2>(self, arg1: isize, arg2: T2) -> isize {
         zzz(); // #break
         arg1
     }
 
-    fn self_owned<T2>(self: Box<Struct<T1>>, arg1: int, arg2: T2) -> int {
+    fn self_owned<T2>(self: Box<Struct<T1>>, arg1: isize, arg2: T2) -> isize {
         zzz(); // #break
         arg1
     }
diff --git a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
index eb1083f624f..f24b221ccec 100644
--- a/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
+++ b/src/test/debuginfo/generic-static-method-on-struct-and-enum.rs
@@ -34,26 +34,26 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    x: int
+    x: isize
 }
 
 impl Struct {
 
-    fn static_method<T1, T2>(arg1: T1, arg2: T2) -> int {
+    fn static_method<T1, T2>(arg1: T1, arg2: T2) -> isize {
         zzz(); // #break
         return 0;
     }
 }
 
 enum Enum {
-    Variant1 { x: int },
+    Variant1 { x: isize },
     Variant2,
-    Variant3(f64, int, char),
+    Variant3(f64, isize, char),
 }
 
 impl Enum {
 
-    fn static_method<T1, T2, T3>(arg1: T1, arg2: T2, arg3: T3) -> int {
+    fn static_method<T1, T2, T3>(arg1: T1, arg2: T2, arg3: T3) -> isize {
         zzz(); // #break
         return 1;
     }
diff --git a/src/test/debuginfo/generic-trait-generic-static-default-method.rs b/src/test/debuginfo/generic-trait-generic-static-default-method.rs
index 4382861fd20..45da87a5674 100644
--- a/src/test/debuginfo/generic-trait-generic-static-default-method.rs
+++ b/src/test/debuginfo/generic-trait-generic-static-default-method.rs
@@ -28,11 +28,11 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    x: int
+    x: isize
 }
 
 trait Trait<T1> {
-    fn generic_static_default_method<T2>(arg1: int, arg2: &(T1, T2)) -> int {
+    fn generic_static_default_method<T2>(arg1: isize, arg2: &(T1, T2)) -> isize {
         zzz(); // #break
         arg1
     }
@@ -43,8 +43,9 @@ impl<T> Trait<T> for Struct {}
 fn main() {
 
     // Is this really how to use these?
-    Trait::generic_static_default_method::<int, Struct, float>(1000, &(1, 2.5));
-    Trait::generic_static_default_method::<float, Struct, (int, int, int)>(2000, &(3.5, (4, 5, 6)));
+    Trait::generic_static_default_method::<isize, Struct, float>(1000, &(1, 2.5));
+    Trait::generic_static_default_method::<float, Struct, (isize, isize, isize)>(2000,
+            &(3.5, (4, 5, 6)));
 
 }
 
diff --git a/src/test/debuginfo/issue12886.rs b/src/test/debuginfo/issue12886.rs
index 424ba50e3c9..2268f07438f 100644
--- a/src/test/debuginfo/issue12886.rs
+++ b/src/test/debuginfo/issue12886.rs
@@ -28,7 +28,7 @@
 // contained in the output, after calling `next` just once, we can be sure that we did not stop in
 // unwrap(). (The testing framework doesn't allow for checking that some text is *not* contained in
 // the output, which is why we have to make the test in this kind of roundabout way)
-fn bar() -> int {
+fn bar() -> isize {
     let s = Some(5).unwrap(); // #break
     s
 }
diff --git a/src/test/debuginfo/lexical-scope-in-match.rs b/src/test/debuginfo/lexical-scope-in-match.rs
index c2cddd25768..228799848c6 100644
--- a/src/test/debuginfo/lexical-scope-in-match.rs
+++ b/src/test/debuginfo/lexical-scope-in-match.rs
@@ -128,8 +128,8 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    x: int,
-    y: int
+    x: isize,
+    y: isize
 }
 
 fn main() {
diff --git a/src/test/debuginfo/lexical-scope-in-stack-closure.rs b/src/test/debuginfo/lexical-scope-in-stack-closure.rs
index 6a909ced818..c0b65fbb22b 100644
--- a/src/test/debuginfo/lexical-scope-in-stack-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-stack-closure.rs
@@ -78,7 +78,7 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let closure = |x: int| {
+    let closure = |x: isize| {
         zzz(); // #break
         sentinel();
 
diff --git a/src/test/debuginfo/lexical-scope-in-unique-closure.rs b/src/test/debuginfo/lexical-scope-in-unique-closure.rs
index c0a5a31c9ce..5bae2aa7ae2 100644
--- a/src/test/debuginfo/lexical-scope-in-unique-closure.rs
+++ b/src/test/debuginfo/lexical-scope-in-unique-closure.rs
@@ -79,7 +79,7 @@ fn main() {
     zzz(); // #break
     sentinel();
 
-    let unique_closure = |x:int| {
+    let unique_closure = |x:isize| {
         zzz(); // #break
         sentinel();
 
diff --git a/src/test/debuginfo/lexical-scopes-in-block-expression.rs b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
index c1ec837a4b8..63e2402c65d 100644
--- a/src/test/debuginfo/lexical-scopes-in-block-expression.rs
+++ b/src/test/debuginfo/lexical-scopes-in-block-expression.rs
@@ -350,14 +350,14 @@
 #![allow(unused_assignments)]
 #![omit_gdb_pretty_printer_section]
 
-static mut MUT_INT: int = 0;
+static mut MUT_INT: isize = 0;
 
 struct Point {
-    x: int,
-    y: int
+    x: isize,
+    y: isize
 }
 
-fn a_function(x: int) -> int {
+fn a_function(x: isize) -> isize {
     x + 1
 }
 
@@ -502,7 +502,7 @@ fn main() {
         zzz(); // #break
         sentinel();
 
-        val as uint
+        val as usize
     }];
 
     zzz(); // #break
diff --git a/src/test/debuginfo/limited-debuginfo.rs b/src/test/debuginfo/limited-debuginfo.rs
index c140390604b..ea7d150164d 100644
--- a/src/test/debuginfo/limited-debuginfo.rs
+++ b/src/test/debuginfo/limited-debuginfo.rs
@@ -44,7 +44,7 @@ fn main() {
 
 fn zzz() {()}
 
-fn some_function(a: int, b: int) {
+fn some_function(a: isize, b: isize) {
     let some_variable = Struct { a: 11, b: 22 };
     let some_other_variable = 23;
 
@@ -53,4 +53,4 @@ fn some_function(a: int, b: int) {
     }
 }
 
-fn some_other_function(a: int, b: int) -> bool { true }
+fn some_other_function(a: isize, b: isize) -> bool { true }
diff --git a/src/test/debuginfo/method-on-enum.rs b/src/test/debuginfo/method-on-enum.rs
index 7172a880f4c..314ec472b69 100644
--- a/src/test/debuginfo/method-on-enum.rs
+++ b/src/test/debuginfo/method-on-enum.rs
@@ -123,17 +123,17 @@ enum Enum {
 
 impl Enum {
 
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_owned(self: Box<Enum>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<Enum>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
diff --git a/src/test/debuginfo/method-on-generic-struct.rs b/src/test/debuginfo/method-on-generic-struct.rs
index bf6635f833f..564c2d26493 100644
--- a/src/test/debuginfo/method-on-generic-struct.rs
+++ b/src/test/debuginfo/method-on-generic-struct.rs
@@ -122,17 +122,17 @@ struct Struct<T> {
 
 impl<T> Struct<T> {
 
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_owned(self: Box<Struct<T>>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<Struct<T>>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
diff --git a/src/test/debuginfo/method-on-struct.rs b/src/test/debuginfo/method-on-struct.rs
index 54779e00708..eba4370e698 100644
--- a/src/test/debuginfo/method-on-struct.rs
+++ b/src/test/debuginfo/method-on-struct.rs
@@ -117,22 +117,22 @@
 
 #[derive(Copy)]
 struct Struct {
-    x: int
+    x: isize
 }
 
 impl Struct {
 
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
 
-    fn self_owned(self: Box<Struct>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<Struct>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
diff --git a/src/test/debuginfo/method-on-trait.rs b/src/test/debuginfo/method-on-trait.rs
index 7954bcae1b2..6df7cdfd47f 100644
--- a/src/test/debuginfo/method-on-trait.rs
+++ b/src/test/debuginfo/method-on-trait.rs
@@ -117,28 +117,28 @@
 
 #[derive(Copy)]
 struct Struct {
-    x: int
+    x: isize
 }
 
 trait Trait {
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int;
-    fn self_by_val(self, arg1: int, arg2: int) -> int;
-    fn self_owned(self: Box<Self>, arg1: int, arg2: int) -> int;
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize;
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize;
+    fn self_owned(self: Box<Self>, arg1: isize, arg2: isize) -> isize;
 }
 
 impl Trait for Struct {
 
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
 
-    fn self_owned(self: Box<Struct>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<Struct>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         self.x + arg1 + arg2
     }
diff --git a/src/test/debuginfo/method-on-tuple-struct.rs b/src/test/debuginfo/method-on-tuple-struct.rs
index af128706650..b638e210dd3 100644
--- a/src/test/debuginfo/method-on-tuple-struct.rs
+++ b/src/test/debuginfo/method-on-tuple-struct.rs
@@ -116,21 +116,21 @@
 #![omit_gdb_pretty_printer_section]
 
 #[derive(Copy)]
-struct TupleStruct(int, f64);
+struct TupleStruct(isize, f64);
 
 impl TupleStruct {
 
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_owned(self: Box<TupleStruct>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<TupleStruct>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
diff --git a/src/test/debuginfo/recursive-struct.rs b/src/test/debuginfo/recursive-struct.rs
index fe262a7ea8d..4772ee10ff7 100644
--- a/src/test/debuginfo/recursive-struct.rs
+++ b/src/test/debuginfo/recursive-struct.rs
@@ -105,7 +105,7 @@ struct LongCycle4<T> {
 
 struct LongCycleWithAnonymousTypes {
     next: Opt<Box<Box<Box<Box<Box<LongCycleWithAnonymousTypes>>>>>>,
-    value: uint,
+    value: usize,
 }
 
 // This test case makes sure that recursive structs are properly described. The Node structs are
diff --git a/src/test/debuginfo/self-in-default-method.rs b/src/test/debuginfo/self-in-default-method.rs
index 008eeda92d0..f61b78d5449 100644
--- a/src/test/debuginfo/self-in-default-method.rs
+++ b/src/test/debuginfo/self-in-default-method.rs
@@ -116,21 +116,21 @@
 
 #[derive(Copy)]
 struct Struct {
-    x: int
+    x: isize
 }
 
 trait Trait : Sized {
-    fn self_by_ref(&self, arg1: int, arg2: int) -> int {
+    fn self_by_ref(&self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_by_val(self, arg1: int, arg2: int) -> int {
+    fn self_by_val(self, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 
-    fn self_owned(self: Box<Self>, arg1: int, arg2: int) -> int {
+    fn self_owned(self: Box<Self>, arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
diff --git a/src/test/debuginfo/self-in-generic-default-method.rs b/src/test/debuginfo/self-in-generic-default-method.rs
index 94e5f6f6c10..4ac436c9325 100644
--- a/src/test/debuginfo/self-in-generic-default-method.rs
+++ b/src/test/debuginfo/self-in-generic-default-method.rs
@@ -116,22 +116,22 @@
 
 #[derive(Copy)]
 struct Struct {
-    x: int
+    x: isize
 }
 
 trait Trait : Sized {
 
-    fn self_by_ref<T>(&self, arg1: int, arg2: T) -> int {
+    fn self_by_ref<T>(&self, arg1: isize, arg2: T) -> isize {
         zzz(); // #break
         arg1
     }
 
-    fn self_by_val<T>(self, arg1: int, arg2: T) -> int {
+    fn self_by_val<T>(self, arg1: isize, arg2: T) -> isize {
         zzz(); // #break
         arg1
     }
 
-    fn self_owned<T>(self: Box<Self>, arg1: int, arg2: T) -> int {
+    fn self_owned<T>(self: Box<Self>, arg1: isize, arg2: T) -> isize {
         zzz(); // #break
         arg1
     }
diff --git a/src/test/debuginfo/static-method-on-struct-and-enum.rs b/src/test/debuginfo/static-method-on-struct-and-enum.rs
index 48db69289c0..59fe96f9958 100644
--- a/src/test/debuginfo/static-method-on-struct-and-enum.rs
+++ b/src/test/debuginfo/static-method-on-struct-and-enum.rs
@@ -56,26 +56,26 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    x: int
+    x: isize
 }
 
 impl Struct {
 
-    fn static_method(arg1: int, arg2: int) -> int {
+    fn static_method(arg1: isize, arg2: isize) -> isize {
         zzz(); // #break
         arg1 + arg2
     }
 }
 
 enum Enum {
-    Variant1 { x: int },
+    Variant1 { x: isize },
     Variant2,
-    Variant3(f64, int, char),
+    Variant3(f64, isize, char),
 }
 
 impl Enum {
 
-    fn static_method(arg1: int, arg2: f64, arg3: uint) -> int {
+    fn static_method(arg1: isize, arg2: f64, arg3: usize) -> isize {
         zzz(); // #break
         arg1
     }
diff --git a/src/test/debuginfo/trait-generic-static-default-method.rs b/src/test/debuginfo/trait-generic-static-default-method.rs
index 2ecafb02ae5..d066af53e35 100644
--- a/src/test/debuginfo/trait-generic-static-default-method.rs
+++ b/src/test/debuginfo/trait-generic-static-default-method.rs
@@ -48,11 +48,11 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    x: int
+    x: isize
 }
 
 trait Trait {
-    fn generic_static_default_method<T>(arg1: int, arg2: T) -> int {
+    fn generic_static_default_method<T>(arg1: isize, arg2: T) -> isize {
         zzz(); // #break
         arg1
     }
@@ -64,7 +64,7 @@ fn main() {
 
     // Is this really how to use these?
     Trait::generic_static_default_method::<Struct, float>(1000, 0.5);
-    Trait::generic_static_default_method::<Struct, &(int, int, int)>(2000, &(1, 2, 3));
+    Trait::generic_static_default_method::<Struct, &(isize, isize, isize)>(2000, &(1, 2, 3));
 
 }
 
diff --git a/src/test/debuginfo/trait-pointers.rs b/src/test/debuginfo/trait-pointers.rs
index f74c9953f7d..3054f646b91 100644
--- a/src/test/debuginfo/trait-pointers.rs
+++ b/src/test/debuginfo/trait-pointers.rs
@@ -19,11 +19,11 @@
 #![omit_gdb_pretty_printer_section]
 
 trait Trait {
-    fn method(&self) -> int { 0 }
+    fn method(&self) -> isize { 0 }
 }
 
 struct Struct {
-    a: int,
+    a: isize,
     b: f64
 }
 
diff --git a/src/test/debuginfo/var-captured-in-nested-closure.rs b/src/test/debuginfo/var-captured-in-nested-closure.rs
index 05872e3fc36..d576aff8b1c 100644
--- a/src/test/debuginfo/var-captured-in-nested-closure.rs
+++ b/src/test/debuginfo/var-captured-in-nested-closure.rs
@@ -82,9 +82,9 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    a: int,
+    a: isize,
     b: f64,
-    c: uint
+    c: usize
 }
 
 fn main() {
diff --git a/src/test/debuginfo/var-captured-in-sendable-closure.rs b/src/test/debuginfo/var-captured-in-sendable-closure.rs
index 295d57f4cfa..2b27f938b30 100644
--- a/src/test/debuginfo/var-captured-in-sendable-closure.rs
+++ b/src/test/debuginfo/var-captured-in-sendable-closure.rs
@@ -44,9 +44,9 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    a: int,
+    a: isize,
     b: f64,
-    c: uint
+    c: usize
 }
 
 fn main() {
@@ -80,7 +80,7 @@ fn main() {
     immedate_env();
 }
 
-fn do_something(_: &int, _:&int, _:&int) {
+fn do_something(_: &isize, _:&isize, _:&isize) {
 
 }
 
diff --git a/src/test/debuginfo/var-captured-in-stack-closure.rs b/src/test/debuginfo/var-captured-in-stack-closure.rs
index 57dcac409ba..54ef42b48f1 100644
--- a/src/test/debuginfo/var-captured-in-stack-closure.rs
+++ b/src/test/debuginfo/var-captured-in-stack-closure.rs
@@ -74,9 +74,9 @@
 #![omit_gdb_pretty_printer_section]
 
 struct Struct {
-    a: int,
+    a: isize,
     b: f64,
-    c: uint
+    c: usize
 }
 
 fn main() {