Convert required suffixes into a use of `as`.

src/libcoretest/any.rs

@@ -35,7 +35,7 @@ fn any_referenced() {
 
 #[test]
 fn any_owning() {
-    let (a, b, c) = (box 5us as Box<Any>, box TEST as Box<Any>, box Test as Box<Any>);
+    let (a, b, c) = (box 5_usize as Box<Any>, box TEST as Box<Any>, box Test as Box<Any>);
 
     assert!(a.is::<uint>());
     assert!(!b.is::<uint>());
@@ -52,7 +52,7 @@ fn any_owning() {
 
 #[test]
 fn any_downcast_ref() {
-    let a = &5us as &Any;
+    let a = &5_usize as &Any;
 
     match a.downcast_ref::<uint>() {
         Some(&5) => {}
@@ -67,8 +67,8 @@ fn any_downcast_ref() {
 
 #[test]
 fn any_downcast_mut() {
-    let mut a = 5us;
-    let mut b = box 7us;
+    let mut a = 5_usize;
+    let mut b = box 7_usize;
 
     let a_r = &mut a as &mut Any;
     let tmp: &mut uint = &mut *b;
@@ -113,7 +113,7 @@ fn any_downcast_mut() {
 
 #[test]
 fn any_fixed_vec() {
-    let test = [0us; 8];
+    let test = [0_usize; 8];
     let test = &test as &Any;
     assert!(test.is::<[uint; 8]>());
     assert!(!test.is::<[uint; 10]>());

src/libcoretest/fmt/num.rs

@@ -16,68 +16,68 @@ fn test_format_int() {
     // Formatting integers should select the right implementation based off
     // the type of the argument. Also, hex/octal/binary should be defined
     // for integers, but they shouldn't emit the negative sign.
-    assert!(format!("{}", 1is) == "1");
+    assert!(format!("{}", 1isize) == "1");
     assert!(format!("{}", 1i8) == "1");
     assert!(format!("{}", 1i16) == "1");
     assert!(format!("{}", 1i32) == "1");
     assert!(format!("{}", 1i64) == "1");
-    assert!(format!("{}", -1is) == "-1");
+    assert!(format!("{}", -1isize) == "-1");
     assert!(format!("{}", -1i8) == "-1");
     assert!(format!("{}", -1i16) == "-1");
     assert!(format!("{}", -1i32) == "-1");
     assert!(format!("{}", -1i64) == "-1");
-    assert!(format!("{:?}", 1is) == "1");
+    assert!(format!("{:?}", 1isize) == "1");
     assert!(format!("{:?}", 1i8) == "1");
     assert!(format!("{:?}", 1i16) == "1");
     assert!(format!("{:?}", 1i32) == "1");
     assert!(format!("{:?}", 1i64) == "1");
-    assert!(format!("{:b}", 1is) == "1");
+    assert!(format!("{:b}", 1isize) == "1");
     assert!(format!("{:b}", 1i8) == "1");
     assert!(format!("{:b}", 1i16) == "1");
     assert!(format!("{:b}", 1i32) == "1");
     assert!(format!("{:b}", 1i64) == "1");
-    assert!(format!("{:x}", 1is) == "1");
+    assert!(format!("{:x}", 1isize) == "1");
     assert!(format!("{:x}", 1i8) == "1");
     assert!(format!("{:x}", 1i16) == "1");
     assert!(format!("{:x}", 1i32) == "1");
     assert!(format!("{:x}", 1i64) == "1");
-    assert!(format!("{:X}", 1is) == "1");
+    assert!(format!("{:X}", 1isize) == "1");
     assert!(format!("{:X}", 1i8) == "1");
     assert!(format!("{:X}", 1i16) == "1");
     assert!(format!("{:X}", 1i32) == "1");
     assert!(format!("{:X}", 1i64) == "1");
-    assert!(format!("{:o}", 1is) == "1");
+    assert!(format!("{:o}", 1isize) == "1");
     assert!(format!("{:o}", 1i8) == "1");
     assert!(format!("{:o}", 1i16) == "1");
     assert!(format!("{:o}", 1i32) == "1");
     assert!(format!("{:o}", 1i64) == "1");
 
-    assert!(format!("{}", 1us) == "1");
+    assert!(format!("{}", 1usize) == "1");
     assert!(format!("{}", 1u8) == "1");
     assert!(format!("{}", 1u16) == "1");
     assert!(format!("{}", 1u32) == "1");
     assert!(format!("{}", 1u64) == "1");
-    assert!(format!("{:?}", 1us) == "1");
+    assert!(format!("{:?}", 1usize) == "1");
     assert!(format!("{:?}", 1u8) == "1");
     assert!(format!("{:?}", 1u16) == "1");
     assert!(format!("{:?}", 1u32) == "1");
     assert!(format!("{:?}", 1u64) == "1");
-    assert!(format!("{:b}", 1us) == "1");
+    assert!(format!("{:b}", 1usize) == "1");
     assert!(format!("{:b}", 1u8) == "1");
     assert!(format!("{:b}", 1u16) == "1");
     assert!(format!("{:b}", 1u32) == "1");
     assert!(format!("{:b}", 1u64) == "1");
-    assert!(format!("{:x}", 1us) == "1");
+    assert!(format!("{:x}", 1usize) == "1");
     assert!(format!("{:x}", 1u8) == "1");
     assert!(format!("{:x}", 1u16) == "1");
     assert!(format!("{:x}", 1u32) == "1");
     assert!(format!("{:x}", 1u64) == "1");
-    assert!(format!("{:X}", 1us) == "1");
+    assert!(format!("{:X}", 1usize) == "1");
     assert!(format!("{:X}", 1u8) == "1");
     assert!(format!("{:X}", 1u16) == "1");
     assert!(format!("{:X}", 1u32) == "1");
     assert!(format!("{:X}", 1u64) == "1");
-    assert!(format!("{:o}", 1us) == "1");
+    assert!(format!("{:o}", 1usize) == "1");
     assert!(format!("{:o}", 1u8) == "1");
     assert!(format!("{:o}", 1u16) == "1");
     assert!(format!("{:o}", 1u32) == "1");

src/libcoretest/hash/mod.rs

@@ -46,17 +46,17 @@ fn hash<T: Hash<MyHasher>>(t: &T) -> u64 {
 
     assert_eq!(hash(&()), 0);
 
-    assert_eq!(hash(&5u8), 5);
-    assert_eq!(hash(&5u16), 5);
-    assert_eq!(hash(&5u32), 5);
-    assert_eq!(hash(&5u64), 5);
-    assert_eq!(hash(&5us), 5);
-
-    assert_eq!(hash(&5i8), 5);
-    assert_eq!(hash(&5i16), 5);
-    assert_eq!(hash(&5i32), 5);
-    assert_eq!(hash(&5i64), 5);
-    assert_eq!(hash(&5is), 5);
+    assert_eq!(hash(&5_u8), 5);
+    assert_eq!(hash(&5_u16), 5);
+    assert_eq!(hash(&5_u32), 5);
+    assert_eq!(hash(&5_u64), 5);
+    assert_eq!(hash(&5_usize), 5);
+
+    assert_eq!(hash(&5_i8), 5);
+    assert_eq!(hash(&5_i16), 5);
+    assert_eq!(hash(&5_i32), 5);
+    assert_eq!(hash(&5_i64), 5);
+    assert_eq!(hash(&5_isize), 5);
 
     assert_eq!(hash(&false), 0);
     assert_eq!(hash(&true), 1);
@@ -76,12 +76,12 @@ fn hash<T: Hash<MyHasher>>(t: &T) -> u64 {
     // FIXME (#18248) Add tests for hashing Rc<str> and Rc<[T]>
 
     unsafe {
-        let ptr: *const i32 = mem::transmute(5us);
+        let ptr: *const i32 = mem::transmute(5_usize);
         assert_eq!(hash(&ptr), 5);
     }
 
     unsafe {
-        let ptr: *mut i32 = mem::transmute(5us);
+        let ptr: *mut i32 = mem::transmute(5_usize);
         assert_eq!(hash(&ptr), 5);
     }
 }

src/librustc/lint/builtin.rs

@@ -494,13 +494,12 @@ fn check_foreign_fn(cx: &Context, decl: &ast::FnDecl) {
 impl BoxPointers {
     fn check_heap_type<'a, 'tcx>(&self, cx: &Context<'a, 'tcx>,
                                  span: Span, ty: Ty<'tcx>) {
-        let mut n_uniq = 0us;
+        let mut n_uniq: usize = 0;
         ty::fold_ty(cx.tcx, ty, |t| {
             match t.sty {
                 ty::ty_uniq(_) => {
                     n_uniq += 1;
                 }
-
                 _ => ()
             };
             t

src/libserialize/json.rs

@@ -3905,12 +3905,12 @@ fn test_to_json() {
 
         assert_eq!(array2.to_json(), array2);
         assert_eq!(object.to_json(), object);
-        assert_eq!(3_i.to_json(), I64(3));
+        assert_eq!(3_isize.to_json(), I64(3));
         assert_eq!(4_i8.to_json(), I64(4));
         assert_eq!(5_i16.to_json(), I64(5));
         assert_eq!(6_i32.to_json(), I64(6));
         assert_eq!(7_i64.to_json(), I64(7));
-        assert_eq!(8_u.to_json(), U64(8));
+        assert_eq!(8_usize.to_json(), U64(8));
         assert_eq!(9_u8.to_json(), U64(9));
         assert_eq!(10_u16.to_json(), U64(10));
         assert_eq!(11_u32.to_json(), U64(11));
@@ -3924,22 +3924,22 @@ fn test_to_json() {
         assert_eq!(false.to_json(), Boolean(false));
         assert_eq!("abc".to_json(), String("abc".to_string()));
         assert_eq!("abc".to_string().to_json(), String("abc".to_string()));
-        assert_eq!((1us, 2us).to_json(), array2);
-        assert_eq!((1us, 2us, 3us).to_json(), array3);
-        assert_eq!([1us, 2us].to_json(), array2);
-        assert_eq!((&[1us, 2us, 3us]).to_json(), array3);
-        assert_eq!((vec![1us, 2us]).to_json(), array2);
-        assert_eq!(vec!(1us, 2us, 3us).to_json(), array3);
+        assert_eq!((1_usize, 2_usize).to_json(), array2);
+        assert_eq!((1_usize, 2_usize, 3_usize).to_json(), array3);
+        assert_eq!([1_usize, 2_usize].to_json(), array2);
+        assert_eq!((&[1_usize, 2_usize, 3_usize]).to_json(), array3);
+        assert_eq!((vec![1_usize, 2_usize]).to_json(), array2);
+        assert_eq!(vec!(1_usize, 2_usize, 3_usize).to_json(), array3);
         let mut tree_map = BTreeMap::new();
-        tree_map.insert("a".to_string(), 1us);
+        tree_map.insert("a".to_string(), 1 as usize);
         tree_map.insert("b".to_string(), 2);
         assert_eq!(tree_map.to_json(), object);
         let mut hash_map = HashMap::new();
-        hash_map.insert("a".to_string(), 1us);
+        hash_map.insert("a".to_string(), 1 as usize);
         hash_map.insert("b".to_string(), 2);
         assert_eq!(hash_map.to_json(), object);
         assert_eq!(Some(15).to_json(), I64(15));
-        assert_eq!(Some(15us).to_json(), U64(15));
+        assert_eq!(Some(15 as usize).to_json(), U64(15));
         assert_eq!(None::<int>.to_json(), Null);
     }
 

src/libstd/num/mod.rs

@@ -1123,20 +1123,20 @@ mod tests {
         ($_20:expr) => ({
             let _20 = $_20;
 
-            assert_eq!(20u,   _20.to_uint().unwrap());
-            assert_eq!(20u8,  _20.to_u8().unwrap());
-            assert_eq!(20u16, _20.to_u16().unwrap());
-            assert_eq!(20u32, _20.to_u32().unwrap());
-            assert_eq!(20u64, _20.to_u64().unwrap());
-            assert_eq!(20,   _20.to_int().unwrap());
-            assert_eq!(20i8,  _20.to_i8().unwrap());
-            assert_eq!(20i16, _20.to_i16().unwrap());
-            assert_eq!(20i32, _20.to_i32().unwrap());
-            assert_eq!(20i64, _20.to_i64().unwrap());
-            assert_eq!(20f32, _20.to_f32().unwrap());
-            assert_eq!(20f64, _20.to_f64().unwrap());
-
-            assert_eq!(_20, NumCast::from(20u).unwrap());
+            assert_eq!(20usize, _20.to_uint().unwrap());
+            assert_eq!(20u8,    _20.to_u8().unwrap());
+            assert_eq!(20u16,   _20.to_u16().unwrap());
+            assert_eq!(20u32,   _20.to_u32().unwrap());
+            assert_eq!(20u64,   _20.to_u64().unwrap());
+            assert_eq!(20,      _20.to_int().unwrap());
+            assert_eq!(20i8,    _20.to_i8().unwrap());
+            assert_eq!(20i16,   _20.to_i16().unwrap());
+            assert_eq!(20i32,   _20.to_i32().unwrap());
+            assert_eq!(20i64,   _20.to_i64().unwrap());
+            assert_eq!(20f32,   _20.to_f32().unwrap());
+            assert_eq!(20f64,   _20.to_f64().unwrap());
+
+            assert_eq!(_20, NumCast::from(20usize).unwrap());
             assert_eq!(_20, NumCast::from(20u8).unwrap());
             assert_eq!(_20, NumCast::from(20u16).unwrap());
             assert_eq!(_20, NumCast::from(20u32).unwrap());
@@ -1164,18 +1164,18 @@ mod tests {
         })
     }
 
-    #[test] fn test_u8_cast()    { test_cast_20!(20u8)  }
-    #[test] fn test_u16_cast()   { test_cast_20!(20u16) }
-    #[test] fn test_u32_cast()   { test_cast_20!(20u32) }
-    #[test] fn test_u64_cast()   { test_cast_20!(20u64) }
-    #[test] fn test_uint_cast()  { test_cast_20!(20u)   }
-    #[test] fn test_i8_cast()    { test_cast_20!(20i8)  }
-    #[test] fn test_i16_cast()   { test_cast_20!(20i16) }
-    #[test] fn test_i32_cast()   { test_cast_20!(20i32) }
-    #[test] fn test_i64_cast()   { test_cast_20!(20i64) }
-    #[test] fn test_int_cast()   { test_cast_20!(20)   }
-    #[test] fn test_f32_cast()   { test_cast_20!(20f32) }
-    #[test] fn test_f64_cast()   { test_cast_20!(20f64) }
+    #[test] fn test_u8_cast()    { test_cast_20!(20u8)    }
+    #[test] fn test_u16_cast()   { test_cast_20!(20u16)   }
+    #[test] fn test_u32_cast()   { test_cast_20!(20u32)   }
+    #[test] fn test_u64_cast()   { test_cast_20!(20u64)   }
+    #[test] fn test_uint_cast()  { test_cast_20!(20usize) }
+    #[test] fn test_i8_cast()    { test_cast_20!(20i8)    }
+    #[test] fn test_i16_cast()   { test_cast_20!(20i16)   }
+    #[test] fn test_i32_cast()   { test_cast_20!(20i32)   }
+    #[test] fn test_i64_cast()   { test_cast_20!(20i64)   }
+    #[test] fn test_int_cast()   { test_cast_20!(20)      }
+    #[test] fn test_f32_cast()   { test_cast_20!(20f32)   }
+    #[test] fn test_f64_cast()   { test_cast_20!(20f64)   }
 
     #[test]
     fn test_cast_range_int_min() {
@@ -1548,8 +1548,8 @@ fn check_word_size() {
     #[test]
     fn test_saturating_add_uint() {
         use uint::MAX;
-        assert_eq!(3u.saturating_add(5u), 8u);
-        assert_eq!(3u.saturating_add(MAX-1), MAX);
+        assert_eq!(3_usize.saturating_add(5_usize), 8_usize);
+        assert_eq!(3_usize.saturating_add(MAX-1), MAX);
         assert_eq!(MAX.saturating_add(MAX), MAX);
         assert_eq!((MAX-2).saturating_add(1), MAX-1);
     }
@@ -1557,9 +1557,9 @@ fn test_saturating_add_uint() {
     #[test]
     fn test_saturating_sub_uint() {
         use uint::MAX;
-        assert_eq!(5u.saturating_sub(3u), 2u);
-        assert_eq!(3u.saturating_sub(5u), 0u);
-        assert_eq!(0u.saturating_sub(1u), 0u);
+        assert_eq!(5_usize.saturating_sub(3_usize), 2_usize);
+        assert_eq!(3_usize.saturating_sub(5_usize), 0_usize);
+        assert_eq!(0_usize.saturating_sub(1_usize), 0_usize);
         assert_eq!((MAX-1).saturating_sub(MAX), 0);
     }
 
@@ -1602,14 +1602,14 @@ fn test_checked_add() {
 
     #[test]
     fn test_checked_sub() {
-        assert_eq!(5u.checked_sub(0), Some(5));
-        assert_eq!(5u.checked_sub(1), Some(4));
-        assert_eq!(5u.checked_sub(2), Some(3));
-        assert_eq!(5u.checked_sub(3), Some(2));
-        assert_eq!(5u.checked_sub(4), Some(1));
-        assert_eq!(5u.checked_sub(5), Some(0));
-        assert_eq!(5u.checked_sub(6), None);
-        assert_eq!(5u.checked_sub(7), None);
+        assert_eq!(5_usize.checked_sub(0), Some(5));
+        assert_eq!(5_usize.checked_sub(1), Some(4));
+        assert_eq!(5_usize.checked_sub(2), Some(3));
+        assert_eq!(5_usize.checked_sub(3), Some(2));
+        assert_eq!(5_usize.checked_sub(4), Some(1));
+        assert_eq!(5_usize.checked_sub(5), Some(0));
+        assert_eq!(5_usize.checked_sub(6), None);
+        assert_eq!(5_usize.checked_sub(7), None);
     }
 
     #[test]

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

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

@@ -21,7 +21,7 @@ pub fn main() {
     let mut x: isize = 0;
     unsafe {
         // extra colon
-        asm!("mov $1, $0" : "=r"(x) : "r"(5us), "0"(x) : : "cc");
+        asm!("mov $1, $0" : "=r"(x) : "r"(5_usize), "0"(x) : : "cc");
         //~^ WARNING unrecognized option
     }
     assert_eq!(x, 5);

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

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

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

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

src/test/compile-fail/issue-13058.rs

@@ -34,7 +34,7 @@ fn check<'r, I: Iterator<Item=usize>, T: Itble<'r, usize, I>>(cont: &T) -> bool
 }
 
 fn main() {
-    check((3us, 5us));
+    check((3_usize, 5_usize));
 //~^ ERROR mismatched types
 //~| expected `&_`
 //~| found `(usize, usize)`

src/test/pretty/issue-4264.pp

@@ -23,7 +23,7 @@ extern crate "std" as std;
 pub fn foo(_: [i32; (3 as usize)]) { }
 
 pub fn bar() {
-    const FOO: usize = ((5us as usize) - (4us as usize) as usize);
+    const FOO: usize = ((5usize as usize) - (4usize as usize) as usize);
     let _: [(); (FOO as usize)] = ([(() as ())] as [(); 1]);
 
     let _: [(); (1us as usize)] = ([(() as ())] as [(); 1]);

src/test/run-pass/numeric-method-autoexport.rs

@@ -21,22 +21,22 @@
 pub fn main() {
 // ints
     // num
-    assert_eq!(15is.add(6is), 21is);
-    assert_eq!(15i8.add(6i8), 21i8);
-    assert_eq!(15i16.add(6i16), 21i16);
-    assert_eq!(15i32.add(6i32), 21i32);
-    assert_eq!(15i64.add(6i64), 21i64);
+    assert_eq!(15_isize.add(6_isize), 21_isize);
+    assert_eq!(15_i8.add(6i8), 21_i8);
+    assert_eq!(15_i16.add(6i16), 21_i16);
+    assert_eq!(15_i32.add(6i32), 21_i32);
+    assert_eq!(15_i64.add(6i64), 21_i64);
 
 // uints
     // num
-    assert_eq!(15us.add(6us), 21us);
-    assert_eq!(15u8.add(6u8), 21u8);
-    assert_eq!(15u16.add(6u16), 21u16);
-    assert_eq!(15u32.add(6u32), 21u32);
-    assert_eq!(15u64.add(6u64), 21u64);
+    assert_eq!(15_usize.add(6us), 21_usize);
+    assert_eq!(15_u8.add(6u8), 21_u8);
+    assert_eq!(15_u16.add(6u16), 21_u16);
+    assert_eq!(15_u32.add(6u32), 21_u32);
+    assert_eq!(15_u64.add(6u64), 21_u64);
 
 // floats
     // num
-    assert_eq!(10f32.to_i32().unwrap(), 10);
-    assert_eq!(10f64.to_i32().unwrap(), 10);
+    assert_eq!(10_f32.to_i32().unwrap(), 10);
+    assert_eq!(10_f64.to_i32().unwrap(), 10);
 }