Convert required suffixes into a use of `as`.

diff --git a/src/libcoretest/any.rs b/src/libcoretest/any.rs
index 2156a99c332908cc962906cb80b929f8e5f71c69..8b5e46f85fa6ac181b1e7968adaa364214c407ad 100644 (file)
--- a/src/libcoretest/any.rs
+++ b/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]>());

diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs
index dba355373ce64256d5bdc6b9e1163137d7b3c430..bc8461b0b9e09cf9c8c43d8a5d4752be40731959 100644 (file)
--- a/src/libcoretest/fmt/num.rs
+++ b/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");

diff --git a/src/libcoretest/hash/mod.rs b/src/libcoretest/hash/mod.rs
index 2da3f370b40ac467435f5da7379213ea30aacbbe..fd0d3c676a45ab4d1c0c50cb20087092526576dd 100644 (file)
--- a/src/libcoretest/hash/mod.rs
+++ b/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);
     }
 }

diff --git a/src/librustc/lint/builtin.rs b/src/librustc/lint/builtin.rs
index ba108b5488edee23cb7d84a09192b74f2e20b987..eb51046d7c9a75ad2e918255266a87cf9e69d8cf 100644 (file)
--- a/src/librustc/lint/builtin.rs
+++ b/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

diff --git a/src/libserialize/json.rs b/src/libserialize/json.rs
index d79a31718555357fc8a06df0a8872388e0ed202e..68b28784b4254de9460c6048e62a1460503513a2 100644 (file)
--- a/src/libserialize/json.rs
+++ b/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);
     }
 

diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index a1780652c8176b556356f6e6ee8e41ab099f5222..c94c16498332924e2fd5348fc12e317983c792e3 100644 (file)
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -1123,20 +1123,20 @@ macro_rules! test_cast_20 {
         ($_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 @@ macro_rules! test_cast_20 {
         })
     }
 
-    #[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]

diff --git a/src/test/compile-fail/asm-in-bad-modifier.rs b/src/test/compile-fail/asm-in-bad-modifier.rs
index ffbb25e266ac644c6bb46943b3f462ff9bb92b51..01481af817b7e5caa4bc303c4b1742a1db947603 100644 (file)
--- a/src/test/compile-fail/asm-in-bad-modifier.rs
+++ b/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);

diff --git a/src/test/compile-fail/asm-misplaced-option.rs b/src/test/compile-fail/asm-misplaced-option.rs
index 8bc6f206dec02c7118c09a82ab3a621922fbfe47..a29ead02b611b8001456393e91ca38ad17fd5e5d 100644 (file)
--- a/src/test/compile-fail/asm-misplaced-option.rs
+++ b/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);

diff --git a/src/test/compile-fail/asm-out-assign-imm.rs b/src/test/compile-fail/asm-out-assign-imm.rs
index 9ad5d7e9f09eefbf021648eae0ff8cf739e7115c..ff56fb14f7d5753cc2b42845b0fe60482dfcf481 100644 (file)
--- a/src/test/compile-fail/asm-out-assign-imm.rs
+++ b/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);
 }

diff --git a/src/test/compile-fail/asm-out-no-modifier.rs b/src/test/compile-fail/asm-out-no-modifier.rs
index b58d41e1d825c163ca84fe737b25dba72debf493..17c19c77ab9abd6ebe988e00b0b72132ef849870 100644 (file)
--- a/src/test/compile-fail/asm-out-no-modifier.rs
+++ b/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);
 }

diff --git a/src/test/compile-fail/issue-13058.rs b/src/test/compile-fail/issue-13058.rs
index 61b50ef705f6a44f8acc388136e73e6f5ba55f80..06f14158b91577f7b4219f5b2bcc767e231fc511 100644 (file)
--- a/src/test/compile-fail/issue-13058.rs
+++ b/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)`

diff --git a/src/test/pretty/issue-4264.pp b/src/test/pretty/issue-4264.pp
index ffe45c0ac46163b0ab0f01b575263a1ba2da176f..b817371b8703a2bb7d08b5abebab1a1d0c82a51f 100644 (file)
--- a/src/test/pretty/issue-4264.pp
+++ b/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]);

diff --git a/src/test/run-pass/numeric-method-autoexport.rs b/src/test/run-pass/numeric-method-autoexport.rs
index fec4a806b43890b24b4a7897acd785849c922e6e..c414d735f7c522b3efb0482daffaae3110047a73 100644 (file)
--- a/src/test/run-pass/numeric-method-autoexport.rs
+++ b/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);
 }