auto merge of #15163 : alexcrichton/rust/rollup, r=alexcrichton

32 files changed, 177 insertions, 148 deletions

diff --git a/src/libstd/collections/hashmap.rs b/src/libstd/collections/hashmap.rs
index 8feb0e0b7ee..d06d4ea7177 100644
--- a/src/libstd/collections/hashmap.rs
+++ b/src/libstd/collections/hashmap.rs
@@ -1688,7 +1688,7 @@ mod test_map {
     fn test_create_capacity_zero() {
         let mut m = HashMap::with_capacity(0);
 
-        assert!(m.insert(1, 1));
+        assert!(m.insert(1i, 1i));
 
         assert!(m.contains_key(&1));
         assert!(!m.contains_key(&0));
@@ -1698,9 +1698,9 @@ mod test_map {
     fn test_insert() {
         let mut m = HashMap::new();
         assert_eq!(m.len(), 0);
-        assert!(m.insert(1, 2));
+        assert!(m.insert(1i, 2i));
         assert_eq!(m.len(), 1);
-        assert!(m.insert(2, 4));
+        assert!(m.insert(2i, 4i));
         assert_eq!(m.len(), 2);
         assert_eq!(*m.find(&1).unwrap(), 2);
         assert_eq!(*m.find(&2).unwrap(), 4);
@@ -1732,7 +1732,7 @@ mod test_map {
 
     #[test]
     fn test_drops() {
-        drop_vector.replace(Some(RefCell::new(Vec::from_elem(200, 0))));
+        drop_vector.replace(Some(RefCell::new(Vec::from_elem(200, 0i))));
 
         {
             let mut m = HashMap::new();
@@ -1796,10 +1796,10 @@ mod test_map {
 
         // Try this a few times to make sure we never screw up the hashmap's
         // internal state.
-        for _ in range(0, 10) {
+        for _ in range(0i, 10) {
             assert!(m.is_empty());
 
-            for i in range_inclusive(1, 1000) {
+            for i in range_inclusive(1i, 1000) {
                 assert!(m.insert(i, i));
 
                 for j in range_inclusive(1, i) {
@@ -1813,12 +1813,12 @@ mod test_map {
                 }
             }
 
-            for i in range_inclusive(1001, 2000) {
+            for i in range_inclusive(1001i, 2000) {
                 assert!(!m.contains_key(&i));
             }
 
             // remove forwards
-            for i in range_inclusive(1, 1000) {
+            for i in range_inclusive(1i, 1000) {
                 assert!(m.remove(&i));
 
                 for j in range_inclusive(1, i) {
@@ -1830,16 +1830,16 @@ mod test_map {
                 }
             }
 
-            for i in range_inclusive(1, 1000) {
+            for i in range_inclusive(1i, 1000) {
                 assert!(!m.contains_key(&i));
             }
 
-            for i in range_inclusive(1, 1000) {
+            for i in range_inclusive(1i, 1000) {
                 assert!(m.insert(i, i));
             }
 
             // remove backwards
-            for i in range_step_inclusive(1000, 1, -1) {
+            for i in range_step_inclusive(1000i, 1, -1) {
                 assert!(m.remove(&i));
 
                 for j in range_inclusive(i, 1000) {
@@ -1856,9 +1856,9 @@ mod test_map {
     #[test]
     fn test_find_mut() {
         let mut m = HashMap::new();
-        assert!(m.insert(1, 12));
-        assert!(m.insert(2, 8));
-        assert!(m.insert(5, 14));
+        assert!(m.insert(1i, 12i));
+        assert!(m.insert(2i, 8i));
+        assert!(m.insert(5i, 14i));
         let new = 100;
         match m.find_mut(&5) {
             None => fail!(), Some(x) => *x = new
@@ -1869,18 +1869,18 @@ mod test_map {
     #[test]
     fn test_insert_overwrite() {
         let mut m = HashMap::new();
-        assert!(m.insert(1, 2));
+        assert!(m.insert(1i, 2i));
         assert_eq!(*m.find(&1).unwrap(), 2);
-        assert!(!m.insert(1, 3));
+        assert!(!m.insert(1i, 3i));
         assert_eq!(*m.find(&1).unwrap(), 3);
     }
 
     #[test]
     fn test_insert_conflicts() {
         let mut m = HashMap::with_capacity(4);
-        assert!(m.insert(1, 2));
-        assert!(m.insert(5, 3));
-        assert!(m.insert(9, 4));
+        assert!(m.insert(1i, 2i));
+        assert!(m.insert(5i, 3i));
+        assert!(m.insert(9i, 4i));
         assert_eq!(*m.find(&9).unwrap(), 4);
         assert_eq!(*m.find(&5).unwrap(), 3);
         assert_eq!(*m.find(&1).unwrap(), 2);
@@ -1889,7 +1889,7 @@ mod test_map {
     #[test]
     fn test_conflict_remove() {
         let mut m = HashMap::with_capacity(4);
-        assert!(m.insert(1, 2));
+        assert!(m.insert(1i, 2i));
         assert_eq!(*m.find(&1).unwrap(), 2);
         assert!(m.insert(5, 3));
         assert_eq!(*m.find(&1).unwrap(), 2);
@@ -1906,7 +1906,7 @@ mod test_map {
     #[test]
     fn test_is_empty() {
         let mut m = HashMap::with_capacity(4);
-        assert!(m.insert(1, 2));
+        assert!(m.insert(1i, 2i));
         assert!(!m.is_empty());
         assert!(m.remove(&1));
         assert!(m.is_empty());
@@ -1915,7 +1915,7 @@ mod test_map {
     #[test]
     fn test_pop() {
         let mut m = HashMap::new();
-        m.insert(1, 2);
+        m.insert(1i, 2i);
         assert_eq!(m.pop(&1), Some(2));
         assert_eq!(m.pop(&1), None);
     }
@@ -1924,7 +1924,7 @@ mod test_map {
     #[allow(experimental)]
     fn test_pop_equiv() {
         let mut m = HashMap::new();
-        m.insert(1, 2);
+        m.insert(1i, 2i);
         assert_eq!(m.pop_equiv(&KindaIntLike(1)), Some(2));
         assert_eq!(m.pop_equiv(&KindaIntLike(1)), None);
     }
@@ -1932,9 +1932,9 @@ mod test_map {
     #[test]
     fn test_swap() {
         let mut m = HashMap::new();
-        assert_eq!(m.swap(1, 2), None);
-        assert_eq!(m.swap(1, 3), Some(2));
-        assert_eq!(m.swap(1, 4), Some(3));
+        assert_eq!(m.swap(1i, 2i), None);
+        assert_eq!(m.swap(1i, 3i), Some(2));
+        assert_eq!(m.swap(1i, 4i), Some(3));
     }
 
     #[test]
@@ -1942,8 +1942,8 @@ mod test_map {
         let hm = {
             let mut hm = HashMap::new();
 
-            hm.insert('a', 1);
-            hm.insert('b', 2);
+            hm.insert('a', 1i);
+            hm.insert('b', 2i);
 
             hm
         };
@@ -1971,7 +1971,7 @@ mod test_map {
 
     #[test]
     fn test_keys() {
-        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+        let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
         let map = vec.move_iter().collect::<HashMap<int, char>>();
         let keys = map.keys().map(|&k| k).collect::<Vec<int>>();
         assert_eq!(keys.len(), 3);
@@ -1982,7 +1982,7 @@ mod test_map {
 
     #[test]
     fn test_values() {
-        let vec = vec![(1, 'a'), (2, 'b'), (3, 'c')];
+        let vec = vec![(1i, 'a'), (2i, 'b'), (3i, 'c')];
         let map = vec.move_iter().collect::<HashMap<int, char>>();
         let values = map.values().map(|&v| v).collect::<Vec<char>>();
         assert_eq!(values.len(), 3);
@@ -1994,8 +1994,8 @@ mod test_map {
     #[test]
     fn test_find() {
         let mut m = HashMap::new();
-        assert!(m.find(&1).is_none());
-        m.insert(1, 2);
+        assert!(m.find(&1i).is_none());
+        m.insert(1i, 2i);
         match m.find(&1) {
             None => fail!(),
             Some(v) => assert_eq!(*v, 2)
@@ -2005,17 +2005,17 @@ mod test_map {
     #[test]
     fn test_eq() {
         let mut m1 = HashMap::new();
-        m1.insert(1, 2);
-        m1.insert(2, 3);
-        m1.insert(3, 4);
+        m1.insert(1i, 2i);
+        m1.insert(2i, 3i);
+        m1.insert(3i, 4i);
 
         let mut m2 = HashMap::new();
-        m2.insert(1, 2);
-        m2.insert(2, 3);
+        m2.insert(1i, 2i);
+        m2.insert(2i, 3i);
 
         assert!(m1 != m2);
 
-        m2.insert(3, 4);
+        m2.insert(3i, 4i);
 
         assert_eq!(m1, m2);
     }
@@ -2025,8 +2025,8 @@ mod test_map {
         let mut map: HashMap<int, int> = HashMap::new();
         let empty: HashMap<int, int> = HashMap::new();
 
-        map.insert(1, 2);
-        map.insert(3, 4);
+        map.insert(1i, 2i);
+        map.insert(3i, 4i);
 
         let map_str = format!("{}", map);
 
@@ -2102,7 +2102,7 @@ mod test_map {
     fn test_find_equiv() {
         let mut m = HashMap::new();
 
-        let (foo, bar, baz) = (1,2,3);
+        let (foo, bar, baz) = (1i,2i,3i);
         m.insert("foo".to_string(), foo);
         m.insert("bar".to_string(), bar);
         m.insert("baz".to_string(), baz);
@@ -2117,7 +2117,7 @@ mod test_map {
 
     #[test]
     fn test_from_iter() {
-        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
         let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
 
@@ -2128,7 +2128,7 @@ mod test_map {
 
     #[test]
     fn test_size_hint() {
-        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
         let map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
 
@@ -2141,7 +2141,7 @@ mod test_map {
 
     #[test]
     fn test_mut_size_hint() {
-        let xs = [(1, 1), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
+        let xs = [(1i, 1i), (2, 2), (3, 3), (4, 4), (5, 5), (6, 6)];
 
         let mut map: HashMap<int, int> = xs.iter().map(|&x| x).collect();
 
@@ -2167,8 +2167,8 @@ mod test_set {
         let mut ys = HashSet::new();
         assert!(xs.is_disjoint(&ys));
         assert!(ys.is_disjoint(&xs));
-        assert!(xs.insert(5));
-        assert!(ys.insert(11));
+        assert!(xs.insert(5i));
+        assert!(ys.insert(11i));
         assert!(xs.is_disjoint(&ys));
         assert!(ys.is_disjoint(&xs));
         assert!(xs.insert(7));
@@ -2186,13 +2186,13 @@ mod test_set {
     #[test]
     fn test_subset_and_superset() {
         let mut a = HashSet::new();
-        assert!(a.insert(0));
+        assert!(a.insert(0i));
         assert!(a.insert(5));
         assert!(a.insert(11));
         assert!(a.insert(7));
 
         let mut b = HashSet::new();
-        assert!(b.insert(0));
+        assert!(b.insert(0i));
         assert!(b.insert(7));
         assert!(b.insert(19));
         assert!(b.insert(250));
@@ -2230,7 +2230,7 @@ mod test_set {
         let mut a = HashSet::new();
         let mut b = HashSet::new();
 
-        assert!(a.insert(11));
+        assert!(a.insert(11i));
         assert!(a.insert(1));
         assert!(a.insert(3));
         assert!(a.insert(77));
@@ -2238,7 +2238,7 @@ mod test_set {
         assert!(a.insert(5));
         assert!(a.insert(-5));
 
-        assert!(b.insert(2));
+        assert!(b.insert(2i));
         assert!(b.insert(11));
         assert!(b.insert(77));
         assert!(b.insert(-9));
@@ -2260,13 +2260,13 @@ mod test_set {
         let mut a = HashSet::new();
         let mut b = HashSet::new();
 
-        assert!(a.insert(1));
+        assert!(a.insert(1i));
         assert!(a.insert(3));
         assert!(a.insert(5));
         assert!(a.insert(9));
         assert!(a.insert(11));
 
-        assert!(b.insert(3));
+        assert!(b.insert(3i));
         assert!(b.insert(9));
 
         let mut i = 0;
@@ -2283,13 +2283,13 @@ mod test_set {
         let mut a = HashSet::new();
         let mut b = HashSet::new();
 
-        assert!(a.insert(1));
+        assert!(a.insert(1i));
         assert!(a.insert(3));
         assert!(a.insert(5));
         assert!(a.insert(9));
         assert!(a.insert(11));
 
-        assert!(b.insert(-2));
+        assert!(b.insert(-2i));
         assert!(b.insert(3));
         assert!(b.insert(9));
         assert!(b.insert(14));
@@ -2309,7 +2309,7 @@ mod test_set {
         let mut a = HashSet::new();
         let mut b = HashSet::new();
 
-        assert!(a.insert(1));
+        assert!(a.insert(1i));
         assert!(a.insert(3));
         assert!(a.insert(5));
         assert!(a.insert(9));
@@ -2318,7 +2318,7 @@ mod test_set {
         assert!(a.insert(19));
         assert!(a.insert(24));
 
-        assert!(b.insert(-2));
+        assert!(b.insert(-2i));
         assert!(b.insert(1));
         assert!(b.insert(5));
         assert!(b.insert(9));
@@ -2336,7 +2336,7 @@ mod test_set {
 
     #[test]
     fn test_from_iter() {
-        let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
+        let xs = [1i, 2, 3, 4, 5, 6, 7, 8, 9];
 
         let set: HashSet<int> = xs.iter().map(|&x| x).collect();
 
@@ -2366,13 +2366,13 @@ mod test_set {
         // I'm keeping them around to prevent a regression.
         let mut s1 = HashSet::new();
 
-        s1.insert(1);
+        s1.insert(1i);
         s1.insert(2);
         s1.insert(3);
 
         let mut s2 = HashSet::new();
 
-        s2.insert(1);
+        s2.insert(1i);
         s2.insert(2);
 
         assert!(s1 != s2);
@@ -2387,7 +2387,7 @@ mod test_set {
         let mut set: HashSet<int> = HashSet::new();
         let empty: HashSet<int> = HashSet::new();
 
-        set.insert(1);
+        set.insert(1i);
         set.insert(2);
 
         let set_str = format!("{}", set);
@@ -2421,7 +2421,7 @@ mod bench {
 
         b.iter(|| {
             let mut m = HashMap::new();
-            m.insert(0, 0);
+            m.insert(0i, 0i);
             assert_eq!(m.len(), 1);
         })
     }
@@ -2432,7 +2432,7 @@ mod bench {
 
         let mut m = HashMap::new();
 
-        for i in range_inclusive(1, 1000) {
+        for i in range_inclusive(1i, 1000) {
             m.insert(i, i);
         }
 
@@ -2450,12 +2450,12 @@ mod bench {
 
         let mut m = HashMap::new();
 
-        for i in range_inclusive(1, 1000) {
+        for i in range_inclusive(1i, 1000) {
             m.insert(i, i);
         }
 
         b.iter(|| {
-            for i in range_inclusive(1, 1000) {
+            for i in range_inclusive(1i, 1000) {
                 m.contains_key(&i);
             }
         });
@@ -2467,12 +2467,12 @@ mod bench {
 
         let mut m = HashMap::new();
 
-        for i in range_inclusive(1, 1000) {
+        for i in range_inclusive(1i, 1000) {
             m.insert(i, i);
         }
 
         b.iter(|| {
-            for i in range_inclusive(1001, 2000) {
+            for i in range_inclusive(1001i, 2000) {
                 m.contains_key(&i);
             }
         });
@@ -2484,11 +2484,11 @@ mod bench {
 
         let mut m = HashMap::new();
 
-        for i in range_inclusive(1, 1000) {
+        for i in range_inclusive(1i, 1000) {
             m.insert(i, i);
         }
 
-        let mut k = 1;
+        let mut k = 1i;
 
         b.iter(|| {
             m.pop(&k);
@@ -2503,11 +2503,11 @@ mod bench {
 
         let mut m = HashMap::new();
 
-        for i in range_inclusive(1, 1000) {
+        for i in range_inclusive(1i, 1000) {
             m.insert(i, i);
         }
 
-        let mut k = 1;
+        let mut k = 1i;
 
         b.iter(|| {
             m.find(&(k + 400));
diff --git a/src/libstd/fmt.rs b/src/libstd/fmt.rs
index 7236b527831..b1164981c0b 100644
--- a/src/libstd/fmt.rs
+++ b/src/libstd/fmt.rs
@@ -36,12 +36,12 @@ Some examples of the `format!` extension are:
 ```rust
 # extern crate debug;
 # fn main() {
-format!("Hello");                 // => "Hello"
-format!("Hello, {:s}!", "world"); // => "Hello, world!"
-format!("The number is {:d}", 1); // => "The number is 1"
-format!("{:?}", (3, 4));          // => "(3, 4)"
-format!("{value}", value=4);      // => "4"
-format!("{} {}", 1, 2);           // => "1 2"
+format!("Hello");                  // => "Hello"
+format!("Hello, {:s}!", "world");  // => "Hello, world!"
+format!("The number is {:d}", 1i); // => "The number is 1"
+format!("{:?}", (3i, 4i));         // => "(3, 4)"
+format!("{value}", value=4i);      // => "4"
+format!("{} {}", 1i, 2i);          // => "1 2"
 # }
 ```
 
@@ -65,7 +65,7 @@ iterator over the argument. Each time a "next argument" specifier is seen, the
 iterator advances. This leads to behavior like this:
 
 ```rust
-format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
+format!("{1} {} {0} {}", 1i, 2i); // => "2 1 1 2"
 ```
 
 The internal iterator over the argument has not been advanced by the time the
@@ -94,9 +94,9 @@ For example, the following `format!` expressions all use named argument:
 ```rust
 # extern crate debug;
 # fn main() {
-format!("{argument}", argument = "test");       // => "test"
-format!("{name} {}", 1, name = 2);              // => "2 1"
-format!("{a:s} {c:d} {b:?}", a="a", b=(), c=3); // => "a 3 ()"
+format!("{argument}", argument = "test");        // => "test"
+format!("{name} {}", 1i, name = 2i);             // => "2 1"
+format!("{a:s} {c:d} {b:?}", a="a", b=(), c=3i); // => "a 3 ()"
 # }
 ```
 
diff --git a/src/libstd/from_str.rs b/src/libstd/from_str.rs
index 4394fb9d355..642bec48b83 100644
--- a/src/libstd/from_str.rs
+++ b/src/libstd/from_str.rs
@@ -16,6 +16,7 @@ use str::StrAllocating;
 
 /// A trait to abstract the idea of creating a new instance of a type from a
 /// string.
+#[experimental = "might need to return Result"]
 pub trait FromStr {
     /// Parses a string `s` to return an optional value of this type. If the
     /// string is ill-formatted, the None is returned.
diff --git a/src/libstd/gc.rs b/src/libstd/gc.rs
index e889752f4fc..0f30e7231b1 100644
--- a/src/libstd/gc.rs
+++ b/src/libstd/gc.rs
@@ -37,6 +37,7 @@ pub struct Gc<T> {
     marker: marker::NoSend,
 }
 
+#[unstable]
 impl<T> Clone for Gc<T> {
     /// Clone the pointer only
     #[inline]
diff --git a/src/libstd/io/extensions.rs b/src/libstd/io/extensions.rs
index 84a1253e5b4..5d9865fded3 100644
--- a/src/libstd/io/extensions.rs
+++ b/src/libstd/io/extensions.rs
@@ -93,7 +93,7 @@ pub fn u64_to_le_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
         let mut n = n;
         while i > 0u {
             bytes.push((n & 255_u64) as u8);
-            n >>= 8_u64;
+            n >>= 8;
             i -= 1u;
         }
         f(bytes.as_slice())
@@ -130,7 +130,7 @@ pub fn u64_to_be_bytes<T>(n: u64, size: uint, f: |v: &[u8]| -> T) -> T {
         let mut bytes = vec!();
         let mut i = size;
         while i > 0u {
-            let shift = ((i - 1u) * 8u) as u64;
+            let shift = (i - 1u) * 8u;
             bytes.push((n >> shift) as u8);
             i -= 1u;
         }
diff --git a/src/libstd/io/fs.rs b/src/libstd/io/fs.rs
index a801dd0e7cb..d8e04f18239 100644
--- a/src/libstd/io/fs.rs
+++ b/src/libstd/io/fs.rs
@@ -1164,7 +1164,7 @@ mod test {
         let dir = &tmpdir.join("di_readdir");
         check!(mkdir(dir, io::UserRWX));
         let prefix = "foo";
-        for n in range(0,3) {
+        for n in range(0i,3) {
             let f = dir.join(format!("{}.txt", n));
             let mut w = check!(File::create(&f));
             let msg_str = format!("{}{}", prefix, n.to_str());
diff --git a/src/libstd/io/mem.rs b/src/libstd/io/mem.rs
index ec3d9370833..3443a85b468 100644
--- a/src/libstd/io/mem.rs
+++ b/src/libstd/io/mem.rs
@@ -611,7 +611,7 @@ mod test {
     fn bench_mem_writer(b: &mut Bencher) {
         b.iter(|| {
             let mut wr = MemWriter::new();
-            for _i in range(0, 10) {
+            for _i in range(0u, 10) {
                 wr.write([5, .. 10]).unwrap();
             }
             assert_eq!(wr.unwrap().as_slice(), [5, .. 100].as_slice());
@@ -624,7 +624,7 @@ mod test {
             let buf = Vec::from_slice([5 as u8, ..100]);
             {
                 let mut rdr = MemReader::new(buf);
-                for _i in range(0, 10) {
+                for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
                     rdr.read(buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
@@ -639,7 +639,7 @@ mod test {
             let mut buf = [0 as u8, ..100];
             {
                 let mut wr = BufWriter::new(buf);
-                for _i in range(0, 10) {
+                for _i in range(0u, 10) {
                     wr.write([5, .. 10]).unwrap();
                 }
             }
@@ -653,7 +653,7 @@ mod test {
             let buf = [5 as u8, ..100];
             {
                 let mut rdr = BufReader::new(buf);
-                for _i in range(0, 10) {
+                for _i in range(0u, 10) {
                     let mut buf = [0 as u8, .. 10];
                     rdr.read(buf).unwrap();
                     assert_eq!(buf.as_slice(), [5, .. 10].as_slice());
diff --git a/src/libstd/io/net/tcp.rs b/src/libstd/io/net/tcp.rs
index 8ffb057c934..7d6ab9d7419 100644
--- a/src/libstd/io/net/tcp.rs
+++ b/src/libstd/io/net/tcp.rs
@@ -1154,7 +1154,7 @@ mod test {
                                            port).unwrap());
             });
             let _l = rx.recv();
-            for i in range(0, 1001) {
+            for i in range(0i, 1001) {
                 match a.accept() {
                     Ok(..) => break,
                     Err(ref e) if e.kind == TimedOut => {}
@@ -1258,7 +1258,7 @@ mod test {
         assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
-        for i in range(0, 1001) {
+        for i in range(0i, 1001) {
             match s.write([0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
@@ -1298,7 +1298,7 @@ mod test {
         assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
-        for _ in range(0, 100) {
+        for _ in range(0i, 100) {
             assert!(s.write([0, ..128 * 1024]).is_ok());
         }
     })
@@ -1318,7 +1318,7 @@ mod test {
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
-        for i in range(0, 1001) {
+        for i in range(0i, 1001) {
             match s.write([0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/io/net/udp.rs b/src/libstd/io/net/udp.rs
index e1f9cb3889f..5f6de52f866 100644
--- a/src/libstd/io/net/udp.rs
+++ b/src/libstd/io/net/udp.rs
@@ -569,7 +569,7 @@ mod test {
         let _b = UdpSocket::bind(addr2).unwrap();
 
         a.set_write_timeout(Some(1000));
-        for _ in range(0, 100) {
+        for _ in range(0u, 100) {
             match a.sendto([0, ..4*1024], addr2) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/io/net/unix.rs b/src/libstd/io/net/unix.rs
index 8f4f66836ad..c5ddda9945d 100644
--- a/src/libstd/io/net/unix.rs
+++ b/src/libstd/io/net/unix.rs
@@ -321,7 +321,7 @@ mod tests {
         };
 
         spawn(proc() {
-            for _ in range(0, times) {
+            for _ in range(0u, times) {
                 let mut stream = UnixStream::connect(&path2);
                 match stream.write([100]) {
                     Ok(..) => {}
@@ -477,7 +477,7 @@ mod tests {
             tx.send(UnixStream::connect(&addr2).unwrap());
         });
         let l = rx.recv();
-        for i in range(0, 1001) {
+        for i in range(0u, 1001) {
             match a.accept() {
                 Ok(..) => break,
                 Err(ref e) if e.kind == TimedOut => {}
@@ -586,7 +586,7 @@ mod tests {
         assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
 
         s.set_timeout(Some(20));
-        for i in range(0, 1001) {
+        for i in range(0u, 1001) {
             match s.write([0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
@@ -629,7 +629,7 @@ mod tests {
         assert_eq!(s.read([0]).err().unwrap().kind, TimedOut);
 
         tx.send(());
-        for _ in range(0, 100) {
+        for _ in range(0u, 100) {
             assert!(s.write([0, ..128 * 1024]).is_ok());
         }
     })
@@ -647,7 +647,7 @@ mod tests {
 
         let mut s = a.accept().unwrap();
         s.set_write_timeout(Some(20));
-        for i in range(0, 1001) {
+        for i in range(0u, 1001) {
             match s.write([0, .. 128 * 1024]) {
                 Ok(()) | Err(IoError { kind: ShortWrite(..), .. }) => {},
                 Err(IoError { kind: TimedOut, .. }) => break,
diff --git a/src/libstd/io/process.rs b/src/libstd/io/process.rs
index 1dcf08b2322..ecd6693990c 100644
--- a/src/libstd/io/process.rs
+++ b/src/libstd/io/process.rs
@@ -908,7 +908,7 @@ mod tests {
     iotest!(fn test_zero() {
         let mut p = sleeper();
         p.signal_kill().unwrap();
-        for _ in range(0, 20) {
+        for _ in range(0i, 20) {
             if p.signal(0).is_err() {
                 assert!(!p.wait().unwrap().success());
                 return
diff --git a/src/libstd/io/timer.rs b/src/libstd/io/timer.rs
index da099953a49..9ae855536ac 100644
--- a/src/libstd/io/timer.rs
+++ b/src/libstd/io/timer.rs
@@ -115,7 +115,7 @@ impl Timer {
     /// let mut timer = Timer::new().unwrap();
     /// let ten_milliseconds = timer.oneshot(10);
     ///
-    /// for _ in range(0, 100) { /* do work */ }
+    /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 10 ms after the `oneshot` call
     /// ten_milliseconds.recv();
@@ -157,12 +157,12 @@ impl Timer {
     /// let mut timer = Timer::new().unwrap();
     /// let ten_milliseconds = timer.periodic(10);
     ///
-    /// for _ in range(0, 100) { /* do work */ }
+    /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 10 ms after the `periodic` call
     /// ten_milliseconds.recv();
     ///
-    /// for _ in range(0, 100) { /* do work */ }
+    /// for _ in range(0u, 100) { /* do work */ }
     ///
     /// // blocks until 20 ms after the `periodic` call (*not* 10ms after the
     /// // previous `recv`)
diff --git a/src/libstd/macros.rs b/src/libstd/macros.rs
index 58f65c90b3b..4db15d2cbbe 100644
--- a/src/libstd/macros.rs
+++ b/src/libstd/macros.rs
@@ -32,7 +32,7 @@
 /// # #![allow(unreachable_code)]
 /// fail!();
 /// fail!("this is a terrible mistake!");
-/// fail!(4); // fail with the value of 4 to be collected elsewhere
+/// fail!(4i); // fail with the value of 4 to be collected elsewhere
 /// fail!("this is a {} {message}", "fancy", message = "message");
 /// ```
 #[macro_export]
@@ -80,7 +80,7 @@ macro_rules! fail(
 /// // assert with a custom message
 /// # let x = true;
 /// assert!(x, "x wasn't true!");
-/// # let a = 3; let b = 27;
+/// # let a = 3i; let b = 27i;
 /// assert!(a + b == 30, "a = {}, b = {}", a, b);
 /// ```
 #[macro_export]
@@ -105,8 +105,8 @@ macro_rules! assert(
 /// # Example
 ///
 /// ```
-/// let a = 3;
-/// let b = 1 + 2;
+/// let a = 3i;
+/// let b = 1i + 2i;
 /// assert_eq!(a, b);
 /// ```
 #[macro_export]
@@ -147,7 +147,7 @@ macro_rules! assert_eq(
 /// // assert with a custom message
 /// # let x = true;
 /// debug_assert!(x, "x wasn't true!");
-/// # let a = 3; let b = 27;
+/// # let a = 3i; let b = 27i;
 /// debug_assert!(a + b == 30, "a = {}, b = {}", a, b);
 /// ```
 #[macro_export]
@@ -168,8 +168,8 @@ macro_rules! debug_assert(
 /// # Example
 ///
 /// ```
-/// let a = 3;
-/// let b = 1 + 2;
+/// let a = 3i;
+/// let b = 1i + 2i;
 /// debug_assert_eq!(a, b);
 /// ```
 #[macro_export]
@@ -220,7 +220,7 @@ macro_rules! unimplemented(
 /// ```
 /// format!("test");
 /// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10, y = 30);
+/// format!("x = {}, y = {y}", 10i, y = 30i);
 /// ```
 #[macro_export]
 macro_rules! format(
@@ -335,7 +335,7 @@ macro_rules! vec(
 /// let (tx1, rx1) = channel();
 /// let (tx2, rx2) = channel();
 /// # fn long_running_task() {}
-/// # fn calculate_the_answer() -> int { 42 }
+/// # fn calculate_the_answer() -> int { 42i }
 ///
 /// spawn(proc() { long_running_task(); tx1.send(()) });
 /// spawn(proc() { tx2.send(calculate_the_answer()) });
@@ -506,7 +506,7 @@ pub mod builtin {
     /// # Example
     ///
     /// ```
-    /// let s = concat!("test", 10, 'b', true);
+    /// let s = concat!("test", 10i, 'b', true);
     /// assert_eq!(s, "test10btrue");
     /// ```
     #[macro_export]
diff --git a/src/libstd/num/i16.rs b/src/libstd/num/i16.rs
index cfa0662e225..9b97513935c 100644
--- a/src/libstd/num/i16.rs
+++ b/src/libstd/num/i16.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for signed 16-bits integers (`i16` type)
 
+#![unstable]
 #![doc(primitive = "i16")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/i32.rs b/src/libstd/num/i32.rs
index 3c656b20ee5..03dcbb0f6d6 100644
--- a/src/libstd/num/i32.rs
+++ b/src/libstd/num/i32.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for signed 32-bits integers (`i32` type)
 
+#![unstable]
 #![doc(primitive = "i32")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/i64.rs b/src/libstd/num/i64.rs
index 857f78efc9c..347b5b4b93c 100644
--- a/src/libstd/num/i64.rs
+++ b/src/libstd/num/i64.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for signed 64-bits integers (`i64` type)
 
+#![unstable]
 #![doc(primitive = "i64")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/i8.rs b/src/libstd/num/i8.rs
index a939c1d6b76..fd6f96a0f97 100644
--- a/src/libstd/num/i8.rs
+++ b/src/libstd/num/i8.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for signed 8-bits integers (`i8` type)
 
+#![unstable]
 #![doc(primitive = "i8")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/int.rs b/src/libstd/num/int.rs
index 415d11b3145..1888d6a519e 100644
--- a/src/libstd/num/int.rs
+++ b/src/libstd/num/int.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for architecture-sized signed integers (`int` type)
 
+#![unstable]
 #![doc(primitive = "int")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/int_macros.rs b/src/libstd/num/int_macros.rs
index 889a42ec00e..9b3c9d29cc7 100644
--- a/src/libstd/num/int_macros.rs
+++ b/src/libstd/num/int_macros.rs
@@ -26,11 +26,13 @@ macro_rules! int_module (($T:ty) => (
 /// assert!(num == Some(123456789));
 /// ```
 #[inline]
+#[experimental = "might need to return Result"]
 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
     strconv::from_str_bytes_common(buf, radix, true, false, false,
                                strconv::ExpNone, false, false)
 }
 
+#[experimental = "might need to return Result"]
 impl FromStr for $T {
     #[inline]
     fn from_str(s: &str) -> Option<$T> {
@@ -39,6 +41,7 @@ impl FromStr for $T {
     }
 }
 
+#[experimental = "might need to return Result"]
 impl FromStrRadix for $T {
     #[inline]
     fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
@@ -56,11 +59,14 @@ impl FromStrRadix for $T {
 /// # Examples
 ///
 /// ```
+/// #![allow(deprecated)]
+///
 /// std::int::to_str_bytes(123, 10, |v| {
 ///     assert!(v == "123".as_bytes());
 /// });
 /// ```
 #[inline]
+#[deprecated = "just use .to_string(), or a BufWriter with write! if you mustn't allocate"]
 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     use io::{Writer, Seek};
     // The radix can be as low as 2, so we need at least 64 characters for a
@@ -74,6 +80,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     f(buf.slice(0, amt))
 }
 
+#[deprecated = "use fmt::radix"]
 impl ToStrRadix for $T {
     /// Convert to a string in a given base.
     #[inline]
diff --git a/src/libstd/num/mod.rs b/src/libstd/num/mod.rs
index 7301f9b08e9..65056652e3f 100644
--- a/src/libstd/num/mod.rs
+++ b/src/libstd/num/mod.rs
@@ -111,16 +111,19 @@ pub trait FloatMath: Float {
 }
 
 /// A generic trait for converting a value to a string with a radix (base)
+#[deprecated = "use fmt::radix"]
 pub trait ToStrRadix {
     fn to_str_radix(&self, radix: uint) -> String;
 }
 
 /// A generic trait for converting a string with a radix (base) to a value
+#[experimental = "might need to return Result"]
 pub trait FromStrRadix {
     fn from_str_radix(str: &str, radix: uint) -> Option<Self>;
 }
 
 /// A utility function that just calls FromStrRadix::from_str_radix.
+#[experimental = "might need to return Result"]
 pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
     FromStrRadix::from_str_radix(str, radix)
 }
@@ -128,11 +131,11 @@ pub fn from_str_radix<T: FromStrRadix>(str: &str, radix: uint) -> Option<T> {
 /// Helper function for testing numeric operations
 #[cfg(test)]
 pub fn test_num<T:Num + NumCast + Show>(ten: T, two: T) {
-    assert_eq!(ten.add(&two),  cast(12).unwrap());
-    assert_eq!(ten.sub(&two),  cast(8).unwrap());
-    assert_eq!(ten.mul(&two),  cast(20).unwrap());
-    assert_eq!(ten.div(&two),  cast(5).unwrap());
-    assert_eq!(ten.rem(&two),  cast(0).unwrap());
+    assert_eq!(ten.add(&two),  cast(12i).unwrap());
+    assert_eq!(ten.sub(&two),  cast(8i).unwrap());
+    assert_eq!(ten.mul(&two),  cast(20i).unwrap());
+    assert_eq!(ten.div(&two),  cast(5i).unwrap());
+    assert_eq!(ten.rem(&two),  cast(0i).unwrap());
 
     assert_eq!(ten.add(&two),  ten + two);
     assert_eq!(ten.sub(&two),  ten - two);
@@ -760,14 +763,14 @@ mod tests {
                 assert_eq!(result, naive_pow($num, $exp));
             }}
         )
-        assert_pow!((3,    0 ) => 1);
-        assert_pow!((5,    1 ) => 5);
-        assert_pow!((-4,   2 ) => 16);
-        assert_pow!((0.5,  5 ) => 0.03125);
-        assert_pow!((8,    3 ) => 512);
-        assert_pow!((8.0,  5 ) => 32768.0);
-        assert_pow!((8.5,  5 ) => 44370.53125);
-        assert_pow!((2u64, 50) => 1125899906842624);
+        assert_pow!((3i,     0 ) => 1);
+        assert_pow!((5i,     1 ) => 5);
+        assert_pow!((-4i,    2 ) => 16);
+        assert_pow!((0.5f64, 5 ) => 0.03125);
+        assert_pow!((8i,     3 ) => 512);
+        assert_pow!((8.0f64, 5 ) => 32768.0);
+        assert_pow!((8.5f64, 5 ) => 44370.53125);
+        assert_pow!((2u64,   50) => 1125899906842624);
     }
 }
 
@@ -781,7 +784,7 @@ mod bench {
 
     #[bench]
     fn bench_pow_function(b: &mut Bencher) {
-        let v = Vec::from_fn(1024, |n| n);
-        b.iter(|| {v.iter().fold(0, |old, new| num::pow(old, *new));});
+        let v = Vec::from_fn(1024u, |n| n);
+        b.iter(|| {v.iter().fold(0u, |old, new| num::pow(old, *new));});
     }
 }
diff --git a/src/libstd/num/u16.rs b/src/libstd/num/u16.rs
index 3b018414be2..727d7561062 100644
--- a/src/libstd/num/u16.rs
+++ b/src/libstd/num/u16.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for unsigned 16-bits integers (`u16` type)
 
+#![unstable]
 #![doc(primitive = "u16")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/u32.rs b/src/libstd/num/u32.rs
index 98012943109..d18bfdf9fba 100644
--- a/src/libstd/num/u32.rs
+++ b/src/libstd/num/u32.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for unsigned 32-bits integers (`u32` type)
 
+#![unstable]
 #![doc(primitive = "u32")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/u64.rs b/src/libstd/num/u64.rs
index b3a8bfc20df..53e88a96f33 100644
--- a/src/libstd/num/u64.rs
+++ b/src/libstd/num/u64.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for unsigned 64-bits integer (`u64` type)
 
+#![unstable]
 #![doc(primitive = "u64")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/u8.rs b/src/libstd/num/u8.rs
index d72049d2533..e6cbd14bf41 100644
--- a/src/libstd/num/u8.rs
+++ b/src/libstd/num/u8.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for unsigned 8-bits integers (`u8` type)
 
+#![unstable]
 #![doc(primitive = "u8")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/uint.rs b/src/libstd/num/uint.rs
index 1f43ad8af33..41c4caf4006 100644
--- a/src/libstd/num/uint.rs
+++ b/src/libstd/num/uint.rs
@@ -10,6 +10,7 @@
 
 //! Operations and constants for architecture-sized unsigned integers (`uint` type)
 
+#![unstable]
 #![doc(primitive = "uint")]
 
 use from_str::FromStr;
diff --git a/src/libstd/num/uint_macros.rs b/src/libstd/num/uint_macros.rs
index 769588d0bcb..19e45b292fb 100644
--- a/src/libstd/num/uint_macros.rs
+++ b/src/libstd/num/uint_macros.rs
@@ -27,11 +27,13 @@ macro_rules! uint_module (($T:ty) => (
 /// assert!(num == Some(123456789));
 /// ```
 #[inline]
+#[experimental = "might need to return Result"]
 pub fn parse_bytes(buf: &[u8], radix: uint) -> Option<$T> {
     strconv::from_str_bytes_common(buf, radix, false, false, false,
                                    strconv::ExpNone, false, false)
 }
 
+#[experimental = "might need to return Result"]
 impl FromStr for $T {
     #[inline]
     fn from_str(s: &str) -> Option<$T> {
@@ -40,6 +42,7 @@ impl FromStr for $T {
     }
 }
 
+#[experimental = "might need to return Result"]
 impl FromStrRadix for $T {
     #[inline]
     fn from_str_radix(s: &str, radix: uint) -> Option<$T> {
@@ -57,11 +60,14 @@ impl FromStrRadix for $T {
 /// # Examples
 ///
 /// ```
+/// #![allow(deprecated)]
+///
 /// std::uint::to_str_bytes(123, 10, |v| {
 ///     assert!(v == "123".as_bytes());
 /// });
 /// ```
 #[inline]
+#[deprecated = "just use .to_string(), or a BufWriter with write! if you mustn't allocate"]
 pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     use io::{Writer, Seek};
     // The radix can be as low as 2, so we need at least 64 characters for a
@@ -75,6 +81,7 @@ pub fn to_str_bytes<U>(n: $T, radix: uint, f: |v: &[u8]| -> U) -> U {
     f(buf.slice(0, amt))
 }
 
+#[deprecated = "use fmt::radix"]
 impl ToStrRadix for $T {
     /// Convert to a string in a given base.
     #[inline]
diff --git a/src/libstd/rand/mod.rs b/src/libstd/rand/mod.rs
index adc532879e2..ffe4a94d2a2 100644
--- a/src/libstd/rand/mod.rs
+++ b/src/libstd/rand/mod.rs
@@ -252,7 +252,7 @@ pub fn random<T: Rand>() -> T {
 /// use std::rand::{task_rng, sample};
 ///
 /// let mut rng = task_rng();
-/// let sample = sample(&mut rng, range(1, 100), 5);
+/// let sample = sample(&mut rng, range(1i, 100), 5);
 /// println!("{}", sample);
 /// ```
 pub fn sample<T, I: Iterator<T>, R: Rng>(rng: &mut R,
@@ -305,17 +305,17 @@ mod test {
     #[test]
     fn test_gen_range() {
         let mut r = task_rng();
-        for _ in range(0, 1000) {
+        for _ in range(0u, 1000) {
             let a = r.gen_range(-3i, 42);
             assert!(a >= -3 && a < 42);
-            assert_eq!(r.gen_range(0, 1), 0);
-            assert_eq!(r.gen_range(-12, -11), -12);
+            assert_eq!(r.gen_range(0i, 1), 0);
+            assert_eq!(r.gen_range(-12i, -11), -12);
         }
 
-        for _ in range(0, 1000) {
-            let a = r.gen_range(10, 42);
+        for _ in range(0u, 1000) {
+            let a = r.gen_range(10i, 42);
             assert!(a >= 10 && a < 42);
-            assert_eq!(r.gen_range(0, 1), 0);
+            assert_eq!(r.gen_range(0i, 1), 0);
             assert_eq!(r.gen_range(3_000_000u, 3_000_001), 3_000_000);
         }
 
@@ -369,7 +369,7 @@ mod test {
     #[test]
     fn test_choose() {
         let mut r = task_rng();
-        assert_eq!(r.choose([1, 1, 1]).map(|&x|x), Some(1));
+        assert_eq!(r.choose([1i, 1, 1]).map(|&x|x), Some(1));
 
         let v: &[int] = &[];
         assert_eq!(r.choose(v), None);
@@ -380,15 +380,15 @@ mod test {
         let mut r = task_rng();
         let empty: &mut [int] = &mut [];
         r.shuffle(empty);
-        let mut one = [1];
+        let mut one = [1i];
         r.shuffle(one);
         assert_eq!(one.as_slice(), &[1]);
 
-        let mut two = [1, 2];
+        let mut two = [1i, 2];
         r.shuffle(two);
         assert!(two == [1, 2] || two == [2, 1]);
 
-        let mut x = [1, 1, 1];
+        let mut x = [1i, 1, 1];
         r.shuffle(x);
         assert_eq!(x.as_slice(), &[1, 1, 1]);
     }
@@ -397,7 +397,7 @@ mod test {
     fn test_task_rng() {
         let mut r = task_rng();
         r.gen::<int>();
-        let mut v = [1, 1, 1];
+        let mut v = [1i, 1, 1];
         r.shuffle(v);
         assert_eq!(v.as_slice(), &[1, 1, 1]);
         assert_eq!(r.gen_range(0u, 1u), 0u);
@@ -419,8 +419,8 @@ mod test {
 
     #[test]
     fn test_sample() {
-        let min_val = 1;
-        let max_val = 100;
+        let min_val = 1i;
+        let max_val = 100i;
 
         let mut r = task_rng();
         let vals = range(min_val, max_val).collect::<Vec<int>>();
diff --git a/src/libstd/rand/os.rs b/src/libstd/rand/os.rs
index f507011c2b9..1c1aab15361 100644
--- a/src/libstd/rand/os.rs
+++ b/src/libstd/rand/os.rs
@@ -282,7 +282,7 @@ mod test {
     fn test_os_rng_tasks() {
 
         let mut txs = vec!();
-        for _ in range(0, 20) {
+        for _ in range(0u, 20) {
             let (tx, rx) = channel();
             txs.push(tx);
             task::spawn(proc() {
@@ -295,7 +295,7 @@ mod test {
                 task::deschedule();
                 let mut v = [0u8, .. 1000];
 
-                for _ in range(0, 100) {
+                for _ in range(0u, 100) {
                     r.next_u32();
                     task::deschedule();
                     r.next_u64();
diff --git a/src/libstd/rt/backtrace.rs b/src/libstd/rt/backtrace.rs
index b98fe8f0aae..e3652ffac6e 100644
--- a/src/libstd/rt/backtrace.rs
+++ b/src/libstd/rt/backtrace.rs
@@ -949,7 +949,7 @@ mod imp {
         let _c = Cleanup { handle: process, SymCleanup: SymCleanup };
 
         // And now that we're done with all the setup, do the stack walking!
-        let mut i = 0;
+        let mut i = 0i;
         try!(write!(w, "stack backtrace:\n"));
         while StackWalk64(image, process, thread, &mut frame, &mut context,
                           0 as *libc::c_void, 0 as *libc::c_void,
diff --git a/src/libstd/sync/future.rs b/src/libstd/sync/future.rs
index ccc67e3f8b0..78da605143d 100644
--- a/src/libstd/sync/future.rs
+++ b/src/libstd/sync/future.rs
@@ -181,7 +181,7 @@ mod test {
 
     #[test]
     fn test_get_ref_method() {
-        let mut f = Future::from_value(22);
+        let mut f = Future::from_value(22i);
         assert_eq!(*f.get_ref(), 22);
     }
 
diff --git a/src/libstd/sync/task_pool.rs b/src/libstd/sync/task_pool.rs
index cf95f5b088f..da0c3daefe7 100644
--- a/src/libstd/sync/task_pool.rs
+++ b/src/libstd/sync/task_pool.rs
@@ -89,7 +89,7 @@ impl<T> TaskPool<T> {
 fn test_task_pool() {
     let f: || -> proc(uint):Send -> uint = || { proc(i) i };
     let mut pool = TaskPool::new(4, f);
-    for _ in range(0, 8) {
+    for _ in range(0u, 8) {
         pool.execute(proc(i) println!("Hello from thread {}!", *i));
     }
 }
diff --git a/src/libstd/to_str.rs b/src/libstd/to_str.rs
index 9a1c0151e54..5deb7f151bb 100644
--- a/src/libstd/to_str.rs
+++ b/src/libstd/to_str.rs
@@ -56,9 +56,9 @@ mod tests {
     fn test_vectors() {
         let x: Vec<int> = vec![];
         assert_eq!(x.to_str(), "[]".to_string());
-        assert_eq!((vec![1]).to_str(), "[1]".to_string());
-        assert_eq!((vec![1, 2, 3]).to_str(), "[1, 2, 3]".to_string());
-        assert!((vec![vec![], vec![1], vec![1, 1]]).to_str() ==
+        assert_eq!((vec![1i]).to_str(), "[1]".to_string());
+        assert_eq!((vec![1i, 2, 3]).to_str(), "[1, 2, 3]".to_string());
+        assert!((vec![vec![], vec![1i], vec![1i, 1]]).to_str() ==
                "[[], [1], [1, 1]]".to_string());
     }
 }