Audit the option and ptr types for proper integer usage

src/libcore/finally.rs

@@ -72,7 +72,7 @@ impl<T, F> Finally<T> for F where F: FnMut() -> T {
 /// ```
 /// use std::finally::try_finally;
 ///
-/// struct State<'a> { buffer: &'a mut [u8], len: uint }
+/// struct State<'a> { buffer: &'a mut [u8], len: usize }
 /// # let mut buf = [];
 /// let mut state = State { buffer: &mut buf, len: 0 };
 /// try_finally(

src/libcore/ops.rs

@@ -37,8 +37,8 @@
 //!
 //! #[derive(Debug)]
 //! struct Point {
-//!     x: int,
-//!     y: int
+//!     x: i32,
+//!     y: i32
 //! }
 //!
 //! impl Add for Point {
@@ -206,7 +206,7 @@ macro_rules! add_impl {
     )*)
 }
 
-add_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
+add_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 
 /// The `Sub` trait is used to specify the functionality of `-`.
 ///
@@ -259,7 +259,7 @@ macro_rules! sub_impl {
     )*)
 }
 
-sub_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
+sub_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 
 /// The `Mul` trait is used to specify the functionality of `*`.
 ///
@@ -312,7 +312,7 @@ macro_rules! mul_impl {
     )*)
 }
 
-mul_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
+mul_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 
 /// The `Div` trait is used to specify the functionality of `/`.
 ///
@@ -365,7 +365,7 @@ macro_rules! div_impl {
     )*)
 }
 
-div_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 f32 f64 }
+div_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 }
 
 /// The `Rem` trait is used to specify the functionality of `%`.
 ///
@@ -435,7 +435,7 @@ macro_rules! rem_float_impl {
     }
 }
 
-rem_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+rem_impl! { usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 rem_float_impl! { f32, fmodf }
 rem_float_impl! { f64, fmod }
 
@@ -506,9 +506,9 @@ macro_rules! neg_uint_impl {
     }
 }
 
-neg_impl! { int i8 i16 i32 i64 f32 f64 }
+neg_impl! { isize i8 i16 i32 i64 f32 f64 }
 
-neg_uint_impl! { uint, int }
+neg_uint_impl! { usize, isize }
 neg_uint_impl! { u8, i8 }
 neg_uint_impl! { u16, i16 }
 neg_uint_impl! { u32, i32 }
@@ -566,7 +566,7 @@ macro_rules! not_impl {
     )*)
 }
 
-not_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+not_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 
 /// The `BitAnd` trait is used to specify the functionality of `&`.
 ///
@@ -619,7 +619,7 @@ macro_rules! bitand_impl {
     )*)
 }
 
-bitand_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+bitand_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 
 /// The `BitOr` trait is used to specify the functionality of `|`.
 ///
@@ -672,7 +672,7 @@ macro_rules! bitor_impl {
     )*)
 }
 
-bitor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+bitor_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 
 /// The `BitXor` trait is used to specify the functionality of `^`.
 ///
@@ -725,7 +725,7 @@ macro_rules! bitxor_impl {
     )*)
 }
 
-bitxor_impl! { bool uint u8 u16 u32 u64 int i8 i16 i32 i64 }
+bitxor_impl! { bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 }
 
 /// The `Shl` trait is used to specify the functionality of `<<`.
 ///

src/libcore/option.rs

@@ -60,19 +60,19 @@
 //! the optional owned box, `Option<Box<T>>`.
 //!
 //! The following example uses `Option` to create an optional box of
-//! `int`. Notice that in order to use the inner `int` value first the
+//! `i32`. Notice that in order to use the inner `i32` value first the
 //! `check_optional` function needs to use pattern matching to
 //! determine whether the box has a value (i.e. it is `Some(...)`) or
 //! not (`None`).
 //!
 //! ```
-//! let optional: Option<Box<int>> = None;
+//! let optional: Option<Box<i32>> = None;
 //! check_optional(&optional);
 //!
-//! let optional: Option<Box<int>> = Some(Box::new(9000));
+//! let optional: Option<Box<i32>> = Some(Box::new(9000));
 //! check_optional(&optional);
 //!
-//! fn check_optional(optional: &Option<Box<int>>) {
+//! fn check_optional(optional: &Option<Box<i32>>) {
 //!     match *optional {
 //!         Some(ref p) => println!("have value {}", p),
 //!         None => println!("have no value")
@@ -108,7 +108,7 @@
 //! Initialize a result to `None` before a loop:
 //!
 //! ```
-//! enum Kingdom { Plant(uint, &'static str), Animal(uint, &'static str) }
+//! enum Kingdom { Plant(u32, &'static str), Animal(u32, &'static str) }
 //!
 //! // A list of data to search through.
 //! let all_the_big_things = [
