Auto merge of #23031 - Manishearth:rollup, r=Manishearth

4 files changed, 31 insertions, 31 deletions

diff --git a/src/libstd/num/f32.rs b/src/libstd/num/f32.rs
index 7d15a16309e..093cde55bbb 100644
--- a/src/libstd/num/f32.rs
+++ b/src/libstd/num/f32.rs
@@ -824,14 +824,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f32.integer_decode(), (13176795u64, -22i16, 1i8));
-        assert_eq!((-8573.5918555f32).integer_decode(), (8779358u64, -10i16, -1i8));
-        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608u64, 77i16, 1i8));
-        assert_eq!(0f32.integer_decode(), (0u64, -150i16, 1i8));
-        assert_eq!((-0f32).integer_decode(), (0u64, -150i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (8388608u64, 105i16, 1i8));
-        assert_eq!(NEG_INFINITY.integer_decode(), (8388608u64, 105i16, -1i8));
-        assert_eq!(NAN.integer_decode(), (12582912u64, 105i16, 1i8));
+        assert_eq!(3.14159265359f32.integer_decode(), (13176795, -22, 1));
+        assert_eq!((-8573.5918555f32).integer_decode(), (8779358, -10, -1));
+        assert_eq!(2f32.powf(100.0).integer_decode(), (8388608, 77, 1));
+        assert_eq!(0f32.integer_decode(), (0, -150, 1));
+        assert_eq!((-0f32).integer_decode(), (0, -150, -1));
+        assert_eq!(INFINITY.integer_decode(), (8388608, 105, 1));
+        assert_eq!(NEG_INFINITY.integer_decode(), (8388608, 105, -1));
+        assert_eq!(NAN.integer_decode(), (12582912, 105, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/f64.rs b/src/libstd/num/f64.rs
index 0ce56371c77..a7bdad70a36 100644
--- a/src/libstd/num/f64.rs
+++ b/src/libstd/num/f64.rs
@@ -826,14 +826,14 @@ mod tests {
 
     #[test]
     fn test_integer_decode() {
-        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906u64, -51i16, 1i8));
-        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931u64, -39i16, -1i8));
-        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496u64, 48i16, 1i8));
-        assert_eq!(0f64.integer_decode(), (0u64, -1075i16, 1i8));
-        assert_eq!((-0f64).integer_decode(), (0u64, -1075i16, -1i8));
-        assert_eq!(INFINITY.integer_decode(), (4503599627370496u64, 972i16, 1i8));
+        assert_eq!(3.14159265359f64.integer_decode(), (7074237752028906, -51, 1));
+        assert_eq!((-8573.5918555f64).integer_decode(), (4713381968463931, -39, -1));
+        assert_eq!(2f64.powf(100.0).integer_decode(), (4503599627370496, 48, 1));
+        assert_eq!(0f64.integer_decode(), (0, -1075, 1));
+        assert_eq!((-0f64).integer_decode(), (0, -1075, -1));
+        assert_eq!(INFINITY.integer_decode(), (4503599627370496, 972, 1));
         assert_eq!(NEG_INFINITY.integer_decode(), (4503599627370496, 972, -1));
-        assert_eq!(NAN.integer_decode(), (6755399441055744u64, 972i16, 1i8));
+        assert_eq!(NAN.integer_decode(), (6755399441055744, 972, 1));
     }
 
     #[test]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 0bca60ed1a0..9458ed1d353 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -312,7 +312,7 @@ pub trait Float
     ///
     /// let num = 2.0f32;
     ///
-    /// // (8388608u64, -22i16, 1i8)
+    /// // (8388608, -22, 1)
     /// let (mantissa, exponent, sign) = num.integer_decode();
     /// let sign_f = sign as f32;
     /// let mantissa_f = mantissa as f32;
