From 76e9fa63ba0b6d892aa880db9c8373ede3e67c03 Mon Sep 17 00:00:00 2001 From: Brian Anderson Date: Thu, 19 Feb 2015 21:05:35 -0800 Subject: [PATCH] core: Audit num module for int/uint * count_ones/zeros, trailing_ones/zeros return u32, not usize * rotate_left/right take u32, not usize * RADIX, MANTISSA_DIGITS, DIGITS, BITS, BYTES are u32, not usize Doesn't touch pow because there's another PR for it. [breaking-change] --- src/libcollections/bit.rs | 118 ++++++++++---------- src/libcollections/enum_set.rs | 6 +- src/libcore/fmt/float.rs | 4 +- src/libcore/hash/mod.rs | 2 +- src/libcore/iter.rs | 6 +- src/libcore/num/f32.rs | 26 ++--- src/libcore/num/f64.rs | 26 ++--- src/libcore/num/int_macros.rs | 4 +- src/libcore/num/mod.rs | 110 +++++++++++++----- src/libcore/num/uint_macros.rs | 4 +- src/librustc/middle/astencode.rs | 2 +- src/librustc/middle/dataflow.rs | 10 +- src/librustc/middle/lang_items.rs | 2 +- src/libstd/num/strconv.rs | 4 +- src/libstd/old_io/mod.rs | 16 +-- src/libstd/sys/unix/c.rs | 4 +- src/libtest/stats.rs | 24 ++-- src/test/run-pass/vector-sort-panic-safe.rs | 2 +- 18 files changed, 215 insertions(+), 155 deletions(-) diff --git a/src/libcollections/bit.rs b/src/libcollections/bit.rs index 5b19de42ac919..a92eccce142b1 100644 --- a/src/libcollections/bit.rs +++ b/src/libcollections/bit.rs @@ -189,17 +189,17 @@ fn blocks_for_bits(bits: usize) -> usize { // // Note that we can technically avoid this branch with the expression // `(nbits + u32::BITS - 1) / 32::BITS`, but if nbits is almost usize::MAX this will overflow. - if bits % u32::BITS == 0 { - bits / u32::BITS + if bits % u32::BITS as usize == 0 { + bits / u32::BITS as usize } else { - bits / u32::BITS + 1 + bits / u32::BITS as usize + 1 } } /// Computes the bitmask for the final word of the vector fn mask_for_bits(bits: usize) -> u32 { // Note especially that a perfect multiple of u32::BITS should mask all 1s. - !0u32 >> (u32::BITS - bits % u32::BITS) % u32::BITS + !0u32 >> (u32::BITS as usize - bits % u32::BITS as usize) % u32::BITS as usize } impl BitVec { @@ -237,7 +237,7 @@ impl BitVec { /// An operation might screw up the unused bits in the last block of the /// `BitVec`. As per (3), it's assumed to be all 0s. This method fixes it up. fn fix_last_block(&mut self) { - let extra_bits = self.len() % u32::BITS; + let extra_bits = self.len() % u32::BITS as usize; if extra_bits > 0 { let mask = (1 << extra_bits) - 1; let storage_len = self.storage.len(); @@ -313,7 +313,7 @@ impl BitVec { /// false, false, true, false])); /// ``` pub fn from_bytes(bytes: &[u8]) -> BitVec { - let len = bytes.len().checked_mul(u8::BITS).expect("capacity overflow"); + let len = bytes.len().checked_mul(u8::BITS as usize).expect("capacity overflow"); let mut bit_vec = BitVec::with_capacity(len); let complete_words = bytes.len() / 4; let extra_bytes = bytes.len() % 4; @@ -380,8 +380,8 @@ impl BitVec { if i >= self.nbits { return None; } - let w = i / u32::BITS; - let b = i % u32::BITS; + let w = i / u32::BITS as usize; + let b = i % u32::BITS as usize; self.storage.get(w).map(|&block| (block & (1 << b)) != 0 ) @@ -407,8 +407,8 @@ impl BitVec { reason = "panic semantics are likely to change in the future")] pub fn set(&mut self, i: usize, x: bool) { assert!(i < self.nbits); - let w = i / u32::BITS; - let b = i % u32::BITS; + let w = i / u32::BITS as usize; + let b = i % u32::BITS as usize; let flag = 1 << b; let val = if x { self.storage[w] | flag } else { self.storage[w] & !flag }; @@ -789,7 +789,7 @@ impl BitVec { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn capacity(&self) -> usize { - self.storage.capacity().checked_mul(u32::BITS).unwrap_or(usize::MAX) + self.storage.capacity().checked_mul(u32::BITS as usize).unwrap_or(usize::MAX) } /// Grows the `BitVec` in-place, adding `n` copies of `value` to the `BitVec`. @@ -819,7 +819,7 @@ impl BitVec { // Correct the old tail word, setting or clearing formerly unused bits let old_last_word = blocks_for_bits(self.nbits) - 1; - if self.nbits % u32::BITS > 0 { + if self.nbits % u32::BITS as usize > 0 { let mask = mask_for_bits(self.nbits); if value { self.storage[old_last_word] |= !mask; @@ -868,7 +868,7 @@ impl BitVec { // (3) self.set(i, false); self.nbits = i; - if self.nbits % u32::BITS == 0 { + if self.nbits % u32::BITS as usize == 0 { // (2) self.storage.pop(); } @@ -890,7 +890,7 @@ impl BitVec { /// ``` #[stable(feature = "rust1", since = "1.0.0")] pub fn push(&mut self, elem: bool) { - if self.nbits % u32::BITS == 0 { + if self.nbits % u32::BITS as usize == 0 { self.storage.push(0); } let insert_pos = self.nbits; @@ -1406,7 +1406,7 @@ impl BitSet { // Truncate let trunc_len = cmp::max(old_len - n, 1); bit_vec.storage.truncate(trunc_len); - bit_vec.nbits = trunc_len * u32::BITS; + bit_vec.nbits = trunc_len * u32::BITS as usize; } /// Iterator over each u32 stored in the `BitSet`. @@ -1663,7 +1663,7 @@ impl BitSet { #[inline] #[stable(feature = "rust1", since = "1.0.0")] pub fn len(&self) -> usize { - self.bit_vec.blocks().fold(0, |acc, n| acc + n.count_ones()) + self.bit_vec.blocks().fold(0, |acc, n| acc + n.count_ones() as usize) } /// Returns whether there are no bits set in this set @@ -1831,13 +1831,13 @@ impl<'a> Iterator for TwoBitPositions<'a> { fn next(&mut self) -> Option { while self.next_idx < self.set.bit_vec.len() || self.next_idx < self.other.bit_vec.len() { - let bit_idx = self.next_idx % u32::BITS; + let bit_idx = self.next_idx % u32::BITS as usize; if bit_idx == 0 { let s_bit_vec = &self.set.bit_vec; let o_bit_vec = &self.other.bit_vec; // Merging the two words is a bit of an awkward dance since // one BitVec might be longer than the other - let word_idx = self.next_idx / u32::BITS; + let word_idx = self.next_idx / u32::BITS as usize; let w1 = if word_idx < s_bit_vec.storage.len() { s_bit_vec.storage[word_idx] } else { 0 }; @@ -2441,43 +2441,43 @@ mod tests { #[test] fn test_bit_vec_push_pop() { - let mut s = BitVec::from_elem(5 * u32::BITS - 2, false); - assert_eq!(s.len(), 5 * u32::BITS - 2); - assert_eq!(s[5 * u32::BITS - 3], false); + let mut s = BitVec::from_elem(5 * u32::BITS as usize - 2, false); + assert_eq!(s.len(), 5 * u32::BITS as usize - 2); + assert_eq!(s[5 * u32::BITS as usize - 3], false); s.push(true); s.push(true); - assert_eq!(s[5 * u32::BITS - 2], true); - assert_eq!(s[5 * u32::BITS - 1], true); + assert_eq!(s[5 * u32::BITS as usize - 2], true); + assert_eq!(s[5 * u32::BITS as usize - 1], true); // Here the internal vector will need to be extended s.push(false); - assert_eq!(s[5 * u32::BITS], false); + assert_eq!(s[5 * u32::BITS as usize], false); s.push(false); - assert_eq!(s[5 * u32::BITS + 1], false); - assert_eq!(s.len(), 5 * u32::BITS + 2); + assert_eq!(s[5 * u32::BITS as usize + 1], false); + assert_eq!(s.len(), 5 * u32::BITS as usize + 2); // Pop it all off assert_eq!(s.pop(), Some(false)); assert_eq!(s.pop(), Some(false)); assert_eq!(s.pop(), Some(true)); assert_eq!(s.pop(), Some(true)); - assert_eq!(s.len(), 5 * u32::BITS - 2); + assert_eq!(s.len(), 5 * u32::BITS as usize - 2); } #[test] fn test_bit_vec_truncate() { - let mut s = BitVec::from_elem(5 * u32::BITS, true); + let mut s = BitVec::from_elem(5 * u32::BITS as usize, true); - assert_eq!(s, BitVec::from_elem(5 * u32::BITS, true)); - assert_eq!(s.len(), 5 * u32::BITS); - s.truncate(4 * u32::BITS); - assert_eq!(s, BitVec::from_elem(4 * u32::BITS, true)); - assert_eq!(s.len(), 4 * u32::BITS); + assert_eq!(s, BitVec::from_elem(5 * u32::BITS as usize, true)); + assert_eq!(s.len(), 5 * u32::BITS as usize); + s.truncate(4 * u32::BITS as usize); + assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true)); + assert_eq!(s.len(), 4 * u32::BITS as usize); // Truncating to a size > s.len() should be a noop - s.truncate(5 * u32::BITS); - assert_eq!(s, BitVec::from_elem(4 * u32::BITS, true)); - assert_eq!(s.len(), 4 * u32::BITS); - s.truncate(3 * u32::BITS - 10); - assert_eq!(s, BitVec::from_elem(3 * u32::BITS - 10, true)); - assert_eq!(s.len(), 3 * u32::BITS - 10); + s.truncate(5 * u32::BITS as usize); + assert_eq!(s, BitVec::from_elem(4 * u32::BITS as usize, true)); + assert_eq!(s.len(), 4 * u32::BITS as usize); + s.truncate(3 * u32::BITS as usize - 10); + assert_eq!(s, BitVec::from_elem(3 * u32::BITS as usize - 10, true)); + assert_eq!(s.len(), 3 * u32::BITS as usize - 10); s.truncate(0); assert_eq!(s, BitVec::from_elem(0, true)); assert_eq!(s.len(), 0); @@ -2485,26 +2485,26 @@ mod tests { #[test] fn test_bit_vec_reserve() { - let mut s = BitVec::from_elem(5 * u32::BITS, true); + let mut s = BitVec::from_elem(5 * u32::BITS as usize, true); // Check capacity - assert!(s.capacity() >= 5 * u32::BITS); - s.reserve(2 * u32::BITS); - assert!(s.capacity() >= 7 * u32::BITS); - s.reserve(7 * u32::BITS); - assert!(s.capacity() >= 12 * u32::BITS); - s.reserve_exact(7 * u32::BITS); - assert!(s.capacity() >= 12 * u32::BITS); - s.reserve(7 * u32::BITS + 1); - assert!(s.capacity() >= 12 * u32::BITS + 1); + assert!(s.capacity() >= 5 * u32::BITS as usize); + s.reserve(2 * u32::BITS as usize); + assert!(s.capacity() >= 7 * u32::BITS as usize); + s.reserve(7 * u32::BITS as usize); + assert!(s.capacity() >= 12 * u32::BITS as usize); + s.reserve_exact(7 * u32::BITS as usize); + assert!(s.capacity() >= 12 * u32::BITS as usize); + s.reserve(7 * u32::BITS as usize + 1); + assert!(s.capacity() >= 12 * u32::BITS as usize + 1); // Check that length hasn't changed - assert_eq!(s.len(), 5 * u32::BITS); + assert_eq!(s.len(), 5 * u32::BITS as usize); s.push(true); s.push(false); s.push(true); - assert_eq!(s[5 * u32::BITS - 1], true); - assert_eq!(s[5 * u32::BITS - 0], true); - assert_eq!(s[5 * u32::BITS + 1], false); - assert_eq!(s[5 * u32::BITS + 2], true); + assert_eq!(s[5 * u32::BITS as usize - 1], true); + assert_eq!(s[5 * u32::BITS as usize - 0], true); + assert_eq!(s[5 * u32::BITS as usize + 1], false); + assert_eq!(s[5 * u32::BITS as usize + 2], true); } #[test] @@ -2557,7 +2557,7 @@ mod bit_vec_bench { let mut bit_vec = 0 as usize; b.iter(|| { for _ in 0..100 { - bit_vec |= 1 << ((r.next_u32() as usize) % u32::BITS); + bit_vec |= 1 << ((r.next_u32() as usize) % u32::BITS as usize); } black_box(&bit_vec); }); @@ -2590,10 +2590,10 @@ mod bit_vec_bench { #[bench] fn bench_bit_set_small(b: &mut Bencher) { let mut r = rng(); - let mut bit_vec = BitVec::from_elem(u32::BITS, false); + let mut bit_vec = BitVec::from_elem(u32::BITS as usize, false); b.iter(|| { for _ in 0..100 { - bit_vec.set((r.next_u32() as usize) % u32::BITS, true); + bit_vec.set((r.next_u32() as usize) % u32::BITS as usize, true); } black_box(&bit_vec); }); @@ -2610,7 +2610,7 @@ mod bit_vec_bench { #[bench] fn bench_bit_vec_small_iter(b: &mut Bencher) { - let bit_vec = BitVec::from_elem(u32::BITS, false); + let bit_vec = BitVec::from_elem(u32::BITS as usize, false); b.iter(|| { let mut sum = 0; for _ in 0..10 { @@ -3052,7 +3052,7 @@ mod bit_set_bench { let mut bit_vec = BitSet::new(); b.iter(|| { for _ in 0..100 { - bit_vec.insert((r.next_u32() as usize) % u32::BITS); + bit_vec.insert((r.next_u32() as usize) % u32::BITS as usize); } black_box(&bit_vec); }); diff --git a/src/libcollections/enum_set.rs b/src/libcollections/enum_set.rs index 62dd91915211b..4c966c0d44b4d 100644 --- a/src/libcollections/enum_set.rs +++ b/src/libcollections/enum_set.rs @@ -78,7 +78,7 @@ pub trait CLike { fn bit(e: &E) -> usize { use core::usize; let value = e.to_usize(); - assert!(value < usize::BITS, + assert!(value < usize::BITS as usize, "EnumSet only supports up to {} variants.", usize::BITS - 1); 1 << value } @@ -95,7 +95,7 @@ impl EnumSet { #[unstable(feature = "collections", reason = "matches collection reform specification, waiting for dust to settle")] pub fn len(&self) -> usize { - self.bits.count_ones() + self.bits.count_ones() as usize } /// Returns true if the `EnumSet` is empty. @@ -250,7 +250,7 @@ impl Iterator for Iter { } fn size_hint(&self) -> (usize, Option) { - let exact = self.bits.count_ones(); + let exact = self.bits.count_ones() as usize; (exact, Some(exact)) } } diff --git a/src/libcore/fmt/float.rs b/src/libcore/fmt/float.rs index f92e631c1f25c..81eef132b9c65 100644 --- a/src/libcore/fmt/float.rs +++ b/src/libcore/fmt/float.rs @@ -156,7 +156,7 @@ pub fn float_to_str_bytes_common( deccum = deccum / radix_gen; deccum = deccum.trunc(); - let c = char::from_digit(current_digit.to_int().unwrap() as u32, radix); + let c = char::from_digit(current_digit.to_isize().unwrap() as u32, radix); buf[end] = c.unwrap() as u8; end += 1; @@ -211,7 +211,7 @@ pub fn float_to_str_bytes_common( // See note in first loop. let current_digit = deccum.trunc().abs(); - let c = char::from_digit(current_digit.to_int().unwrap() as u32, + let c = char::from_digit(current_digit.to_isize().unwrap() as u32, radix); buf[end] = c.unwrap() as u8; end += 1; diff --git a/src/libcore/hash/mod.rs b/src/libcore/hash/mod.rs index edc4b7e10ee49..4b545435ea171 100644 --- a/src/libcore/hash/mod.rs +++ b/src/libcore/hash/mod.rs @@ -182,7 +182,7 @@ mod impls { } fn hash_slice(data: &[$ty], state: &mut H) { - let newlen = data.len() * ::$ty::BYTES; + let newlen = data.len() * ::$ty::BYTES as usize; let ptr = data.as_ptr() as *const u8; state.write(unsafe { slice::from_raw_parts(ptr, newlen) }) } diff --git a/src/libcore/iter.rs b/src/libcore/iter.rs index 88a729a3db09e..518ec05f5b980 100644 --- a/src/libcore/iter.rs +++ b/src/libcore/iter.rs @@ -2467,7 +2467,7 @@ impl Iterator for Range { Some(a) => { let sz = self.stop.to_i64().map(|b| b.checked_sub(a)); match sz { - Some(Some(bound)) => bound.to_uint(), + Some(Some(bound)) => bound.to_usize(), _ => None, } }, @@ -2475,7 +2475,7 @@ impl Iterator for Range { Some(a) => { let sz = self.stop.to_u64().map(|b| b.checked_sub(a)); match sz { - Some(Some(bound)) => bound.to_uint(), + Some(Some(bound)) => bound.to_usize(), _ => None } }, @@ -2741,7 +2741,7 @@ impl Iterator for ::ops::Range { if self.start >= self.end { (0, Some(0)) } else { - let length = (self.end - self.start).to_uint(); + let length = (self.end - self.start).to_usize(); (length.unwrap_or(0), length) } } diff --git a/src/libcore/num/f32.rs b/src/libcore/num/f32.rs index b542c9d47f7d4..0d8e3044eccea 100644 --- a/src/libcore/num/f32.rs +++ b/src/libcore/num/f32.rs @@ -23,12 +23,12 @@ use num::FpCategory as Fp; use option::Option; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const RADIX: uint = 2; +pub const RADIX: u32 = 2; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MANTISSA_DIGITS: uint = 24; +pub const MANTISSA_DIGITS: u32 = 24; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const DIGITS: uint = 6; +pub const DIGITS: u32 = 6; #[stable(feature = "rust1", since = "1.0.0")] pub const EPSILON: f32 = 1.19209290e-07_f32; @@ -57,14 +57,14 @@ pub const MIN_POSITIVE: f32 = 1.17549435e-38_f32; pub const MAX: f32 = 3.40282347e+38_f32; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MIN_EXP: int = -125; +pub const MIN_EXP: i32 = -125; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MAX_EXP: int = 128; +pub const MAX_EXP: i32 = 128; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MIN_10_EXP: int = -37; +pub const MIN_10_EXP: i32 = -37; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MAX_10_EXP: int = 38; +pub const MAX_10_EXP: i32 = 38; #[stable(feature = "rust1", since = "1.0.0")] pub const NAN: f32 = 0.0_f32/0.0_f32; @@ -193,12 +193,12 @@ impl Float for f32 { #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn mantissa_digits(_: Option) -> uint { MANTISSA_DIGITS } + fn mantissa_digits(_: Option) -> uint { MANTISSA_DIGITS as uint } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn digits(_: Option) -> uint { DIGITS } + fn digits(_: Option) -> uint { DIGITS as uint } #[inline] #[unstable(feature = "core")] @@ -208,22 +208,22 @@ impl Float for f32 { #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn min_exp(_: Option) -> int { MIN_EXP } + fn min_exp(_: Option) -> int { MIN_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn max_exp(_: Option) -> int { MAX_EXP } + fn max_exp(_: Option) -> int { MAX_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn min_10_exp(_: Option) -> int { MIN_10_EXP } + fn min_10_exp(_: Option) -> int { MIN_10_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn max_10_exp(_: Option) -> int { MAX_10_EXP } + fn max_10_exp(_: Option) -> int { MAX_10_EXP as int } #[inline] #[unstable(feature = "core")] diff --git a/src/libcore/num/f64.rs b/src/libcore/num/f64.rs index 2aae7107548c6..d7e91058a46fb 100644 --- a/src/libcore/num/f64.rs +++ b/src/libcore/num/f64.rs @@ -27,11 +27,11 @@ use option::Option; // members of `Bounded` and `Float`. #[unstable(feature = "core", reason = "pending integer conventions")] -pub const RADIX: uint = 2; +pub const RADIX: u32 = 2; -pub const MANTISSA_DIGITS: uint = 53; +pub const MANTISSA_DIGITS: u32 = 53; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const DIGITS: uint = 15; +pub const DIGITS: u32 = 15; #[stable(feature = "rust1", since = "1.0.0")] pub const EPSILON: f64 = 2.2204460492503131e-16_f64; @@ -60,14 +60,14 @@ pub const MIN_POSITIVE: f64 = 2.2250738585072014e-308_f64; pub const MAX: f64 = 1.7976931348623157e+308_f64; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MIN_EXP: int = -1021; +pub const MIN_EXP: i32 = -1021; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MAX_EXP: int = 1024; +pub const MAX_EXP: i32 = 1024; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MIN_10_EXP: int = -307; +pub const MIN_10_EXP: i32 = -307; #[unstable(feature = "core", reason = "pending integer conventions")] -pub const MAX_10_EXP: int = 308; +pub const MAX_10_EXP: i32 = 308; #[stable(feature = "rust1", since = "1.0.0")] pub const NAN: f64 = 0.0_f64/0.0_f64; @@ -200,12 +200,12 @@ impl Float for f64 { #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn mantissa_digits(_: Option) -> uint { MANTISSA_DIGITS } + fn mantissa_digits(_: Option) -> uint { MANTISSA_DIGITS as uint } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn digits(_: Option) -> uint { DIGITS } + fn digits(_: Option) -> uint { DIGITS as uint } #[inline] #[unstable(feature = "core")] @@ -215,22 +215,22 @@ impl Float for f64 { #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn min_exp(_: Option) -> int { MIN_EXP } + fn min_exp(_: Option) -> int { MIN_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn max_exp(_: Option) -> int { MAX_EXP } + fn max_exp(_: Option) -> int { MAX_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn min_10_exp(_: Option) -> int { MIN_10_EXP } + fn min_10_exp(_: Option) -> int { MIN_10_EXP as int } #[inline] #[unstable(feature = "core")] #[deprecated(since = "1.0.0")] - fn max_10_exp(_: Option) -> int { MAX_10_EXP } + fn max_10_exp(_: Option) -> int { MAX_10_EXP as int } #[inline] #[unstable(feature = "core")] diff --git a/src/libcore/num/int_macros.rs b/src/libcore/num/int_macros.rs index 954c8a08e64d6..fe0d6d13c4c06 100644 --- a/src/libcore/num/int_macros.rs +++ b/src/libcore/num/int_macros.rs @@ -15,11 +15,11 @@ macro_rules! int_module { ($T:ty, $bits:expr) => ( // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. #[unstable(feature = "core")] -pub const BITS : uint = $bits; +pub const BITS : u32 = $bits; // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `mem::size_of` function. #[unstable(feature = "core")] -pub const BYTES : uint = ($bits / 8); +pub const BYTES : u32 = ($bits / 8); // FIXME(#11621): Should be deprecated once CTFE is implemented in favour of // calling the `Bounded::min_value` function. diff --git a/src/libcore/num/mod.rs b/src/libcore/num/mod.rs index 318799f59a810..d77a1eb4203c6 100644 --- a/src/libcore/num/mod.rs +++ b/src/libcore/num/mod.rs @@ -86,7 +86,7 @@ pub trait Int /// ``` #[unstable(feature = "core", reason = "pending integer conventions")] - fn count_ones(self) -> uint; + fn count_ones(self) -> u32; /// Returns the number of zeros in the binary representation of `self`. /// @@ -102,7 +102,7 @@ pub trait Int #[unstable(feature = "core", reason = "pending integer conventions")] #[inline] - fn count_zeros(self) -> uint { + fn count_zeros(self) -> u32 { (!self).count_ones() } @@ -120,7 +120,7 @@ pub trait Int /// ``` #[unstable(feature = "core", reason = "pending integer conventions")] - fn leading_zeros(self) -> uint; + fn leading_zeros(self) -> u32; /// Returns the number of trailing zeros in the binary representation /// of `self`. @@ -136,7 +136,7 @@ pub trait Int /// ``` #[unstable(feature = "core", reason = "pending integer conventions")] - fn trailing_zeros(self) -> uint; + fn trailing_zeros(self) -> u32; /// Shifts the bits to the left by a specified amount amount, `n`, wrapping /// the truncated bits to the end of the resulting integer. @@ -153,7 +153,7 @@ pub trait Int /// ``` #[unstable(feature = "core", reason = "pending integer conventions")] - fn rotate_left(self, n: uint) -> Self; + fn rotate_left(self, n: u32) -> Self; /// Shifts the bits to the right by a specified amount amount, `n`, wrapping /// the truncated bits to the beginning of the resulting integer. @@ -170,7 +170,7 @@ pub trait Int /// ``` #[unstable(feature = "core", reason = "pending integer conventions")] - fn rotate_right(self, n: uint) -> Self; + fn rotate_right(self, n: u32) -> Self; /// Reverses the byte order of the integer. /// @@ -418,23 +418,23 @@ macro_rules! uint_impl { fn max_value() -> $T { -1 } #[inline] - fn count_ones(self) -> uint { unsafe { $ctpop(self as $ActualT) as uint } } + fn count_ones(self) -> u32 { unsafe { $ctpop(self as $ActualT) as u32 } } #[inline] - fn leading_zeros(self) -> uint { unsafe { $ctlz(self as $ActualT) as uint } } + fn leading_zeros(self) -> u32 { unsafe { $ctlz(self as $ActualT) as u32 } } #[inline] - fn trailing_zeros(self) -> uint { unsafe { $cttz(self as $ActualT) as uint } } + fn trailing_zeros(self) -> u32 { unsafe { $cttz(self as $ActualT) as u32 } } #[inline] - fn rotate_left(self, n: uint) -> $T { + fn rotate_left(self, n: u32) -> $T { // Protect against undefined behaviour for over-long bit shifts let n = n % $BITS; (self << n) | (self >> (($BITS - n) % $BITS)) } #[inline] - fn rotate_right(self, n: uint) -> $T { + fn rotate_right(self, n: u32) -> $T { // Protect against undefined behaviour for over-long bit shifts let n = n % $BITS; (self >> n) | (self << (($BITS - n) % $BITS)) @@ -549,19 +549,19 @@ macro_rules! int_impl { fn max_value() -> $T { let min: $T = Int::min_value(); !min } #[inline] - fn count_ones(self) -> uint { (self as $UnsignedT).count_ones() } + fn count_ones(self) -> u32 { (self as $UnsignedT).count_ones() } #[inline] - fn leading_zeros(self) -> uint { (self as $UnsignedT).leading_zeros() } + fn leading_zeros(self) -> u32 { (self as $UnsignedT).leading_zeros() } #[inline] - fn trailing_zeros(self) -> uint { (self as $UnsignedT).trailing_zeros() } + fn trailing_zeros(self) -> u32 { (self as $UnsignedT).trailing_zeros() } #[inline] - fn rotate_left(self, n: uint) -> $T { (self as $UnsignedT).rotate_left(n) as $T } + fn rotate_left(self, n: u32) -> $T { (self as $UnsignedT).rotate_left(n) as $T } #[inline] - fn rotate_right(self, n: uint) -> $T { (self as $UnsignedT).rotate_right(n) as $T } + fn rotate_right(self, n: u32) -> $T { (self as $UnsignedT).rotate_right(n) as $T } #[inline] fn swap_bytes(self) -> $T { (self as $UnsignedT).swap_bytes() as $T } @@ -706,7 +706,7 @@ pub trait UnsignedInt: Int { fn next_power_of_two(self) -> Self { let bits = size_of::() * 8; let one: Self = Int::one(); - one << ((bits - (self - one).leading_zeros()) % bits) + one << ((bits - (self - one).leading_zeros() as usize) % bits) } /// Returns the smallest power of two greater than or equal to `n`. If the @@ -743,8 +743,16 @@ impl UnsignedInt for u64 {} pub trait ToPrimitive { /// Converts the value of `self` to an `int`. #[inline] + #[unstable(feature = "core")] + #[deprecated(since = "1.0.0", reason = "use to_isize")] fn to_int(&self) -> Option { - self.to_i64().and_then(|x| x.to_int()) + self.to_i64().and_then(|x| x.to_isize()) + } + + /// Converts the value of `self` to an `isize`. + #[inline] + fn to_isize(&self) -> Option { + self.to_i64().and_then(|x| x.to_isize()) } /// Converts the value of `self` to an `i8`. @@ -770,8 +778,16 @@ pub trait ToPrimitive { /// Converts the value of `self` to an `uint`. #[inline] + #[unstable(feature = "core")] + #[deprecated(since = "1.0.0", reason = "use to_usize")] fn to_uint(&self) -> Option { - self.to_u64().and_then(|x| x.to_uint()) + self.to_u64().and_then(|x| x.to_usize()) + } + + /// Converts the value of `self` to a `usize`. + #[inline] + fn to_usize(&self) -> Option { + self.to_u64().and_then(|x| x.to_usize()) } /// Converts the value of `self` to an `u8`. @@ -848,6 +864,8 @@ macro_rules! impl_to_primitive_int { #[inline] fn to_int(&self) -> Option { impl_to_primitive_int_to_int!($T, int, *self) } #[inline] + fn to_isize(&self) -> Option { impl_to_primitive_int_to_int!($T, isize, *self) } + #[inline] fn to_i8(&self) -> Option { impl_to_primitive_int_to_int!($T, i8, *self) } #[inline] fn to_i16(&self) -> Option { impl_to_primitive_int_to_int!($T, i16, *self) } @@ -859,6 +877,8 @@ macro_rules! impl_to_primitive_int { #[inline] fn to_uint(&self) -> Option { impl_to_primitive_int_to_uint!($T, uint, *self) } #[inline] + fn to_usize(&self) -> Option { impl_to_primitive_int_to_uint!($T, usize, *self) } + #[inline] fn to_u8(&self) -> Option { impl_to_primitive_int_to_uint!($T, u8, *self) } #[inline] fn to_u16(&self) -> Option { impl_to_primitive_int_to_uint!($T, u16, *self) } @@ -875,7 +895,7 @@ macro_rules! impl_to_primitive_int { ) } -impl_to_primitive_int! { int } +impl_to_primitive_int! { isize } impl_to_primitive_int! { i8 } impl_to_primitive_int! { i16 } impl_to_primitive_int! { i32 } @@ -918,6 +938,8 @@ macro_rules! impl_to_primitive_uint { #[inline] fn to_int(&self) -> Option { impl_to_primitive_uint_to_int!(int, *self) } #[inline] + fn to_isize(&self) -> Option { impl_to_primitive_uint_to_int!(isize, *self) } + #[inline] fn to_i8(&self) -> Option { impl_to_primitive_uint_to_int!(i8, *self) } #[inline] fn to_i16(&self) -> Option { impl_to_primitive_uint_to_int!(i16, *self) } @@ -929,6 +951,8 @@ macro_rules! impl_to_primitive_uint { #[inline] fn to_uint(&self) -> Option { impl_to_primitive_uint_to_uint!($T, uint, *self) } #[inline] + fn to_usize(&self) -> Option { impl_to_primitive_uint_to_uint!($T, usize, *self) } + #[inline] fn to_u8(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u8, *self) } #[inline] fn to_u16(&self) -> Option { impl_to_primitive_uint_to_uint!($T, u16, *self) } @@ -945,7 +969,7 @@ macro_rules! impl_to_primitive_uint { ) } -impl_to_primitive_uint! { uint } +impl_to_primitive_uint! { usize } impl_to_primitive_uint! { u8 } impl_to_primitive_uint! { u16 } impl_to_primitive_uint! { u32 } @@ -973,6 +997,8 @@ macro_rules! impl_to_primitive_float { #[inline] fn to_int(&self) -> Option { Some(*self as int) } #[inline] + fn to_isize(&self) -> Option { Some(*self as isize) } + #[inline] fn to_i8(&self) -> Option { Some(*self as i8) } #[inline] fn to_i16(&self) -> Option { Some(*self as i16) } @@ -984,6 +1010,8 @@ macro_rules! impl_to_primitive_float { #[inline] fn to_uint(&self) -> Option { Some(*self as uint) } #[inline] + fn to_usize(&self) -> Option { Some(*self as usize) } + #[inline] fn to_u8(&self) -> Option { Some(*self as u8) } #[inline] fn to_u16(&self) -> Option { Some(*self as u16) } @@ -1009,10 +1037,19 @@ pub trait FromPrimitive : ::marker::Sized { /// Convert an `int` to return an optional value of this type. If the /// value cannot be represented by this value, the `None` is returned. #[inline] + #[unstable(feature = "core")] + #[deprecated(since = "1.0.0", reason = "use from_isize")] fn from_int(n: int) -> Option { FromPrimitive::from_i64(n as i64) } + /// Convert an `isize` to return an optional value of this type. If the + /// value cannot be represented by this value, the `None` is returned. + #[inline] + fn from_isize(n: isize) -> Option { + FromPrimitive::from_i64(n as i64) + } + /// Convert an `i8` to return an optional value of this type. If the /// type cannot be represented by this value, the `None` is returned. #[inline] @@ -1041,10 +1078,19 @@ pub trait FromPrimitive : ::marker::Sized { /// Convert an `uint` to return an optional value of this type. If the /// type cannot be represented by this value, the `None` is returned. #[inline] + #[unstable(feature = "core")] + #[deprecated(since = "1.0.0", reason = "use from_usize")] fn from_uint(n: uint) -> Option { FromPrimitive::from_u64(n as u64) } + /// Convert a `usize` to return an optional value of this type. If the + /// type cannot be represented by this value, the `None` is returned. + #[inline] + fn from_usize(n: usize) -> Option { + FromPrimitive::from_u64(n as u64) + } + /// Convert an `u8` to return an optional value of this type. If the /// type cannot be represented by this value, the `None` is returned. #[inline] @@ -1087,8 +1133,15 @@ pub trait FromPrimitive : ::marker::Sized { /// A utility function that just calls `FromPrimitive::from_int`. #[unstable(feature = "core", reason = "likely to be removed")] +#[deprecated(since = "1.0.0", reason = "use from_isize")] pub fn from_int(n: int) -> Option { - FromPrimitive::from_int(n) + FromPrimitive::from_isize(n) +} + +/// A utility function that just calls `FromPrimitive::from_isize`. +#[unstable(feature = "core", reason = "likely to be removed")] +pub fn from_isize(n: isize) -> Option { + FromPrimitive::from_isize(n) } /// A utility function that just calls `FromPrimitive::from_i8`. @@ -1117,8 +1170,15 @@ pub fn from_i64(n: i64) -> Option { /// A utility function that just calls `FromPrimitive::from_uint`. #[unstable(feature = "core", reason = "likely to be removed")] +#[deprecated(since = "1.0.0", reason = "use from_uint")] pub fn from_uint(n: uint) -> Option { - FromPrimitive::from_uint(n) + FromPrimitive::from_usize(n) +} + +/// A utility function that just calls `FromPrimitive::from_usize`. +#[unstable(feature = "core", reason = "likely to be removed")] +pub fn from_usize(n: usize) -> Option { + FromPrimitive::from_usize(n) } /// A utility function that just calls `FromPrimitive::from_u8`. @@ -1718,12 +1778,12 @@ macro_rules! from_str_radix_int_impl { } } } -from_str_radix_int_impl! { int } +from_str_radix_int_impl! { isize } from_str_radix_int_impl! { i8 } from_str_radix_int_impl! { i16 } from_str_radix_int_impl! { i32 } from_str_radix_int_impl! { i64 } -from_str_radix_int_impl! { uint } +from_str_radix_int_impl! { usize } from_str_radix_int_impl! { u8 } from_str_radix_int_impl! { u16 } from_str_radix_int_impl! { u32 } diff --git a/src/libcore/num/uint_macros.rs b/src/libcore/num/uint_macros.rs index 06502be54aacc..330f0b91bf183 100644 --- a/src/libcore/num/uint_macros.rs +++ b/src/libcore/num/uint_macros.rs @@ -13,9 +13,9 @@ macro_rules! uint_module { ($T:ty, $T_SIGNED:ty, $bits:expr) => ( #[unstable(feature = "core")] -pub const BITS : uint = $bits; +pub const BITS : u32 = $bits; #[unstable(feature = "core")] -pub const BYTES : uint = ($bits / 8); +pub const BYTES : u32 = ($bits / 8); #[stable(feature = "rust1", since = "1.0.0")] pub const MIN: $T = 0 as $T; diff --git a/src/librustc/middle/astencode.rs b/src/librustc/middle/astencode.rs index 5983829ed8fbe..9f18a0e88e739 100644 --- a/src/librustc/middle/astencode.rs +++ b/src/librustc/middle/astencode.rs @@ -1837,7 +1837,7 @@ fn decode_side_tables(dcx: &DecodeContext, debug!(">> Side table document with tag 0x{:x} \ found for id {} (orig {})", tag, id, id0); - let decoded_tag: Option = FromPrimitive::from_uint(tag); + let decoded_tag: Option = FromPrimitive::from_usize(tag); match decoded_tag { None => { dcx.tcx.sess.bug( diff --git a/src/librustc/middle/dataflow.rs b/src/librustc/middle/dataflow.rs index 1718df702553f..faed3f5977fdc 100644 --- a/src/librustc/middle/dataflow.rs +++ b/src/librustc/middle/dataflow.rs @@ -205,7 +205,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { oper: O, id_range: IdRange, bits_per_id: uint) -> DataFlowContext<'a, 'tcx, O> { - let words_per_id = (bits_per_id + usize::BITS - 1) / usize::BITS; + let words_per_id = (bits_per_id + usize::BITS as usize - 1) / usize::BITS as usize; let num_nodes = cfg.graph.all_nodes().len(); debug!("DataFlowContext::new(analysis_name: {}, id_range={:?}, \ @@ -377,7 +377,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { for (word_index, &word) in words.iter().enumerate() { if word != 0 { - let base_index = word_index * usize::BITS; + let base_index = word_index * usize::BITS as usize; for offset in 0..usize::BITS { let bit = 1 << offset; if (word & bit) != 0 { @@ -390,7 +390,7 @@ impl<'a, 'tcx, O:DataFlowOperator> DataFlowContext<'a, 'tcx, O> { // whether the bit_index is greater than the // actual value the user specified and stop // iterating if so. - let bit_index = base_index + offset; + let bit_index = base_index + offset as usize; if bit_index >= self.bits_per_id { return true; } else if !f(bit_index) { @@ -609,8 +609,8 @@ fn bitwise(out_vec: &mut [uint], fn set_bit(words: &mut [uint], bit: uint) -> bool { debug!("set_bit: words={} bit={}", mut_bits_to_string(words), bit_str(bit)); - let word = bit / usize::BITS; - let bit_in_word = bit % usize::BITS; + let word = bit / usize::BITS as usize; + let bit_in_word = bit % usize::BITS as usize; let bit_mask = 1 << bit_in_word; debug!("word={} bit_in_word={} bit_mask={}", word, bit_in_word, word); let oldv = words[word]; diff --git a/src/librustc/middle/lang_items.rs b/src/librustc/middle/lang_items.rs index 56c5928a132b1..3525d46a1f2f1 100644 --- a/src/librustc/middle/lang_items.rs +++ b/src/librustc/middle/lang_items.rs @@ -71,7 +71,7 @@ impl LanguageItems { } pub fn item_name(index: uint) -> &'static str { - let item: Option = FromPrimitive::from_uint(index); + let item: Option = FromPrimitive::from_usize(index); match item { $( Some($variant) => $name, )* None => "???" diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs index f6d05f961e173..ca2e6ba5d5dfb 100644 --- a/src/libstd/num/strconv.rs +++ b/src/libstd/num/strconv.rs @@ -253,7 +253,7 @@ pub fn float_to_str_bytes_common( deccum = deccum / radix_gen; deccum = deccum.trunc(); - buf.push(char::from_digit(current_digit.to_int().unwrap() as u32, radix) + buf.push(char::from_digit(current_digit.to_isize().unwrap() as u32, radix) .unwrap() as u8); // No more digits to calculate for the non-fractional part -> break @@ -310,7 +310,7 @@ pub fn float_to_str_bytes_common( let current_digit = deccum.trunc().abs(); buf.push(char::from_digit( - current_digit.to_int().unwrap() as u32, radix).unwrap() as u8); + current_digit.to_isize().unwrap() as u32, radix).unwrap() as u8); // Decrease the deccumulator one fractional digit at a time deccum = deccum.fract(); diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs index b82572fc08957..728a5dac4e4c9 100644 --- a/src/libstd/old_io/mod.rs +++ b/src/libstd/old_io/mod.rs @@ -714,28 +714,28 @@ pub trait Reader { /// /// The number of bytes returned is system-dependent. fn read_le_uint(&mut self) -> IoResult { - self.read_le_uint_n(usize::BYTES).map(|i| i as uint) + self.read_le_uint_n(usize::BYTES as usize).map(|i| i as uint) } /// Reads a little-endian integer. /// /// The number of bytes returned is system-dependent. fn read_le_int(&mut self) -> IoResult { - self.read_le_int_n(isize::BYTES).map(|i| i as int) + self.read_le_int_n(isize::BYTES as usize).map(|i| i as int) } /// Reads a big-endian unsigned integer. /// /// The number of bytes returned is system-dependent. fn read_be_uint(&mut self) -> IoResult { - self.read_be_uint_n(usize::BYTES).map(|i| i as uint) + self.read_be_uint_n(usize::BYTES as usize).map(|i| i as uint) } /// Reads a big-endian integer. /// /// The number of bytes returned is system-dependent. fn read_be_int(&mut self) -> IoResult { - self.read_be_int_n(isize::BYTES).map(|i| i as int) + self.read_be_int_n(isize::BYTES as usize).map(|i| i as int) } /// Reads a big-endian `u64`. @@ -1098,25 +1098,25 @@ pub trait Writer { /// Write a little-endian uint (number of bytes depends on system). #[inline] fn write_le_uint(&mut self, n: uint) -> IoResult<()> { - extensions::u64_to_le_bytes(n as u64, usize::BYTES, |v| self.write_all(v)) + extensions::u64_to_le_bytes(n as u64, usize::BYTES as usize, |v| self.write_all(v)) } /// Write a little-endian int (number of bytes depends on system). #[inline] fn write_le_int(&mut self, n: int) -> IoResult<()> { - extensions::u64_to_le_bytes(n as u64, isize::BYTES, |v| self.write_all(v)) + extensions::u64_to_le_bytes(n as u64, isize::BYTES as usize, |v| self.write_all(v)) } /// Write a big-endian uint (number of bytes depends on system). #[inline] fn write_be_uint(&mut self, n: uint) -> IoResult<()> { - extensions::u64_to_be_bytes(n as u64, usize::BYTES, |v| self.write_all(v)) + extensions::u64_to_be_bytes(n as u64, usize::BYTES as usize, |v| self.write_all(v)) } /// Write a big-endian int (number of bytes depends on system). #[inline] fn write_be_int(&mut self, n: int) -> IoResult<()> { - extensions::u64_to_be_bytes(n as u64, isize::BYTES, |v| self.write_all(v)) + extensions::u64_to_be_bytes(n as u64, isize::BYTES as usize, |v| self.write_all(v)) } /// Write a big-endian u64 (8 bytes). diff --git a/src/libstd/sys/unix/c.rs b/src/libstd/sys/unix/c.rs index 14394a653b0ed..4e9f9c80a1821 100644 --- a/src/libstd/sys/unix/c.rs +++ b/src/libstd/sys/unix/c.rs @@ -194,12 +194,12 @@ mod select { #[repr(C)] pub struct fd_set { // FIXME: shouldn't this be a c_ulong? - fds_bits: [libc::uintptr_t; (FD_SETSIZE / usize::BITS)] + fds_bits: [libc::uintptr_t; (FD_SETSIZE / usize::BITS as usize)] } pub fn fd_set(set: &mut fd_set, fd: i32) { let fd = fd as uint; - set.fds_bits[fd / usize::BITS] |= 1 << (fd % usize::BITS); + set.fds_bits[fd / usize::BITS as usize] |= 1 << (fd % usize::BITS as usize); } } diff --git a/src/libtest/stats.rs b/src/libtest/stats.rs index 7cc07e926b267..42812e1e597bc 100644 --- a/src/libtest/stats.rs +++ b/src/libtest/stats.rs @@ -210,11 +210,11 @@ impl Stats for [T] { fn mean(&self) -> T { assert!(self.len() != 0); - self.sum() / FromPrimitive::from_uint(self.len()).unwrap() + self.sum() / FromPrimitive::from_usize(self.len()).unwrap() } fn median(&self) -> T { - self.percentile(FromPrimitive::from_uint(50).unwrap()) + self.percentile(FromPrimitive::from_usize(50).unwrap()) } fn var(&self) -> T { @@ -230,7 +230,7 @@ impl Stats for [T] { // NB: this is _supposed to be_ len-1, not len. If you // change it back to len, you will be calculating a // population variance, not a sample variance. - let denom = FromPrimitive::from_uint(self.len()-1).unwrap(); + let denom = FromPrimitive::from_usize(self.len()-1).unwrap(); v/denom } } @@ -240,7 +240,7 @@ impl Stats for [T] { } fn std_dev_pct(&self) -> T { - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_usize(100).unwrap(); (self.std_dev() / self.mean()) * hundred } @@ -254,7 +254,7 @@ impl Stats for [T] { } fn median_abs_dev_pct(&self) -> T { - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_usize(100).unwrap(); (self.median_abs_dev() / self.median()) * hundred } @@ -267,11 +267,11 @@ impl Stats for [T] { fn quartiles(&self) -> (T,T,T) { let mut tmp = self.to_vec(); local_sort(&mut tmp); - let first = FromPrimitive::from_uint(25).unwrap(); + let first = FromPrimitive::from_usize(25).unwrap(); let a = percentile_of_sorted(&tmp, first); - let secound = FromPrimitive::from_uint(50).unwrap(); + let secound = FromPrimitive::from_usize(50).unwrap(); let b = percentile_of_sorted(&tmp, secound); - let third = FromPrimitive::from_uint(75).unwrap(); + let third = FromPrimitive::from_usize(75).unwrap(); let c = percentile_of_sorted(&tmp, third); (a,b,c) } @@ -293,16 +293,16 @@ fn percentile_of_sorted(sorted_samples: &[T], } let zero: T = Float::zero(); assert!(zero <= pct); - let hundred = FromPrimitive::from_uint(100).unwrap(); + let hundred = FromPrimitive::from_usize(100).unwrap(); assert!(pct <= hundred); if pct == hundred { return sorted_samples[sorted_samples.len() - 1]; } - let length = FromPrimitive::from_uint(sorted_samples.len() - 1).unwrap(); + let length = FromPrimitive::from_usize(sorted_samples.len() - 1).unwrap(); let rank = (pct / hundred) * length; let lrank = rank.floor(); let d = rank - lrank; - let n = lrank.to_uint().unwrap(); + let n = lrank.to_usize().unwrap(); let lo = sorted_samples[n]; let hi = sorted_samples[n+1]; lo + (hi - lo) * d @@ -319,7 +319,7 @@ pub fn winsorize(samples: &mut [T], pct: T) { let mut tmp = samples.to_vec(); local_sort(&mut tmp); let lo = percentile_of_sorted(&tmp, pct); - let hundred: T = FromPrimitive::from_uint(100).unwrap(); + let hundred: T = FromPrimitive::from_usize(100).unwrap(); let hi = percentile_of_sorted(&tmp, hundred-pct); for samp in samples { if *samp > hi { diff --git a/src/test/run-pass/vector-sort-panic-safe.rs b/src/test/run-pass/vector-sort-panic-safe.rs index 08d39e58b7ce2..a6f4b8299cb68 100644 --- a/src/test/run-pass/vector-sort-panic-safe.rs +++ b/src/test/run-pass/vector-sort-panic-safe.rs @@ -53,7 +53,7 @@ impl Drop for DropCounter { } pub fn main() { - assert!(MAX_LEN <= std::usize::BITS); + assert!(MAX_LEN <= std::usize::BITS as usize); // len can't go above 64. for len in 2..MAX_LEN { for _ in 0..REPEATS {