rollup merge of #22497: nikomatsakis/suffixes

Conflicts:
	src/librustc_trans/trans/tvec.rs

27 files changed, 152 insertions, 152 deletions

diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 4582dcd2b03..c94c1649833 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -1123,20 +1123,20 @@ mod tests {
         ($_20:expr) => ({
             let _20 = $_20;
 
-            assert_eq!(20u,   _20.to_uint().unwrap());
-            assert_eq!(20u8,  _20.to_u8().unwrap());
-            assert_eq!(20u16, _20.to_u16().unwrap());
-            assert_eq!(20u32, _20.to_u32().unwrap());
-            assert_eq!(20u64, _20.to_u64().unwrap());
-            assert_eq!(20,   _20.to_int().unwrap());
-            assert_eq!(20i8,  _20.to_i8().unwrap());
-            assert_eq!(20i16, _20.to_i16().unwrap());
-            assert_eq!(20i32, _20.to_i32().unwrap());
-            assert_eq!(20i64, _20.to_i64().unwrap());
-            assert_eq!(20f32, _20.to_f32().unwrap());
-            assert_eq!(20f64, _20.to_f64().unwrap());
-
-            assert_eq!(_20, NumCast::from(20u).unwrap());
+            assert_eq!(20usize, _20.to_uint().unwrap());
+            assert_eq!(20u8,    _20.to_u8().unwrap());
+            assert_eq!(20u16,   _20.to_u16().unwrap());
+            assert_eq!(20u32,   _20.to_u32().unwrap());
+            assert_eq!(20u64,   _20.to_u64().unwrap());
+            assert_eq!(20,      _20.to_int().unwrap());
+            assert_eq!(20i8,    _20.to_i8().unwrap());
+            assert_eq!(20i16,   _20.to_i16().unwrap());
+            assert_eq!(20i32,   _20.to_i32().unwrap());
+            assert_eq!(20i64,   _20.to_i64().unwrap());
+            assert_eq!(20f32,   _20.to_f32().unwrap());
+            assert_eq!(20f64,   _20.to_f64().unwrap());
+
+            assert_eq!(_20, NumCast::from(20usize).unwrap());
             assert_eq!(_20, NumCast::from(20u8).unwrap());
             assert_eq!(_20, NumCast::from(20u16).unwrap());
             assert_eq!(_20, NumCast::from(20u32).unwrap());
@@ -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());
@@ -1164,18 +1164,18 @@ mod tests {
         })
     }
 