@@ -1755,25 +1755,25 @@ mod tests {
 
     #[test]
     fn test_uint_to_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(u8_val.to_string(), "255");
 
         u8_val = u8_val.wrapping_add(1);
         assert_eq!(u8_val.to_string(), "0");
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(u16_val.to_string(), "65535");
 
         u16_val = u16_val.wrapping_add(1);
         assert_eq!(u16_val.to_string(), "0");
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(u32_val.to_string(), "4294967295");
 
         u32_val = u32_val.wrapping_add(1);
         assert_eq!(u32_val.to_string(), "0");
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(u64_val.to_string(), "18446744073709551615");
 
         u64_val = u64_val.wrapping_add(1);
@@ -1786,7 +1786,7 @@ mod tests {
 
     #[test]
     fn test_uint_from_str_overflow() {
-        let mut u8_val: u8 = 255_u8;
+        let mut u8_val: u8 = 255;
         assert_eq!(from_str::<u8>("255"), Some(u8_val));
         assert_eq!(from_str::<u8>("256"), None);
 
@@ -1794,7 +1794,7 @@ mod tests {
         assert_eq!(from_str::<u8>("0"), Some(u8_val));
         assert_eq!(from_str::<u8>("-1"), None);
 
-        let mut u16_val: u16 = 65_535_u16;
+        let mut u16_val: u16 = 65_535;
         assert_eq!(from_str::<u16>("65535"), Some(u16_val));
         assert_eq!(from_str::<u16>("65536"), None);
 
@@ -1802,7 +1802,7 @@ mod tests {
         assert_eq!(from_str::<u16>("0"), Some(u16_val));
         assert_eq!(from_str::<u16>("-1"), None);
 
-        let mut u32_val: u32 = 4_294_967_295_u32;
+        let mut u32_val: u32 = 4_294_967_295;
         assert_eq!(from_str::<u32>("4294967295"), Some(u32_val));
         assert_eq!(from_str::<u32>("4294967296"), None);
 
@@ -1810,7 +1810,7 @@ mod tests {
         assert_eq!(from_str::<u32>("0"), Some(u32_val));
         assert_eq!(from_str::<u32>("-1"), None);
 
-        let mut u64_val: u64 = 18_446_744_073_709_551_615_u64;
+        let mut u64_val: u64 = 18_446_744_073_709_551_615;
         assert_eq!(from_str::<u64>("18446744073709551615"), Some(u64_val));
         assert_eq!(from_str::<u64>("18446744073709551616"), None);
 
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index b38c52dad1a..5fdd42dbc7a 100644
--- a/src/libstd/num/strconv.rs
+++ b/src/libstd/num/strconv.rs
@@ -104,7 +104,7 @@ fn int_to_str_bytes_common<T, F>(num: T, radix: uint, sign: SignFormat, mut f: F
     // This is just for integral types, the largest of which is a u64. The
     // smallest base that we can have is 2, so the most number of digits we're
     // ever going to have is 64
-    let mut buf = [0u8; 64];
+    let mut buf = [0; 64];
     let mut cur = 0;
 
     // Loop at least once to make sure at least a `0` gets emitted.
@@ -221,10 +221,10 @@ pub fn float_to_str_bytes_common<T: Float>(
     let radix_gen: T = num::cast(radix as int).unwrap();
 
     let (num, exp) = match exp_format {
-        ExpNone => (num, 0i32),
+        ExpNone => (num, 0),
         ExpDec | ExpBin => {
             if num == _0 {
-                (num, 0i32)
+                (num, 0)
             } else {
                 let (exp, exp_base) = match exp_format {
                     ExpDec => (num.abs().log10().floor(), num::cast::<f64, T>(10.0f64).unwrap()),
@@ -432,25 +432,25 @@ mod tests {
 
     #[test]
     fn test_int_to_str_overflow() {
-        let mut i8_val: i8 = 127_i8;
+        let mut i8_val: i8 = 127;
         assert_eq!(i8_val.to_string(), "127");
 
         i8_val = i8_val.wrapping_add(1);
         assert_eq!(i8_val.to_string(), "-128");
 
-        let mut i16_val: i16 = 32_767_i16;
+        let mut i16_val: i16 = 32_767;
         assert_eq!(i16_val.to_string(), "32767");
 
         i16_val = i16_val.wrapping_add(1);
         assert_eq!(i16_val.to_string(), "-32768");
 
-        let mut i32_val: i32 = 2_147_483_647_i32;
+        let mut i32_val: i32 = 2_147_483_647;
         assert_eq!(i32_val.to_string(), "2147483647");
 
         i32_val = i32_val.wrapping_add(1);
         assert_eq!(i32_val.to_string(), "-2147483648");
 
-        let mut i64_val: i64 = 9_223_372_036_854_775_807_i64;
+        let mut i64_val: i64 = 9_223_372_036_854_775_807;
         assert_eq!(i64_val.to_string(), "9223372036854775807");
 
         i64_val = i64_val.wrapping_add(1);