Removed integer suffixes that cause a harmless fallback to i32.

Author: eddyb

src/liballoc/arc.rs

@@ -97,7 +97,7 @@ use heap::deallocate;
 /// use std::thread;
 ///
 /// fn main() {
-///     let numbers: Vec<_> = (0..100u32).map(|i| i as f32).collect();
+///     let numbers: Vec<_> = (0..100).map(|i| i as f32).collect();
 ///     let shared_numbers = Arc::new(numbers);
 ///
 ///     for _ in 0..10 {
@@ -770,7 +770,7 @@ mod tests {
 
     #[test]
     fn test_strong_count() {
-        let a = Arc::new(0u32);
+        let a = Arc::new(0);
         assert!(strong_count(&a) == 1);
         let w = a.downgrade();
         assert!(strong_count(&a) == 1);
@@ -787,7 +787,7 @@ mod tests {
 
     #[test]
     fn test_weak_count() {
-        let a = Arc::new(0u32);
+        let a = Arc::new(0);
         assert!(strong_count(&a) == 1);
         assert!(weak_count(&a) == 0);
         let w = a.downgrade();
@@ -813,7 +813,7 @@ mod tests {
 
     #[test]
     fn show_arc() {
-        let a = Arc::new(5u32);
+        let a = Arc::new(5);
         assert_eq!(format!("{:?}", a), "5");
     }
 

src/liballoc/boxed.rs

@@ -136,7 +136,7 @@ impl<T : ?Sized> Box<T> {
 /// ```
 /// use std::boxed;
 ///
-/// let seventeen = Box::new(17u32);
+/// let seventeen = Box::new(17);
 /// let raw = unsafe { boxed::into_raw(seventeen) };
 /// let boxed_again = unsafe { Box::from_raw(raw) };
 /// ```

src/liballoc/rc.rs

@@ -874,7 +874,7 @@ mod tests {
 
     #[test]
     fn test_strong_count() {
-        let a = Rc::new(0u32);
+        let a = Rc::new(0);
         assert!(strong_count(&a) == 1);
         let w = a.downgrade();
         assert!(strong_count(&a) == 1);
@@ -891,7 +891,7 @@ mod tests {
 
     #[test]
     fn test_weak_count() {
-        let a = Rc::new(0u32);
+        let a = Rc::new(0);
         assert!(strong_count(&a) == 1);
         assert!(weak_count(&a) == 0);
         let w = a.downgrade();

src/libcollections/slice.rs

@@ -1795,9 +1795,9 @@ mod tests {
     fn test_swap_remove_noncopyable() {
         // Tests that we don't accidentally run destructors twice.
         let mut v = Vec::new();
-        v.push(box 0u8);
-        v.push(box 0u8);
-        v.push(box 0u8);
+        v.push(box 0);
+        v.push(box 0);
+        v.push(box 0);
         let mut _e = v.swap_remove(0);
         assert_eq!(v.len(), 2);
         _e = v.swap_remove(1);
@@ -2116,7 +2116,7 @@ mod tests {
         let mut v: [i32; 0] = [];
         v.sort();
 
-        let mut v = [0xDEADBEEFu64];
+        let mut v = [0xDEADBEEF];
         v.sort();
         assert!(v == [0xDEADBEEF]);
     }
@@ -2170,8 +2170,8 @@ mod tests {
     fn test_connect() {
         let v: [Vec<i32>; 0] = [];
         assert_eq!(v.connect(&0), []);
-        assert_eq!([vec![1i], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
-        assert_eq!([vec![1i], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
+        assert_eq!([vec![1], vec![2, 3]].connect(&0), [1, 0, 2, 3]);
+        assert_eq!([vec![1], vec![2], vec![3]].connect(&0), [1, 0, 2, 0, 3]);
 
         let v: [&[_]; 2] = [&[1], &[2, 3]];
         assert_eq!(v.connect(&0), [1, 0, 2, 3]);
@@ -2658,7 +2658,7 @@ mod tests {
 
     #[test]
     fn test_mut_split_at() {
-        let mut values = [1u8,2,3,4,5];
+        let mut values = [1,2,3,4,5];
         {
             let (left, right) = values.split_at_mut(2);
             {

src/libcollections/vec.rs

@@ -25,21 +25,21 @@
 //! ```
 //! let ys: Vec<i32> = vec![];
 //!
-//! let zs = vec![1i32, 2, 3, 4, 5];
+//! let zs = vec![1, 2, 3, 4, 5];
 //! ```
 //!
 //! Push:
 //!
 //! ```
-//! let mut xs = vec![1i32, 2];
+//! let mut xs = vec![1, 2];
 //!
 //! xs.push(3);
 //! ```
 //!
 //! And pop:
 //!
 //! ```
-//! let mut xs = vec![1i32, 2];
+//! let mut xs = vec![1, 2];
 //!
 //! let two = xs.pop();
 //! ```
@@ -1975,7 +1975,7 @@ mod tests {
 
     #[test]
     fn test_as_vec() {
-        let xs = [1u8, 2u8, 3u8];
+        let xs = [1, 2, 3];
         assert_eq!(&**as_vec(&xs), xs);
     }
 

src/libcore/iter.rs

@@ -2316,7 +2316,7 @@ impl<I: RandomAccessIterator, F> RandomAccessIterator for Inspect<I, F>
 /// // This iterator will yield up to the last Fibonacci number before the max
 /// // value of `u32`. You can simply change `u32` to `u64` in this line if
 /// // you want higher values than that.
-/// let mut fibonacci = Unfold::new((Some(0u32), Some(1u32)),
+/// let mut fibonacci = Unfold::new((Some(0), Some(1)),
 ///                                 |&mut (ref mut x2, ref mut x1)| {
 ///     // Attempt to get the next Fibonacci number
 ///     // `x1` will be `None` if previously overflowed.

src/libcore/mem.rs

@@ -54,7 +54,7 @@ pub fn size_of<T>() -> usize {
 /// ```
 /// use std::mem;
 ///
-/// assert_eq!(4, mem::size_of_val(&5i32));
+/// assert_eq!(4, mem::size_of_val(&5));
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -86,7 +86,7 @@ pub fn min_align_of<T>() -> usize {
 /// ```
 /// use std::mem;
 ///
-/// assert_eq!(4, mem::min_align_of_val(&5i32));
+/// assert_eq!(4, mem::min_align_of_val(&5));
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -126,7 +126,7 @@ pub fn align_of<T>() -> usize {
 /// ```
 /// use std::mem;
 ///
-/// assert_eq!(4, mem::align_of_val(&5i32));
+/// assert_eq!(4, mem::align_of_val(&5));
 /// ```
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]

src/libcoretest/iter.rs

@@ -477,7 +477,7 @@ fn test_rev() {
 
 #[test]
 fn test_cloned() {
-    let xs = [2u8, 4, 6, 8];
+    let xs = [2, 4, 6, 8];
 
     let mut it = xs.iter().cloned();
     assert_eq!(it.len(), 4);

src/libcoretest/option.rs

@@ -246,8 +246,8 @@ fn test_collect() {
 
 #[test]
 fn test_cloned() {
-    let val1 = 1u32;
-    let mut val2 = 2u32;
+    let val1 = 1;
+    let mut val2 = 2;
     let val1_ref = &val1;
     let opt_none: Option<&'static u32> = None;
     let opt_ref = Some(&val1);
@@ -259,14 +259,14 @@ fn test_cloned() {
     assert_eq!(opt_none.cloned(), None);
 
     // Mutable refs work
-    assert_eq!(opt_mut_ref.cloned(), Some(2u32));
+    assert_eq!(opt_mut_ref.cloned(), Some(2));
 
     // Immutable ref works
     assert_eq!(opt_ref.clone(), Some(&val1));
-    assert_eq!(opt_ref.cloned(), Some(1u32));
+    assert_eq!(opt_ref.cloned(), Some(1));
 
     // Double Immutable ref works
     assert_eq!(opt_ref_ref.clone(), Some(&val1_ref));
     assert_eq!(opt_ref_ref.clone().cloned(), Some(&val1));
-    assert_eq!(opt_ref_ref.cloned().cloned(), Some(1u32));
+    assert_eq!(opt_ref_ref.cloned().cloned(), Some(1));
 }

src/librustc/metadata/encoder.rs

@@ -1595,7 +1595,7 @@ fn encode_index<T, F>(rbml_w: &mut Encoder, index: Vec<entry<T>>, mut write_fn:
     F: FnMut(&mut SeekableMemWriter, &T),
     T: Hash,
 {
-    let mut buckets: Vec<Vec<entry<T>>> = (0..256u16).map(|_| Vec::new()).collect();
+    let mut buckets: Vec<Vec<entry<T>>> = (0..256).map(|_| Vec::new()).collect();
     for elt in index {
         let mut s = SipHasher::new();
         elt.val.hash(&mut s);