---

yaml
---
r: 233721
b: refs/heads/beta
c: 45de9de
h: refs/heads/master
i:
  233719: 5adff35
v: v3

Author: wthrowe

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 685332c8d3c5d4c8fd26503b6ea5d9a00c838feb
+refs/heads/beta: 45de9de1e99c3d6a38055835b0fe6c65e1ddac73
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 370fe2786109360f7c35b8ba552b83b773dd71d6
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/configure

@@ -602,7 +602,6 @@ valopt python "" "set path to python"
 valopt jemalloc-root "" "set directory where libjemalloc_pic.a is located"
 valopt build "${DEFAULT_BUILD}" "GNUs ./configure syntax LLVM build triple"
 valopt android-cross-path "/opt/ndk_standalone" "Android NDK standalone path (deprecated)"
-valopt i686-linux-android-ndk "" "i686-linux-android NDK standalone path"
 valopt arm-linux-androideabi-ndk "" "arm-linux-androideabi NDK standalone path"
 valopt aarch64-linux-android-ndk "" "aarch64-linux-android NDK standalone path"
 valopt release-channel "dev" "the name of the release channel to build"
@@ -1694,7 +1693,6 @@ putvar CFG_LIBDIR_RELATIVE
 putvar CFG_DISABLE_MANAGE_SUBMODULES
 putvar CFG_AARCH64_LINUX_ANDROID_NDK
 putvar CFG_ARM_LINUX_ANDROIDEABI_NDK
-putvar CFG_I686_LINUX_ANDROID_NDK
 putvar CFG_MANDIR
 
 # Avoid spurious warnings from clang by feeding it original source on

branches/beta/mk/cfg/i686-linux-android.mk

@@ -19,7 +19,6 @@
 #![feature(str_char)]
 #![feature(test)]
 #![feature(vec_push_all)]
-#![feature(path_components_peek)]
 
 #![deny(warnings)]
 

branches/beta/src/compiletest/compiletest.rs

@@ -25,7 +25,7 @@ use std::fs::{self, File};
 use std::io::BufReader;
 use std::io::prelude::*;
 use std::net::TcpStream;
-use std::path::{Path, PathBuf, Component};
+use std::path::{Path, PathBuf};
 use std::process::{Command, Output, ExitStatus};
 
 pub fn run(config: Config, testfile: &Path) {
@@ -952,9 +952,6 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
     //    filename:line1:col1: line2:col2: *warning:* msg
     // where line1:col1: is the starting point, line2:col2:
     // is the ending point, and * represents ANSI color codes.
-    //
-    // This pattern is ambiguous on windows, because filename may contain
-    // a colon, so any path prefix must be detected and removed first.
     for line in proc_res.stderr.lines() {
         let mut was_expected = false;
         let mut prev = 0;
@@ -1009,16 +1006,7 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
     }
 }
 