-    #[test] fn test_u8_cast()    { test_cast_20!(20u8)  }
-    #[test] fn test_u16_cast()   { test_cast_20!(20u16) }
-    #[test] fn test_u32_cast()   { test_cast_20!(20u32) }
-    #[test] fn test_u64_cast()   { test_cast_20!(20u64) }
-    #[test] fn test_uint_cast()  { test_cast_20!(20u)   }
-    #[test] fn test_i8_cast()    { test_cast_20!(20i8)  }
-    #[test] fn test_i16_cast()   { test_cast_20!(20i16) }
-    #[test] fn test_i32_cast()   { test_cast_20!(20i32) }
-    #[test] fn test_i64_cast()   { test_cast_20!(20i64) }
-    #[test] fn test_int_cast()   { test_cast_20!(20)   }
-    #[test] fn test_f32_cast()   { test_cast_20!(20f32) }
-    #[test] fn test_f64_cast()   { test_cast_20!(20f64) }
+    #[test] fn test_u8_cast()    { test_cast_20!(20u8)    }
+    #[test] fn test_u16_cast()   { test_cast_20!(20u16)   }
+    #[test] fn test_u32_cast()   { test_cast_20!(20u32)   }
+    #[test] fn test_u64_cast()   { test_cast_20!(20u64)   }
+    #[test] fn test_uint_cast()  { test_cast_20!(20usize) }
+    #[test] fn test_i8_cast()    { test_cast_20!(20i8)    }
+    #[test] fn test_i16_cast()   { test_cast_20!(20i16)   }
+    #[test] fn test_i32_cast()   { test_cast_20!(20i32)   }
+    #[test] fn test_i64_cast()   { test_cast_20!(20i64)   }
+    #[test] fn test_int_cast()   { test_cast_20!(20)      }
+    #[test] fn test_f32_cast()   { test_cast_20!(20f32)   }
+    #[test] fn test_f64_cast()   { test_cast_20!(20f64)   }
 
     #[test]
     fn test_cast_range_int_min() {
@@ -1548,8 +1548,8 @@ mod tests {
     #[test]
     fn test_saturating_add_uint() {
         use uint::MAX;
-        assert_eq!(3u.saturating_add(5u), 8u);
-        assert_eq!(3u.saturating_add(MAX-1), MAX);
+        assert_eq!(3_usize.saturating_add(5_usize), 8_usize);
+        assert_eq!(3_usize.saturating_add(MAX-1), MAX);
         assert_eq!(MAX.saturating_add(MAX), MAX);
         assert_eq!((MAX-2).saturating_add(1), MAX-1);
     }
@@ -1557,9 +1557,9 @@ mod tests {
     #[test]
     fn test_saturating_sub_uint() {
         use uint::MAX;
-        assert_eq!(5u.saturating_sub(3u), 2u);
-        assert_eq!(3u.saturating_sub(5u), 0u);
-        assert_eq!(0u.saturating_sub(1u), 0u);
+        assert_eq!(5_usize.saturating_sub(3_usize), 2_usize);
+        assert_eq!(3_usize.saturating_sub(5_usize), 0_usize);
+        assert_eq!(0_usize.saturating_sub(1_usize), 0_usize);
         assert_eq!((MAX-1).saturating_sub(MAX), 0);
     }
 
@@ -1602,14 +1602,14 @@ mod tests {
 
     #[test]
     fn test_checked_sub() {
-        assert_eq!(5u.checked_sub(0), Some(5));
-        assert_eq!(5u.checked_sub(1), Some(4));
-        assert_eq!(5u.checked_sub(2), Some(3));
-        assert_eq!(5u.checked_sub(3), Some(2));
-        assert_eq!(5u.checked_sub(4), Some(1));
-        assert_eq!(5u.checked_sub(5), Some(0));
-        assert_eq!(5u.checked_sub(6), None);
-        assert_eq!(5u.checked_sub(7), None);
+        assert_eq!(5_usize.checked_sub(0), Some(5));
+        assert_eq!(5_usize.checked_sub(1), Some(4));
+        assert_eq!(5_usize.checked_sub(2), Some(3));
+        assert_eq!(5_usize.checked_sub(3), Some(2));
+        assert_eq!(5_usize.checked_sub(4), Some(1));
+        assert_eq!(5_usize.checked_sub(5), Some(0));
+        assert_eq!(5_usize.checked_sub(6), None);
+        assert_eq!(5_usize.checked_sub(7), None);
     }
 
     #[test]
@@ -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));});
     }
 }
diff --git a/src/libstd/num/strconv.rs b/src/libstd/num/strconv.rs
index cf5e1eb0eb7..f6d05f961e1 100644
--- a/src/libstd/num/strconv.rs
+++ b/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,
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index 4cd6391318f..8d4f0344beb 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/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>);
diff --git a/src/libstd/old_io/extensions.rs b/src/libstd/old_io/extensions.rs
index 95284f2ca40..c2a6c515acc 100644
--- a/src/libstd/old_io/extensions.rs
+++ b/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");
diff --git a/src/libstd/old_io/mem.rs b/src/libstd/old_io/mem.rs
index 0f4d9c8b4ea..1fd527014a3 100644
--- a/src/libstd/old_io/mem.rs
+++ b/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]);
diff --git a/src/libstd/old_io/mod.rs b/src/libstd/old_io/mod.rs
index 4bd0662232f..21282a0c28a 100644
--- a/src/libstd/old_io/mod.rs
+++ b/src/libstd/old_io/mod.rs
@@ -1120,37 +1120,37 @@ pub trait Writer {
     /// Write a big-endian u64 (8 bytes).
     #[inline]
     fn write_be_u64(&mut self, n: u64) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n, 8u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n, 8, |v| self.write_all(v))
     }
 
     /// Write a big-endian u32 (4 bytes).
     #[inline]
     fn write_be_u32(&mut self, n: u32) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n as u64, 4, |v| self.write_all(v))
     }
 
     /// Write a big-endian u16 (2 bytes).
     #[inline]
     fn write_be_u16(&mut self, n: u16) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n as u64, 2, |v| self.write_all(v))
     }
 
     /// Write a big-endian i64 (8 bytes).
     #[inline]
     fn write_be_i64(&mut self, n: i64) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 8u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n as u64, 8, |v| self.write_all(v))
     }
 
     /// Write a big-endian i32 (4 bytes).
     #[inline]
     fn write_be_i32(&mut self, n: i32) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 4u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n as u64, 4, |v| self.write_all(v))
     }
 
     /// Write a big-endian i16 (2 bytes).
     #[inline]
     fn write_be_i16(&mut self, n: i16) -> IoResult<()> {
-        extensions::u64_to_be_bytes(n as u64, 2u, |v| self.write_all(v))
+        extensions::u64_to_be_bytes(n as u64, 2, |v| self.write_all(v))
     }
 
     /// Write a big-endian IEEE754 double-precision floating-point (8 bytes).
