Update compile-fail tests to use is/us, not i/u.

Author: huonw

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: [isize, ..3] = [0i, 1, 2]; //~ ERROR
+    let _x: [isize, ..3] = [0is, 1, 2]; //~ ERROR
 }

src/test/compile-fail/array-old-syntax-2.rs

@@ -11,5 +11,5 @@
 // Test that the old repeating array syntax gives an error.
 
 fn main() {
-    let _ = [0i, ..3]; //~ ERROR
+    let _ = [0is, ..3]; //~ ERROR
 }

src/test/compile-fail/asm-in-bad-modifier.rs

@@ -20,8 +20,8 @@ pub fn main() {
     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 '+'
+        asm!("mov $1, $0" : "=r"(x) : "=r"(5us)); //~ ERROR input operand constraint contains '='
+        asm!("mov $1, $0" : "=r"(y) : "+r"(5us)); //~ ERROR input operand constraint contains '+'
     }
     foo(x);
     foo(y);

src/test/compile-fail/asm-misplaced-option.rs

@@ -21,14 +21,14 @@ pub fn main() {
     let mut x: isize = 0;
     unsafe {
         // extra colon
-        asm!("mov $1, $0" : "=r"(x) : "r"(5u), "0"(x) : : "cc");
+        asm!("mov $1, $0" : "=r"(x) : "r"(5us), "0"(x) : : "cc");
         //~^ WARNING unrecognized option
     }
     assert_eq!(x, 5);
 
     unsafe {
         // comma in place of a colon
-        asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8u) : "cc", "volatile");
+        asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8us) : "cc", "volatile");
         //~^ WARNING expected a clobber, found an option
     }
     assert_eq!(x, 13);

src/test/compile-fail/asm-out-assign-imm.rs

@@ -21,7 +21,7 @@ pub fn main() {
     x = 1; //~ NOTE prior assignment occurs here
     foo(x);
     unsafe {
-        asm!("mov $1, $0" : "=r"(x) : "r"(5u)); //~ ERROR re-assignment of immutable variable `x`
+        asm!("mov $1, $0" : "=r"(x) : "r"(5us)); //~ ERROR re-assignment of immutable variable `x`
     }
     foo(x);
 }

src/test/compile-fail/asm-out-no-modifier.rs

@@ -19,7 +19,7 @@ fn foo(x: isize) { println!("{}", x); }
 pub fn main() {
     let x: isize;
     unsafe {
-        asm!("mov $1, $0" : "r"(x) : "r"(5u)); //~ ERROR output operand constraint lacks '='
+        asm!("mov $1, $0" : "r"(x) : "r"(5us)); //~ ERROR output operand constraint lacks '='
     }
     foo(x);
 }

src/test/compile-fail/assign-to-method.rs

@@ -15,7 +15,7 @@ struct cat {
 }
 
 impl cat {
-    pub fn speak(&self) { self.meows += 1u; }
+    pub fn speak(&self) { self.meows += 1us; }
 }
 
 fn cat(in_x : usize, in_y : isize) -> cat {
@@ -26,6 +26,6 @@ fn cat(in_x : usize, in_y : isize) -> cat {
 }
 
 fn main() {
-  let nyan : cat = cat(52u, 99);
+  let nyan : cat = cat(52us, 99);
   nyan.speak = |&:| println!("meow"); //~ ERROR attempted to take value of method
 }

src/test/compile-fail/associated-types-eq-3.rs

@@ -40,7 +40,7 @@ pub fn baz(x: &Foo<A=Bar>) {
 
 
 pub fn main() {
-    let a = 42i;
+    let a = 42is;
     foo1(a); //~ERROR expected usize, found struct Bar
     baz(&a); //~ERROR expected usize, found struct Bar
 }

src/test/compile-fail/associated-types-incomplete-object.rs

@@ -28,15 +28,15 @@ impl Foo for isize {
 }
 
 pub fn main() {
-    let a = &42i as &Foo<A=usize, B=char>;
+    let a = &42is as &Foo<A=usize, B=char>;
 
-    let b = &42i as &Foo<A=usize>;
+    let b = &42is as &Foo<A=usize>;
     //~^ ERROR the value of the associated type `B` (from the trait `Foo`) must be specified
 
-    let c = &42i as &Foo<B=char>;
+    let c = &42is as &Foo<B=char>;
     //~^ ERROR the value of the associated type `A` (from the trait `Foo`) must be specified
 
-    let d = &42i as &Foo;
+    let d = &42is as &Foo;
     //~^ ERROR the value of the associated type `A` (from the trait `Foo`) must be specified
     //~| ERROR the value of the associated type `B` (from the trait `Foo`) must be specified
 }

src/test/compile-fail/bad-bang-ann-3.rs

@@ -11,7 +11,7 @@
 // Tests that a function with a ! annotation always actually fails
 
 fn bad_bang(i: usize) -> ! {
-    return 7u; //~ ERROR `return` in a function declared as diverging [E0166]
+    return 7us; //~ ERROR `return` in a function declared as diverging [E0166]
 }
 
-fn main() { bad_bang(5u); }
+fn main() { bad_bang(5us); }