---

yaml
---
r: 187385
b: refs/heads/try
c: 79bf783
h: refs/heads/master
i:
  187383: 518e0cb
v: v3

Author: alexcrichton

[refs]

@@ -2,7 +2,7 @@
 refs/heads/master: b4c965ee803a4521d8b4575f634e036f93e408f3
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 3a96d6a9818fe2affc98a187fb1065120458cee9
-refs/heads/try: 6c6f2317bae63261123cd94ebe214e80fb6ad78e
+refs/heads/try: 79bf783ebf41c756641e90f4295fbf98cd8a11ba
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/try/README.md

@@ -15,34 +15,28 @@ Read ["Installing Rust"] from [The Book].
 ## Building from Source
 
 1. Make sure you have installed the dependencies:
-
-   * `g++` 4.7 or `clang++` 3.x
-   * `python` 2.6 or later (but not 3.x)
-   * GNU `make` 3.81 or later
-   * `curl`
-   * `git`
+    * `g++` 4.7 or `clang++` 3.x
+    * `python` 2.6 or later (but not 3.x)
+    * GNU `make` 3.81 or later
+    * `curl`
+    * `git`
 
 2. Clone the [source] with `git`:
 
-   ```sh
-   $ git clone https://github.com/rust-lang/rust.git
-   $ cd rust
-   ```
+        $ git clone https://github.com/rust-lang/rust.git
+        $ cd rust
 
 [source]: https://github.com/rust-lang/rust
 
 3. Build and install:
 
-    ```sh
-    $ ./configure
-    $ make && make install
-    ```
+        $ ./configure
+        $ make && make install
 
-    > ***Note:*** You may need to use `sudo make install` if you do not
-    > normally have permission to modify the destination directory. The
-    > install locations can be adjusted by passing a `--prefix` argument
-    > to `configure`. Various other options are also supported – pass
-    > `--help` for more information on them.
+    > ***Note:*** You may need to use `sudo make install` if you do not normally have
+    > permission to modify the destination directory. The install locations can
+    > be adjusted by passing a `--prefix` argument to `configure`. Various other
+    > options are also supported, pass `--help` for more information on them.
 
     When complete, `make install` will place several programs into
     `/usr/local/bin`: `rustc`, the Rust compiler, and `rustdoc`, the
@@ -53,30 +47,27 @@ Read ["Installing Rust"] from [The Book].
 
 ### Building on Windows
 
-[MSYS2](http://msys2.github.io/) can be used to easily build Rust on Windows:
+To easily build on windows we can use [MSYS2](http://msys2.github.io/):
 
 1. Grab the latest MSYS2 installer and go through the installer.
+2. Now from the MSYS2 terminal we want to install the mingw64 toolchain and the other
+   tools we need.
 
-2. From the MSYS2 terminal, install the `mingw64` toolchain and other required
-   tools.
-
-   ```sh
-   # Choose one based on platform:
-   $ pacman -S mingw-w64-i686-toolchain
-   $ pacman -S mingw-w64-x86_64-toolchain
-   
-   $ pacman -S base-devel
-   ```
+```bash
+# choose one based on platform
+$ pacman -S mingw-w64-i686-toolchain
+$ pacman -S mingw-w64-x86_64-toolchain
 
-3. Run `mingw32_shell.bat` or `mingw64_shell.bat` from wherever you installed
-   MYSY2 (i.e. `C:\msys`), depending on whether you want 32-bit or 64-bit Rust.
+$ pacman -S base-devel
+```
 
-4. Navigate to Rust's source code, configure and build it:
+3. With that now start `mingw32_shell.bat` or `mingw64_shell.bat`
+   from where you installed MSYS2 (i.e. `C:\msys`). Which one you
+   choose depends on if you want 32 or 64 bit Rust.
+4. From there just navigate to where you have Rust's source code, configure and build it:
 
-   ```sh
-   $ ./configure
-   $ make && make install
-   ```
+        $ ./configure
+        $ make && make install
 
 ## Notes
 
@@ -101,15 +92,15 @@ There is more advice about hacking on Rust in [CONTRIBUTING.md].
 
 [CONTRIBUTING.md]: https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md
 
-## Getting Help
+## Getting help
 
 The Rust community congregates in a few places:
 
-* [Stack Overflow] - Direct questions about using the language.
-* [users.rust-lang.org] - General discussion and broader questions.
+* [StackOverflow] - Direct questions about using the language here.
+* [users.rust-lang.org] - General discussion, broader questions.
 * [/r/rust] - News and general discussion.
 
-[Stack Overflow]: http://stackoverflow.com/questions/tagged/rust
+[StackOverflow]: http://stackoverflow.com/questions/tagged/rust
 [/r/rust]: http://reddit.com/r/rust
 [users.rust-lang.org]: http://users.rust-lang.org/
 
@@ -120,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/try/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/try/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,

branches/try/src/compiletest/runtest.rs

@@ -89,7 +89,7 @@ fn run_cfail_test(config: &Config, props: &TestProps, testfile: &Path) {
     let proc_res = compile_test(config, props, testfile);
 
     if proc_res.status.success() {
-        fatal_proc_rec(&format!("{} test compiled successfully!", config.mode)[..],
+        fatal_proc_rec(&format!("{} test compiled successfully!", config.mode)[],
                       &proc_res);
     }
 
@@ -398,7 +398,7 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             for line in breakpoint_lines.iter() {
                 script_str.push_str(&format!("break {:?}:{}\n",
                                              testfile.filename_display(),
-                                             *line)[..]);
+                                             *line)[]);
             }
             script_str.push_str(&cmds);
             script_str.push_str("quit\n");
@@ -553,17 +553,17 @@ fn run_debuginfo_gdb_test(config: &Config, props: &TestProps, testfile: &Path) {
             script_str.push_str("set print pretty off\n");
 
             // Add the pretty printer directory to GDB's source-file search path
-            script_str.push_str(&format!("directory {}\n", rust_pp_module_abs_path)[..]);
+            script_str.push_str(&format!("directory {}\n", rust_pp_module_abs_path)[]);
 
             // Load the target executable
             script_str.push_str(&format!("file {}\n",
-                                         exe_file.as_str().unwrap().replace("\\", "\\\\"))[..]);
+                                         exe_file.as_str().unwrap().replace("\\", "\\\\"))[]);
 
             // Add line breakpoints
             for line in &breakpoint_lines {
                 script_str.push_str(&format!("break '{}':{}\n",
                                              testfile.filename_display(),
-                                             *line)[..]);
+                                             *line)[]);
             }
 
             script_str.push_str(&cmds);
@@ -689,7 +689,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
                                                .unwrap()
                                                .to_string();
 
-    script_str.push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[..])[..]);
+    script_str.push_str(&format!("command script import {}\n", &rust_pp_module_abs_path[..])[]);
     script_str.push_str("type summary add --no-value ");
     script_str.push_str("--python-function lldb_rust_formatters.print_val ");
     script_str.push_str("-x \".*\" --category Rust\n");

branches/try/src/doc/index.md

@@ -68,7 +68,7 @@ There are questions that are asked quite often, and so we've made FAQs for them:
 * [Language Design FAQ](complement-design-faq.html)
 * [Language FAQ](complement-lang-faq.html)
 * [Project FAQ](complement-project-faq.html)
-* [How to submit a bug report](https://github.com/rust-lang/rust/blob/master/CONTRIBUTING.md#bug-reports)
+* [How to submit a bug report](complement-bugreport.html)
 
 # The standard library
 

branches/try/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();
+    }
 }
 ```