@@ -1172,37 +1172,37 @@ pub trait Writer {
     /// Write a little-endian u64 (8 bytes).
     #[inline]
     fn write_le_u64(&mut self, n: u64) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n, 8u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n, 8, |v| self.write_all(v))
     }
 
     /// Write a little-endian u32 (4 bytes).
     #[inline]
     fn write_le_u32(&mut self, n: u32) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n as u64, 4, |v| self.write_all(v))
     }
 
     /// Write a little-endian u16 (2 bytes).
     #[inline]
     fn write_le_u16(&mut self, n: u16) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n as u64, 2, |v| self.write_all(v))
     }
 
     /// Write a little-endian i64 (8 bytes).
     #[inline]
     fn write_le_i64(&mut self, n: i64) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 8u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n as u64, 8, |v| self.write_all(v))
     }
 
     /// Write a little-endian i32 (4 bytes).
     #[inline]
     fn write_le_i32(&mut self, n: i32) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 4u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n as u64, 4, |v| self.write_all(v))
     }
 
     /// Write a little-endian i16 (2 bytes).
     #[inline]
     fn write_le_i16(&mut self, n: i16) -> IoResult<()> {
-        extensions::u64_to_le_bytes(n as u64, 2u, |v| self.write_all(v))
+        extensions::u64_to_le_bytes(n as u64, 2, |v| self.write_all(v))
     }
 
     /// Write a little-endian IEEE754 double-precision floating-point
