---

yaml
---
r: 185677
b: refs/heads/auto
c: 72eaf2c
h: refs/heads/master
i:
  185675: 6cd61ea
v: v3

Author: jxcl

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 26180e9940ea349fbe62ef53b7f737679bb4a970
+refs/heads/auto: 72eaf2c30e846b3d14c520c0c7638b2b16bf8c73
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/README.md

@@ -111,7 +111,7 @@ To contribute to Rust, please see [CONTRIBUTING.md](CONTRIBUTING.md).
 Rust has an [IRC] culture and most real-time collaboration happens in a
 variety of channels on Mozilla's IRC network, irc.mozilla.org. The
 most popular channel is [#rust], a venue for general discussion about
-Rust, and a good place to ask for help.
+Rust, and a good place to ask for help,
 
 [IRC]: https://en.wikipedia.org/wiki/Internet_Relay_Chat
 [#rust]: irc://irc.mozilla.org/rust

branches/auto/src/compiletest/compiletest.rs

@@ -268,7 +268,7 @@ pub fn test_opts(config: &Config) -> test::TestOpts {
         logfile: config.logfile.clone(),
         run_tests: true,
         run_benchmarks: true,
-        nocapture: env::var("RUST_TEST_NOCAPTURE").is_ok(),
+        nocapture: false,
         color: test::AutoColor,
     }
 }

branches/auto/src/compiletest/errors.rs

@@ -58,7 +58,7 @@ pub fn load_errors(testfile: &Path) -> Vec<ExpectedError> {
 fn parse_expected(last_nonfollow_error: Option<uint>,
                   line_num: uint,
                   line: &str) -> Option<(WhichLine, ExpectedError)> {
-    let start = match line.find("//~") { Some(i) => i, None => return None };
+    let start = match line.find_str("//~") { Some(i) => i, None => return None };
     let (follow, adjusts) = if line.char_at(start + 3) == '|' {
         (true, 0)
     } else {

branches/auto/src/compiletest/header.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::env;
-
 use common::Config;
 use common;
 use util;
@@ -127,16 +125,6 @@ pub fn load_props(testfile: &Path) -> TestProps {
         true
     });
 
-    for key in vec!["RUST_TEST_NOCAPTURE", "RUST_TEST_TASKS"] {
-        match env::var(key) {
-            Ok(val) =>
-                if exec_env.iter().find(|&&(ref x, _)| *x == key.to_string()).is_none() {
-                    exec_env.push((key.to_string(), val))
-                },
-            Err(..) => {}
-        }
-    }
-
     TestProps {
         error_patterns: error_patterns,
         compile_flags: compile_flags,
@@ -342,7 +330,7 @@ fn parse_name_directive(line: &str, directive: &str) -> bool {
 pub fn parse_name_value_directive(line: &str, directive: &str)
                                   -> Option<String> {
     let keycolon = format!("{}:", directive);
-    match line.find(&keycolon) {
+    match line.find_str(&keycolon) {
         Some(colon) => {
             let value = line[(colon + keycolon.len()) .. line.len()].to_string();
             debug!("{}: {}", directive, value);

branches/auto/src/compiletest/runtest.rs

@@ -847,7 +847,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
             check_lines.iter().map(|s| {
                 s
                  .trim()
-                 .split("[...]")
+                 .split_str("[...]")
                  .map(|x| x.to_string())
                  .collect()
             }).collect();
@@ -866,7 +866,7 @@ fn check_debugger_output(debugger_run_result: &ProcRes, check_lines: &[String])
                         None
                     }
                 } else {
-                    rest.find(frag)
+                    rest.find_str(frag)
                 };
                 match found {
                     None => {

branches/auto/src/doc/intro.md

@@ -426,33 +426,39 @@ use std::thread::Thread;
 fn main() {
     let mut numbers = vec![1, 2, 3];
 
-    let guards: Vec<_> = (0..3).map(|i| {
-        Thread::scoped(move || {
+    for i in 0..3 {
+        Thread::spawn(move || {
             for j in 0..3 { numbers[j] += 1 }
         });
-    }).collect();
+    }
 }
 ```
 
 It gives us this error:
 
 ```text
-7:29: 9:10 error: cannot move out of captured outer variable in an `FnMut` closure
-7         Thread::scoped(move || {
-8             for j in 0..3 { numbers[j] += 1 }
-9         });
+6:71 error: capture of moved value: `numbers`
+    for j in 0..3 { numbers[j] += 1 }
+                    ^~~~~~~
+7:50 note: `numbers` moved into closure environment here
+    spawn(move || {
+        for j in 0..3 { numbers[j] += 1 }
+    });
+6:79 error: cannot assign to immutable dereference (dereference is implicit, due to indexing)
+        for j in 0..3 { numbers[j] += 1 }
+                        ^~~~~~~~~~~~~~~
 ```
 
-It mentions that "captured outer variable in an `FnMut` closure".
-Because we declared the closure as a moving closure, and it referred
-to `numbers`, the closure will try to take ownership of the
-vector. But the closure itself is created in a loop, and hence we will
-actually create three closures, one for every iteration of the
-loop. This means that all three of those closures would try to own
-`numbers`, which is impossible -- `numbers` must have just one
-owner. Rust detects this and gives us the error: we claim that
-`numbers` has ownership, but our code tries to make three owners. This
-may cause a safety problem, so Rust disallows it.
+It mentions that "numbers moved into closure environment". Because we
+declared the closure as a moving closure, and it referred to
+`numbers`, the closure will try to take ownership of the vector. But
+the closure itself is created in a loop, and hence we will actually
+create three closures, one for every iteration of the loop. This means
+that all three of those closures would try to own `numbers`, which is
+impossible -- `numbers` must have just one owner. Rust detects this
+and gives us the error: we claim that `numbers` has ownership, but our
+code tries to make three owners. This may cause a safety problem, so
+Rust disallows it.
 
 What to do here? Rust has two types that helps us: `Arc<T>` and `Mutex<T>`.
 *Arc* stands for "atomically reference counted". In other words, an Arc will
@@ -474,14 +480,14 @@ use std::sync::{Arc,Mutex};
 fn main() {
     let numbers = Arc::new(Mutex::new(vec![1, 2, 3]));
 
-    let guards: Vec<_> = (0..3).map(|i| {
+    for i in 0..3 {
         let number = numbers.clone();
-        Thread::scoped(move || {
+        Thread::spawn(move || {
             let mut array = number.lock().unwrap();
             array[i] += 1;
             println!("numbers[{}] is {}", i, array[i]);
         });
-    }).collect();
+    }
 }
 ```
 
@@ -510,10 +516,8 @@ numbers[1] is 3
 numbers[0] is 2
 ```
 
-Each time, we can get a slithtly different output because the threads
-are not quaranteed to run in any set order. If you get the same order
-every time it is because each of these threads are very small and
-complete too fast for their indeterminate behavior to surface.
+Each time, we get a slightly different output, because each thread works in a
+different order. You may not get the same output as this sample, even.
 
 The important part here is that the Rust compiler was able to use ownership to
 give us assurance _at compile time_ that we weren't doing something incorrect
@@ -535,13 +539,13 @@ safety check that makes this an error about moved values:
 use std::thread::Thread;
 
 fn main() {
-    let numbers = vec![1, 2, 3];
-    
-    let guards: Vec<_> = (0..3).map(|i| {
-        Thread::scoped(move || {
-            println!("{}", numbers[i]);
+    let vec = vec![1, 2, 3];
+
+    for i in 0..3 {
+        Thread::spawn(move || {
+            println!("{}", vec[i]);
         });
-    }).collect();
+    }
 }
 ```
 

branches/auto/src/doc/reference.md

@@ -515,9 +515,6 @@ This last example is different because it is not possible to use the suffix
 syntax with a floating point literal ending in a period. `2.f64` would attempt
 to call a method named `f64` on `2`.
 
-The representation semantics of floating-point numbers are described in
-["Machine Types"](#machine-types).
-
 #### Boolean literals
 
 The two values of the boolean type are written `true` and `false`.

branches/auto/src/doc/trpl/crates-and-modules.md

@@ -12,7 +12,7 @@ Rust has two distinct terms that relate to the module system: *crate* and
 *module*. A crate is synonymous with a *library* or *package* in other
 languages. Hence "Cargo" as the name of Rust's package management tool: you
 ship your crates to others with Cargo. Crates can produce an executable or a
-library, depending on the project.
+shared library, depending on the project.
 
 Each crate has an implicit *root module* that contains the code for that crate.
 You can then define a tree of sub-modules under that root module. Modules allow

branches/auto/src/doc/trpl/iterators.md

@@ -57,14 +57,13 @@ for i in 0..nums.len() {
 }
 ```
 
-This is strictly worse than using an actual iterator. The `.iter()` method on
-vectors returns an iterator which iterates through a reference to each element
-of the vector in turn. So write this:
+This is strictly worse than using an actual iterator. You can iterate over vectors
+directly, so write this:
 
 ```rust
 let nums = vec![1, 2, 3];
 
-for num in nums.iter() {
+for num in &nums {
     println!("{}", num);
 }
 ```
@@ -86,16 +85,17 @@ see it. This code works fine too:
 ```rust
 let nums = vec![1, 2, 3];
 
-for num in nums.iter() {
+for num in &nums {
     println!("{}", *num);
 }
 ```
 
-Now we're explicitly dereferencing `num`. Why does `iter()` give us references?
-Well, if it gave us the data itself, we would have to be its owner, which would
-involve making a copy of the data and giving us the copy. With references,
-we're just borrowing a reference to the data, and so it's just passing
-a reference, without needing to do the copy.
+Now we're explicitly dereferencing `num`. Why does `&nums` give us
+references?  Because we asked it to with `&`. If we had not had the
+`&`, `nums` would have been moved into the `for` loop and consumed,
+and we we would no longer be able to access `nums` afterward.  With
+references, we're just borrowing a reference to the data, and so it's
+just passing a reference, without needing to do the move.
 
 So, now that we've established that ranges are often not what you want, let's
 talk about what you do want instead.
@@ -230,9 +230,9 @@ let nums = (1..100).collect::<Vec<i32>>();
 Now, `collect()` will require that the range gives it some numbers, and so
 it will do the work of generating the sequence.
 
-Ranges are one of two basic iterators that you'll see. The other is `iter()`,
-which you've used before. `iter()` can turn a vector into a simple iterator
-that gives you each element in turn:
+Ranges are one of two basic iterators that you'll see. The other is `iter()`.
+`iter()` can turn a vector into a simple iterator that gives you each element
+in turn:
 
 ```rust
 let nums = [1, 2, 3];
@@ -242,6 +242,9 @@ for num in nums.iter() {
 }
 ```
 
+Sometimes you need this functionality, but since for loops operate on the
+`IntoIterator` trait, calling `.iter()` is rarely necessary.
+
 These two basic iterators should serve you well. There are some more
 advanced iterators, including ones that are infinite. Like `count`:
 

branches/auto/src/doc/trpl/more-strings.md

@@ -38,9 +38,8 @@ string literal or a `String`.
 
 # String
 
-A `String` is a heap-allocated string. This string is growable, and is
-also guaranteed to be UTF-8. `String`s are commonly created by
-converting from a string slice using the `to_string` method.
+A `String` is a heap-allocated string. This string is growable, and is also
+guaranteed to be UTF-8.
 
 ```
 let mut s = "Hello".to_string();
@@ -50,7 +49,7 @@ s.push_str(", world.");
 println!("{}", s);
 ```
 
-A reference to a `String` will automatically coerce to a string slice:
+You can coerce a `String` into a `&str` by dereferencing it:
 
 ```
 fn takes_slice(slice: &str) {
@@ -59,7 +58,7 @@ fn takes_slice(slice: &str) {
 
 fn main() {
     let s = "Hello".to_string();
-    takes_slice(&s);
+    takes_slice(&*s);
 }
 ```
 

branches/auto/src/doc/trpl/static-and-dynamic-dispatch.md

@@ -79,11 +79,10 @@ fn main() {
 }
 ```
 
-This has a great upside: static dispatch allows function calls to be
-inlined because the callee is known at compile time, and inlining is
-the key to good optimization. Static dispatch is fast, but it comes at
-a tradeoff: 'code bloat', due to many copies of the same function
-existing in the binary, one for each type.
+This has some upsides: static dispatching of any method calls, allowing for
+inlining and hence usually higher performance. It also has some downsides:
+causing code bloat due to many copies of the same function existing in the
+binary, one for each type.
 
 Furthermore, compilers aren’t perfect and may “optimize” code to become slower.
 For example, functions inlined too eagerly will bloat the instruction cache

branches/auto/src/doc/trpl/strings.md

@@ -25,10 +25,8 @@ compiled program, and exists for the entire duration it runs. The `string`
 binding is a reference to this statically allocated string. String slices
 have a fixed size, and cannot be mutated.
 
-A `String`, on the other hand, is a heap-allocated string. This string
-is growable, and is also guaranteed to be UTF-8. `String`s are
-commonly created by converting from a string slice using the
-`to_string` method.
+A `String`, on the other hand, is an in-memory string.  This string is
+growable, and is also guaranteed to be UTF-8.
 
 ```{rust}
 let mut s = "Hello".to_string(); // mut s: String