---

yaml
---
r: 92798
b: refs/heads/auto
c: b6a7463
h: refs/heads/master
v: v3

Author: alexcrichton

[refs]

@@ -13,7 +13,7 @@ refs/heads/try3: 9387340aab40a73e8424c48fd42f0c521a4875c0
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: d2a4a107aea7f078ca0c6f0ef81dde5f02f8e0e1
+refs/heads/auto: b6a746352646965f71fa6c4fd9b37fd94918db8a
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/etc/vim/syntax/rust.vim

@@ -78,7 +78,7 @@ syn keyword rustTrait Default
 syn keyword rustTrait Hash
 syn keyword rustTrait FromStr
 syn keyword rustTrait FromIterator Extendable
-syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator CloneableIterator
+syn keyword rustTrait Iterator DoubleEndedIterator RandomAccessIterator ClonableIterator
 syn keyword rustTrait OrdIterator MutableDoubleEndedIterator ExactSize
 syn keyword rustTrait Times
 

branches/auto/src/librustc/back/link.rs

@@ -111,38 +111,14 @@ pub mod write {
         let llmod = trans.module;
         let llcx = trans.context;
         unsafe {
-            llvm::LLVMInitializePasses();
-
-            // Only initialize the platforms supported by Rust here, because
-            // using --llvm-root will have multiple platforms that rustllvm
-            // doesn't actually link to and it's pointless to put target info
-            // into the registry that Rust can not generate machine code for.
-            llvm::LLVMInitializeX86TargetInfo();
-            llvm::LLVMInitializeX86Target();
-            llvm::LLVMInitializeX86TargetMC();
-            llvm::LLVMInitializeX86AsmPrinter();
-            llvm::LLVMInitializeX86AsmParser();
-
-            llvm::LLVMInitializeARMTargetInfo();
-            llvm::LLVMInitializeARMTarget();
-            llvm::LLVMInitializeARMTargetMC();
-            llvm::LLVMInitializeARMAsmPrinter();
-            llvm::LLVMInitializeARMAsmParser();
-
-            llvm::LLVMInitializeMipsTargetInfo();
-            llvm::LLVMInitializeMipsTarget();
-            llvm::LLVMInitializeMipsTargetMC();
-            llvm::LLVMInitializeMipsAsmPrinter();
-            llvm::LLVMInitializeMipsAsmParser();
+            configure_llvm(sess);
 
             if sess.opts.save_temps {
                 output.with_extension("no-opt.bc").with_c_str(|buf| {
                     llvm::LLVMWriteBitcodeToFile(llmod, buf);
                 })
             }
 
-            configure_llvm(sess);
-
             let OptLevel = match sess.opts.optimize {
               session::No => lib::llvm::CodeGenLevelNone,
               session::Less => lib::llvm::CodeGenLevelLess,
@@ -367,6 +343,30 @@ pub mod write {
 
         LOCK.lock();
         if !CONFIGURED {
+            llvm::LLVMInitializePasses();
+
+            // Only initialize the platforms supported by Rust here, because
+            // using --llvm-root will have multiple platforms that rustllvm
+            // doesn't actually link to and it's pointless to put target info
+            // into the registry that Rust can not generate machine code for.
+            llvm::LLVMInitializeX86TargetInfo();
+            llvm::LLVMInitializeX86Target();
+            llvm::LLVMInitializeX86TargetMC();
+            llvm::LLVMInitializeX86AsmPrinter();
+            llvm::LLVMInitializeX86AsmParser();
+
+            llvm::LLVMInitializeARMTargetInfo();
+            llvm::LLVMInitializeARMTarget();
+            llvm::LLVMInitializeARMTargetMC();
+            llvm::LLVMInitializeARMAsmPrinter();
+            llvm::LLVMInitializeARMAsmParser();
+
+            llvm::LLVMInitializeMipsTargetInfo();
+            llvm::LLVMInitializeMipsTarget();
+            llvm::LLVMInitializeMipsTargetMC();
+            llvm::LLVMInitializeMipsAsmPrinter();
+            llvm::LLVMInitializeMipsAsmParser();
+
             llvm::LLVMRustSetLLVMOptions(llvm_args.len() as c_int,
                                          llvm_args.as_ptr());
             CONFIGURED = true;

branches/auto/src/libstd/io/comm_adapters.rs

@@ -117,6 +117,7 @@ mod test {
     use prelude::*;
     use super::*;
     use io;
+    use comm;
     use task;
 
     #[test]
@@ -135,7 +136,7 @@ mod test {
 
         assert_eq!(false, reader.eof());
 
-        assert_eq!(Some(0), reader.read([]));
+        assert_eq!(Some(0), reader.read(~[]));
         assert_eq!(false, reader.eof());
 
         assert_eq!(Some(3), reader.read(buf));

branches/auto/src/libstd/iter.rs

@@ -906,14 +906,14 @@ impl<A: Ord, T: Iterator<A>> OrdIterator<A> for T {
     }
 }
 
-/// A trait for iterators that are cloneable.
-pub trait CloneableIterator {
+/// A trait for iterators that are clonable.
+pub trait ClonableIterator {
     /// Repeats an iterator endlessly
     ///
     /// # Example
     ///
     /// ```rust
-    /// use std::iter::{CloneableIterator, count};
+    /// use std::iter::{ClonableIterator, count};
     ///
     /// let a = count(1,1).take(1);
     /// let mut cy = a.cycle();
@@ -923,7 +923,7 @@ pub trait CloneableIterator {
     fn cycle(self) -> Cycle<Self>;
 }
 
-impl<A, T: Clone + Iterator<A>> CloneableIterator for T {
+impl<A, T: Clone + Iterator<A>> ClonableIterator for T {
     #[inline]
     fn cycle(self) -> Cycle<T> {
         Cycle{orig: self.clone(), iter: self}

branches/auto/src/libstd/option.rs

@@ -43,7 +43,7 @@ use clone::DeepClone;
 use cmp::{Eq, TotalEq, TotalOrd};
 use default::Default;
 use fmt;
-use iter::{Iterator, DoubleEndedIterator, FromIterator, ExactSize};
+use iter::{Iterator, DoubleEndedIterator, ExactSize};
 use kinds::Send;
 use str::OwnedStr;
 use to_str::ToStr;
@@ -410,46 +410,6 @@ impl<A> DoubleEndedIterator<A> for OptionIterator<A> {
 
 impl<A> ExactSize<A> for OptionIterator<A> {}
 
-/////////////////////////////////////////////////////////////////////////////
-// Free functions
-/////////////////////////////////////////////////////////////////////////////
-
-/// Takes each element in the `Iterator`: if it is `None`, no further
-/// elements are taken, and the `None` is returned. Should no `None` occur, a
-/// vector containing the values of each `Option` is returned.
-///
-/// Here is an example which increments every integer in a vector,
-/// checking for overflow:
-///
-///     fn inc_conditionally(x: uint) -> Option<uint> {
-///         if x == uint::max_value { return None; }
-///         else { return Some(x+1u); }
-///     }
-///     let v = [1u, 2, 3];
-///     let res = collect(v.iter().map(|&x| inc_conditionally(x)));
-///     assert!(res == Some(~[2u, 3, 4]));
-#[inline]
-pub fn collect<T, Iter: Iterator<Option<T>>, V: FromIterator<T>>(iter: Iter) -> Option<V> {
-    // FIXME(#11084): This should be twice as fast once this bug is closed.
-    let mut iter = iter.scan(false, |state, x| {
-        match x {
-            Some(x) => Some(x),
-            None => {
-                *state = true;
-                None
-            }
-        }
-    });
-
-    let v: V = FromIterator::from_iterator(&mut iter);
-
-    if iter.state {
-        None
-    } else {
-        Some(v)
-    }
-}
-
 /////////////////////////////////////////////////////////////////////////////
 // Tests
 /////////////////////////////////////////////////////////////////////////////
@@ -458,10 +418,8 @@ pub fn collect<T, Iter: Iterator<Option<T>>, V: FromIterator<T>>(iter: Iter) ->
 mod tests {
     use super::*;
 
-    use iter::range;
     use str::StrSlice;
     use util;
-    use vec::ImmutableVector;
 
     #[test]
     fn test_get_ptr() {
@@ -703,26 +661,4 @@ mod tests {
         assert!(!x.mutate_default(0i, |i| i+1));
         assert_eq!(x, Some(0i));
     }
-
-    #[test]
-    fn test_collect() {
-        let v: Option<~[int]> = collect(range(0, 0)
-                                        .map(|_| Some(0)));
-        assert_eq!(v, Some(~[]));
-
-        let v: Option<~[int]> = collect(range(0, 3)
-                                        .map(|x| Some(x)));
-        assert_eq!(v, Some(~[0, 1, 2]));
-
-        let v: Option<~[int]> = collect(range(0, 3)
-                                        .map(|x| if x > 1 { None } else { Some(x) }));
-        assert_eq!(v, None);
-
-        // test that it does not take more elements than it needs
-        let functions = [|| Some(()), || None, || fail!()];
-
-        let v: Option<~[()]> = collect(functions.iter().map(|f| (*f)()));
-
-        assert_eq!(v, None);
-    }
 }

branches/auto/src/libstd/prelude.rs

@@ -55,7 +55,7 @@ pub use default::Default;
 pub use from_str::FromStr;
 pub use hash::Hash;
 pub use iter::{FromIterator, Extendable};
-pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, CloneableIterator};
+pub use iter::{Iterator, DoubleEndedIterator, RandomAccessIterator, ClonableIterator};
 pub use iter::{OrdIterator, MutableDoubleEndedIterator, ExactSize};
 pub use num::Times;
 pub use num::{Algebraic, Trigonometric, Exponential, Hyperbolic};

branches/auto/src/libstd/result.rs

@@ -13,10 +13,12 @@
 use clone::Clone;
 use cmp::Eq;
 use fmt;
-use iter::{Iterator, FromIterator};
+use iter::Iterator;
 use option::{None, Option, Some};
 use str::OwnedStr;
 use to_str::ToStr;
+use vec::OwnedVector;
+use vec;
 
 /// `Result` is a type that represents either success (`Ok`) or failure (`Err`).
 #[deriving(Clone, DeepClone, Eq, Ord, TotalEq, TotalOrd, ToStr)]
@@ -219,9 +221,10 @@ impl<T: fmt::Default, E: fmt::Default> fmt::Default for Result<T, E> {
 // Free functions
 /////////////////////////////////////////////////////////////////////////////
 
-/// Takes each element in the `Iterator`: if it is an `Err`, no further
-/// elements are taken, and the `Err` is returned. Should no `Err` occur, a
-/// vector containing the values of each `Result` is returned.
+/// Takes each element in the iterator: if it is an error, no further
+/// elements are taken, and the error is returned.
+/// Should no error occur, a vector containing the values of each Result
+/// is returned.
 ///
 /// Here is an example which increments every integer in a vector,
 /// checking for overflow:
@@ -234,24 +237,17 @@ impl<T: fmt::Default, E: fmt::Default> fmt::Default for Result<T, E> {
 ///     let res = collect(v.iter().map(|&x| inc_conditionally(x)));
 ///     assert!(res == Ok(~[2u, 3, 4]));
 #[inline]
-pub fn collect<T, E, Iter: Iterator<Result<T, E>>, V: FromIterator<T>>(iter: Iter) -> Result<V, E> {
-    // FIXME(#11084): This should be twice as fast once this bug is closed.
-    let mut iter = iter.scan(None, |state, x| {
-        match x {
-            Ok(x) => Some(x),
-            Err(err) => {
-                *state = Some(err);
-                None
-            }
+pub fn collect<T, E, Iter: Iterator<Result<T, E>>>(mut iterator: Iter)
+    -> Result<~[T], E> {
+    let (lower, _) = iterator.size_hint();
+    let mut vs: ~[T] = vec::with_capacity(lower);
+    for t in iterator {
+        match t {
+            Ok(v) => vs.push(v),
+            Err(u) => return Err(u)
         }
-    });
-
-    let v: V = FromIterator::from_iterator(&mut iter);
-
-    match iter.state {
-        Some(err) => Err(err),
-        None => Ok(v),
     }
+    Ok(vs)
 }
 
 /// Perform a fold operation over the result values from an iterator.
@@ -295,8 +291,8 @@ mod tests {
     use super::*;
 
     use iter::range;
-    use to_str::ToStr;
     use vec::ImmutableVector;
+    use to_str::ToStr;
 
     pub fn op1() -> Result<int, ~str> { Ok(666) }
     pub fn op2() -> Result<int, ~str> { Err(~"sadface") }
@@ -351,21 +347,21 @@ mod tests {
 
     #[test]
     fn test_collect() {
-        let v: Result<~[int], ()> = collect(range(0, 0).map(|_| Ok::<int, ()>(0)));
-        assert_eq!(v, Ok(~[]));
-
-        let v: Result<~[int], ()> = collect(range(0, 3).map(|x| Ok::<int, ()>(x)));
-        assert_eq!(v, Ok(~[0, 1, 2]));
-
-        let v: Result<~[int], int> = collect(range(0, 3)
-                                             .map(|x| if x > 1 { Err(x) } else { Ok(x) }));
-        assert_eq!(v, Err(2));
+        assert_eq!(collect(range(0, 0)
+                           .map(|_| Ok::<int, ()>(0))),
+                   Ok(~[]));
+        assert_eq!(collect(range(0, 3)
+                           .map(|x| Ok::<int, ()>(x))),
+                   Ok(~[0, 1, 2]));
+        assert_eq!(collect(range(0, 3)
+                           .map(|x| if x > 1 { Err(x) } else { Ok(x) })),
+                   Err(2));
 
         // test that it does not take more elements than it needs
         let functions = [|| Ok(()), || Err(1), || fail!()];
 
-        let v: Result<~[()], int> = collect(functions.iter().map(|f| (*f)()));
-        assert_eq!(v, Err(1));
+        assert_eq!(collect(functions.iter().map(|f| (*f)())),
+                   Err(1));
     }
 
     #[test]