librustc: Remove the fallback to `int` from typechecking.

This breaks a fair amount of code. The typical patterns are:

* `for _ in range(0, 10)`: change to `for _ in range(0u, 10)`;

* `println!("{}", 3)`: change to `println!("{}", 3i)`;

* `[1, 2, 3].len()`: change to `[1i, 2, 3].len()`.

RFC #30. Closes #6023.

[breaking-change]

8 files changed, 141 insertions, 138 deletions

diff --git a/src/libsync/atomics.rs b/src/libsync/atomics.rs
index 7d9a18cfbda..8ce17b9bf3b 100644
--- a/src/libsync/atomics.rs
+++ b/src/libsync/atomics.rs
@@ -195,8 +195,8 @@ mod test {
 
     #[test]
     fn option_swap() {
-        let p = AtomicOption::new(box 1);
-        let a = box 2;
+        let p = AtomicOption::new(box 1i);
+        let a = box 2i;
 
         let b = p.swap(a, SeqCst);
 
@@ -206,12 +206,12 @@ mod test {
 
     #[test]
     fn option_take() {
-        let p = AtomicOption::new(box 1);
+        let p = AtomicOption::new(box 1i);
 
         assert!(p.take(SeqCst) == Some(box 1));
         assert!(p.take(SeqCst) == None);
 
-        let p2 = box 2;
+        let p2 = box 2i;
         p.swap(p2, SeqCst);
 
         assert!(p.take(SeqCst) == Some(box 2));
@@ -219,11 +219,11 @@ mod test {
 
     #[test]
     fn option_fill() {
-        let p = AtomicOption::new(box 1);
-        assert!(p.fill(box 2, SeqCst).is_some()); // should fail; shouldn't leak!
+        let p = AtomicOption::new(box 1i);
+        assert!(p.fill(box 2i, SeqCst).is_some()); // should fail; shouldn't leak!
         assert!(p.take(SeqCst) == Some(box 1));
 
-        assert!(p.fill(box 2, SeqCst).is_none()); // shouldn't fail
+        assert!(p.fill(box 2i, SeqCst).is_none()); // shouldn't fail
         assert!(p.take(SeqCst) == Some(box 2));
     }
 }
diff --git a/src/libsync/comm/mod.rs b/src/libsync/comm/mod.rs
index 842743657a6..3e8f4eef370 100644
--- a/src/libsync/comm/mod.rs
+++ b/src/libsync/comm/mod.rs
@@ -77,9 +77,9 @@
 //! // Create a simple streaming channel
 //! let (tx, rx) = channel();
 //! spawn(proc() {
-//!     tx.send(10);
+//!     tx.send(10i);
 //! });
-//! assert_eq!(rx.recv(), 10);
+//! assert_eq!(rx.recv(), 10i);
 //! ```
 //!
 //! Shared usage:
@@ -87,14 +87,14 @@
 //! ```
 //! // Create a shared channel which can be sent along from many tasks
 //! let (tx, rx) = channel();
-//! for i in range(0, 10) {
+//! for i in range(0i, 10i) {
 //!     let tx = tx.clone();
 //!     spawn(proc() {
 //!         tx.send(i);
 //!     })
 //! }
 //!
-//! for _ in range(0, 10) {
+//! for _ in range(0i, 10i) {
 //!     let j = rx.recv();
 //!     assert!(0 <= j && j < 10);
 //! }
@@ -113,7 +113,7 @@
 //! Synchronous channels:
 //!
 //! ```
-//! let (tx, rx) = sync_channel(0);
+//! let (tx, rx) = sync_channel::<int>(0);
 //! spawn(proc() {
 //!     // This will wait for the parent task to start receiving
 //!     tx.send(53);
@@ -504,15 +504,15 @@ pub fn channel<T: Send>() -> (Sender<T>, Receiver<T>) {
 /// let (tx, rx) = sync_channel(1);
 ///
 /// // this returns immediately
-/// tx.send(1);
+/// tx.send(1i);
 ///
 /// spawn(proc() {
 ///     // this will block until the previous message has been received
-///     tx.send(2);
+///     tx.send(2i);
 /// });
 ///
-/// assert_eq!(rx.recv(), 1);
-/// assert_eq!(rx.recv(), 2);
+/// assert_eq!(rx.recv(), 1i);
+/// assert_eq!(rx.recv(), 2i);
 /// ```
 pub fn sync_channel<T: Send>(bound: uint) -> (SyncSender<T>, Receiver<T>) {
     let a = Arc::new(Unsafe::new(sync::Packet::new(bound)));
@@ -577,11 +577,11 @@ impl<T: Send> Sender<T> {
     /// let (tx, rx) = channel();
     ///
     /// // This send is always successful
-    /// assert_eq!(tx.send_opt(1), Ok(()));
+    /// assert_eq!(tx.send_opt(1i), Ok(()));
     ///
     /// // This send will fail because the receiver is gone
     /// drop(rx);
-    /// assert_eq!(tx.send_opt(1), Err(1));
+    /// assert_eq!(tx.send_opt(1i), Err(1));
     /// ```
     pub fn send_opt(&self, t: T) -> Result<(), T> {
         // In order to prevent starvation of other tasks in situations where
@@ -1041,25 +1041,25 @@ mod test {
     }
 
     test!(fn smoke() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         tx.send(1);
         assert_eq!(rx.recv(), 1);
     })
 
     test!(fn drop_full() {
         let (tx, _rx) = channel();
-        tx.send(box 1);
+        tx.send(box 1i);
     })
 
     test!(fn drop_full_shared() {
         let (tx, _rx) = channel();
         drop(tx.clone());
         drop(tx.clone());
-        tx.send(box 1);
+        tx.send(box 1i);
     })
 
     test!(fn smoke_shared() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         tx.send(1);
         assert_eq!(rx.recv(), 1);
         let tx = tx.clone();
@@ -1068,7 +1068,7 @@ mod test {
     })
 
     test!(fn smoke_threads() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         spawn(proc() {
             tx.send(1);
         });
@@ -1076,19 +1076,19 @@ mod test {
     })
 
     test!(fn smoke_port_gone() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         drop(rx);
         tx.send(1);
     } #[should_fail])
 
     test!(fn smoke_shared_port_gone() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         drop(rx);
         tx.send(1);
     } #[should_fail])
 
     test!(fn smoke_shared_port_gone2() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         drop(rx);
         let tx2 = tx.clone();
         drop(tx);
@@ -1096,7 +1096,7 @@ mod test {
     } #[should_fail])
 
     test!(fn port_gone_concurrent() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         spawn(proc() {
             rx.recv();
         });
@@ -1104,7 +1104,7 @@ mod test {
     } #[should_fail])
 
     test!(fn port_gone_concurrent_shared() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         let tx2 = tx.clone();
         spawn(proc() {
             rx.recv();
@@ -1130,7 +1130,7 @@ mod test {
     } #[should_fail])
 
     test!(fn chan_gone_concurrent() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         spawn(proc() {
             tx.send(1);
             tx.send(1);
@@ -1139,11 +1139,11 @@ mod test {
     } #[should_fail])
 
     test!(fn stress() {
-        let (tx, rx) = channel();
+        let (tx, rx) = channel::<int>();
         spawn(proc() {
-            for _ in range(0, 10000) { tx.send(1); }
+            for _ in range(0u, 10000) { tx.send(1i); }
         });
-        for _ in range(0, 10000) {
+        for _ in range(0u, 10000) {
             assert_eq!(rx.recv(), 1);
         }
     })
@@ -1183,14 +1183,14 @@ mod test {
         let tx4 = tx3.clone();
         spawn(proc() {
             tx1.send(());
-            for _ in range(0, 40) {
+            for _ in range(0i, 40) {
                 assert_eq!(rx2.recv(), 1);
             }
             tx3.send(());
         });
         rx1.recv();
         native::task::spawn(proc() {
-            for _ in range(0, 40) {
+            for _ in range(0i, 40) {
                 tx2.send(1);
             }
             tx4.send(());
@@ -1204,12 +1204,12 @@ mod test {
         let (tx, rx) = channel::<int>();
         let (dtx, drx) = channel();
         native::task::spawn(proc() {
-            for _ in range(0, 40) {
+            for _ in range(0i, 40) {
                 assert_eq!(rx.recv(), 1);
             }
             dtx.send(());
         });
-        for _ in range(0, 40) {
+        for _ in range(0u, 40) {
             tx.send(1);
         }
         drx.recv();
@@ -1377,10 +1377,10 @@ mod test {
         for _ in range(0, stress_factor()) {
             let (tx, rx) = channel();
             spawn(proc() {
-                tx.send(box 10);
+                tx.send(box 10i);
             });
             spawn(proc() {
-                assert!(rx.recv() == box 10);
+                assert!(rx.recv() == box 10i);
             });
         }
     })
@@ -1415,8 +1415,8 @@ mod test {
     test!(fn recv_a_lot() {
         // Regression test that we don't run out of stack in scheduler context
         let (tx, rx) = channel();
-        for _ in range(0, 10000) { tx.send(()); }
-        for _ in range(0, 10000) { rx.recv(); }
+        for _ in range(0i, 10000) { tx.send(()); }
+        for _ in range(0i, 10000) { rx.recv(); }
     })
 
     test!(fn shared_chan_stress() {
@@ -1511,7 +1511,7 @@ mod test {
             tx2.send(());
         });
         // make sure the other task has gone to sleep
-        for _ in range(0, 5000) { task::deschedule(); }
+        for _ in range(0u, 5000) { task::deschedule(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -1527,11 +1527,11 @@ mod test {
 
         let (tx, rx) = channel();
         let t = Thread::start(proc() {
-            for _ in range(0, 1000) {
+            for _ in range(0u, 1000) {
                 tx.send(());
             }
         });
-        for _ in range(0, 1000) {
+        for _ in range(0u, 1000) {
             rx.recv();
         }
         t.join();
@@ -1553,7 +1553,7 @@ mod test {
             }
             cdone.send(());
         });
-        for _ in range(0, 10) {
+        for _ in range(0u, 10) {
             tx.send(());
         }
         t.join();
@@ -1574,18 +1574,18 @@ mod sync_tests {
     }
 
     test!(fn smoke() {
-        let (tx, rx) = sync_channel(1);
+        let (tx, rx) = sync_channel::<int>(1);
         tx.send(1);
         assert_eq!(rx.recv(), 1);
     })
 
     test!(fn drop_full() {
         let (tx, _rx) = sync_channel(1);
-        tx.send(box 1);
+        tx.send(box 1i);
     })
 
     test!(fn smoke_shared() {
-        let (tx, rx) = sync_channel(1);
+        let (tx, rx) = sync_channel::<int>(1);
         tx.send(1);
         assert_eq!(rx.recv(), 1);
         let tx = tx.clone();
@@ -1594,7 +1594,7 @@ mod sync_tests {
     })
 
     test!(fn smoke_threads() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
             tx.send(1);
         });
@@ -1602,13 +1602,13 @@ mod sync_tests {
     })
 
     test!(fn smoke_port_gone() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         drop(rx);
         tx.send(1);
     } #[should_fail])
 
     test!(fn smoke_shared_port_gone2() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         drop(rx);
         let tx2 = tx.clone();
         drop(tx);
@@ -1616,7 +1616,7 @@ mod sync_tests {
     } #[should_fail])
 
     test!(fn port_gone_concurrent() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
             rx.recv();
         });
@@ -1624,7 +1624,7 @@ mod sync_tests {
     } #[should_fail])
 
     test!(fn port_gone_concurrent_shared() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         let tx2 = tx.clone();
         spawn(proc() {
             rx.recv();
@@ -1650,7 +1650,7 @@ mod sync_tests {
     } #[should_fail])
 
     test!(fn chan_gone_concurrent() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
             tx.send(1);
             tx.send(1);
@@ -1659,11 +1659,11 @@ mod sync_tests {
     } #[should_fail])
 
     test!(fn stress() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
-            for _ in range(0, 10000) { tx.send(1); }
+            for _ in range(0u, 10000) { tx.send(1); }
         });
-        for _ in range(0, 10000) {
+        for _ in range(0u, 10000) {
             assert_eq!(rx.recv(), 1);
         }
     })
@@ -1840,19 +1840,19 @@ mod sync_tests {
 
     test!(fn oneshot_multi_thread_send_recv_stress() {
         for _ in range(0, stress_factor()) {
-            let (tx, rx) = sync_channel(0);
+            let (tx, rx) = sync_channel::<Box<int>>(0);
             spawn(proc() {
-                tx.send(box 10);
+                tx.send(box 10i);
             });
             spawn(proc() {
-                assert!(rx.recv() == box 10);
+                assert!(rx.recv() == box 10i);
             });
         }
     })
 
     test!(fn stream_send_recv_stress() {
         for _ in range(0, stress_factor()) {
-            let (tx, rx) = sync_channel(0);
+            let (tx, rx) = sync_channel::<Box<int>>(0);
 
             send(tx, 0);
             recv(rx, 0);
@@ -1880,8 +1880,8 @@ mod sync_tests {
     test!(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 range(0, 10000) { tx.send(()); }
-        for _ in range(0, 10000) { rx.recv(); }
+        for _ in range(0u, 10000) { tx.send(()); }
+        for _ in range(0u, 10000) { rx.recv(); }
     })
 
     test!(fn shared_chan_stress() {
@@ -1968,15 +1968,15 @@ mod sync_tests {
     // This bug used to end up in a livelock inside of the Receiver destructor
     // because the internal state of the Shared packet was corrupted
     test!(fn destroy_upgraded_shared_port_when_sender_still_active() {
-        let (tx, rx) = sync_channel(0);
-        let (tx2, rx2) = sync_channel(0);
+        let (tx, rx) = sync_channel::<()>(0);
+        let (tx2, rx2) = sync_channel::<()>(0);
         spawn(proc() {
             rx.recv(); // wait on a oneshot
             drop(rx);  // destroy a shared
             tx2.send(());
         });
         // make sure the other task has gone to sleep
-        for _ in range(0, 5000) { task::deschedule(); }
+        for _ in range(0u, 5000) { task::deschedule(); }
 
         // upgrade to a shared chan and send a message
         let t = tx.clone();
@@ -1990,7 +1990,7 @@ mod sync_tests {
     test!(fn try_recvs_off_the_runtime() {
         use std::rt::thread::Thread;
 
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<()>(0);
         let (cdone, pdone) = channel();
         let t = Thread::start(proc() {
             let mut hits = 0;
@@ -2003,7 +2003,7 @@ mod sync_tests {
             }
             cdone.send(());
         });
-        for _ in range(0, 10) {
+        for _ in range(0u, 10) {
             tx.send(());
         }
         t.join();
@@ -2011,26 +2011,26 @@ mod sync_tests {
     })
 
     test!(fn send_opt1() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() { rx.recv(); });
         assert_eq!(tx.send_opt(1), Ok(()));
     })
 
     test!(fn send_opt2() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() { drop(rx); });
         assert_eq!(tx.send_opt(1), Err(1));
     })
 
     test!(fn send_opt3() {
-        let (tx, rx) = sync_channel(1);
+        let (tx, rx) = sync_channel::<int>(1);
         assert_eq!(tx.send_opt(1), Ok(()));
         spawn(proc() { drop(rx); });
         assert_eq!(tx.send_opt(1), Err(1));
     })
 
     test!(fn send_opt4() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         let tx2 = tx.clone();
         let (done, donerx) = channel();
         let done2 = done.clone();
@@ -2048,27 +2048,27 @@ mod sync_tests {
     })
 
     test!(fn try_send1() {
-        let (tx, _rx) = sync_channel(0);
+        let (tx, _rx) = sync_channel::<int>(0);
         assert_eq!(tx.try_send(1), Err(Full(1)));
     })
 
     test!(fn try_send2() {
-        let (tx, _rx) = sync_channel(1);
+        let (tx, _rx) = sync_channel::<int>(1);
         assert_eq!(tx.try_send(1), Ok(()));
         assert_eq!(tx.try_send(1), Err(Full(1)));
     })
 
     test!(fn try_send3() {
-        let (tx, rx) = sync_channel(1);
+        let (tx, rx) = sync_channel::<int>(1);
         assert_eq!(tx.try_send(1), Ok(()));
         drop(rx);
         assert_eq!(tx.try_send(1), Err(RecvDisconnected(1)));
     })
 
     test!(fn try_send4() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
-            for _ in range(0, 1000) { task::deschedule(); }
+            for _ in range(0u, 1000) { task::deschedule(); }
             assert_eq!(tx.try_send(1), Ok(()));
         });
         assert_eq!(rx.recv(), 1);
diff --git a/src/libsync/comm/select.rs b/src/libsync/comm/select.rs
index de89e33ffda..8d56f9a003b 100644
--- a/src/libsync/comm/select.rs
+++ b/src/libsync/comm/select.rs
@@ -30,15 +30,15 @@
 //! let (tx1, rx1) = channel();
 //! let (tx2, rx2) = channel();
 //!
-//! tx1.send(1);
-//! tx2.send(2);
+//! tx1.send(1i);
+//! tx2.send(2i);
 //!
 //! select! {
 //!     val = rx1.recv() => {
-//!         assert_eq!(val, 1);
+//!         assert_eq!(val, 1i);
 //!     },
 //!     val = rx2.recv() => {
-//!         assert_eq!(val, 2);
+//!         assert_eq!(val, 2i);
 //!     }
 //! }
 //! ```
@@ -397,10 +397,10 @@ mod test {
         let (tx3, rx3) = channel::<int>();
 
         spawn(proc() {
-            for _ in range(0, 20) { task::deschedule(); }
+            for _ in range(0u, 20) { task::deschedule(); }
             tx1.send(1);
             rx3.recv();
-            for _ in range(0, 20) { task::deschedule(); }
+            for _ in range(0u, 20) { task::deschedule(); }
         });
 
         select! (
@@ -420,7 +420,7 @@ mod test {
         let (tx3, rx3) = channel::<()>();
 
         spawn(proc() {
-            for _ in range(0, 20) { task::deschedule(); }
+            for _ in range(0u, 20) { task::deschedule(); }
             tx1.send(1);
             tx2.send(2);
             rx3.recv();
@@ -521,7 +521,7 @@ mod test {
             tx3.send(());
         });
 
-        for _ in range(0, 1000) { task::deschedule(); }
+        for _ in range(0u, 1000) { task::deschedule(); }
         drop(tx1.clone());
         tx2.send(());
         rx3.recv();
@@ -624,7 +624,7 @@ mod test {
             tx2.send(());
         });
 
-        for _ in range(0, 100) { task::deschedule() }
+        for _ in range(0u, 100) { task::deschedule() }
         tx1.send(());
         rx2.recv();
     })
@@ -643,7 +643,7 @@ mod test {
             tx2.send(());
         });
 
-        for _ in range(0, 100) { task::deschedule() }
+        for _ in range(0u, 100) { task::deschedule() }
         tx1.send(());
         rx2.recv();
     })
@@ -661,13 +661,13 @@ mod test {
             tx2.send(());
         });
 
-        for _ in range(0, 100) { task::deschedule() }
+        for _ in range(0u, 100) { task::deschedule() }
         tx1.send(());
         rx2.recv();
     })
 
     test!(fn sync1() {
-        let (tx, rx) = sync_channel(1);
+        let (tx, rx) = sync_channel::<int>(1);
         tx.send(1);
         select! {
             n = rx.recv() => { assert_eq!(n, 1); }
@@ -675,9 +675,9 @@ mod test {
     })
 
     test!(fn sync2() {
-        let (tx, rx) = sync_channel(0);
+        let (tx, rx) = sync_channel::<int>(0);
         spawn(proc() {
-            for _ in range(0, 100) { task::deschedule() }
+            for _ in range(0u, 100) { task::deschedule() }
             tx.send(1);
         });
         select! {
@@ -686,8 +686,8 @@ mod test {
     })
 
     test!(fn sync3() {
-        let (tx1, rx1) = sync_channel(0);
-        let (tx2, rx2) = channel();
+        let (tx1, rx1) = sync_channel::<int>(0);
+        let (tx2, rx2): (Sender<int>, Receiver<int>) = channel();
         spawn(proc() { tx1.send(1); });
         spawn(proc() { tx2.send(2); });
         select! {
diff --git a/src/libsync/deque.rs b/src/libsync/deque.rs
index f0184dc8164..18608a0a370 100644
--- a/src/libsync/deque.rs
+++ b/src/libsync/deque.rs
@@ -72,7 +72,7 @@ static K: int = 4;
 // size.
 //
 // The size in question is 1 << MIN_BITS
-static MIN_BITS: int = 7;
+static MIN_BITS: uint = 7;
 
 struct Deque<T> {
     bottom: AtomicInt,
@@ -138,7 +138,7 @@ pub struct BufferPool<T> {
 ///      LLVM is probably pretty good at doing this already.
 struct Buffer<T> {
     storage: *T,
-    log_size: int,
+    log_size: uint,
 }
 
 impl<T: Send> BufferPool<T> {
@@ -157,7 +157,7 @@ impl<T: Send> BufferPool<T> {
          Stealer { deque: b, noshare: marker::NoShare })
     }
 
-    fn alloc(&self, bits: int) -> Box<Buffer<T>> {
+    fn alloc(&mut self, bits: uint) -> Box<Buffer<T>> {
         unsafe {
             let mut pool = self.pool.lock();
             match pool.iter().position(|x| x.size() >= (1 << bits)) {
@@ -225,7 +225,7 @@ impl<T: Send> Clone for Stealer<T> {
 // personally going to heavily comment what's going on here.
 
 impl<T: Send> Deque<T> {
-    fn new(pool: BufferPool<T>) -> Deque<T> {
+    fn new(mut pool: BufferPool<T>) -> Deque<T> {
         let buf = pool.alloc(MIN_BITS);
         Deque {
             bottom: AtomicInt::new(0),
@@ -345,12 +345,12 @@ impl<T: Send> Drop for Deque<T> {
 }
 
 #[inline]
-fn buffer_alloc_size<T>(log_size: int) -> uint {
+fn buffer_alloc_size<T>(log_size: uint) -> uint {
     (1 << log_size) * size_of::<T>()
 }
 
 impl<T: Send> Buffer<T> {
-    unsafe fn new(log_size: int) -> Buffer<T> {
+    unsafe fn new(log_size: uint) -> Buffer<T> {
         let size = buffer_alloc_size::<T>(log_size);
         let buffer = allocate(size, min_align_of::<T>());
         Buffer {
@@ -383,7 +383,10 @@ impl<T: Send> Buffer<T> {
     // Again, unsafe because this has incredibly dubious ownership violations.
     // It is assumed that this buffer is immediately dropped.
     unsafe fn resize(&self, b: int, t: int, delta: int) -> Buffer<T> {
-        let buf = Buffer::new(self.log_size + delta);
+        // NB: not entirely obvious, but thanks to 2's complement,
+        // casting delta to uint and then adding gives the desired
+        // effect.
+        let buf = Buffer::new(self.log_size + delta as uint);
         for i in range(t, b) {
             buf.put(i, self.get(i));
         }
@@ -419,7 +422,7 @@ mod tests {
         let (w, s) = pool.deque();
         assert_eq!(w.pop(), None);
         assert_eq!(s.steal(), Empty);
-        w.push(1);
+        w.push(1i);
         assert_eq!(w.pop(), Some(1));
         w.push(1);
         assert_eq!(s.steal(), Data(1));
@@ -564,7 +567,7 @@ mod tests {
         let mut rng = rand::task_rng();
         let mut expected = 0;
         while expected < AMT {
-            if rng.gen_range(0, 3) == 2 {
+            if rng.gen_range(0i, 3) == 2 {
                 match w.pop() {
                     None => {}
                     Some(2) => unsafe { HITS.fetch_add(1, SeqCst); },
@@ -629,7 +632,7 @@ mod tests {
         let mut myhit = false;
         'outer: loop {
             for _ in range(0, rng.gen_range(0, AMT)) {
-                if !myhit && rng.gen_range(0, 3) == 2 {
+                if !myhit && rng.gen_range(0i, 3) == 2 {
                     match w.pop() {
                         None => {}
                         Some((1, 2)) => myhit = true,
diff --git a/src/libsync/lock.rs b/src/libsync/lock.rs
index 1fe8e8fc0db..dff9fee2b77 100644
--- a/src/libsync/lock.rs
+++ b/src/libsync/lock.rs
@@ -259,7 +259,7 @@ impl<'a, T: Send> DerefMut<T> for MutexGuard<'a, T> {
 /// ```
 /// use sync::{RWLock, Arc};
 ///
-/// let lock1 = Arc::new(RWLock::new(1));
+/// let lock1 = Arc::new(RWLock::new(1i));
 /// let lock2 = lock1.clone();
 ///
 /// spawn(proc() {
@@ -396,7 +396,7 @@ impl<'a, T: Send + Share> DerefMut<T> for RWLockWriteGuard<'a, T> {
 /// use sync::{Arc, Barrier};
 ///
 /// let barrier = Arc::new(Barrier::new(10));
-/// for _ in range(0, 10) {
+/// for _ in range(0u, 10) {
 ///     let c = barrier.clone();
 ///     // The same messages will be printed together.
 ///     // You will NOT see any interleaving.
@@ -508,7 +508,7 @@ mod tests {
 
     #[test] #[should_fail]
     fn test_mutex_arc_poison() {
-        let arc = Arc::new(Mutex::new(1));
+        let arc = Arc::new(Mutex::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.lock();
@@ -522,7 +522,7 @@ mod tests {
     fn test_mutex_arc_nested() {
         // Tests nested mutexes and access
         // to underlying data.
-        let arc = Arc::new(Mutex::new(1));
+        let arc = Arc::new(Mutex::new(1i));
         let arc2 = Arc::new(Mutex::new(arc));
         task::spawn(proc() {
             let lock = arc2.lock();
@@ -554,7 +554,7 @@ mod tests {
 
     #[test] #[should_fail]
     fn test_rw_arc_poison_wr() {
-        let arc = Arc::new(RWLock::new(1));
+        let arc = Arc::new(RWLock::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.write();
@@ -565,7 +565,7 @@ mod tests {
     }
     #[test] #[should_fail]
     fn test_rw_arc_poison_ww() {
-        let arc = Arc::new(RWLock::new(1));
+        let arc = Arc::new(RWLock::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.write();
@@ -576,7 +576,7 @@ mod tests {
     }
     #[test]
     fn test_rw_arc_no_poison_rr() {
-        let arc = Arc::new(RWLock::new(1));
+        let arc = Arc::new(RWLock::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.read();
@@ -587,7 +587,7 @@ mod tests {
     }
     #[test]
     fn test_rw_arc_no_poison_rw() {
-        let arc = Arc::new(RWLock::new(1));
+        let arc = Arc::new(RWLock::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.read();
@@ -598,7 +598,7 @@ mod tests {
     }
     #[test]
     fn test_rw_arc_no_poison_dr() {
-        let arc = Arc::new(RWLock::new(1));
+        let arc = Arc::new(RWLock::new(1i));
         let arc2 = arc.clone();
         let _ = task::try(proc() {
             let lock = arc2.write().downgrade();
@@ -610,13 +610,13 @@ mod tests {
 
     #[test]
     fn test_rw_arc() {
-        let arc = Arc::new(RWLock::new(0));
+        let arc = Arc::new(RWLock::new(0i));
         let arc2 = arc.clone();
         let (tx, rx) = channel();
 
         task::spawn(proc() {
             let mut lock = arc2.write();
-            for _ in range(0, 10) {
+            for _ in range(0u, 10) {
                 let tmp = *lock;
                 *lock = -1;
                 task::deschedule();
@@ -627,7 +627,7 @@ mod tests {
 
         // Readers try to catch the writer in the act
         let mut children = Vec::new();
-        for _ in range(0, 5) {
+        for _ in range(0u, 5) {
             let arc3 = arc.clone();
             children.push(try_future(proc() {
                 let lock = arc3.read();
@@ -675,11 +675,11 @@ mod tests {
         // (4) tells writer and all other readers to contend as it downgrades.
         // (5) Writer attempts to set state back to 42, while downgraded task
         //     and all reader tasks assert that it's 31337.
-        let arc = Arc::new(RWLock::new(0));
+        let arc = Arc::new(RWLock::new(0i));
 
         // Reader tasks
         let mut reader_convos = Vec::new();
-        for _ in range(0, 10) {
+        for _ in range(0u, 10) {
             let ((tx1, rx1), (tx2, rx2)) = (channel(), channel());
             reader_convos.push((tx1, rx2));
             let arcn = arc.clone();
@@ -777,7 +777,7 @@ mod tests {
         let lock = lock.downgrade();
         // if writer mistakenly got in, make sure it mutates state
         // before we assert on it
-        for _ in range(0, 5) { task::deschedule(); }
+        for _ in range(0u, 5) { task::deschedule(); }
         // make sure writer didn't get in.
         assert!(*lock);
     }
@@ -788,7 +788,7 @@ mod tests {
         // deschedules in the intuitively-right locations made it even less
         // likely, and I wasn't sure why :( . This is a mediocre "next best"
         // option.
-        for _ in range(0, 8) {
+        for _ in range(0u, 8) {
             test_rw_write_cond_downgrade_read_race_helper();
         }
     }
@@ -801,7 +801,7 @@ mod tests {
         let barrier = Arc::new(Barrier::new(10));
         let (tx, rx) = channel();
 
-        for _ in range(0, 9) {
+        for _ in range(0u, 9) {
             let c = barrier.clone();
             let tx = tx.clone();
             spawn(proc() {
@@ -819,7 +819,7 @@ mod tests {
 
         barrier.wait();
         // Now, the barrier is cleared and we should get data.
-        for _ in range(0, 9) {
+        for _ in range(0u, 9) {
             rx.recv();
         }
     }
diff --git a/src/libsync/one.rs b/src/libsync/one.rs
index 5240d303ca4..6fad2c8aa40 100644
--- a/src/libsync/one.rs
+++ b/src/libsync/one.rs
@@ -129,7 +129,7 @@ mod test {
     #[test]
     fn smoke_once() {
         static mut o: Once = ONCE_INIT;
-        let mut a = 0;
+        let mut a = 0i;
         unsafe { o.doit(|| a += 1); }
         assert_eq!(a, 1);
         unsafe { o.doit(|| a += 1); }
@@ -142,10 +142,10 @@ mod test {
         static mut run: bool = false;
 
         let (tx, rx) = channel();
-        for _ in range(0, 10) {
+        for _ in range(0u, 10) {
             let tx = tx.clone();
             spawn(proc() {
-                for _ in range(0, 4) { task::deschedule() }
+                for _ in range(0u, 4) { task::deschedule() }
                 unsafe {
                     o.doit(|| {
                         assert!(!run);
@@ -165,7 +165,7 @@ mod test {
             assert!(run);
         }
 
-        for _ in range(0, 10) {
+        for _ in range(0u, 10) {
             rx.recv();
         }
     }
diff --git a/src/libsync/raw.rs b/src/libsync/raw.rs
index c5f452d3e58..28a08a7fef2 100644
--- a/src/libsync/raw.rs
+++ b/src/libsync/raw.rs
@@ -138,7 +138,7 @@ impl<Q: Send> Sem<Q> {
             });
             // Uncomment if you wish to test for sem races. Not
             // valgrind-friendly.
-            /* for _ in range(0, 1000) { task::deschedule(); } */
+            /* for _ in range(0u, 1000) { task::deschedule(); } */
             // Need to wait outside the exclusive.
             if waiter_nobe.is_some() {
                 let _ = waiter_nobe.unwrap().recv();
@@ -642,10 +642,10 @@ mod tests {
         let s2 = s.clone();
         task::spawn(proc() {
             let _g = s2.access();
-            for _ in range(0, 5) { task::deschedule(); }
+            for _ in range(0u, 5) { task::deschedule(); }
         });
         let _g = s.access();
-        for _ in range(0, 5) { task::deschedule(); }
+        for _ in range(0u, 5) { task::deschedule(); }
     }
     #[test]
     fn test_sem_as_cvar() {
@@ -657,7 +657,7 @@ mod tests {
             s2.acquire();
             tx.send(());
         });
-        for _ in range(0, 5) { task::deschedule(); }
+        for _ in range(0u, 5) { task::deschedule(); }
         s.release();
         let _ = rx.recv();
 
@@ -666,7 +666,7 @@ mod tests {
         let s = Arc::new(Semaphore::new(0));
         let s2 = s.clone();
         task::spawn(proc() {
-            for _ in range(0, 5) { task::deschedule(); }
+            for _ in range(0u, 5) { task::deschedule(); }
             s2.release();
             let _ = rx.recv();
         });
@@ -705,7 +705,7 @@ mod tests {
                 tx.send(());
             });
             rx.recv(); // wait for child to come alive
-            for _ in range(0, 5) { task::deschedule(); } // let the child contend
+            for _ in range(0u, 5) { task::deschedule(); } // let the child contend
         }
         rx.recv(); // wait for child to be done
     }
@@ -735,7 +735,7 @@ mod tests {
         }
 
         fn access_shared(sharedstate: *mut int, m: &Arc<Mutex>, n: uint) {
-            for _ in range(0, n) {
+            for _ in range(0u, n) {
                 let _g = m.lock();
                 let oldval = unsafe { *sharedstate };
                 task::deschedule();
@@ -780,7 +780,7 @@ mod tests {
         let m = Arc::new(Mutex::new());
         let mut rxs = Vec::new();
 
-        for _ in range(0, num_waiters) {
+        for _ in range(0u, num_waiters) {
             let mi = m.clone();
             let (tx, rx) = channel();
             rxs.push(rx);
@@ -907,7 +907,7 @@ mod tests {
 
         fn access_shared(sharedstate: &mut int, x: &Arc<RWLock>,
                          mode: RWLockMode, n: uint) {
-            for _ in range(0, n) {
+            for _ in range(0u, n) {
                 lock_rwlock_in_mode(x, mode, || {
                     let oldval = *sharedstate;
                     task::deschedule();
@@ -1033,7 +1033,7 @@ mod tests {
         let x = Arc::new(RWLock::new());
         let mut rxs = Vec::new();
 
-        for _ in range(0, num_waiters) {
+        for _ in range(0u, num_waiters) {
             let xi = x.clone();
             let (tx, rx) = channel();
             rxs.push(rx);
diff --git a/src/libsync/spsc_queue.rs b/src/libsync/spsc_queue.rs
index 55d2f3062ba..a4da1fd2335 100644
--- a/src/libsync/spsc_queue.rs
+++ b/src/libsync/spsc_queue.rs
@@ -237,7 +237,7 @@ mod test {
     #[test]
     fn smoke() {
         let q = Queue::new(0);
-        q.push(1);
+        q.push(1i);
         q.push(2);
         assert_eq!(q.pop(), Some(1));
         assert_eq!(q.pop(), Some(2));
@@ -259,7 +259,7 @@ mod test {
     #[test]
     fn smoke_bound() {
         let q = Queue::new(1);
-        q.push(1);
+        q.push(1i);
         q.push(2);
         assert_eq!(q.pop(), Some(1));
         assert_eq!(q.pop(), Some(2));
@@ -281,7 +281,7 @@ mod test {
             let b = a.clone();
             let (tx, rx) = channel();
             native::task::spawn(proc() {
-                for _ in range(0, 100000) {
+                for _ in range(0u, 100000) {
                     loop {
                         match b.pop() {
                             Some(1) => break,
@@ -292,7 +292,7 @@ mod test {
                 }
                 tx.send(());
             });
-            for _ in range(0, 100000) {
+            for _ in range(0i, 100000) {
                 a.push(1);
             }
             rx.recv();