diff --git a/src/libstd/old_io/net/pipe.rs b/src/libstd/old_io/net/pipe.rs
index 392a253d733..d05669d32b8 100644
--- a/src/libstd/old_io/net/pipe.rs
+++ b/src/libstd/old_io/net/pipe.rs
@@ -390,7 +390,7 @@ mod tests {
         };
 
         let _t = thread::spawn(move|| {
-            for _ in 0u..times {
+            for _ in 0..times {
                 let mut stream = UnixStream::connect(&path2);
                 match stream.write(&[100]) {
                     Ok(..) => {}
@@ -555,7 +555,7 @@ mod tests {
             tx.send(UnixStream::connect(&addr2).unwrap()).unwrap();
         });
         let l = rx.recv().unwrap();
-        for i in 0u..1001 {
+        for i in 0..1001 {
             match a.accept() {
                 Ok(..) => break,
                 Err(ref e) if e.kind == TimedOut => {}
@@ -683,7 +683,7 @@ mod tests {
         assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
-        for i in 0u..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
@@ -727,7 +727,7 @@ mod tests {
         assert_eq!(s.read(&mut [0]).err().unwrap().kind, TimedOut);
 
         tx.send(()).unwrap();
-        for _ in 0u..100 {
+        for _ in 0..100 {
             assert!(s.write(&[0;128 * 1024]).is_ok());
         }
     }
@@ -746,7 +746,7 @@ mod tests {
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
-        for i in 0u..1001 {
+        for i in 0..1001 {
             match s.write(&[0; 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/old_io/net/tcp.rs b/src/libstd/old_io/net/tcp.rs
index 2afff9fc1c9..19a6f6e3def 100644
--- a/src/libstd/old_io/net/tcp.rs
+++ b/src/libstd/old_io/net/tcp.rs
@@ -746,7 +746,7 @@ mod test {
     #[test]
     fn multiple_connect_serial_ip4() {
         let addr = next_test_ip4();
-        let max = 10u;
+        let max = 10;
         let mut acceptor = TcpListener::bind(addr).listen();
 
         let _t = thread::spawn(move|| {
@@ -766,7 +766,7 @@ mod test {
     #[test]
     fn multiple_connect_serial_ip6() {
         let addr = next_test_ip6();
-        let max = 10u;
+        let max = 10;
         let mut acceptor = TcpListener::bind(addr).listen();
 
         let _t = thread::spawn(move|| {
diff --git a/src/libstd/old_io/net/udp.rs b/src/libstd/old_io/net/udp.rs
index 7171198e7a4..67b57b25086 100644
--- a/src/libstd/old_io/net/udp.rs
+++ b/src/libstd/old_io/net/udp.rs
@@ -447,7 +447,7 @@ mod test {
         let _b = UdpSocket::bind(addr2).unwrap();
 
         a.set_write_timeout(Some(1000));
-        for _ in 0u..100 {
+        for _ in 0..100 {
             match a.send_to(&[0;4*1024], addr2) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/old_io/timer.rs b/src/libstd/old_io/timer.rs
index 8b84e27eae1..1f2ef50fcae 100644
--- a/src/libstd/old_io/timer.rs
+++ b/src/libstd/old_io/timer.rs
@@ -121,7 +121,7 @@ impl Timer {
     /// let mut timer = Timer::new().unwrap();
     /// let ten_milliseconds = timer.oneshot(Duration::milliseconds(10));
     ///
-    /// for _ in 0u..100 { /* do work */ }
+    /// for _ in 0..100 { /* do work */ }
     ///
     /// // blocks until 10 ms after the `oneshot` call
     /// ten_milliseconds.recv().unwrap();
@@ -173,12 +173,12 @@ impl Timer {
     /// let mut timer = Timer::new().unwrap();
     /// let ten_milliseconds = timer.periodic(Duration::milliseconds(10));
     ///
-    /// for _ in 0u..100 { /* do work */ }
+    /// for _ in 0..100 { /* do work */ }
     ///
     /// // blocks until 10 ms after the `periodic` call
     /// ten_milliseconds.recv().unwrap();
     ///
-    /// for _ in 0u..100 { /* do work */ }
+    /// for _ in 0..100 { /* do work */ }
     ///
     /// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
     /// // previous `recv`)
diff --git a/src/libstd/old_path/posix.rs b/src/libstd/old_path/posix.rs
index b0fec102103..15eee9e4a0c 100644
--- a/src/libstd/old_path/posix.rs
+++ b/src/libstd/old_path/posix.rs
@@ -418,7 +418,7 @@ fn normalize_helper<'a>(v: &'a [u8], is_abs: bool) -> Option<Vec<&'a [u8]>> {
         return None;
     }
     let mut comps: Vec<&'a [u8]> = vec![];
-    let mut n_up = 0u;
+    let mut n_up = 0;
     let mut changed = false;
     for comp in v.split(is_sep_byte) {
         if comp.is_empty() { changed = true }
diff --git a/src/libstd/old_path/windows.rs b/src/libstd/old_path/windows.rs
index 4754efbd1fe..37687d9b779 100644
--- a/src/libstd/old_path/windows.rs
+++ b/src/libstd/old_path/windows.rs
@@ -1079,7 +1079,7 @@ fn normalize_helper<'a>(s: &'a str, prefix: Option<PathPrefix>) -> (bool, Option
         });
     }
     let mut comps: Vec<&'a str> = vec![];
-    let mut n_up = 0u;
+    let mut n_up = 0;
     let mut changed = false;
     for comp in s_.split(f) {
         if comp.is_empty() { changed = true }
diff --git a/src/libstd/os.rs b/src/libstd/os.rs
index 740a45feb3d..a4213e7373b 100644
--- a/src/libstd/os.rs
+++ b/src/libstd/os.rs
@@ -78,7 +78,7 @@ pub fn num_cpus() -> uint {
     }
 }
 
-pub const TMPBUF_SZ : uint = 1000u;
+pub const TMPBUF_SZ : uint = 1000;
 
 /// Returns the current working directory as a `Path`.
 ///
@@ -1442,7 +1442,7 @@ mod tests {
 
     fn make_rand_name() -> String {
         let mut rng = rand::thread_rng();
-        let n = format!("TEST{}", rng.gen_ascii_chars().take(10u)
+        let n = format!("TEST{}", rng.gen_ascii_chars().take(10)
                                      .collect::<String>());
         assert!(getenv(&n).is_none());
         n
@@ -1522,7 +1522,7 @@ mod tests {
     #[ignore]
     fn test_env_getenv() {
         let e = env();
-        assert!(e.len() > 0u);
+        assert!(e.len() > 0);
         for p in &e {
             let (n, v) = (*p).clone();
             debug!("{}", n);
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index 5b888c7612d..5c891441198 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -102,7 +102,7 @@
 //!    let total = 1_000_000;
 //!    let mut in_circle = 0;
 //!
-//!    for _ in 0u..total {
+//!    for _ in 0..total {
 //!        let a = between.ind_sample(&mut rng);
 //!        let b = between.ind_sample(&mut rng);
 //!        if a*a + b*b <= 1. {
@@ -176,7 +176,7 @@
 //! }
 //!
 //! fn free_doors(blocked: &[uint]) -> Vec<uint> {
-//!     (0u..3).filter(|x| !blocked.contains(x)).collect()
+//!     (0..3).filter(|x| !blocked.contains(x)).collect()
 //! }
 //!
 //! fn main() {
@@ -483,14 +483,14 @@ mod test {
     #[test]
     fn test_gen_range() {
         let mut r = thread_rng();
-        for _ in 0u..1000 {
+        for _ in 0..1000 {
             let a = r.gen_range(-3, 42);
             assert!(a >= -3 && a < 42);
             assert_eq!(r.gen_range(0, 1), 0);
             assert_eq!(r.gen_range(-12, -11), -12);
         }
 
-        for _ in 0u..1000 {
+        for _ in 0..1000 {
             let a = r.gen_range(10, 42);
             assert!(a >= 10 && a < 42);
             assert_eq!(r.gen_range(0, 1), 0);
@@ -510,7 +510,7 @@ mod test {
     #[should_fail]
     fn test_gen_range_panic_uint() {
         let mut r = thread_rng();
-        r.gen_range(5us, 2us);
+        r.gen_range(5, 2);
     }
 
     #[test]
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index 0feacf5581c..0e2766f3889 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -377,7 +377,7 @@ mod test {
     fn test_os_rng_tasks() {
 
         let mut txs = vec!();
-        for _ in 0u..20 {
+        for _ in 0..20 {
             let (tx, rx) = channel();
             txs.push(tx);
 
@@ -391,7 +391,7 @@ mod test {
                 thread::yield_now();
                 let mut v = [0u8; 1000];
 
-                for _ in 0u..100 {
+                for _ in 0..100 {
                     r.next_u32();
                     thread::yield_now();
                     r.next_u64();
diff --git a/src/libstd/sync/barrier.rs b/src/libstd/sync/barrier.rs
index fc781eb4bec..b036177af15 100644
--- a/src/libstd/sync/barrier.rs
+++ b/src/libstd/sync/barrier.rs
@@ -18,7 +18,7 @@ use sync::{Mutex, Condvar};
 /// use std::thread;
 ///
 /// let barrier = Arc::new(Barrier::new(10));
-/// for _ in 0u..10 {
+/// for _ in 0..10 {
 ///     let c = barrier.clone();
 ///     // The same messages will be printed together.
 ///     // You will NOT see any interleaving.
@@ -120,7 +120,7 @@ mod tests {
         let barrier = Arc::new(Barrier::new(N));
         let (tx, rx) = channel();
 
-        for _ in 0u..N - 1 {
+        for _ in 0..N - 1 {
             let c = barrier.clone();
             let tx = tx.clone();
             thread::spawn(move|| {
@@ -138,7 +138,7 @@ mod tests {
         let mut leader_found = barrier.wait().is_leader();
 
         // Now, the barrier is cleared and we should get data.
-        for _ in 0u..N - 1 {
+        for _ in 0..N - 1 {
             if rx.recv().unwrap() {
                 assert!(!leader_found);
                 leader_found = true;
diff --git a/src/libstd/sync/mpsc/mod.rs b/src/libstd/sync/mpsc/mod.rs
index 410d3c0ecd5..21993e51669 100644
--- a/src/libstd/sync/mpsc/mod.rs
+++ b/src/libstd/sync/mpsc/mod.rs
@@ -1147,9 +1147,9 @@ mod test {
     fn stress() {
         let (tx, rx) = channel::<int>();
         let t = thread::spawn(move|| {
-            for _ in 0u..10000 { tx.send(1).unwrap(); }
+            for _ in 0..10000 { tx.send(1).unwrap(); }
         });
-        for _ in 0u..10000 {
+        for _ in 0..10000 {
             assert_eq!(rx.recv().unwrap(), 1);
         }
         t.join().ok().unwrap();
@@ -1209,7 +1209,7 @@ mod test {
                 assert_eq!(rx.recv().unwrap(), 1);
             }
         });
-        for _ in 0u..40 {
+        for _ in 0..40 {
             tx.send(1).unwrap();
         }
         t.join().ok().unwrap();
@@ -1530,7 +1530,7 @@ mod test {
             tx2.send(()).unwrap();
         });
         // make sure the other task has gone to sleep
-        for _ in 0u..5000 { thread::yield_now(); }
+        for _ in 0..5000 { thread::yield_now(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -1654,9 +1654,9 @@ mod sync_tests {
     fn stress() {
         let (tx, rx) = sync_channel::<int>(0);
         thread::spawn(move|| {
-            for _ in 0u..10000 { tx.send(1).unwrap(); }
+            for _ in 0..10000 { tx.send(1).unwrap(); }
         });
-        for _ in 0u..10000 {
+        for _ in 0..10000 {
             assert_eq!(rx.recv().unwrap(), 1);
         }
     }
@@ -1893,8 +1893,8 @@ mod sync_tests {
     fn recv_a_lot() {
         // Regression test that we don't run out of stack in scheduler context
         let (tx, rx) = sync_channel(10000);
-        for _ in 0u..10000 { tx.send(()).unwrap(); }
-        for _ in 0u..10000 { rx.recv().unwrap(); }
+        for _ in 0..10000 { tx.send(()).unwrap(); }
+        for _ in 0..10000 { rx.recv().unwrap(); }
     }
 
     #[test]
@@ -1994,7 +1994,7 @@ mod sync_tests {
             tx2.send(()).unwrap();
         });
         // make sure the other task has gone to sleep
-        for _ in 0u..5000 { thread::yield_now(); }
+        for _ in 0..5000 { thread::yield_now(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -2082,7 +2082,7 @@ mod sync_tests {
             rx2.recv().unwrap();
         }
 
-        for _ in 0u..100 {
+        for _ in 0..100 {
             repro()
         }
     }
diff --git a/src/libstd/sync/mpsc/mpsc_queue.rs b/src/libstd/sync/mpsc/mpsc_queue.rs
index 0a4ff8769ab..a2accb128c3 100644
--- a/src/libstd/sync/mpsc/mpsc_queue.rs
+++ b/src/libstd/sync/mpsc/mpsc_queue.rs
@@ -171,8 +171,8 @@ mod tests {
 
     #[test]
     fn test() {
-        let nthreads = 8u;
-        let nmsgs = 1000u;
+        let nthreads = 8;
+        let nmsgs = 1000;
         let q = Queue::new();
         match q.pop() {
             Empty => {}
@@ -192,7 +192,7 @@ mod tests {
             });
         }
 
-        let mut i = 0u;
+        let mut i = 0;
         while i < nthreads * nmsgs {
             match q.pop() {
                 Empty | Inconsistent => {},
diff --git a/src/libstd/sync/mpsc/select.rs b/src/libstd/sync/mpsc/select.rs
index 4756ef612f9..8fcedd2ab57 100644
--- a/src/libstd/sync/mpsc/select.rs
+++ b/src/libstd/sync/mpsc/select.rs
@@ -428,10 +428,10 @@ mod test {
         let (tx3, rx3) = channel::<int>();
 
         let _t = thread::spawn(move|| {
-            for _ in 0u..20 { thread::yield_now(); }
+            for _ in 0..20 { thread::yield_now(); }
             tx1.send(1).unwrap();
             rx3.recv().unwrap();
-            for _ in 0u..20 { thread::yield_now(); }
+            for _ in 0..20 { thread::yield_now(); }
         });
 
         select! {
@@ -452,7 +452,7 @@ mod test {
         let (tx3, rx3) = channel::<()>();
 
         let _t = thread::spawn(move|| {
-            for _ in 0u..20 { thread::yield_now(); }
+            for _ in 0..20 { thread::yield_now(); }
             tx1.send(1).unwrap();
             tx2.send(2).unwrap();
             rx3.recv().unwrap();
@@ -557,7 +557,7 @@ mod test {
             tx3.send(()).unwrap();
         });
 
-        for _ in 0u..1000 { thread::yield_now(); }
+        for _ in 0..1000 { thread::yield_now(); }
         drop(tx1.clone());
         tx2.send(()).unwrap();
         rx3.recv().unwrap();
@@ -670,7 +670,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in 0u..100 { thread::yield_now() }
+        for _ in 0..100 { thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -690,7 +690,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in 0u..100 { thread::yield_now() }
+        for _ in 0..100 { thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -709,7 +709,7 @@ mod test {
             tx2.send(()).unwrap();
         });
 
-        for _ in 0u..100 { thread::yield_now() }
+        for _ in 0..100 { thread::yield_now() }
         tx1.send(()).unwrap();
         rx2.recv().unwrap();
     }
@@ -727,7 +727,7 @@ mod test {
     fn sync2() {
         let (tx, rx) = sync_channel::<int>(0);
         let _t = thread::spawn(move|| {
-            for _ in 0u..100 { thread::yield_now() }
+            for _ in 0..100 { thread::yield_now() }
             tx.send(1).unwrap();
         });
         select! {
diff --git a/src/libstd/sync/mpsc/spsc_queue.rs b/src/libstd/sync/mpsc/spsc_queue.rs
index b8f835bde51..e1a89706509 100644
--- a/src/libstd/sync/mpsc/spsc_queue.rs
+++ b/src/libstd/sync/mpsc/spsc_queue.rs
@@ -325,7 +325,7 @@ mod test {
             let (tx, rx) = channel();
             let q2 = q.clone();
             let _t = thread::spawn(move|| {
-                for _ in 0u..100000 {
+                for _ in 0..100000 {
                     loop {
                         match q2.pop() {
                             Some(1) => break,
diff --git a/src/libstd/sync/mutex.rs b/src/libstd/sync/mutex.rs
index 65cae90857e..e77c4d2e5eb 100644
--- a/src/libstd/sync/mutex.rs
+++ b/src/libstd/sync/mutex.rs
@@ -60,7 +60,7 @@ use sys_common::mutex as sys;
 /// let data = Arc::new(Mutex::new(0));
 ///
 /// let (tx, rx) = channel();
-/// for _ in 0u..10 {
+/// for _ in 0..10 {
 ///     let (data, tx) = (data.clone(), tx.clone());
 ///     thread::spawn(move || {
 ///         // The shared static can only be accessed once the lock is held.
@@ -87,7 +87,7 @@ use sys_common::mutex as sys;
 /// use std::sync::{Arc, Mutex};
 /// use std::thread;
 ///
-/// let lock = Arc::new(Mutex::new(0u));
+/// let lock = Arc::new(Mutex::new(0_u32));
 /// let lock2 = lock.clone();
 ///
 /// let _ = thread::spawn(move || -> () {
diff --git a/src/libstd/sync/once.rs b/src/libstd/sync/once.rs
index 1e87c0d612b..97f985e21e8 100644
--- a/src/libstd/sync/once.rs
+++ b/src/libstd/sync/once.rs
@@ -147,10 +147,10 @@ mod test {
         static mut run: bool = false;
 
         let (tx, rx) = channel();
-        for _ in 0u..10 {
+        for _ in 0..10 {
             let tx = tx.clone();
             thread::spawn(move|| {
-                for _ in 0u..4 { thread::yield_now() }
+                for _ in 0..4 { thread::yield_now() }
                 unsafe {
                     O.call_once(|| {
                         assert!(!run);
@@ -170,7 +170,7 @@ mod test {
             assert!(run);
         }
 
-        for _ in 0u..10 {
+        for _ in 0..10 {
             rx.recv().unwrap();
         }
     }
diff --git a/src/libstd/sync/rwlock.rs b/src/libstd/sync/rwlock.rs
index b8d157d341e..cd833b17867 100644
--- a/src/libstd/sync/rwlock.rs
+++ b/src/libstd/sync/rwlock.rs
@@ -503,7 +503,7 @@ mod tests {
 
         thread::spawn(move|| {
             let mut lock = arc2.write().unwrap();
-            for _ in 0u..10 {
+            for _ in 0..10 {
                 let tmp = *lock;
                 *lock = -1;
                 thread::yield_now();
@@ -514,7 +514,7 @@ mod tests {
 
         // Readers try to catch the writer in the act
         let mut children = Vec::new();
-        for _ in 0u..5 {
+        for _ in 0..5 {
             let arc3 = arc.clone();
             children.push(thread::spawn(move|| {
                 let lock = arc3.read().unwrap();
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index f4274dd91cc..a45048be24c 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -63,17 +63,17 @@ impl<'a> Drop for Sentinel<'a> {
 /// use std::iter::AdditiveIterator;
 /// use std::sync::mpsc::channel;
 ///
-/// let pool = TaskPool::new(4u);
+/// let pool = TaskPool::new(4);
 ///
 /// let (tx, rx) = channel();
-/// for _ in 0..8u {
+/// for _ in 0..8 {
 ///     let tx = tx.clone();
 ///     pool.execute(move|| {
-///         tx.send(1u).unwrap();
+///         tx.send(1_u32).unwrap();
 ///     });
 /// }
 ///
-/// assert_eq!(rx.iter().take(8u).sum(), 8u);
+/// assert_eq!(rx.iter().take(8).sum(), 8);
 /// ```
 pub struct TaskPool {
     // How the threadpool communicates with subthreads.
@@ -142,7 +142,7 @@ mod test {
     use super::*;
     use sync::mpsc::channel;
 
-    const TEST_TASKS: uint = 4u;
+    const TEST_TASKS: uint = 4;
 
     #[test]
     fn test_works() {
@@ -154,7 +154,7 @@ mod test {
         for _ in 0..TEST_TASKS {
             let tx = tx.clone();
             pool.execute(move|| {
-                tx.send(1u).unwrap();
+                tx.send(1).unwrap();
             });
         }
 
@@ -183,7 +183,7 @@ mod test {
         for _ in 0..TEST_TASKS {
             let tx = tx.clone();
             pool.execute(move|| {
-                tx.send(1u).unwrap();
+                tx.send(1).unwrap();
             });
         }
 
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index ad56555997f..66856a2f2c2 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -175,13 +175,13 @@ pub fn current_exe() -> IoResult<Path> {
         let mut sz: libc::size_t = 0;
         let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
                          ptr::null_mut(), &mut sz, ptr::null_mut(),
-                         0u as libc::size_t);
+                         0 as libc::size_t);
         if err != 0 { return Err(IoError::last_error()); }
         if sz == 0 { return Err(IoError::last_error()); }
         let mut v: Vec<u8> = Vec::with_capacity(sz as uint);
         let err = sysctl(mib.as_mut_ptr(), mib.len() as ::libc::c_uint,
                          v.as_mut_ptr() as *mut libc::c_void, &mut sz,
-                         ptr::null_mut(), 0u as libc::size_t);
+                         ptr::null_mut(), 0 as libc::size_t);
         if err != 0 { return Err(IoError::last_error()); }
         if sz == 0 { return Err(IoError::last_error()); }
         v.set_len(sz as uint - 1); // chop off trailing NUL
diff --git a/src/libstd/sys/windows/c.rs b/src/libstd/sys/windows/c.rs
index 3a1b797eeb4..f861255a00a 100644
--- a/src/libstd/sys/windows/c.rs
+++ b/src/libstd/sys/windows/c.rs
@@ -105,7 +105,7 @@ pub struct WSAPROTOCOL_INFO {
     pub iSecurityScheme: libc::c_int,
     pub dwMessageSize: libc::DWORD,
     pub dwProviderReserved: libc::DWORD,
-    pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1us],
+    pub szProtocol: [u16; (WSAPROTOCOL_LEN as usize) + 1],
 }
 
 pub type LPWSAPROTOCOL_INFO = *mut WSAPROTOCOL_INFO;
diff --git a/src/libstd/sys/windows/process.rs b/src/libstd/sys/windows/process.rs
index eab60047aa2..96ffc4daddd 100644
--- a/src/libstd/sys/windows/process.rs
+++ b/src/libstd/sys/windows/process.rs
@@ -388,7 +388,7 @@ fn make_command_line(prog: &CString, args: &[CString]) -> String {
             cmd.push('"');
         }
         let argvec: Vec<char> = arg.chars().collect();
-        for i in 0u..argvec.len() {
+        for i in 0..argvec.len() {
             append_char_at(cmd, &argvec, i);
         }
         if quote {