@@ -188,10 +188,10 @@ impl<T> Option<T> {
     /// # Example
     ///
     /// ```
-    /// let x: Option<uint> = Some(2);
+    /// let x: Option<u32> = Some(2);
     /// assert_eq!(x.is_some(), true);
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// assert_eq!(x.is_some(), false);
     /// ```
     #[inline]
@@ -208,10 +208,10 @@ impl<T> Option<T> {
     /// # Example
     ///
     /// ```
-    /// let x: Option<uint> = Some(2);
+    /// let x: Option<u32> = Some(2);
     /// assert_eq!(x.is_none(), false);
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// assert_eq!(x.is_none(), true);
     /// ```
     #[inline]
@@ -228,7 +228,7 @@ impl<T> Option<T> {
     ///
     /// # Example
     ///
-    /// Convert an `Option<String>` into an `Option<int>`, preserving the original.
+    /// Convert an `Option<String>` into an `Option<usize>`, preserving the original.
     /// The `map` method takes the `self` argument by value, consuming the original,
     /// so this technique uses `as_ref` to first take an `Option` to a reference
     /// to the value inside the original.
@@ -237,7 +237,7 @@ impl<T> Option<T> {
     /// let num_as_str: Option<String> = Some("10".to_string());
     /// // First, cast `Option<String>` to `Option<&String>` with `as_ref`,
     /// // then consume *that* with `map`, leaving `num_as_str` on the stack.
-    /// let num_as_int: Option<uint> = num_as_str.as_ref().map(|n| n.len());
+    /// let num_as_int: Option<usize> = num_as_str.as_ref().map(|n| n.len());
     /// println!("still can print num_as_str: {:?}", num_as_str);
     /// ```
     #[inline]
@@ -406,12 +406,12 @@ impl<T> Option<T> {
     ///
     /// # Example
     ///
-    /// Convert an `Option<String>` into an `Option<uint>`, consuming the original:
+    /// Convert an `Option<String>` into an `Option<usize>`, consuming the original:
     ///
     /// ```
     /// let num_as_str: Option<String> = Some("10".to_string());
     /// // `Option::map` takes self *by value*, consuming `num_as_str`
-    /// let num_as_int: Option<uint> = num_as_str.map(|n| n.len());
+    /// let num_as_int: Option<usize> = num_as_str.map(|n| n.len());
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -518,7 +518,7 @@ impl<T> Option<T> {
     /// let x = Some(4);
     /// assert_eq!(x.iter().next(), Some(&4));
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// assert_eq!(x.iter().next(), None);
     /// ```
     #[inline]
@@ -539,7 +539,7 @@ impl<T> Option<T> {
     /// }
     /// assert_eq!(x, Some(42));
     ///
-    /// let mut x: Option<uint> = None;
+    /// let mut x: Option<u32> = None;
     /// assert_eq!(x.iter_mut().next(), None);
     /// ```
     #[inline]
@@ -581,15 +581,15 @@ impl<T> Option<T> {
     /// let y: Option<&str> = None;
     /// assert_eq!(x.and(y), None);
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// let y = Some("foo");
     /// assert_eq!(x.and(y), None);
     ///
     /// let x = Some(2);
     /// let y = Some("foo");
     /// assert_eq!(x.and(y), Some("foo"));
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// let y: Option<&str> = None;
     /// assert_eq!(x.and(y), None);
     /// ```
@@ -608,8 +608,8 @@ impl<T> Option<T> {
     /// # Example
     ///
     /// ```
-    /// fn sq(x: uint) -> Option<uint> { Some(x * x) }
-    /// fn nope(_: uint) -> Option<uint> { None }
+    /// fn sq(x: u32) -> Option<u32> { Some(x * x) }
+    /// fn nope(_: u32) -> Option<u32> { None }
     ///
     /// assert_eq!(Some(2).and_then(sq).and_then(sq), Some(16));
     /// assert_eq!(Some(2).and_then(sq).and_then(nope), None);
@@ -642,7 +642,7 @@ impl<T> Option<T> {
     /// let y = Some(100);
     /// assert_eq!(x.or(y), Some(2));
     ///
-    /// let x: Option<uint> = None;
+    /// let x: Option<u32> = None;
     /// let y = None;
     /// assert_eq!(x.or(y), None);
     /// ```
@@ -690,7 +690,7 @@ impl<T> Option<T> {
     /// x.take();
     /// assert_eq!(x, None);
     ///
-    /// let mut x: Option<uint> = None;
+    /// let mut x: Option<u32> = None;
     /// x.take();
     /// assert_eq!(x, None);
     /// ```
@@ -789,7 +789,7 @@ impl<A> Iterator for Item<A> {
     }
 
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) {
+    fn size_hint(&self) -> (usize, Option<usize>) {
         match self.opt {
             Some(_) => (1, Some(1)),
             None => (0, Some(0)),
@@ -817,7 +817,7 @@ impl<'a, A> Iterator for Iter<'a, A> {
     #[inline]
     fn next(&mut self) -> Option<&'a A> { self.inner.next() }
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -847,7 +847,7 @@ impl<'a, A> Iterator for IterMut<'a, A> {
     #[inline]
     fn next(&mut self) -> Option<&'a mut A> { self.inner.next() }
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -870,7 +870,7 @@ impl<A> Iterator for IntoIter<A> {
     #[inline]
     fn next(&mut self) -> Option<A> { self.inner.next() }
     #[inline]
-    fn size_hint(&self) -> (uint, Option<uint>) { self.inner.size_hint() }
+    fn size_hint(&self) -> (usize, Option<usize>) { self.inner.size_hint() }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -896,11 +896,11 @@ impl<A, V: FromIterator<A>> FromIterator<Option<A>> for Option<V> {
     /// checking for overflow:
     ///
     /// ```rust
-    /// use std::uint;
+    /// use std::u16;
     ///
     /// let v = vec!(1, 2);
-    /// let res: Option<Vec<uint>> = v.iter().map(|&x: &uint|
-    ///     if x == uint::MAX { None }
+    /// let res: Option<Vec<u16>> = v.iter().map(|&x: &u16|
+    ///     if x == u16::MAX { None }
     ///     else { Some(x + 1) }
     /// ).collect();
     /// assert!(res == Some(vec!(2, 3)));