Round 1 fixes and rebase conflicts

Author: alexcrichton

src/libcollections/bit.rs

@@ -925,7 +925,7 @@ impl Default for BitVec {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl FromIterator<bool> for BitVec {
     fn from_iter<I: IntoIterator<Item=bool>>(iter: I) -> BitVec {
-        let mut ret = Bitv::new();
+        let mut ret = BitVec::new();
         ret.extend(iter);
         ret
     }
@@ -1146,7 +1146,7 @@ impl Default for BitSet {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl FromIterator<usize> for BitSet {
     fn from_iter<I: IntoIterator<Item=usize>>(iter: I) -> BitSet {
-        let mut ret = BitvSet::new();
+        let mut ret = BitSet::new();
         ret.extend(iter);
         ret
     }

src/libcore/iter.rs

@@ -522,11 +522,11 @@ pub trait IteratorExt: Iterator + Sized {
     ///
     /// let a = [1, 4, 2, 3, 8, 9, 6];
     /// let sum = a.iter()
-    ///             .cloned()
-    ///             .inspect(|&x| println!("filtering {}", x))
-    ///             .filter(|&x| x % 2 == 0)
-    ///             .inspect(|&x| println!("{} made it through", x))
-    ///             .sum();
+    ///            .map(|x| *x)
+    ///            .inspect(|&x| println!("filtering {}", x))
+    ///            .filter(|&x| x % 2 == 0)
+    ///            .inspect(|&x| println!("{} made it through", x))
+    ///            .sum();
     /// println!("{}", sum);
     /// ```
     #[inline]

src/libcoretest/hash/mod.rs

@@ -23,7 +23,6 @@ impl Default for MyHasher {
 }
 
 impl Hasher for MyHasher {
-    type Output = u64;
     fn write(&mut self, buf: &[u8]) {
         for byte in buf {
             self.hash += *byte as u64;
@@ -85,7 +84,6 @@ struct Custom { hash: u64 }
 struct CustomHasher { output: u64 }
 
 impl Hasher for CustomHasher {
-    type Output = u64;
     fn finish(&self) -> u64 { self.output }
     fn write(&mut self, data: &[u8]) { panic!() }
     fn write_u64(&mut self, data: u64) { self.output = data; }

src/librustc_trans/trans/tvec.rs

@@ -426,7 +426,7 @@ pub fn iter_vec_loop<'blk, 'tcx, F>(bcx: Block<'blk, 'tcx>,
     Br(bcx, loop_bcx.llbb, DebugLoc::None);
 
     let loop_counter = Phi(loop_bcx, bcx.ccx().int_type(),
-                           &[C_uint(bcx.ccx(), 0)], &[bcx.llbb]);
+                           &[C_uint(bcx.ccx(), 0 as usize)], &[bcx.llbb]);
 
     let bcx = loop_bcx;
 

src/librustdoc/flock.rs

@@ -112,7 +112,7 @@ mod imp {
 
     impl Lock {
         pub fn new(p: &Path) -> Lock {
-            let buf = CString::from_slice(p.as_vec()).unwrap();
+            let buf = CString::new(p.as_vec()).unwrap();
             let fd = unsafe {
                 libc::open(buf.as_ptr(), libc::O_RDWR | libc::O_CREAT,
                            libc::S_IRWXU)

src/librustdoc/html/markdown.rs

@@ -236,7 +236,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
                 s.push_str(&highlight::highlight(&text,
                                                  None,
                                                  Some("rust-example-rendered")));
-                let output = CString::from_vec(s.into_bytes()).unwrap();
+                let output = CString::new(s).unwrap();
                 hoedown_buffer_puts(ob, output.as_ptr());
             })
         }
@@ -293,7 +293,7 @@ pub fn render(w: &mut fmt::Formatter, s: &str, print_toc: bool) -> fmt::Result {
                                format!("{} ", sec)
                            });
 
-        let text = CString::from_vec(text.into_bytes()).unwrap();
+        let text = CString::new(text).unwrap();
         unsafe { hoedown_buffer_puts(ob, text.as_ptr()) }
     }
 

src/libstd/collections/hash/map_stage0.rs

@@ -1552,7 +1552,8 @@ impl<K, V, S, H> FromIterator<(K, V)> for HashMap<K, V, S>
           S: HashState<Hasher=H> + Default,
           H: hash::Hasher<Output=u64>
 {
-    fn from_iter<T: Iterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, S> {
+    fn from_iter<T: IntoIterator<Item=(K, V)>>(iter: T) -> HashMap<K, V, S> {
+        let iter = iter.into_iter();
         let lower = iter.size_hint().0;
         let mut map = HashMap::with_capacity_and_hash_state(lower,
                                                             Default::default());
@@ -1567,7 +1568,7 @@ impl<K, V, S, H> Extend<(K, V)> for HashMap<K, V, S>
           S: HashState<Hasher=H>,
           H: hash::Hasher<Output=u64>
 {
-    fn extend<T: Iterator<Item=(K, V)>>(&mut self, iter: T) {
+    fn extend<T: IntoIterator<Item=(K, V)>>(&mut self, iter: T) {
         for (k, v) in iter {
             self.insert(k, v);
         }

src/libstd/collections/hash/set_stage0.rs

@@ -622,7 +622,8 @@ impl<T, S, H> FromIterator<T> for HashSet<T, S>
           S: HashState<Hasher=H> + Default,
           H: hash::Hasher<Output=u64>
 {
-    fn from_iter<I: Iterator<Item=T>>(iter: I) -> HashSet<T, S> {
+    fn from_iter<I: IntoIterator<Item=T>>(iter: I) -> HashSet<T, S> {
+        let iter = iter.into_iter();
         let lower = iter.size_hint().0;
         let mut set = HashSet::with_capacity_and_hash_state(lower, Default::default());
         set.extend(iter);
@@ -636,7 +637,7 @@ impl<T, S, H> Extend<T> for HashSet<T, S>
           S: HashState<Hasher=H>,
           H: hash::Hasher<Output=u64>
 {
-    fn extend<I: Iterator<Item=T>>(&mut self, iter: I) {
+    fn extend<I: IntoIterator<Item=T>>(&mut self, iter: I) {
         for k in iter {
             self.insert(k);
         }

src/libstd/ffi/c_str.rs

@@ -105,7 +105,7 @@ pub struct CString {
 /// }
 ///
 /// fn main() {
-///     let s = CString::from_slice(b"data data data data").unwrap();
+///     let s = CString::new("data data data data").unwrap();
 ///     work(&s);
 /// }
 /// ```
@@ -141,7 +141,7 @@ impl CString {
     /// extern { fn puts(s: *const libc::c_char); }
     ///
     /// fn main() {
-    ///     let to_print = CString::from_slice(b"Hello!").unwrap();
+    ///     let to_print = CString::new("Hello!").unwrap();
     ///     unsafe {
     ///         puts(to_print.as_ptr());
     ///     }
@@ -175,7 +175,7 @@ impl CString {
     /// extern { fn puts(s: *const libc::c_char); }
     ///
     /// fn main() {
-    ///     let to_print = CString::from_slice(b"Hello!").unwrap();
+    ///     let to_print = CString::new("Hello!").unwrap();
     ///     unsafe {
     ///         puts(to_print.as_ptr());
     ///     }
@@ -436,18 +436,18 @@ mod tests {
 
     #[test]
     fn simple() {
-        let s = CString::from_slice(b"1234").unwrap();
+        let s = CString::new(b"1234").unwrap();
         assert_eq!(s.as_bytes(), b"1234");
         assert_eq!(s.as_bytes_with_nul(), b"1234\0");
     }
 
     #[test]
     fn build_with_zero1() {
-        assert!(CString::from_slice(b"\0").is_err());
+        assert!(CString::new(b"\0").is_err());
     }
     #[test]
     fn build_with_zero2() {
-        assert!(CString::from_vec(vec![0]).is_err());
+        assert!(CString::new(vec![0]).is_err());
     }
 
     #[test]
@@ -460,7 +460,7 @@ mod tests {
 
     #[test]
     fn formatted() {
-        let s = CString::from_slice(b"12").unwrap();
+        let s = CString::new(b"12").unwrap();
         assert_eq!(format!("{:?}", s), "\"12\"");
     }
 

src/test/run-pass/bitv-perf-test.rs

@@ -13,11 +13,11 @@
 #![feature(box_syntax)]
 
 extern crate collections;
-use std::collections::Bitv;
+use std::collections::BitVec;
 
 fn bitv_test() {
-    let mut v1 = box Bitv::from_elem(31, false);
-    let v2 = box Bitv::from_elem(31, true);
+    let mut v1 = box BitVec::from_elem(31, false);
+    let v2 = box BitVec::from_elem(31, true);
     v1.union(&*v2);
 }