mathieu/granite-rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Convert required suffixes into a use of as.

Browse source
This commit is contained in:
Niko Matsakis 2015-02-17 09:48:01 -05:00
parent 2b5720a15f
commit 01615b04c6
13 changed files with 100 additions and 100 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

10
src/libcoretest/any.rs
View file

@ -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]>());

26
src/libcoretest/fmt/num.rs
View file

@ -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");

24
src/libcoretest/hash/mod.rs
View file

@ -46,17 +46,17 @@ fn test_writer_hasher() {
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(&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(&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_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 test_writer_hasher() {
// 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);
}
}

3
src/librustc/lint/builtin.rs
View file

@ -494,13 +494,12 @@ pub struct BoxPointers;
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

22
src/libserialize/json.rs
View file

@ -3905,12 +3905,12 @@ mod tests {
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 @@ mod tests {
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);
}

76
src/libstd/num/mod.rs
View file

@ -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!(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(20u).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 @@ mod tests {
#[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 @@ mod tests {
#[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 @@ mod tests {
#[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]

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

@ -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);

2
src/test/compile-fail/asm-misplaced-option.rs
View file

@ -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);

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

@ -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);
}

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

@ -19,7 +19,7 @@ fn foo(x: isize) { println!("{}", x); }
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);
}

2
src/test/compile-fail/issue-13058.rs
View file

@ -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)`

2
src/test/pretty/issue-4264.pp
View file

@ -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]);

24
src/test/run-pass/numeric-method-autoexport.rs
View file

@ -21,22 +21,22 @@ use std::num::ToPrimitive;
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);
}