-fn is_compiler_error_or_warning(mut line: &str) -> bool {
-    // Remove initial prefix which may contain a colon
-    let mut components = Path::new(line).components();
-    if let Some(Component::Prefix(_)) = components.peek() {
-        components.next();
-    }
-
-    // Safe as path was originally constructed from a &str ^
-    line = components.as_path().to_str().unwrap();
-
+fn is_compiler_error_or_warning(line: &str) -> bool {
     let mut i = 0;
     return
         scan_until_char(line, ':', &mut i) &&

branches/beta/src/compiletest/runtest.rs

@@ -1452,7 +1452,7 @@ fn draw_twice<T: Shape>(surface: Surface, sh: T) {
 }
 ```
 
-Traits also define a [trait object](#trait-objects) with the same
+Traits also define an [trait object](#trait-objects) with the same
 name as the trait. Values of this type are created by coercing from a
 pointer of some specific type to a pointer of trait type. For example,
 `&T` could be coerced to `&Shape` if `T: Shape` holds (and similarly
@@ -1881,15 +1881,11 @@ type int8_t = i8;
 - `no_start` - disable linking to the `native` crate, which specifies the
   "start" language item.
 - `no_std` - disable linking to the `std` crate.
-- `plugin` - load a list of named crates as compiler plugins, e.g.
+- `plugin` — load a list of named crates as compiler plugins, e.g.
              `#![plugin(foo, bar)]`. Optional arguments for each plugin,
              i.e. `#![plugin(foo(... args ...))]`, are provided to the plugin's
              registrar function.  The `plugin` feature gate is required to use
              this attribute.
-- `recursion_limit` - Sets the maximum depth for potentially
-                      infinitely-recursive compile-time operations like
-                      auto-dereference or macro expansion. The default is
-                      `#![recursion_limit="64"]`.
 
 ### Module-only attributes
 

branches/beta/src/doc/reference.md

@@ -208,8 +208,8 @@ Because these kinds of situations are relatively rare, use panics sparingly.
 
 In certain circumstances, even though a function may fail, we may want to treat
 it as a panic instead. For example, `io::stdin().read_line(&mut buffer)` returns
-a `Result<usize>`, which can indicate an error if one occurs when reading the line.
-This allows us to handle and possibly recover from errors.
+a `Result<usize>`, when there is an error reading the line. This allows us to
+handle and possibly recover from error.
 
 If we don't want to handle this error, and would rather just abort the program,
 we can use the `unwrap()` method:

branches/beta/src/doc/trpl/error-handling.md

@@ -219,66 +219,6 @@ fn it_works() {
 This is a very common use of `assert_eq!`: call some function with
 some known arguments and compare it to the expected output.
 
-# The `ignore` attribute
-
-Sometimes a few specific tests can be very time-consuming to execute. These
-can be disabled by default by using the `ignore` attribute:
-
-```rust
-#[test]
-fn it_works() {
-    assert_eq!(4, add_two(2));
-}
-
-#[test]
-#[ignore]
-fn expensive_test() {
-    // code that takes an hour to run
-}
-```
-
-Now we run our tests and see that `it_works` is run, but `expensive_test` is
-not:
-
-```bash
-$ cargo test
-   Compiling adder v0.0.1 (file:///home/you/projects/adder)
-     Running target/adder-91b3e234d4ed382a
-
-running 2 tests
-test expensive_test ... ignored
-test it_works ... ok
-
-test result: ok. 1 passed; 0 failed; 1 ignored; 0 measured
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
-```
-
-The expensive tests can be run explicitly using `cargo test -- --ignored`:
-
-```bash
-$ cargo test -- --ignored
-     Running target/adder-91b3e234d4ed382a
-
-running 1 test
-test expensive_test ... ok
-
-test result: ok. 1 passed; 0 failed; 0 ignored; 0 measured
-
-   Doc-tests adder
-
-running 0 tests
-
-test result: ok. 0 passed; 0 failed; 0 ignored; 0 measured
-```
-
-The `--ignored` argument is an argument to the test binary, and not to cargo,
-which is why the command is `cargo test -- --ignored`.
-
 # The `tests` module
 
 There is one way in which our existing example is not idiomatic: it's

branches/beta/src/doc/trpl/testing.md

@@ -813,7 +813,11 @@ impl<'a> Extend<&'a char> for String {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<'a> Extend<&'a str> for String {
     fn extend<I: IntoIterator<Item=&'a str>>(&mut self, iterable: I) {
-        for s in iterable {
+        let iterator = iterable.into_iter();
+        // A guess that at least one byte per iterator element will be needed.
+        let (lower_bound, _) = iterator.size_hint();
+        self.reserve(lower_bound);
+        for s in iterator {
             self.push_str(s)
         }
     }

branches/beta/src/libcollections/string.rs

@@ -184,7 +184,7 @@ pub trait Iterator {
     fn chain<U>(self, other: U) -> Chain<Self, U::IntoIter> where
         Self: Sized, U: IntoIterator<Item=Self::Item>,
     {
-        Chain{a: self, b: other.into_iter(), state: ChainState::Both}
+        Chain{a: self, b: other.into_iter(), flag: false}
     }
 
     /// Creates an iterator that iterates over both this and the specified
@@ -1277,30 +1277,7 @@ impl<I> Iterator for Cycle<I> where I: Clone + Iterator {
 pub struct Chain<A, B> {
     a: A,
     b: B,
-    state: ChainState,
-}
-
-// The iterator protocol specifies that iteration ends with the return value
-// `None` from `.next()` (or `.next_back()`) and it is unspecified what
-// further calls return. The chain adaptor must account for this since it uses
-// two subiterators.
-//
-//  It uses three states:
-//
-//  - Both: `a` and `b` are remaining
-//  - Front: `a` remaining
-//  - Back: `b` remaining
-//
-//  The fourth state (neither iterator is remaining) only occurs after Chain has
-//  returned None once, so we don't need to store this state.
-#[derive(Clone)]
-enum ChainState {
-    // both front and back iterator are remaining
-    Both,
-    // only front is remaining
-    Front,
-    // only back is remaining
-    Back,
+    flag: bool,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -1312,58 +1289,42 @@ impl<A, B> Iterator for Chain<A, B> where
 
     #[inline]
     fn next(&mut self) -> Option<A::Item> {
-        match self.state {
-            ChainState::Both => match self.a.next() {
-                elt @ Some(..) => return elt,
-                None => {
-                    self.state = ChainState::Back;
-                    self.b.next()
-                }
-            },
-            ChainState::Front => self.a.next(),
-            ChainState::Back => self.b.next(),
+        if self.flag {
+            self.b.next()
+        } else {
+            match self.a.next() {
+                Some(x) => return Some(x),
+                _ => ()
+            }
+            self.flag = true;
+            self.b.next()
         }
     }
 
     #[inline]
     fn count(self) -> usize {
-        match self.state {
-            ChainState::Both => self.a.count() + self.b.count(),
-            ChainState::Front => self.a.count(),
-            ChainState::Back => self.b.count(),
-        }
+        (if !self.flag { self.a.count() } else { 0 }) + self.b.count()
     }
 
     #[inline]
     fn nth(&mut self, mut n: usize) -> Option<A::Item> {
-        match self.state {
-            ChainState::Both | ChainState::Front => {
-                for x in self.a.by_ref() {
-                    if n == 0 {
-                        return Some(x)
-                    }
-                    n -= 1;
-                }
-                if let ChainState::Both = self.state {
-                    self.state = ChainState::Back;
+        if !self.flag {
+            for x in self.a.by_ref() {
+                if n == 0 {
+                    return Some(x)
                 }
+                n -= 1;
             }
-            ChainState::Back => {}
-        }
-        if let ChainState::Back = self.state {
-            self.b.nth(n)
-        } else {
-            None
+            self.flag = true;
         }
+        self.b.nth(n)
     }
 
     #[inline]
     fn last(self) -> Option<A::Item> {
-        match self.state {
-            ChainState::Both => self.b.last().or(self.a.last()),
-            ChainState::Front => self.a.last(),
-            ChainState::Back => self.b.last()
-        }
+        let a_last = if self.flag { None } else { self.a.last() };
+        let b_last = self.b.last();
+        b_last.or(a_last)
     }
 
     #[inline]
@@ -1389,16 +1350,9 @@ impl<A, B> DoubleEndedIterator for Chain<A, B> where
 {
     #[inline]
     fn next_back(&mut self) -> Option<A::Item> {
-        match self.state {
-            ChainState::Both => match self.b.next_back() {
-                elt @ Some(..) => return elt,
-                None => {
-                    self.state = ChainState::Front;
-                    self.a.next_back()
-                }
-            },
-            ChainState::Front => self.a.next_back(),
-            ChainState::Back => self.b.next_back(),
+        match self.b.next_back() {
+            Some(x) => Some(x),
+            None => self.a.next_back()
         }
     }
 }

branches/beta/src/libcore/iter.rs

@@ -729,26 +729,6 @@ fn test_double_ended_chain() {
     assert_eq!(it.next_back().unwrap(), &5);
     assert_eq!(it.next_back().unwrap(), &7);
     assert_eq!(it.next_back(), None);
-
-
-    // test that .chain() is well behaved with an unfused iterator
-    struct CrazyIterator(bool);
-    impl CrazyIterator { fn new() -> CrazyIterator { CrazyIterator(false) } }
-    impl Iterator for CrazyIterator {
-        type Item = i32;
-        fn next(&mut self) -> Option<i32> {
-            if self.0 { Some(99) } else { self.0 = true; None }
-        }
-    }
-
-    impl DoubleEndedIterator for CrazyIterator {
-        fn next_back(&mut self) -> Option<i32> {
-            self.next()
-        }
-    }
-
-    assert_eq!(CrazyIterator::new().chain(0..10).rev().last(), Some(0));
-    assert!((0..10).chain(CrazyIterator::new()).rev().any(|i| i == 0));
 }
 
 #[test]