Remove i, is, u, or us suffixes that are not necessary.

Author: nikomatsakis

src/libcollections/fmt.rs

@@ -27,12 +27,12 @@
 //! Some examples of the `format!` extension are:
 //!
 //! ```
-//! format!("Hello");                  // => "Hello"
-//! format!("Hello, {}!", "world");    // => "Hello, world!"
+//! format!("Hello");                 // => "Hello"
+//! format!("Hello, {}!", "world");   // => "Hello, world!"
 //! format!("The number is {}", 1);   // => "The number is 1"
-//! format!("{:?}", (3, 4));         // => "(3, 4)"
+//! format!("{:?}", (3, 4));          // => "(3, 4)"
 //! format!("{value}", value=4);      // => "4"
-//! format!("{} {}", 1, 2u);          // => "1 2"
+//! format!("{} {}", 1, 2);           // => "1 2"
 //! ```
 //!
 //! From these, you can see that the first argument is a format string. It is

src/libcore/char.rs

@@ -441,18 +441,18 @@ pub fn encode_utf8_raw(code: u32, dst: &mut [u8]) -> Option<usize> {
         dst[0] = code as u8;
         Some(1)
     } else if code < MAX_TWO_B && dst.len() >= 2 {
-        dst[0] = (code >> 6u & 0x1F_u32) as u8 | TAG_TWO_B;
+        dst[0] = (code >> 6 & 0x1F_u32) as u8 | TAG_TWO_B;
         dst[1] = (code & 0x3F_u32) as u8 | TAG_CONT;
         Some(2)
     } else if code < MAX_THREE_B && dst.len() >= 3  {
-        dst[0] = (code >> 12u & 0x0F_u32) as u8 | TAG_THREE_B;
-        dst[1] = (code >>  6u & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 12 & 0x0F_u32) as u8 | TAG_THREE_B;
+        dst[1] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
         dst[2] = (code & 0x3F_u32) as u8 | TAG_CONT;
         Some(3)
     } else if dst.len() >= 4 {
-        dst[0] = (code >> 18u & 0x07_u32) as u8 | TAG_FOUR_B;
-        dst[1] = (code >> 12u & 0x3F_u32) as u8 | TAG_CONT;
-        dst[2] = (code >>  6u & 0x3F_u32) as u8 | TAG_CONT;
+        dst[0] = (code >> 18 & 0x07_u32) as u8 | TAG_FOUR_B;
+        dst[1] = (code >> 12 & 0x3F_u32) as u8 | TAG_CONT;
+        dst[2] = (code >>  6 & 0x3F_u32) as u8 | TAG_CONT;
         dst[3] = (code & 0x3F_u32) as u8 | TAG_CONT;
         Some(4)
     } else {

src/liblibc/lib.rs

@@ -1930,7 +1930,7 @@ pub mod types {
                     pub iSecurityScheme: c_int,
                     pub dwMessageSize: DWORD,
                     pub dwProviderReserved: DWORD,
-                    pub szProtocol: [u8; WSAPROTOCOL_LEN as usize + 1us],
+                    pub szProtocol: [u8; WSAPROTOCOL_LEN as usize + 1],
                 }
 
                 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;

src/librbml/lib.rs

@@ -713,10 +713,10 @@ pub mod writer {
         match size {
             1 => w.write_all(&[0x80u8 | (n as u8)]),
             2 => w.write_all(&[0x40u8 | ((n >> 8) as u8), n as u8]),
-            3 => w.write_all(&[0x20u8 | ((n >> 16) as u8), (n >> 8_u) as u8,
+            3 => w.write_all(&[0x20u8 | ((n >> 16) as u8), (n >> 8) as u8,
                             n as u8]),
-            4 => w.write_all(&[0x10u8 | ((n >> 24) as u8), (n >> 16_u) as u8,
-                            (n >> 8_u) as u8, n as u8]),
+            4 => w.write_all(&[0x10u8 | ((n >> 24) as u8), (n >> 16) as u8,
+                            (n >> 8) as u8, n as u8]),
             _ => Err(old_io::IoError {
                 kind: old_io::OtherIoError,
                 desc: "int too big",
@@ -863,7 +863,7 @@ pub mod writer {
     impl<'a, W: Writer + Seek> Encoder<'a, W> {
         // used internally to emit things like the vector length and so on
         fn _emit_tagged_uint(&mut self, t: EbmlEncoderTag, v: uint) -> EncodeResult {
-            assert!(v <= 0xFFFF_FFFF_u);
+            assert!(v <= 0xFFFF_FFFF);
             self.wr_tagged_u32(t as uint, v as u32)
         }
 

src/librustc/util/ppaux.rs

@@ -560,7 +560,7 @@ pub fn parameterized<'tcx,GG>(cx: &ctxt<'tcx>,
 pub fn ty_to_short_str<'tcx>(cx: &ctxt<'tcx>, typ: Ty<'tcx>) -> String {
     let mut s = typ.repr(cx).to_string();
     if s.len() >= 32 {
-        s = (&s[0u..32]).to_string();
+        s = (&s[0..32]).to_string();
     }
     return s;
 }

src/librustc_trans/back/lto.rs

@@ -62,7 +62,7 @@ pub fn run(sess: &session::Session, llmod: ModuleRef,
         let file = path.filename_str().unwrap();
         let file = &file[3..file.len() - 5]; // chop off lib/.rlib
         debug!("reading {}", file);
-        for i in iter::count(0us, 1) {
+        for i in iter::count(0, 1) {
             let bc_encoded = time(sess.time_passes(),
                                   &format!("check for {}.{}.bytecode.deflate", name, i),
                                   (),

src/librustc_trans/trans/common.rs

@@ -443,9 +443,9 @@ impl<'a, 'tcx> FunctionContext<'a, 'tcx> {
 
     pub fn env_arg_pos(&self) -> uint {
         if self.caller_expects_out_pointer {
-            1u
+            1
         } else {
-            0u
+            0
         }
     }
 

src/librustc_trans/trans/expr.rs

@@ -467,7 +467,7 @@ fn apply_adjustments<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 PointerCast(bcx, lval.val, type_of::type_of(bcx.ccx(), unsized_ty).ptr_to())
             }
             ty::UnsizeLength(..) => {
-                GEPi(bcx, lval.val, &[0u, 0u])
+                GEPi(bcx, lval.val, &[0, 0])
             }
         };
 

src/librustc_trans/trans/tvec.rs

@@ -76,7 +76,7 @@ pub fn make_drop_glue_unboxed<'blk, 'tcx>(bcx: Block<'blk, 'tcx>,
                 let not_empty = ICmp(bcx,
                                      llvm::IntNE,
                                      len,
-                                     C_uint(ccx, 0us),
+                                     C_uint(ccx, 0_u32),
                                      DebugLoc::None);
                 with_cond(bcx, not_empty, |bcx| {
                     let llalign = C_uint(ccx, machine::llalign_of_min(ccx, llty));
@@ -436,7 +436,7 @@ pub fn iter_vec_loop<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
     let loop_counter = {
         // i = 0
         let i = alloca(loop_bcx, bcx.ccx().int_type(), "__i");
-        Store(loop_bcx, C_uint(bcx.ccx(), 0us), i);
+        Store(loop_bcx, C_uint(bcx.ccx(), 0_u32), i);
 
         Br(loop_bcx, cond_bcx.llbb, DebugLoc::None);
         i
@@ -464,7 +464,7 @@ pub fn iter_vec_loop<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
 
     { // i += 1
         let i = Load(inc_bcx, loop_counter);
-        let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1us), DebugLoc::None);
+        let plusone = Add(inc_bcx, i, C_uint(bcx.ccx(), 1_u32), DebugLoc::None);
         Store(inc_bcx, plusone, loop_counter);
 
         Br(inc_bcx, cond_bcx.llbb, DebugLoc::None);

src/libstd/num/mod.rs

@@ -1149,7 +1149,7 @@ mod tests {
             assert_eq!(_20, NumCast::from(20f32).unwrap());
             assert_eq!(_20, NumCast::from(20f64).unwrap());
 
-            assert_eq!(_20, cast(20u).unwrap());
+            assert_eq!(_20, cast(20usize).unwrap());
             assert_eq!(_20, cast(20u8).unwrap());
             assert_eq!(_20, cast(20u16).unwrap());
             assert_eq!(_20, cast(20u32).unwrap());
@@ -1763,7 +1763,7 @@ mod bench {
 
     #[bench]
     fn bench_pow_function(b: &mut Bencher) {
-        let v = (0..1024u).collect::<Vec<_>>();
-        b.iter(|| {v.iter().fold(0u, |old, new| old.pow(*new));});
+        let v = (0..1024).collect::<Vec<_>>();
+        b.iter(|| {v.iter().fold(0, |old, new| old.pow(*new));});
     }
 }

src/libstd/num/strconv.rs

@@ -262,7 +262,7 @@ pub fn float_to_str_bytes_common<T: Float>(
 
     // If limited digits, calculate one digit more for rounding.
     let (limit_digits, digit_count, exact) = match digits {
-        DigAll          => (false, 0u,      false),
+        DigAll          => (false, 0,       false),
         DigMax(count)   => (true,  count+1, false),
         DigExact(count) => (true,  count+1, true)
     };
@@ -289,7 +289,7 @@ pub fn float_to_str_bytes_common<T: Float>(
     deccum = num.fract();
     if deccum != _0 || (limit_digits && exact && digit_count > 0) {
         buf.push(b'.');
-        let mut dig = 0u;
+        let mut dig = 0;
 
         // calculate new digits while
         // - there is no limit and there are digits left
@@ -314,7 +314,7 @@ pub fn float_to_str_bytes_common<T: Float>(
 
             // Decrease the deccumulator one fractional digit at a time
             deccum = deccum.fract();
-            dig += 1u;
+            dig += 1;
         }
 
         // If digits are limited, and that limit has been reached,

src/libstd/num/uint_macros.rs

@@ -25,11 +25,11 @@ mod tests {
 
     #[test]
     pub fn test_from_str() {
-        assert_eq!(from_str::<$T>("0"), Some(0u as $T));
-        assert_eq!(from_str::<$T>("3"), Some(3u as $T));
-        assert_eq!(from_str::<$T>("10"), Some(10u as $T));
+        assert_eq!(from_str::<$T>("0"), Some(0 as $T));
+        assert_eq!(from_str::<$T>("3"), Some(3 as $T));
+        assert_eq!(from_str::<$T>("10"), Some(10 as $T));
         assert_eq!(from_str::<u32>("123456789"), Some(123456789 as u32));
-        assert_eq!(from_str::<$T>("00100"), Some(100u as $T));
+        assert_eq!(from_str::<$T>("00100"), Some(100 as $T));
 
         assert_eq!(from_str::<$T>(""), None);
         assert_eq!(from_str::<$T>(" "), None);
@@ -38,12 +38,12 @@ mod tests {
 
     #[test]
     pub fn test_parse_bytes() {
-        assert_eq!(FromStrRadix::from_str_radix("123", 10), Ok(123u as $T));
-        assert_eq!(FromStrRadix::from_str_radix("1001", 2), Ok(9u as $T));
-        assert_eq!(FromStrRadix::from_str_radix("123", 8), Ok(83u as $T));
-        assert_eq!(FromStrRadix::from_str_radix("123", 16), Ok(291u as u16));
-        assert_eq!(FromStrRadix::from_str_radix("ffff", 16), Ok(65535u as u16));
-        assert_eq!(FromStrRadix::from_str_radix("z", 36), Ok(35u as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 10), Ok(123 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("1001", 2), Ok(9 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 8), Ok(83 as $T));
+        assert_eq!(FromStrRadix::from_str_radix("123", 16), Ok(291 as u16));
+        assert_eq!(FromStrRadix::from_str_radix("ffff", 16), Ok(65535 as u16));
+        assert_eq!(FromStrRadix::from_str_radix("z", 36), Ok(35 as $T));
 
         assert_eq!(FromStrRadix::from_str_radix("Z", 10).ok(), None::<$T>);
         assert_eq!(FromStrRadix::from_str_radix("_", 2).ok(), None::<$T>);

src/libstd/old_io/extensions.rs

@@ -85,21 +85,21 @@ pub fn u64_to_le_bytes<T, F>(n: u64, size: uint, f: F) -> T where
     use mem::transmute;
 
     // LLVM fails to properly optimize this when using shifts instead of the to_le* intrinsics
-    assert!(size <= 8u);
+    assert!(size <= 8);
     match size {
-      1u => f(&[n as u8]),
-      2u => f(unsafe { & transmute::<_, [u8; 2]>((n as u16).to_le()) }),
-      4u => f(unsafe { & transmute::<_, [u8; 4]>((n as u32).to_le()) }),
-      8u => f(unsafe { & transmute::<_, [u8; 8]>(n.to_le()) }),
+      1 => f(&[n as u8]),
+      2 => f(unsafe { & transmute::<_, [u8; 2]>((n as u16).to_le()) }),
+      4 => f(unsafe { & transmute::<_, [u8; 4]>((n as u32).to_le()) }),
+      8 => f(unsafe { & transmute::<_, [u8; 8]>(n.to_le()) }),
       _ => {
 
         let mut bytes = vec!();
         let mut i = size;
         let mut n = n;
-        while i > 0u {
+        while i > 0 {
             bytes.push((n & 255_u64) as u8);
             n >>= 8;
-            i -= 1u;
+            i -= 1;
         }
         f(&bytes)
       }
@@ -126,19 +126,19 @@ pub fn u64_to_be_bytes<T, F>(n: u64, size: uint, f: F) -> T where
     use mem::transmute;
 
     // LLVM fails to properly optimize this when using shifts instead of the to_be* intrinsics
-    assert!(size <= 8u);
+    assert!(size <= 8);
     match size {
-      1u => f(&[n as u8]),
-      2u => f(unsafe { & transmute::<_, [u8; 2]>((n as u16).to_be()) }),
-      4u => f(unsafe { & transmute::<_, [u8; 4]>((n as u32).to_be()) }),
-      8u => f(unsafe { & transmute::<_, [u8; 8]>(n.to_be()) }),
+      1 => f(&[n as u8]),
+      2 => f(unsafe { & transmute::<_, [u8; 2]>((n as u16).to_be()) }),
+      4 => f(unsafe { & transmute::<_, [u8; 4]>((n as u32).to_be()) }),
+      8 => f(unsafe { & transmute::<_, [u8; 8]>(n.to_be()) }),
       _ => {
         let mut bytes = vec!();
         let mut i = size;
-        while i > 0u {
-            let shift = (i - 1u) * 8u;
+        while i > 0 {
+            let shift = (i - 1) * 8;
             bytes.push((n >> shift) as u8);
-            i -= 1u;
+            i -= 1;
         }
         f(&bytes)
       }
@@ -160,7 +160,7 @@ pub fn u64_from_be_bytes(data: &[u8], start: uint, size: uint) -> u64 {
     use ptr::{copy_nonoverlapping_memory};
     use slice::SliceExt;
 
-    assert!(size <= 8u);
+    assert!(size <= 8);
 
     if data.len() - start < size {
         panic!("index out of bounds");

src/libstd/old_io/mem.rs

@@ -720,7 +720,7 @@ mod test {
             let buf = [5 as u8; 100].to_vec();
             {
                 let mut rdr = MemReader::new(buf);
-                for _i in 0u..10 {
+                for _i in 0..10 {
                     let mut buf = [0 as u8; 10];
                     rdr.read(&mut buf).unwrap();
                     assert_eq!(buf, [5; 10]);
@@ -735,7 +735,7 @@ mod test {
             let mut buf = [0 as u8; 100];
             {
                 let mut wr = BufWriter::new(&mut buf);
-                for _i in 0u..10 {
+                for _i in 0..10 {
                     wr.write(&[5; 10]).unwrap();
                 }
             }
@@ -749,7 +749,7 @@ mod test {
             let buf = [5 as u8; 100];
             {
                 let mut rdr = BufReader::new(&buf);
-                for _i in 0u..10 {
+                for _i in 0..10 {
                     let mut buf = [0 as u8; 10];
                     rdr.read(&mut buf).unwrap();
                     assert_eq!(buf, [5; 10]);