1 files changed, 15 insertions, 15 deletions

diff --git a/src/test/run-pass/dst-struct.rs b/src/test/run-pass/dst-struct.rs
index 50ba85ad718..055b61b25fb 100644
--- a/src/test/run-pass/dst-struct.rs
+++ b/src/test/run-pass/dst-struct.rs
@@ -14,13 +14,13 @@
 #![feature(box_syntax)]
 
 struct Fat<T: ?Sized> {
-    f1: int,
+    f1: isize,
     f2: &'static str,
     ptr: T
 }
 
 // x is a fat pointer
-fn foo(x: &Fat<[int]>) {
+fn foo(x: &Fat<[isize]>) {
     let y = &x.ptr;
     assert!(x.ptr.len() == 3);
     assert!(y[0] == 1);
@@ -39,7 +39,7 @@ fn foo2<T:ToBar>(x: &Fat<[T]>) {
     assert!(x.f2 == "some str");
 }
 
-fn foo3(x: &Fat<Fat<[int]>>) {
+fn foo3(x: &Fat<Fat<[isize]>>) {
     let y = &x.ptr.ptr;
     assert!(x.f1 == 5);
     assert!(x.f2 == "some str");
@@ -70,11 +70,11 @@ pub fn main() {
     foo(&f1);
     let f2 = &f1;
     foo(f2);
-    let f3: &Fat<[int]> = f2;
+    let f3: &Fat<[isize]> = f2;
     foo(f3);
-    let f4: &Fat<[int]> = &f1;
+    let f4: &Fat<[isize]> = &f1;
     foo(f4);
-    let f5: &Fat<[int]> = &Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f5: &Fat<[isize]> = &Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
     foo(f5);
 
     // With a vec of Bars.
@@ -91,14 +91,14 @@ pub fn main() {
     foo2(f5);
 
     // Assignment.
-    let f5: &mut Fat<[int]> = &mut Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f5: &mut Fat<[isize]> = &mut Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
     f5.ptr[1] = 34;
     assert!(f5.ptr[0] == 1);
     assert!(f5.ptr[1] == 34);
     assert!(f5.ptr[2] == 3);
 
     // Zero size vec.
-    let f5: &Fat<[int]> = &Fat { f1: 5, f2: "some str", ptr: [] };
+    let f5: &Fat<[isize]> = &Fat { f1: 5, f2: "some str", ptr: [] };
     assert!(f5.ptr.len() == 0);
     let f5: &Fat<[Bar]> = &Fat { f1: 5, f2: "some str", ptr: [] };
     assert!(f5.ptr.len() == 0);
@@ -108,28 +108,28 @@ pub fn main() {
     foo3(&f1);
     let f2 = &f1;
     foo3(f2);
-    let f3: &Fat<Fat<[int]>> = f2;
+    let f3: &Fat<Fat<[isize]>> = f2;
     foo3(f3);
-    let f4: &Fat<Fat<[int]>> = &f1;
+    let f4: &Fat<Fat<[isize]>> = &f1;
     foo3(f4);
-    let f5: &Fat<Fat<[int]>> =
+    let f5: &Fat<Fat<[isize]>> =
         &Fat { f1: 5, f2: "some str", ptr: Fat { f1: 8, f2: "deep str", ptr: [1, 2, 3]} };
     foo3(f5);
 
     // Box.
     let f1 = Box::new([1, 2, 3]);
     assert!((*f1)[1] == 2);
-    let f2: Box<[int]> = f1;
+    let f2: Box<[isize]> = f1;
     assert!((*f2)[1] == 2);
 
     // Nested Box.
-    let f1 : Box<Fat<[int; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
+    let f1 : Box<Fat<[isize; 3]>> = box Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] };
     foo(&*f1);
-    let f2 : Box<Fat<[int]>> = f1;
+    let f2 : Box<Fat<[isize]>> = f1;
     foo(&*f2);
 
     // FIXME (#22405): Replace `Box::new` with `box` here when/if possible.
-    let f3 : Box<Fat<[int]>> =
+    let f3 : Box<Fat<[isize]>> =
         Box::<Fat<[_; 3]>>::new(Fat { f1: 5, f2: "some str", ptr: [1, 2, 3] });
     foo(&*f3);
 }