Rollup merge of #22567 - Gankro:unstable, r=alexcrichton

 * Adds features and allows
* Removes unused muts, unused imports, dead code
* Migrates some deprecated code to new io/env
* Changes std::num::uint/int to be re-exports of std::num::usize/isize

libcollections, liballoc, and libcoretest no longer warn during testing.

libstd warns much less, though there's some dangly bits that weren't obvious fixes. In particular, how to only supress deprecated warnings in specific submodules of std.

3 files changed, 105 insertions, 149 deletions

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 }