diff options
| -rw-r--r-- | src/liballoc/lib.rs | 1 | ||||
| -rw-r--r-- | src/libcoretest/fmt/num.rs | 28 | ||||
| -rw-r--r-- | src/libcoretest/lib.rs | 9 | ||||
| -rw-r--r-- | src/librand/lib.rs | 2 | ||||
| -rw-r--r-- | src/librbml/lib.rs | 2 | ||||
| -rw-r--r-- | src/libstd/collections/hash/map.rs | 2 | ||||
| -rw-r--r-- | src/libstd/fs.rs | 6 | ||||
| -rw-r--r-- | src/libstd/io/buffered.rs | 7 | ||||
| -rw-r--r-- | src/libstd/io/mod.rs | 8 | ||||
| -rw-r--r-- | src/libstd/lib.rs | 7 | ||||
| -rw-r--r-- | src/libstd/net/tcp.rs | 6 | ||||
| -rw-r--r-- | src/libstd/net/test.rs | 2 | ||||
| -rw-r--r-- | src/libstd/num/int.rs | 22 | ||||
| -rw-r--r-- | src/libstd/num/mod.rs | 210 | ||||
| -rw-r--r-- | src/libstd/num/uint.rs | 22 | ||||
| -rw-r--r-- | src/libstd/old_io/mod.rs | 2 | ||||
| -rw-r--r-- | src/libstd/old_path/mod.rs | 2 | ||||
| -rwxr-xr-x | src/libstd/path.rs | 1 | ||||
| -rw-r--r-- | src/libstd/process.rs | 8 | ||||
| -rw-r--r-- | src/libstd/thread.rs | 4 |
20 files changed, 157 insertions, 194 deletions
diff --git a/src/liballoc/lib.rs b/src/liballoc/lib.rs index bc349ebebde..0cdc71b6f60 100644 --- a/src/liballoc/lib.rs +++ b/src/liballoc/lib.rs @@ -73,6 +73,7 @@ #![feature(unboxed_closures)] #![feature(unsafe_no_drop_flag)] #![feature(core)] +#![cfg_attr(test, feature(test, alloc, rustc_private))] #![cfg_attr(all(not(feature = "external_funcs"), not(feature = "external_crate")), feature(libc))] diff --git a/src/libcoretest/fmt/num.rs b/src/libcoretest/fmt/num.rs index bc8461b0b9e..bc3995439a0 100644 --- a/src/libcoretest/fmt/num.rs +++ b/src/libcoretest/fmt/num.rs @@ -170,42 +170,42 @@ mod u32 { use test::Bencher; use core::fmt::radix; use std::rand::{weak_rng, Rng}; - use std::old_io::util::NullWriter; + use std::io::{Write, sink}; #[bench] fn format_bin(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:b}", rng.gen::<u32>()) }) + b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<u32>()) }) } #[bench] fn format_oct(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:o}", rng.gen::<u32>()) }) + b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<u32>()) }) } #[bench] fn format_dec(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{}", rng.gen::<u32>()) }) + b.iter(|| { write!(&mut sink(), "{}", rng.gen::<u32>()) }) } #[bench] fn format_hex(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:x}", rng.gen::<u32>()) }) + b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<u32>()) }) } #[bench] fn format_show(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:?}", rng.gen::<u32>()) }) + b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<u32>()) }) } #[bench] fn format_base_36(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{}", radix(rng.gen::<u32>(), 36)) }) + b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<u32>(), 36)) }) } } @@ -213,41 +213,41 @@ mod i32 { use test::Bencher; use core::fmt::radix; use std::rand::{weak_rng, Rng}; - use std::old_io::util::NullWriter; + use std::io::{Write, sink}; #[bench] fn format_bin(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:b}", rng.gen::<i32>()) }) + b.iter(|| { write!(&mut sink(), "{:b}", rng.gen::<i32>()) }) } #[bench] fn format_oct(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:o}", rng.gen::<i32>()) }) + b.iter(|| { write!(&mut sink(), "{:o}", rng.gen::<i32>()) }) } #[bench] fn format_dec(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{}", rng.gen::<i32>()) }) + b.iter(|| { write!(&mut sink(), "{}", rng.gen::<i32>()) }) } #[bench] fn format_hex(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:x}", rng.gen::<i32>()) }) + b.iter(|| { write!(&mut sink(), "{:x}", rng.gen::<i32>()) }) } #[bench] fn format_show(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{:?}", rng.gen::<i32>()) }) + b.iter(|| { write!(&mut sink(), "{:?}", rng.gen::<i32>()) }) } #[bench] fn format_base_36(b: &mut Bencher) { let mut rng = weak_rng(); - b.iter(|| { write!(&mut NullWriter, "{}", radix(rng.gen::<i32>(), 36)) }) + b.iter(|| { write!(&mut sink(), "{}", radix(rng.gen::<i32>(), 36)) }) } } diff --git a/src/libcoretest/lib.rs b/src/libcoretest/lib.rs index 2dfd81f32c2..03924910e04 100644 --- a/src/libcoretest/lib.rs +++ b/src/libcoretest/lib.rs @@ -12,6 +12,15 @@ #![feature(int_uint)] #![feature(unboxed_closures)] #![feature(unsafe_destructor)] +#![feature(core)] +#![feature(test)] +#![feature(rand)] +#![feature(unicode)] +#![feature(std_misc)] +#![feature(libc)] +#![feature(hash)] +#![feature(io)] +#![feature(collections)] #![allow(deprecated)] // rand extern crate core; diff --git a/src/librand/lib.rs b/src/librand/lib.rs index 7588bf7c515..583c658dfe0 100644 --- a/src/librand/lib.rs +++ b/src/librand/lib.rs @@ -32,6 +32,8 @@ #![deprecated(reason = "use the crates.io `rand` library instead", since = "1.0.0-alpha")] +#![cfg_attr(test, feature(test, rand))] + #![allow(deprecated)] #[macro_use] diff --git a/src/librbml/lib.rs b/src/librbml/lib.rs index 4af322089d5..c48dd7a6ee8 100644 --- a/src/librbml/lib.rs +++ b/src/librbml/lib.rs @@ -32,6 +32,8 @@ #![feature(rustc_private)] #![feature(staged_api)] +#![cfg_attr(test, feature(test))] + extern crate serialize; #[macro_use] extern crate log; diff --git a/src/libstd/collections/hash/map.rs b/src/libstd/collections/hash/map.rs index ade4f1f0533..f5d2b8aed29 100644 --- a/src/libstd/collections/hash/map.rs +++ b/src/libstd/collections/hash/map.rs @@ -88,7 +88,6 @@ impl DefaultResizePolicy { #[test] fn test_resize_policy() { - use prelude::v1::*; let rp = DefaultResizePolicy; for n in 0..1000 { assert!(rp.min_capacity(rp.usable_capacity(n)) <= n); @@ -2256,6 +2255,7 @@ mod test_map { #[test] fn test_entry_take_doesnt_corrupt() { + #![allow(deprecated)] //rand // Test for #19292 fn check(m: &HashMap<isize, ()>) { for k in m.keys() { diff --git a/src/libstd/fs.rs b/src/libstd/fs.rs index 69791084e2f..98c1b50a9bf 100644 --- a/src/libstd/fs.rs +++ b/src/libstd/fs.rs @@ -744,6 +744,8 @@ pub fn set_permissions<P: AsPath + ?Sized>(path: &P, perm: Permissions) #[cfg(test)] mod tests { + #![allow(deprecated)] //rand + use prelude::v1::*; use io::prelude::*; @@ -1035,7 +1037,7 @@ mod tests { let msg = msg_str.as_bytes(); check!(w.write(msg)); } - let mut files = check!(fs::read_dir(dir)); + let files = check!(fs::read_dir(dir)); let mut mem = [0u8; 4]; for f in files { let f = f.unwrap().path(); @@ -1065,7 +1067,7 @@ mod tests { check!(fs::create_dir_all(dir2)); check!(File::create(&dir2.join("14"))); - let mut files = check!(fs::walk_dir(dir)); + let files = check!(fs::walk_dir(dir)); let mut cur = [0u8; 2]; for f in files { let f = f.unwrap().path(); diff --git a/src/libstd/io/buffered.rs b/src/libstd/io/buffered.rs index e9a8dbb4098..9ef31978236 100644 --- a/src/libstd/io/buffered.rs +++ b/src/libstd/io/buffered.rs @@ -497,7 +497,6 @@ mod tests { assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8]); writer.write(&[9, 10, 11]).unwrap(); - let a: &[_] = &[0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]; assert_eq!(*writer.get_ref(), [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11]); writer.flush().unwrap(); @@ -593,7 +592,7 @@ mod tests { #[test] fn test_lines() { let in_buf = b"a\nb\nc"; - let mut reader = BufReader::with_capacity(2, in_buf); + let reader = BufReader::with_capacity(2, in_buf); let mut it = reader.lines(); assert_eq!(it.next(), Some(Ok("a".to_string()))); assert_eq!(it.next(), Some(Ok("b".to_string()))); @@ -618,14 +617,14 @@ mod tests { #[test] fn read_char_buffered() { let buf = [195u8, 159u8]; - let mut reader = BufReader::with_capacity(1, &buf[..]); + let reader = BufReader::with_capacity(1, &buf[..]); assert_eq!(reader.chars().next(), Some(Ok('ß'))); } #[test] fn test_chars() { let buf = [195u8, 159u8, b'a']; - let mut reader = BufReader::with_capacity(1, &buf[..]); + let reader = BufReader::with_capacity(1, &buf[..]); let mut it = reader.chars(); assert_eq!(it.next(), Some(Ok('ß'))); assert_eq!(it.next(), Some(Ok('a'))); diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs index 1133bd87a7d..5b319f4c687 100644 --- a/src/libstd/io/mod.rs +++ b/src/libstd/io/mod.rs @@ -869,12 +869,12 @@ mod tests { #[test] fn split() { - let mut buf = Cursor::new(b"12"); + let buf = Cursor::new(b"12"); let mut s = buf.split(b'3'); assert_eq!(s.next(), Some(Ok(vec![b'1', b'2']))); assert_eq!(s.next(), None); - let mut buf = Cursor::new(b"1233"); + let buf = Cursor::new(b"1233"); let mut s = buf.split(b'3'); assert_eq!(s.next(), Some(Ok(vec![b'1', b'2']))); assert_eq!(s.next(), Some(Ok(vec![]))); @@ -902,12 +902,12 @@ mod tests { #[test] fn lines() { - let mut buf = Cursor::new(b"12"); + let buf = Cursor::new(b"12"); let mut s = buf.lines(); assert_eq!(s.next(), Some(Ok("12".to_string()))); assert_eq!(s.next(), None); - let mut buf = Cursor::new(b"12\n\n"); + let buf = Cursor::new(b"12\n\n"); let mut s = buf.lines(); assert_eq!(s.next(), Some(Ok("12".to_string()))); assert_eq!(s.next(), Some(Ok(String::new()))); diff --git a/src/libstd/lib.rs b/src/libstd/lib.rs index fbd403ea593..4b6e9cf76f9 100644 --- a/src/libstd/lib.rs +++ b/src/libstd/lib.rs @@ -109,7 +109,6 @@ #![feature(box_syntax)] #![feature(collections)] #![feature(core)] -#![feature(hash)] #![feature(int_uint)] #![feature(lang_items)] #![feature(libc)] @@ -123,7 +122,7 @@ #![feature(unsafe_destructor)] #![feature(unsafe_no_drop_flag)] #![feature(macro_reexport)] -#![cfg_attr(test, feature(test))] +#![cfg_attr(test, feature(test, rustc_private, env))] // Don't link to std. We are std. #![feature(no_std)] @@ -219,15 +218,15 @@ mod int_macros; #[macro_use] mod uint_macros; -#[path = "num/int.rs"] pub mod int; #[path = "num/isize.rs"] pub mod isize; +pub use isize as int; #[path = "num/i8.rs"] pub mod i8; #[path = "num/i16.rs"] pub mod i16; #[path = "num/i32.rs"] pub mod i32; #[path = "num/i64.rs"] pub mod i64; -#[path = "num/uint.rs"] pub mod uint; #[path = "num/usize.rs"] pub mod usize; +pub use usize as uint; #[path = "num/u8.rs"] pub mod u8; #[path = "num/u16.rs"] pub mod u16; #[path = "num/u32.rs"] pub mod u32; diff --git a/src/libstd/net/tcp.rs b/src/libstd/net/tcp.rs index b861b74947e..f99cd2b1d1b 100644 --- a/src/libstd/net/tcp.rs +++ b/src/libstd/net/tcp.rs @@ -456,12 +456,6 @@ mod tests { } } - pub fn socket_name(addr: SocketAddr) { - } - - pub fn peer_name(addr: SocketAddr) { - } - #[test] fn socket_and_peer_name_ip4() { each_ip(&mut |addr| { diff --git a/src/libstd/net/test.rs b/src/libstd/net/test.rs index 971fb4b69c8..c70e92884ac 100644 --- a/src/libstd/net/test.rs +++ b/src/libstd/net/test.rs @@ -33,7 +33,7 @@ fn base_port() -> u16 { let cwd = env::current_dir().unwrap(); let dirs = ["32-opt", "32-nopt", "64-opt", "64-nopt", "64-opt-vg", "all-opt", "snap3", "dist"]; - dirs.iter().enumerate().find(|&(i, dir)| { + dirs.iter().enumerate().find(|&(_, dir)| { cwd.as_str().unwrap().contains(dir) }).map(|p| p.0).unwrap_or(0) as u16 * 1000 + 19600 } diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs deleted file mode 100644 index 669952eee39..00000000000 --- a/src/libstd/num/int.rs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Deprecated: replaced by `isize`. -//! -//! The rollout of the new type will gradually take place over the -//! alpha cycle along with the development of clearer conventions -//! around integer types. - -#![unstable(feature = "std_misc")] -#![deprecated(since = "1.0.0", reason = "replaced by isize")] - -pub use core::int::{BITS, BYTES, MIN, MAX}; - -int_module! { int } diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs index c94c1649833..968adfafeab 100644 --- a/src/libstd/num/mod.rs +++ b/src/libstd/num/mod.rs @@ -11,7 +11,7 @@ //! Numeric traits and functions for generic mathematics //! //! These are implemented for the primitive numeric types in `std::{u8, u16, -//! u32, u64, uint, i8, i16, i32, i64, int, f32, f64}`. +//! u32, u64, usize, i8, i16, i32, i64, isize, f32, f64}`. #![stable(feature = "rust1", since = "1.0.0")] #![allow(missing_docs)] @@ -146,12 +146,12 @@ pub trait Float #[deprecated(since = "1.0.0", reason = "use `std::f32::MANTISSA_DIGITS` or \ `std::f64::MANTISSA_DIGITS` as appropriate")] - fn mantissa_digits(unused_self: Option<Self>) -> uint; + fn mantissa_digits(unused_self: Option<Self>) -> usize; /// Deprecated: use `std::f32::DIGITS` or `std::f64::DIGITS` instead. #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", reason = "use `std::f32::DIGITS` or `std::f64::DIGITS` as appropriate")] - fn digits(unused_self: Option<Self>) -> uint; + fn digits(unused_self: Option<Self>) -> usize; /// Deprecated: use `std::f32::EPSILON` or `std::f64::EPSILON` instead. #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", @@ -161,22 +161,22 @@ pub trait Float #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", reason = "use `std::f32::MIN_EXP` or `std::f64::MIN_EXP` as appropriate")] - fn min_exp(unused_self: Option<Self>) -> int; + fn min_exp(unused_self: Option<Self>) -> isize; /// Deprecated: use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` instead. #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", reason = "use `std::f32::MAX_EXP` or `std::f64::MAX_EXP` as appropriate")] - fn max_exp(unused_self: Option<Self>) -> int; + fn max_exp(unused_self: Option<Self>) -> isize; /// Deprecated: use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` instead. #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", reason = "use `std::f32::MIN_10_EXP` or `std::f64::MIN_10_EXP` as appropriate")] - fn min_10_exp(unused_self: Option<Self>) -> int; + fn min_10_exp(unused_self: Option<Self>) -> isize; /// Deprecated: use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` instead. #[unstable(feature = "std_misc")] #[deprecated(since = "1.0.0", reason = "use `std::f32::MAX_10_EXP` or `std::f64::MAX_10_EXP` as appropriate")] - fn max_10_exp(unused_self: Option<Self>) -> int; + fn max_10_exp(unused_self: Option<Self>) -> isize; /// Returns the smallest finite value that this type can represent. /// @@ -698,7 +698,7 @@ pub trait Float /// ``` #[unstable(feature = "std_misc", reason = "pending integer conventions")] - fn ldexp(x: Self, exp: int) -> Self; + fn ldexp(x: Self, exp: isize) -> Self; /// Breaks the number into a normalized fraction and a base-2 exponent, /// satisfying: /// @@ -720,7 +720,7 @@ pub trait Float /// ``` #[unstable(feature = "std_misc", reason = "pending integer conventions")] - fn frexp(self) -> (Self, int); + fn frexp(self) -> (Self, isize); /// Returns the next representable floating-point value in the direction of /// `other`. /// @@ -1112,12 +1112,12 @@ mod tests { use i16; use i32; use i64; - use int; + use isize; use u8; use u16; use u32; use u64; - use uint; + use usize; macro_rules! test_cast_20 { ($_20:expr) => ({ @@ -1179,25 +1179,25 @@ mod tests { #[test] fn test_cast_range_int_min() { - assert_eq!(int::MIN.to_int(), Some(int::MIN as int)); - assert_eq!(int::MIN.to_i8(), None); - assert_eq!(int::MIN.to_i16(), None); - // int::MIN.to_i32() is word-size specific - assert_eq!(int::MIN.to_i64(), Some(int::MIN as i64)); - assert_eq!(int::MIN.to_uint(), None); - assert_eq!(int::MIN.to_u8(), None); - assert_eq!(int::MIN.to_u16(), None); - assert_eq!(int::MIN.to_u32(), None); - assert_eq!(int::MIN.to_u64(), None); + assert_eq!(isize::MIN.to_int(), Some(isize::MIN as isize)); + assert_eq!(isize::MIN.to_i8(), None); + assert_eq!(isize::MIN.to_i16(), None); + // isize::MIN.to_i32() is word-size specific + assert_eq!(isize::MIN.to_i64(), Some(isize::MIN as i64)); + assert_eq!(isize::MIN.to_uint(), None); + assert_eq!(isize::MIN.to_u8(), None); + assert_eq!(isize::MIN.to_u16(), None); + assert_eq!(isize::MIN.to_u32(), None); + assert_eq!(isize::MIN.to_u64(), None); #[cfg(target_pointer_width = "32")] fn check_word_size() { - assert_eq!(int::MIN.to_i32(), Some(int::MIN as i32)); + assert_eq!(isize::MIN.to_i32(), Some(isize::MIN as i32)); } #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(int::MIN.to_i32(), None); + assert_eq!(isize::MIN.to_i32(), None); } check_word_size(); @@ -1205,7 +1205,7 @@ mod tests { #[test] fn test_cast_range_i8_min() { - assert_eq!(i8::MIN.to_int(), Some(i8::MIN as int)); + assert_eq!(i8::MIN.to_int(), Some(i8::MIN as isize)); assert_eq!(i8::MIN.to_i8(), Some(i8::MIN as i8)); assert_eq!(i8::MIN.to_i16(), Some(i8::MIN as i16)); assert_eq!(i8::MIN.to_i32(), Some(i8::MIN as i32)); @@ -1219,7 +1219,7 @@ mod tests { #[test] fn test_cast_range_i16_min() { - assert_eq!(i16::MIN.to_int(), Some(i16::MIN as int)); + assert_eq!(i16::MIN.to_int(), Some(i16::MIN as isize)); assert_eq!(i16::MIN.to_i8(), None); assert_eq!(i16::MIN.to_i16(), Some(i16::MIN as i16)); assert_eq!(i16::MIN.to_i32(), Some(i16::MIN as i32)); @@ -1233,7 +1233,7 @@ mod tests { #[test] fn test_cast_range_i32_min() { - assert_eq!(i32::MIN.to_int(), Some(i32::MIN as int)); + assert_eq!(i32::MIN.to_int(), Some(i32::MIN as isize)); assert_eq!(i32::MIN.to_i8(), None); assert_eq!(i32::MIN.to_i16(), None); assert_eq!(i32::MIN.to_i32(), Some(i32::MIN as i32)); @@ -1265,7 +1265,7 @@ mod tests { #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(i64::MIN.to_int(), Some(i64::MIN as int)); + assert_eq!(i64::MIN.to_int(), Some(i64::MIN as isize)); } check_word_size(); @@ -1273,26 +1273,26 @@ mod tests { #[test] fn test_cast_range_int_max() { - assert_eq!(int::MAX.to_int(), Some(int::MAX as int)); - assert_eq!(int::MAX.to_i8(), None); - assert_eq!(int::MAX.to_i16(), None); - // int::MAX.to_i32() is word-size specific - assert_eq!(int::MAX.to_i64(), Some(int::MAX as i64)); - assert_eq!(int::MAX.to_u8(), None); - assert_eq!(int::MAX.to_u16(), None); - // int::MAX.to_u32() is word-size specific - assert_eq!(int::MAX.to_u64(), Some(int::MAX as u64)); + assert_eq!(isize::MAX.to_int(), Some(isize::MAX as isize)); + assert_eq!(isize::MAX.to_i8(), None); + assert_eq!(isize::MAX.to_i16(), None); + // isize::MAX.to_i32() is word-size specific + assert_eq!(isize::MAX.to_i64(), Some(isize::MAX as i64)); + assert_eq!(isize::MAX.to_u8(), None); + assert_eq!(isize::MAX.to_u16(), None); + // isize::MAX.to_u32() is word-size specific + assert_eq!(isize::MAX.to_u64(), Some(isize::MAX as u64)); #[cfg(target_pointer_width = "32")] fn check_word_size() { - assert_eq!(int::MAX.to_i32(), Some(int::MAX as i32)); - assert_eq!(int::MAX.to_u32(), Some(int::MAX as u32)); + assert_eq!(isize::MAX.to_i32(), Some(isize::MAX as i32)); + assert_eq!(isize::MAX.to_u32(), Some(isize::MAX as u32)); } #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(int::MAX.to_i32(), None); - assert_eq!(int::MAX.to_u32(), None); + assert_eq!(isize::MAX.to_i32(), None); + assert_eq!(isize::MAX.to_u32(), None); } check_word_size(); @@ -1300,12 +1300,12 @@ mod tests { #[test] fn test_cast_range_i8_max() { - assert_eq!(i8::MAX.to_int(), Some(i8::MAX as int)); + assert_eq!(i8::MAX.to_int(), Some(i8::MAX as isize)); assert_eq!(i8::MAX.to_i8(), Some(i8::MAX as i8)); assert_eq!(i8::MAX.to_i16(), Some(i8::MAX as i16)); assert_eq!(i8::MAX.to_i32(), Some(i8::MAX as i32)); assert_eq!(i8::MAX.to_i64(), Some(i8::MAX as i64)); - assert_eq!(i8::MAX.to_uint(), Some(i8::MAX as uint)); + assert_eq!(i8::MAX.to_uint(), Some(i8::MAX as usize)); assert_eq!(i8::MAX.to_u8(), Some(i8::MAX as u8)); assert_eq!(i8::MAX.to_u16(), Some(i8::MAX as u16)); assert_eq!(i8::MAX.to_u32(), Some(i8::MAX as u32)); @@ -1314,12 +1314,12 @@ mod tests { #[test] fn test_cast_range_i16_max() { - assert_eq!(i16::MAX.to_int(), Some(i16::MAX as int)); + assert_eq!(i16::MAX.to_int(), Some(i16::MAX as isize)); assert_eq!(i16::MAX.to_i8(), None); assert_eq!(i16::MAX.to_i16(), Some(i16::MAX as i16)); assert_eq!(i16::MAX.to_i32(), Some(i16::MAX as i32)); assert_eq!(i16::MAX.to_i64(), Some(i16::MAX as i64)); - assert_eq!(i16::MAX.to_uint(), Some(i16::MAX as uint)); + assert_eq!(i16::MAX.to_uint(), Some(i16::MAX as usize)); assert_eq!(i16::MAX.to_u8(), None); assert_eq!(i16::MAX.to_u16(), Some(i16::MAX as u16)); assert_eq!(i16::MAX.to_u32(), Some(i16::MAX as u32)); @@ -1328,12 +1328,12 @@ mod tests { #[test] fn test_cast_range_i32_max() { - assert_eq!(i32::MAX.to_int(), Some(i32::MAX as int)); + assert_eq!(i32::MAX.to_int(), Some(i32::MAX as isize)); assert_eq!(i32::MAX.to_i8(), None); assert_eq!(i32::MAX.to_i16(), None); assert_eq!(i32::MAX.to_i32(), Some(i32::MAX as i32)); assert_eq!(i32::MAX.to_i64(), Some(i32::MAX as i64)); - assert_eq!(i32::MAX.to_uint(), Some(i32::MAX as uint)); + assert_eq!(i32::MAX.to_uint(), Some(i32::MAX as usize)); assert_eq!(i32::MAX.to_u8(), None); assert_eq!(i32::MAX.to_u16(), None); assert_eq!(i32::MAX.to_u32(), Some(i32::MAX as u32)); @@ -1361,8 +1361,8 @@ mod tests { #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(i64::MAX.to_int(), Some(i64::MAX as int)); - assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as uint)); + assert_eq!(i64::MAX.to_int(), Some(i64::MAX as isize)); + assert_eq!(i64::MAX.to_uint(), Some(i64::MAX as usize)); } check_word_size(); @@ -1370,26 +1370,26 @@ mod tests { #[test] fn test_cast_range_uint_min() { - assert_eq!(uint::MIN.to_int(), Some(uint::MIN as int)); - assert_eq!(uint::MIN.to_i8(), Some(uint::MIN as i8)); - assert_eq!(uint::MIN.to_i16(), Some(uint::MIN as i16)); - assert_eq!(uint::MIN.to_i32(), Some(uint::MIN as i32)); - assert_eq!(uint::MIN.to_i64(), Some(uint::MIN as i64)); - assert_eq!(uint::MIN.to_uint(), Some(uint::MIN as uint)); - assert_eq!(uint::MIN.to_u8(), Some(uint::MIN as u8)); - assert_eq!(uint::MIN.to_u16(), Some(uint::MIN as u16)); - assert_eq!(uint::MIN.to_u32(), Some(uint::MIN as u32)); - assert_eq!(uint::MIN.to_u64(), Some(uint::MIN as u64)); + assert_eq!(usize::MIN.to_int(), Some(usize::MIN as isize)); + assert_eq!(usize::MIN.to_i8(), Some(usize::MIN as i8)); + assert_eq!(usize::MIN.to_i16(), Some(usize::MIN as i16)); + assert_eq!(usize::MIN.to_i32(), Some(usize::MIN as i32)); + assert_eq!(usize::MIN.to_i64(), Some(usize::MIN as i64)); + assert_eq!(usize::MIN.to_uint(), Some(usize::MIN as usize)); + assert_eq!(usize::MIN.to_u8(), Some(usize::MIN as u8)); + assert_eq!(usize::MIN.to_u16(), Some(usize::MIN as u16)); + assert_eq!(usize::MIN.to_u32(), Some(usize::MIN as u32)); + assert_eq!(usize::MIN.to_u64(), Some(usize::MIN as u64)); } #[test] fn test_cast_range_u8_min() { - assert_eq!(u8::MIN.to_int(), Some(u8::MIN as int)); + assert_eq!(u8::MIN.to_int(), Some(u8::MIN as isize)); assert_eq!(u8::MIN.to_i8(), Some(u8::MIN as i8)); assert_eq!(u8::MIN.to_i16(), Some(u8::MIN as i16)); assert_eq!(u8::MIN.to_i32(), Some(u8::MIN as i32)); assert_eq!(u8::MIN.to_i64(), Some(u8::MIN as i64)); - assert_eq!(u8::MIN.to_uint(), Some(u8::MIN as uint)); + assert_eq!(u8::MIN.to_uint(), Some(u8::MIN as usize)); assert_eq!(u8::MIN.to_u8(), Some(u8::MIN as u8)); assert_eq!(u8::MIN.to_u16(), Some(u8::MIN as u16)); assert_eq!(u8::MIN.to_u32(), Some(u8::MIN as u32)); @@ -1398,12 +1398,12 @@ mod tests { #[test] fn test_cast_range_u16_min() { - assert_eq!(u16::MIN.to_int(), Some(u16::MIN as int)); + assert_eq!(u16::MIN.to_int(), Some(u16::MIN as isize)); assert_eq!(u16::MIN.to_i8(), Some(u16::MIN as i8)); assert_eq!(u16::MIN.to_i16(), Some(u16::MIN as i16)); assert_eq!(u16::MIN.to_i32(), Some(u16::MIN as i32)); assert_eq!(u16::MIN.to_i64(), Some(u16::MIN as i64)); - assert_eq!(u16::MIN.to_uint(), Some(u16::MIN as uint)); + assert_eq!(u16::MIN.to_uint(), Some(u16::MIN as usize)); assert_eq!(u16::MIN.to_u8(), Some(u16::MIN as u8)); assert_eq!(u16::MIN.to_u16(), Some(u16::MIN as u16)); assert_eq!(u16::MIN.to_u32(), Some(u16::MIN as u32)); @@ -1412,12 +1412,12 @@ mod tests { #[test] fn test_cast_range_u32_min() { - assert_eq!(u32::MIN.to_int(), Some(u32::MIN as int)); + assert_eq!(u32::MIN.to_int(), Some(u32::MIN as isize)); assert_eq!(u32::MIN.to_i8(), Some(u32::MIN as i8)); assert_eq!(u32::MIN.to_i16(), Some(u32::MIN as i16)); assert_eq!(u32::MIN.to_i32(), Some(u32::MIN as i32)); assert_eq!(u32::MIN.to_i64(), Some(u32::MIN as i64)); - assert_eq!(u32::MIN.to_uint(), Some(u32::MIN as uint)); + assert_eq!(u32::MIN.to_uint(), Some(u32::MIN as usize)); assert_eq!(u32::MIN.to_u8(), Some(u32::MIN as u8)); assert_eq!(u32::MIN.to_u16(), Some(u32::MIN as u16)); assert_eq!(u32::MIN.to_u32(), Some(u32::MIN as u32)); @@ -1426,12 +1426,12 @@ mod tests { #[test] fn test_cast_range_u64_min() { - assert_eq!(u64::MIN.to_int(), Some(u64::MIN as int)); + assert_eq!(u64::MIN.to_int(), Some(u64::MIN as isize)); assert_eq!(u64::MIN.to_i8(), Some(u64::MIN as i8)); assert_eq!(u64::MIN.to_i16(), Some(u64::MIN as i16)); assert_eq!(u64::MIN.to_i32(), Some(u64::MIN as i32)); assert_eq!(u64::MIN.to_i64(), Some(u64::MIN as i64)); - assert_eq!(u64::MIN.to_uint(), Some(u64::MIN as uint)); + assert_eq!(u64::MIN.to_uint(), Some(u64::MIN as usize)); assert_eq!(u64::MIN.to_u8(), Some(u64::MIN as u8)); assert_eq!(u64::MIN.to_u16(), Some(u64::MIN as u16)); assert_eq!(u64::MIN.to_u32(), Some(u64::MIN as u32)); @@ -1440,26 +1440,26 @@ mod tests { #[test] fn test_cast_range_uint_max() { - assert_eq!(uint::MAX.to_int(), None); - assert_eq!(uint::MAX.to_i8(), None); - assert_eq!(uint::MAX.to_i16(), None); - assert_eq!(uint::MAX.to_i32(), None); - // uint::MAX.to_i64() is word-size specific - assert_eq!(uint::MAX.to_u8(), None); - assert_eq!(uint::MAX.to_u16(), None); - // uint::MAX.to_u32() is word-size specific - assert_eq!(uint::MAX.to_u64(), Some(uint::MAX as u64)); + assert_eq!(usize::MAX.to_int(), None); + assert_eq!(usize::MAX.to_i8(), None); + assert_eq!(usize::MAX.to_i16(), None); + assert_eq!(usize::MAX.to_i32(), None); + // usize::MAX.to_i64() is word-size specific + assert_eq!(usize::MAX.to_u8(), None); + assert_eq!(usize::MAX.to_u16(), None); + // usize::MAX.to_u32() is word-size specific + assert_eq!(usize::MAX.to_u64(), Some(usize::MAX as u64)); #[cfg(target_pointer_width = "32")] fn check_word_size() { - assert_eq!(uint::MAX.to_u32(), Some(uint::MAX as u32)); - assert_eq!(uint::MAX.to_i64(), Some(uint::MAX as i64)); + assert_eq!(usize::MAX.to_u32(), Some(usize::MAX as u32)); + assert_eq!(usize::MAX.to_i64(), Some(usize::MAX as i64)); } #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(uint::MAX.to_u32(), None); - assert_eq!(uint::MAX.to_i64(), None); + assert_eq!(usize::MAX.to_u32(), None); + assert_eq!(usize::MAX.to_i64(), None); } check_word_size(); @@ -1467,12 +1467,12 @@ mod tests { #[test] fn test_cast_range_u8_max() { - assert_eq!(u8::MAX.to_int(), Some(u8::MAX as int)); + assert_eq!(u8::MAX.to_int(), Some(u8::MAX as isize)); assert_eq!(u8::MAX.to_i8(), None); assert_eq!(u8::MAX.to_i16(), Some(u8::MAX as i16)); assert_eq!(u8::MAX.to_i32(), Some(u8::MAX as i32)); assert_eq!(u8::MAX.to_i64(), Some(u8::MAX as i64)); - assert_eq!(u8::MAX.to_uint(), Some(u8::MAX as uint)); + assert_eq!(u8::MAX.to_uint(), Some(u8::MAX as usize)); assert_eq!(u8::MAX.to_u8(), Some(u8::MAX as u8)); assert_eq!(u8::MAX.to_u16(), Some(u8::MAX as u16)); assert_eq!(u8::MAX.to_u32(), Some(u8::MAX as u32)); @@ -1481,12 +1481,12 @@ mod tests { #[test] fn test_cast_range_u16_max() { - assert_eq!(u16::MAX.to_int(), Some(u16::MAX as int)); + assert_eq!(u16::MAX.to_int(), Some(u16::MAX as isize)); assert_eq!(u16::MAX.to_i8(), None); assert_eq!(u16::MAX.to_i16(), None); assert_eq!(u16::MAX.to_i32(), Some(u16::MAX as i32)); assert_eq!(u16::MAX.to_i64(), Some(u16::MAX as i64)); - assert_eq!(u16::MAX.to_uint(), Some(u16::MAX as uint)); + assert_eq!(u16::MAX.to_uint(), Some(u16::MAX as usize)); assert_eq!(u16::MAX.to_u8(), None); assert_eq!(u16::MAX.to_u16(), Some(u16::MAX as u16)); assert_eq!(u16::MAX.to_u32(), Some(u16::MAX as u32)); @@ -1500,7 +1500,7 @@ mod tests { assert_eq!(u32::MAX.to_i16(), None); assert_eq!(u32::MAX.to_i32(), None); assert_eq!(u32::MAX.to_i64(), Some(u32::MAX as i64)); - assert_eq!(u32::MAX.to_uint(), Some(u32::MAX as uint)); + assert_eq!(u32::MAX.to_uint(), Some(u32::MAX as usize)); assert_eq!(u32::MAX.to_u8(), None); assert_eq!(u32::MAX.to_u16(), None); assert_eq!(u32::MAX.to_u32(), Some(u32::MAX as u32)); @@ -1513,7 +1513,7 @@ mod tests { #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(u32::MAX.to_int(), Some(u32::MAX as int)); + assert_eq!(u32::MAX.to_int(), Some(u32::MAX as isize)); } check_word_size(); @@ -1539,7 +1539,7 @@ mod tests { #[cfg(target_pointer_width = "64")] fn check_word_size() { - assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as uint)); + assert_eq!(u64::MAX.to_uint(), Some(u64::MAX as usize)); } check_word_size(); @@ -1547,7 +1547,7 @@ mod tests { #[test] fn test_saturating_add_uint() { - use uint::MAX; + use usize::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); @@ -1556,7 +1556,7 @@ mod tests { #[test] fn test_saturating_sub_uint() { - use uint::MAX; + use usize::MAX; 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); @@ -1565,7 +1565,7 @@ mod tests { #[test] fn test_saturating_add_int() { - use int::{MIN,MAX}; + use isize::{MIN,MAX}; assert_eq!(3.saturating_add(5), 8); assert_eq!(3.saturating_add(MAX-1), MAX); assert_eq!(MAX.saturating_add(MAX), MAX); @@ -1577,7 +1577,7 @@ mod tests { #[test] fn test_saturating_sub_int() { - use int::{MIN,MAX}; + use isize::{MIN,MAX}; assert_eq!(3.saturating_sub(5), -2); assert_eq!(MIN.saturating_sub(1), MIN); assert_eq!((-2).saturating_sub(MAX), MIN); @@ -1589,13 +1589,13 @@ mod tests { #[test] fn test_checked_add() { - let five_less = uint::MAX - 5; - assert_eq!(five_less.checked_add(0), Some(uint::MAX - 5)); - assert_eq!(five_less.checked_add(1), Some(uint::MAX - 4)); - assert_eq!(five_less.checked_add(2), Some(uint::MAX - 3)); - assert_eq!(five_less.checked_add(3), Some(uint::MAX - 2)); - assert_eq!(five_less.checked_add(4), Some(uint::MAX - 1)); - assert_eq!(five_less.checked_add(5), Some(uint::MAX)); + let five_less = usize::MAX - 5; + assert_eq!(five_less.checked_add(0), Some(usize::MAX - 5)); + assert_eq!(five_less.checked_add(1), Some(usize::MAX - 4)); + assert_eq!(five_less.checked_add(2), Some(usize::MAX - 3)); + assert_eq!(five_less.checked_add(3), Some(usize::MAX - 2)); + assert_eq!(five_less.checked_add(4), Some(usize::MAX - 1)); + assert_eq!(five_less.checked_add(5), Some(usize::MAX)); assert_eq!(five_less.checked_add(6), None); assert_eq!(five_less.checked_add(7), None); } @@ -1614,7 +1614,7 @@ mod tests { #[test] fn test_checked_mul() { - let third = uint::MAX / 3; + let third = usize::MAX / 3; assert_eq!(third.checked_mul(0), Some(0)); assert_eq!(third.checked_mul(1), Some(third)); assert_eq!(third.checked_mul(2), Some(third * 2)); @@ -1641,7 +1641,7 @@ mod tests { test_is_power_of_two!{ test_is_power_of_two_u16, u16 } test_is_power_of_two!{ test_is_power_of_two_u32, u32 } test_is_power_of_two!{ test_is_power_of_two_u64, u64 } - test_is_power_of_two!{ test_is_power_of_two_uint, uint } + test_is_power_of_two!{ test_is_power_of_two_uint, usize } macro_rules! test_next_power_of_two { ($test_name:ident, $T:ident) => ( @@ -1661,7 +1661,7 @@ mod tests { test_next_power_of_two! { test_next_power_of_two_u16, u16 } test_next_power_of_two! { test_next_power_of_two_u32, u32 } test_next_power_of_two! { test_next_power_of_two_u64, u64 } - test_next_power_of_two! { test_next_power_of_two_uint, uint } + test_next_power_of_two! { test_next_power_of_two_uint, usize } macro_rules! test_checked_next_power_of_two { ($test_name:ident, $T:ident) => ( @@ -1684,10 +1684,10 @@ mod tests { test_checked_next_power_of_two! { test_checked_next_power_of_two_u16, u16 } test_checked_next_power_of_two! { test_checked_next_power_of_two_u32, u32 } test_checked_next_power_of_two! { test_checked_next_power_of_two_u64, u64 } - test_checked_next_power_of_two! { test_checked_next_power_of_two_uint, uint } + test_checked_next_power_of_two! { test_checked_next_power_of_two_uint, usize } #[derive(PartialEq, Debug)] - struct Value { x: int } + struct Value { x: isize } impl ToPrimitive for Value { fn to_i64(&self) -> Option<i64> { self.x.to_i64() } @@ -1695,8 +1695,8 @@ mod tests { } impl FromPrimitive for Value { - fn from_i64(n: i64) -> Option<Value> { Some(Value { x: n as int }) } - fn from_u64(n: u64) -> Option<Value> { Some(Value { x: n as int }) } + fn from_i64(n: i64) -> Option<Value> { Some(Value { x: n as isize }) } + fn from_u64(n: u64) -> Option<Value> { Some(Value { x: n as isize }) } } #[test] @@ -1734,7 +1734,7 @@ mod tests { #[test] fn test_pow() { - fn naive_pow<T: Int>(base: T, exp: uint) -> T { + fn naive_pow<T: Int>(base: T, exp: usize) -> T { let one: T = Int::one(); (0..exp).fold(one, |acc, _| acc * base) } diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs deleted file mode 100644 index c7b491381f3..00000000000 --- a/src/libstd/num/uint.rs +++ /dev/null @@ -1,22 +0,0 @@ -// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT -// file at the top-level directory of this distribution and at -// http://rust-lang.org/COPYRIGHT. -// -// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or -// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license -// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your -// option. This file may not be copied, modified, or distributed -// except according to those terms. - -//! Deprecated: replaced by `usize`. -//! -//! The rollout of the new type will gradually take place over the -//! alpha cycle along with the development of clearer conventions -//! around integer types. - -#![unstable(feature = "std_misc")] -#![deprecated(since = "1.0.0", reason = "replaced by usize")] - -pub use core::uint::{BITS, BYTES, MIN, MAX}; - -uint_module! { uint } diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs index fc3deb67f41..b82572fc089 100644 --- a/src/libstd/old_io/mod.rs +++ b/src/libstd/old_io/mod.rs @@ -240,6 +240,8 @@ #![unstable(feature = "old_io")] #![deny(unused_must_use)] +#![allow(deprecated)] // seriously this is all deprecated +#![allow(unused_imports)] pub use self::SeekStyle::*; pub use self::FileMode::*; diff --git a/src/libstd/old_path/mod.rs b/src/libstd/old_path/mod.rs index e9005aa22bc..4f8976fb2ec 100644 --- a/src/libstd/old_path/mod.rs +++ b/src/libstd/old_path/mod.rs @@ -60,6 +60,8 @@ //! ``` #![unstable(feature = "old_path")] +#![allow(deprecated)] // seriously this is all deprecated +#![allow(unused_imports)] use core::marker::Sized; use ffi::CString; diff --git a/src/libstd/path.rs b/src/libstd/path.rs index 49a5efec7c2..88543ad85ed 100755 --- a/src/libstd/path.rs +++ b/src/libstd/path.rs @@ -1324,7 +1324,6 @@ impl<T: AsOsStr + ?Sized> AsPath for T { #[cfg(test)] mod tests { use super::*; - use ffi::OsStr; use core::prelude::*; use string::{ToString, String}; use vec::Vec; diff --git a/src/libstd/process.rs b/src/libstd/process.rs index 5baa095d359..86604f62171 100644 --- a/src/libstd/process.rs +++ b/src/libstd/process.rs @@ -489,18 +489,14 @@ impl Child { mod tests { use io::ErrorKind; use io::prelude::*; - use prelude::v1::{Ok, Err, range, drop, Some, None, Vec}; + use prelude::v1::{Ok, Err, drop, Some, Vec}; use prelude::v1::{String, Clone}; use prelude::v1::{SliceExt, Str, StrExt, AsSlice, ToString, GenericPath}; - use path::Path; use old_path; use old_io::fs::PathExtensions; use rt::running_on_valgrind; use str; - use super::{Child, Command, Output, ExitStatus, Stdio}; - use sync::mpsc::channel; - use thread; - use time::Duration; + use super::{Command, Output, Stdio}; // FIXME(#10380) these tests should not all be ignored on android. diff --git a/src/libstd/thread.rs b/src/libstd/thread.rs index 1c64b6961d7..1f70e1526a0 100644 --- a/src/libstd/thread.rs +++ b/src/libstd/thread.rs @@ -702,7 +702,7 @@ mod test { use boxed::BoxAny; use result; use std::old_io::{ChanReader, ChanWriter}; - use super::{Thread, Builder}; + use super::{Builder}; use thread; use thunk::Thunk; use time::Duration; @@ -767,7 +767,7 @@ mod test { #[test] #[should_fail] fn test_scoped_implicit_panic() { - thread::scoped(|| panic!()); + let _ = thread::scoped(|| panic!()); } #[test] |