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);

src/librustc_typeck/check/mod.rs

@@ -215,7 +215,7 @@ impl<'tcx> Expectation<'tcx> {
     // can lead us astray. Consider for example `if cond
     // {22} else {c} as u8` -- if we propagate the
     // "castable to u8" constraint to 22, it will pick the
-    // type 22u8, which is overly constrained (c might not
+    // type 22, which is overly constrained (c might not
     // be a u8). In effect, the problem is that the
     // "castable to" expectation is not the tightest thing
     // we can say, so we want to drop it in this case.

src/libstd/rand/mod.rs

@@ -387,7 +387,7 @@ impl Rng for ThreadRng {
 /// use std::rand;
 ///
 /// let x = rand::random();
-/// println!("{}", 2u8 * x);
+/// println!("{}", 2 * x);
 ///
 /// let y = rand::random::<f64>();
 /// println!("{}", y);

src/libstd/sync/mutex.rs

@@ -88,7 +88,7 @@ use fmt;
 /// use std::sync::{Arc, Mutex};
 /// use std::thread;
 ///
-/// let lock = Arc::new(Mutex::new(0_u32));
+/// let lock = Arc::new(Mutex::new(0));
 /// let lock2 = lock.clone();
 ///
 /// let _ = thread::spawn(move || -> () {

src/libstd/sync/task_pool.rs

@@ -71,7 +71,7 @@ impl<'a> Drop for Sentinel<'a> {
 /// for _ in 0..8 {
 ///     let tx = tx.clone();
 ///     pool.execute(move|| {
-///         tx.send(1_u32).unwrap();
+///         tx.send(1).unwrap();
 ///     });
 /// }
 ///

src/test/bench/sudoku.rs

@@ -81,9 +81,9 @@ impl Sudoku {
     }
 
     pub fn write(&self, writer: &mut old_io::Writer) {
-        for row in 0u8..9u8 {
+        for row in 0..9 {
             write!(writer, "{}", self.grid[row as uint][0]);
-            for col in 1u8..9u8 {
+            for col in 1..9 {
                 write!(writer, " {}", self.grid[row as uint][col as uint]);
             }
             write!(writer, "\n");

src/test/compile-fail/asm-misplaced-option.rs

@@ -21,14 +21,14 @@ pub fn main() {
     let mut x: isize = 0;
     unsafe {
         // extra colon
-        asm!("mov $1, $0" : "=r"(x) : "r"(5_usize), "0"(x) : : "cc");
+        asm!("mov $1, $0" : "=r"(x) : "r"(5), "0"(x) : : "cc");
         //~^ WARNING unrecognized option
     }
     assert_eq!(x, 5);
 
     unsafe {
         // comma in place of a colon
-        asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8_usize) : "cc", "volatile");
+        asm!("add $2, $1; mov $1, $0" : "=r"(x) : "r"(x), "r"(8) : "cc", "volatile");
         //~^ WARNING expected a clobber, found an option
     }
     assert_eq!(x, 13);

src/test/compile-fail/associated-types-path-2.rs

@@ -26,30 +26,30 @@ pub fn f2<T: Foo>(a: T) -> T::A {
 }
 
 pub fn f1_int_int() {
-    f1(2i32, 4i32);
+    f1(2, 4);
     //~^ ERROR mismatched types
     //~| expected u32
     //~| found i32
 }
 
 pub fn f1_int_uint() {
-    f1(2i32, 4u32);
+    f1(2, 4);
 }
 
 pub fn f1_uint_uint() {
-    f1(2u32, 4u32);
+    f1(2, 4);
     //~^ ERROR the trait `Foo` is not implemented
     //~| ERROR the trait `Foo` is not implemented
 }
 
 pub fn f1_uint_int() {
-    f1(2u32, 4i32);
+    f1(2, 4);
     //~^ ERROR the trait `Foo` is not implemented
     //~| ERROR the trait `Foo` is not implemented
 }
 
 pub fn f2_int() {
-    let _: i32 = f2(2i32);
+    let _: i32 = f2(2);
     //~^ ERROR mismatched types
     //~| expected `i32`
     //~| found `u32`

src/test/compile-fail/cast-to-nil.rs

@@ -9,4 +9,4 @@
 // except according to those terms.
 
 // error-pattern: non-scalar cast: `u32` as `()`
-fn main() { let u = 0u32 as (); }
+fn main() { let u = 0 as (); }

src/test/compile-fail/method-ambig-two-traits-cross-crate.rs

@@ -18,5 +18,5 @@ trait me2 {
     fn me(&self) -> usize;
 }
 impl me2 for usize { fn me(&self) -> usize { *self } }
-fn main() { 1_usize.me(); } //~ ERROR E0034
+fn main() { 1.me(); } //~ ERROR E0034
 

src/test/compile-fail/method-ambig-two-traits-with-default-method.rs

@@ -19,5 +19,5 @@ impl Foo for usize {}
 impl Bar for usize {}
 
 fn main() {
-    1_usize.method(); //~ ERROR E0034
+    1.method(); //~ ERROR E0034
 }

src/test/debuginfo/gdb-pretty-struct-and-enums.rs

@@ -125,7 +125,7 @@ fn main() {
         the_fourth_field: "I'm so pretty, oh so pretty..."
     };
 
-    let tuple = ( true, 103u32, "blub" );
+    let tuple = ( true, 103, "blub" );
 
     let tuple_struct = TupleStruct(-104.5, 105);
 
@@ -139,7 +139,7 @@ fn main() {
     let mixed_enum_tuple_var = MixedEnumTupleVar(106, 107, false);
     let mixed_enum_struct_var = MixedEnumStructVar { field1: 108.5, field2: 109 };
 
-    let some = Some(110_usize);
+    let some = Some(110);
     let none: Option<int> = None;
     let some_fat = Some("abc");
     let none_fat: Option<&'static str> = None;

src/test/debuginfo/generic-function.rs

@@ -86,7 +86,7 @@ fn dup_tup<T0: Clone, T1: Clone>(t0: &T0, t1: &T1) -> ((T0, T1), (T1, T0)) {
 fn main() {
 
     let _ = dup_tup(&1, &2.5f64);
-    let _ = dup_tup(&3.5f64, &4_u16);
+    let _ = dup_tup(&3.5f64, &4);
     let _ = dup_tup(&5, &Struct { a: 6, b: 7.5 });
 }
 

src/test/debuginfo/generic-method-on-generic-struct.rs

@@ -138,13 +138,13 @@ impl<T1> Struct<T1> {
 }
 
 fn main() {
-    let stack = Struct { x: (8888_u32, -8888_i32) };
-    let _ = stack.self_by_ref(-1, 2_u16);
-    let _ = stack.self_by_val(-3, -4_i16);
+    let stack = Struct { x: (8888, -8888) };
+    let _ = stack.self_by_ref(-1, 2);
+    let _ = stack.self_by_val(-3, -4);
 
     let owned = box Struct { x: 1234.5f64 };
-    let _ = owned.self_by_ref(-5, -6_i32);
-    let _ = owned.self_by_val(-7, -8_i64);
+    let _ = owned.self_by_ref(-5, -6);
+    let _ = owned.self_by_val(-7, -8);
     let _ = owned.self_owned(-9, -10.5_f32);
 }