---

yaml
---
r: 192437
b: refs/heads/auto
c: 4a81e66
h: refs/heads/master
i:
  192435: 3acc7f5
v: v3

Author: steveklabnik

[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: fcf2ba794ec9522296db1df438e89dc70e447f59
+refs/heads/auto: 4a81e66b44f6e7dbbd8741b562ea7f6ac4d799bc
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/src/compiletest/compiletest.rs

@@ -20,8 +20,6 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(path_ext)]
-#![feature(convert)]
-#![feature(str_char)]
 
 #![deny(warnings)]
 
@@ -117,7 +115,7 @@ pub fn parse_config(args: Vec<String> ) -> Config {
 
     fn opt_path(m: &getopts::Matches, nm: &str) -> PathBuf {
         match m.opt_str(nm) {
-            Some(s) => PathBuf::from(&s),
+            Some(s) => PathBuf::new(&s),
             None => panic!("no option (=path) found for {}", nm),
         }
     }
@@ -132,18 +130,18 @@ pub fn parse_config(args: Vec<String> ) -> Config {
         compile_lib_path: matches.opt_str("compile-lib-path").unwrap(),
         run_lib_path: matches.opt_str("run-lib-path").unwrap(),
         rustc_path: opt_path(matches, "rustc-path"),
-        clang_path: matches.opt_str("clang-path").map(|s| PathBuf::from(&s)),
+        clang_path: matches.opt_str("clang-path").map(|s| PathBuf::new(&s)),
         valgrind_path: matches.opt_str("valgrind-path"),
         force_valgrind: matches.opt_present("force-valgrind"),
-        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| PathBuf::from(&s)),
+        llvm_bin_path: matches.opt_str("llvm-bin-path").map(|s| PathBuf::new(&s)),
         src_base: opt_path(matches, "src-base"),
         build_base: opt_path(matches, "build-base"),
         aux_base: opt_path(matches, "aux-base"),
         stage_id: matches.opt_str("stage-id").unwrap(),
         mode: matches.opt_str("mode").unwrap().parse().ok().expect("invalid mode"),
         run_ignored: matches.opt_present("ignored"),
         filter: filter,
-        logfile: matches.opt_str("logfile").map(|s| PathBuf::from(&s)),
+        logfile: matches.opt_str("logfile").map(|s| PathBuf::new(&s)),
         runtool: matches.opt_str("runtool"),
         host_rustcflags: matches.opt_str("host-rustcflags"),
         target_rustcflags: matches.opt_str("target-rustcflags"),

branches/auto/src/compiletest/header.rs

@@ -328,10 +328,10 @@ fn parse_exec_env(line: &str) -> Option<(String, String)> {
 
 fn parse_pp_exact(line: &str, testfile: &Path) -> Option<PathBuf> {
     match parse_name_value_directive(line, "pp-exact") {
-      Some(s) => Some(PathBuf::from(&s)),
+      Some(s) => Some(PathBuf::new(&s)),
       None => {
         if parse_name_directive(line, "pp-exact") {
-            testfile.file_name().map(|s| PathBuf::from(s))
+            testfile.file_name().map(|s| PathBuf::new(s))
         } else {
             None
         }

branches/auto/src/compiletest/runtest.rs

@@ -1440,7 +1440,7 @@ fn aux_output_dir_name(config: &Config, testfile: &Path) -> PathBuf {
 }
 
 fn output_testname(testfile: &Path) -> PathBuf {
-    PathBuf::from(testfile.file_stem().unwrap())
+    PathBuf::new(testfile.file_stem().unwrap())
 }
 
 fn output_base_name(config: &Config, testfile: &Path) -> PathBuf {

branches/auto/src/doc/intro.md

@@ -446,16 +446,16 @@ It gives us this error:
 error: aborting due to previous error
 ```
 
-This is a little confusing because there are two closures here: the one passed
-to `map`, and the one passed to `thread::scoped`. In this case, the closure for
-`thread::scoped` is attempting to reference `numbers`, a `Vec<i32>`. This
-closure is a `FnOnce` closure, as that’s what `thread::scoped` takes as an
-argument. `FnOnce` closures take ownership of their environment. That’s fine,
-but there’s one detail: because of `map`, we’re going to make three of these
-closures. And since all three try to take ownership of `numbers`, that would be
-a problem. That’s what it means by ‘cannot move out of captured outer
-variable’: our `thread::scoped` closure wants to take ownership, and it can’t,
-because the closure for `map` won’t let it.
+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.
 
 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

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

@@ -1,6 +1,6 @@
 % Crates and Modules
 
-When a project starts getting large, it's considered good software
+When a project starts getting large, it's considered a good software
 engineering practice to split it up into a bunch of smaller pieces, and then
 fit them together. It's also important to have a well-defined interface, so
 that some of your functionality is private, and some is public. To facilitate
@@ -24,23 +24,23 @@ in different languages. To keep things simple, we'll stick to "greetings" and
 two languages for those phrases to be in. We'll use this module layout:
 
 ```text
-                                    +-----------+
-                                +---| greetings |
-                                |   +-----------+
-                  +---------+   |
-              +---| english |---+
-              |   +---------+   |   +-----------+
-              |                 +---| farewells |
-+---------+   |                     +-----------+
+                                +-----------+
+                            +---| greetings |
+                            |   +-----------+
+              +---------+   |
+              | english |---+
+              +---------+   |   +-----------+
+              |             +---| farewells |
++---------+   |                 +-----------+
 | phrases |---+
-+---------+   |                     +-----------+
-              |                 +---| greetings |
-              |   +----------+  |   +-----------+
-              +---| japanese |--+
-                  +----------+  |
-                                |   +-----------+
-                                +---| farewells |
-                                    +-----------+
++---------+   |                  +-----------+
+              |              +---| greetings |
+              +----------+   |   +-----------+
+              | japanese |---+
+              +----------+   |
+                             |   +-----------+
+                             +---| farewells |
+                                 +-----------+
 ```
 
 In this example, `phrases` is the name of our crate. All of the rest are
@@ -76,19 +76,25 @@ To define each of our modules, we use the `mod` keyword. Let's make our
 `src/lib.rs` look like this:
 
 ```
+// in src/lib.rs
+
 mod english {
     mod greetings {
+
     }
 
     mod farewells {
+
     }
 }
 
 mod japanese {
     mod greetings {
+
     }
 
     mod farewells {
+
     }
 }
 ```
@@ -139,7 +145,11 @@ mod english;
 ```
 
 If we do that, Rust will expect to find either a `english.rs` file, or a
-`english/mod.rs` file with the contents of our module.
+`english/mod.rs` file with the contents of our module:
+
+```{rust,ignore}
+// contents of our module go here
+```
 
 Note that in these files, you don't need to re-declare the module: that's
 already been done with the initial `mod` declaration.
@@ -171,7 +181,10 @@ $ tree .
 `src/lib.rs` is our crate root, and looks like this:
 
 ```{rust,ignore}
+// in src/lib.rs
+
 mod english;
+
 mod japanese;
 ```
 
@@ -182,7 +195,10 @@ chosen the second. Both `src/english/mod.rs` and `src/japanese/mod.rs` look
 like this:
 
 ```{rust,ignore}
+// both src/english/mod.rs and src/japanese/mod.rs
+
 mod greetings;
+
 mod farewells;
 ```
 
@@ -198,6 +214,8 @@ both empty at the moment. Let's add some functions.
 Put this in `src/english/greetings.rs`:
 
 ```rust
+// in src/english/greetings.rs
+
 fn hello() -> String {
     "Hello!".to_string()
 }
@@ -206,6 +224,8 @@ fn hello() -> String {
 Put this in `src/english/farewells.rs`:
 
 ```rust
+// in src/english/farewells.rs
+
 fn goodbye() -> String {
     "Goodbye.".to_string()
 }
@@ -228,6 +248,8 @@ about the module system.
 Put this in `src/japanese/farewells.rs`:
 
 ```rust
+// in src/japanese/farewells.rs
+
 fn goodbye() -> String {
     "さようなら".to_string()
 }
@@ -243,9 +265,11 @@ another crate.
 We have a library crate. Let's make an executable crate that imports and uses
 our library.
 
-Make a `src/main.rs` and put this in it (it won't quite compile yet):
+Make a `src/main.rs` and put this in it: (it won't quite compile yet)
 
 ```rust,ignore
+// in src/main.rs
+
 extern crate phrases;
 
 fn main() {
@@ -296,6 +320,8 @@ keyword. Let's focus on the `english` module first, so let's reduce our `src/mai
 to just this:
 
 ```{rust,ignore}
+// in src/main.rs
+
 extern crate phrases;
 
 fn main() {
@@ -307,20 +333,28 @@ fn main() {
 In our `src/lib.rs`, let's add `pub` to the `english` module declaration:
 
 ```{rust,ignore}
+// in src/lib.rs
+
 pub mod english;
+
 mod japanese;
 ```
 
 And in our `src/english/mod.rs`, let's make both `pub`:
 
 ```{rust,ignore}
+// in src/english/mod.rs
+
 pub mod greetings;
+
 pub mod farewells;
 ```
 
 In our `src/english/greetings.rs`, let's add `pub` to our `fn` declaration:
 
 ```{rust,ignore}
+// in src/english/greetings.rs
+
 pub fn hello() -> String {
     "Hello!".to_string()
 }
@@ -329,6 +363,8 @@ pub fn hello() -> String {
 And also in `src/english/farewells.rs`:
 
 ```{rust,ignore}
+// in src/english/farewells.rs
+
 pub fn goodbye() -> String {
     "Goodbye.".to_string()
 }
@@ -364,6 +400,8 @@ Rust has a `use` keyword, which allows us to import names into our local scope.
 Let's change our `src/main.rs` to look like this:
 
 ```{rust,ignore}
+// in src/main.rs
+
 extern crate phrases;
 
 use phrases::english::greetings;
@@ -422,19 +460,21 @@ Could not compile `phrases`.
 ```
 
 If we're importing multiple names from the same module, we don't have to type it out
-twice. Instead of this:
+twice. Rust has a shortcut syntax for writing this:
 
 ```{rust,ignore}
 use phrases::english::greetings;
 use phrases::english::farewells;
 ```
 
-We can use this shortcut:
+You use curly braces:
 
 ```{rust,ignore}
 use phrases::english::{greetings, farewells};
 ```
 
+These two declarations are equivalent, but the second is a lot less typing.
+
 ## Re-exporting with `pub use`
 
 You don't just use `use` to shorten identifiers. You can also use it inside of your crate
@@ -444,6 +484,8 @@ interface that may not directly map to your internal code organization.
 Let's look at an example. Modify your `src/main.rs` to read like this:
 
 ```{rust,ignore}
+// in src/main.rs
+
 extern crate phrases;
 
 use phrases::english::{greetings,farewells};
@@ -461,13 +503,18 @@ fn main() {
 Then, modify your `src/lib.rs` to make the `japanese` mod public:
 
 ```{rust,ignore}
+// in src/lib.rs
+
 pub mod english;
+
 pub mod japanese;
 ```
 
 Next, make the two functions public, first in `src/japanese/greetings.rs`:
 
 ```{rust,ignore}
+// in src/japanese/greetings.rs
+
 pub fn hello() -> String {
     "こんにちは".to_string()
 }
@@ -476,6 +523,8 @@ pub fn hello() -> String {
 And then in `src/japanese/farewells.rs`:
 
 ```{rust,ignore}
+// in src/japanese/farewells.rs
+
 pub fn goodbye() -> String {
     "さようなら".to_string()
 }
@@ -484,10 +533,13 @@ pub fn goodbye() -> String {
 Finally, modify your `src/japanese/mod.rs` to read like this:
 
 ```{rust,ignore}
+// in src/japanese/mod.rs
+
 pub use self::greetings::hello;
 pub use self::farewells::goodbye;
 
 mod greetings;
+
 mod farewells;
 ```