---

yaml
---
r: 212574
b: refs/heads/auto
c: d6b7ca0
h: refs/heads/master
v: v3

Author: Kimundi

[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: 5ea3ed0fd0ee8c17ddfdfee58381053a849fdd03
+refs/heads/auto: d6b7ca041a68a9056b2295a3901800c727ccee03
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/mk/cfg/x86_64-pc-windows-msvc.mk

@@ -9,8 +9,8 @@ CFG_STATIC_LIB_NAME_x86_64-pc-windows-msvc=$(1).lib
 CFG_LIB_GLOB_x86_64-pc-windows-msvc=$(1)-*.dll
 CFG_LIB_DSYM_GLOB_x86_64-pc-windows-msvc=$(1)-*.dylib.dSYM
 CFG_JEMALLOC_CFLAGS_x86_64-pc-windows-msvc :=
-CFG_GCCISH_CFLAGS_x86_64-pc-windows-msvc := -MD
-CFG_GCCISH_CXXFLAGS_x86_64-pc-windows-msvc := -MD
+CFG_GCCISH_CFLAGS_x86_64-pc-windows-msvc :=
+CFG_GCCISH_CXXFLAGS_x86_64-pc-windows-msvc :=
 CFG_GCCISH_LINK_FLAGS_x86_64-pc-windows-msvc :=
 CFG_GCCISH_DEF_FLAG_x86_64-pc-windows-msvc :=
 CFG_LLC_FLAGS_x86_64-pc-windows-msvc :=

branches/auto/mk/docs.mk

@@ -169,7 +169,6 @@ DOC_TARGETS += doc/not_found.html
 doc/not_found.html: $(D)/not_found.md $(HTML_DEPS) | doc/
 	@$(call E, rustdoc: $@)
 	$(Q)$(RUSTDOC) $(RUSTDOC_HTML_OPTS_NO_CSS) \
-		--markdown-no-toc \
 		--markdown-css http://doc.rust-lang.org/rust.css $<
 
 define DEF_DOC

branches/auto/src/compiletest/runtest.rs

@@ -651,7 +651,7 @@ fn run_debuginfo_lldb_test(config: &Config, props: &TestProps, testfile: &Path)
 
     // Write debugger script:
     // We don't want to hang when calling `quit` while the process is still running
-    let mut script_str = String::from("settings set auto-confirm true\n");
+    let mut script_str = String::from_str("settings set auto-confirm true\n");
 
     // Make LLDB emit its version, so we have it documented in the test output
     script_str.push_str("version\n");

branches/auto/src/doc/not_found.md

@@ -11,20 +11,20 @@ Looks like you've taken a wrong turn.
 
 Some things that might be helpful to you though:
 
-# Search
+## Search
 
 * <form action="https://duckduckgo.com/">
     <input type="text" id="site-search" name="q" size="80"></input>
     <input type="submit" value="Search DuckDuckGo">
 </form>
 * Rust doc search: <span id="core-search"></span>
 
-# Reference
+## Reference
 
 * [The Rust official site](http://rust-lang.org)
 * [The Rust reference](http://doc.rust-lang.org/reference.html)
 
-# Docs
+## Docs
 
 * [The standard library](http://doc.rust-lang.org/std/)
 

branches/auto/src/doc/reference.md

@@ -1038,7 +1038,7 @@ be undesired.
 
 * Deadlocks
 * Reading data from private fields (`std::repr`)
-* Leaks of memory and other resources
+* Leaks due to reference count cycles, even in the global heap
 * Exiting without calling destructors
 * Sending signals
 * Accessing/modifying the file system
@@ -1367,6 +1367,7 @@ Traits can include default implementations of methods, as in:
 ```
 trait Foo {
     fn bar(&self);
+
     fn baz(&self) { println!("We called baz."); }
 }
 ```
@@ -1417,13 +1418,9 @@ impl<T> Container for Vec<T> {
 ```
 
 Generic functions may use traits as _bounds_ on their type parameters. This
-will have two effects:
-
-- Only types that have the trait may instantiate the parameter.
-- Within the generic function, the methods of the trait can be
-  called on values that have the parameter's type.
-
-For example:
+will have two effects: only types that have the trait may instantiate the
+parameter, and within the generic function, the methods of the trait can be
+called on values that have the parameter's type. For example:
 
 ```
 # type Surface = i32;
@@ -2834,13 +2831,13 @@ on the right-hand side.
 An example of an `as` expression:
 
 ```
-# fn sum(values: &[f64]) -> f64 { 0.0 }
-# fn len(values: &[f64]) -> i32 { 0 }
+# fn sum(v: &[f64]) -> f64 { 0.0 }
+# fn len(v: &[f64]) -> i32 { 0 }
 
-fn average(values: &[f64]) -> f64 {
-  let sum: f64 = sum(values);
-  let size: f64 = len(values) as f64;
-  sum / size
+fn avg(v: &[f64]) -> f64 {
+  let sum: f64 = sum(v);
+  let sz: f64 = len(v) as f64;
+  return sum / sz;
 }
 ```
 

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

@@ -33,8 +33,8 @@ let plus_two = |x| {
 assert_eq!(4, plus_two(2));
 ```
 
-You’ll notice a few things about closures that are a bit different from regular
-functions defined with `fn`. The first is that we did not need to
+You’ll notice a few things about closures that are a bit different than regular
+functions defined with `fn`. The first of which is that we did not need to
 annotate the types of arguments the closure takes or the values it returns. We
 can:
 
@@ -48,18 +48,18 @@ But we don’t have to. Why is this? Basically, it was chosen for ergonomic reas
 While specifying the full type for named functions is helpful with things like
 documentation and type inference, the types of closures are rarely documented
 since they’re anonymous, and they don’t cause the kinds of error-at-a-distance
-problems that inferring named function types can.
+that inferring named function types can.
 
 The second is that the syntax is similar, but a bit different. I’ve added spaces
-here for easier comparison:
+here to make them look a little closer:
 
 ```rust
 fn  plus_one_v1   (x: i32) -> i32 { x + 1 }
 let plus_one_v2 = |x: i32| -> i32 { x + 1 };
 let plus_one_v3 = |x: i32|          x + 1  ;
 ```
 
-Small differences, but they’re similar.
+Small differences, but they’re similar in ways.
 
 # Closures and their environment
 
@@ -99,7 +99,7 @@ note: previous borrow ends here
 fn main() {
     let mut num = 5;
     let plus_num = |x| x + num;
-
+    
     let y = &mut num;
 }
 ^
@@ -161,7 +161,7 @@ of `num`. So what’s the difference?
 ```rust
 let mut num = 5;
 
-{
+{ 
     let mut add_num = |x: i32| num += x;
 
     add_num(5);
@@ -180,7 +180,7 @@ If we change to a `move` closure, it’s different:
 ```rust
 let mut num = 5;
 
-{
+{ 
     let mut add_num = move |x: i32| num += x;
 
     add_num(5);

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

@@ -29,9 +29,6 @@ The other kind of comment is a doc comment. Doc comments use `///` instead of
 /// let five = 5;
 ///
 /// assert_eq!(6, add_one(5));
-/// # fn add_one(x: i32) -> i32 {
-/// #     x + 1
-/// # }
 /// ```
 fn add_one(x: i32) -> i32 {
     x + 1

branches/auto/src/doc/trpl/const-and-static.md

@@ -64,10 +64,7 @@ unsafe {
 
 [unsafe]: unsafe.html
 
-Furthermore, any type stored in a `static` must be `Sync`, and may not have
-a [`Drop`][drop] implementation.
-
-[drop]: drop.html
+Furthermore, any type stored in a `static` must be `Sync`.
 
 # Initializing
 
@@ -81,3 +78,7 @@ Almost always, if you can choose between the two, choose `const`. It’s pretty
 rare that you actually want a memory location associated with your constant,
 and using a const allows for optimizations like constant propagation not only
 in your crate but downstream crates.
+
+A const can be thought of as a `#define` in C: it has metadata overhead but it
+has no runtime overhead. “Should I use a #define or a static in C,” is largely
+the same question as whether you should use a const or a static in Rust.

branches/auto/src/doc/trpl/dining-philosophers.md

@@ -432,9 +432,7 @@ an extra annotation, `move`, to indicate that the closure is going to take
 ownership of the values it’s capturing. Primarily, the `p` variable of the
 `map` function.
 
-Inside the thread, all we do is call `eat()` on `p`. Also note that the call to `thread::spawn` lacks a trailing semicolon, making this an expression. This distinction is important, yielding the correct return value. For more details, read [Expressions vs. Statements][es].
-
-[es]: functions.html#expressions-vs.-statements
+Inside the thread, all we do is call `eat()` on `p`.
 
 ```rust,ignore
 }).collect();
@@ -674,13 +672,9 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 
 Finally, inside of our `map()`/`collect()` loop, we call `table.clone()`. The
 `clone()` method on `Arc<T>` is what bumps up the reference count, and when it
-goes out of scope, it decrements the count. This is needed so that we know how
-many references to `table` exist across our threads. If we didn’t have a count,
-we wouldn’t know how to deallocate it.
-
-You’ll notice we can introduce a new binding to `table` here, and it will
-shadow the old one. This is often used so that you don’t need to come up with
-two unique names.
+goes out of scope, it decrements the count. You’ll notice we can introduce a
+new binding to `table` here, and it will shadow the old one. This is often used
+so that you don’t need to come up with two unique names.
 
 With this, our program works! Only two philosophers can eat at any one time,
 and so you’ll get some output like this:

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

@@ -284,7 +284,7 @@ struct Info {
 }
 
 fn write_info(info: &Info) -> io::Result<()> {
-    let mut file = File::create("my_best_friends.txt").unwrap();
+    let mut file = try!(File::create("my_best_friends.txt"));
 
     try!(writeln!(&mut file, "name: {}", info.name));
     try!(writeln!(&mut file, "age: {}", info.age));

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

@@ -342,10 +342,8 @@ Note that frameworks are only available on OSX targets.
 The different `kind` values are meant to differentiate how the native library
 participates in linkage. From a linkage perspective, the rust compiler creates
 two flavors of artifacts: partial (rlib/staticlib) and final (dylib/binary).
-Native dynamic library and framework dependencies are propagated to the final
-artifact boundary, while static library dependencies are not propagated at
-all, because the static libraries are integrated directly into the subsequent
-artifact.
+Native dynamic libraries and frameworks are propagated to the final artifact
+boundary, while static libraries are not propagated at all.
 
 A few examples of how this model can be used are:
 

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

@@ -1,8 +1,8 @@
 % Generics
 
 Sometimes, when writing a function or data type, we may want it to work for
-multiple types of arguments. In Rust, we can do this with generics.
-Generics are called ‘parametric polymorphism’ in type theory,
+multiple types of arguments. Luckily, Rust has a feature that gives us a better
+way: generics. Generics are called ‘parametric polymorphism’ in type theory,
 which means that they are types or functions that have multiple forms (‘poly’
 is multiple, ‘morph’ is form) over a given parameter (‘parametric’).
 

branches/auto/src/doc/trpl/hello-cargo.md

@@ -36,7 +36,7 @@ Note that since we're creating an executable, we used `main.rs`. If we
 want to make a library instead, we should use `lib.rs`. This convention is required
 for Cargo to successfully compile our projects, but it can be overridden if we wish. 
 Custom file locations for the entry point can be specified
-with a [`[lib]` or `[[bin]]`][crates-custom] key in the TOML file.
+with a [`[[lib]]` or `[[bin]]`][crates-custom] key in the TOML file described below.
 
 [crates-custom]: http://doc.crates.io/manifest.html#configuring-a-target
 
@@ -170,7 +170,7 @@ This is all we need to get started. First, let’s check out `Cargo.toml`:
 [package]
 
 name = "hello_world"
-version = "0.1.0"
+version = "0.0.1"
 authors = ["Your Name <[email protected]>"]
 ```
 

branches/auto/src/doc/trpl/method-syntax.md

@@ -86,8 +86,8 @@ impl Circle {
 # Chaining method calls
 
 So, now we know how to call a method, such as `foo.bar()`. But what about our
-original example, `foo.bar().baz()`? This is called ‘method chaining’. Let’s
-look at an example:
+original example, `foo.bar().baz()`? This is called ‘method chaining’, and we
+can do it by returning `self`.
 
 ```rust
 struct Circle {

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

@@ -156,46 +156,6 @@ that, just like a move, when we assign `v` to `v2`, a copy of the data is made.
 But, unlike a move, we can still use `v` afterward. This is because an `i32`
 has no pointers to data somewhere else, copying it is a full copy.
 
-All primitive types implement the `Copy` trait and their ownership is
-therefore not moved like one would assume, following the ´ownership rules´.
-To give an example, the two following snippets of code only compile because the 
-`i32` and `bool` types implement the `Copy` trait. 
-
-```rust
-fn main() {
-    let a = 5;
-
-    let _y = double(a);
-    println!("{}", a);
-}
-
-fn double(x: i32) -> i32 {
-    x * 2
-}
-```
-
-```rust
-fn main() {
-    let a = true;
-
-    let _y = change_truth(a);
-    println!("{}", a);
-}
-
-fn change_truth(x: bool) -> bool {
-    !x
-}
-```
-
-If we would have used types that do not implement the `Copy` trait,
-we would have gotten a compile error because we tried to use a moved value.
-
-```text
-error: use of moved value: `a`
-println!("{}", a);
-               ^
-```
-
 We will discuss how to make your own types `Copy` in the [traits][traits]
 section.
 

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

@@ -154,31 +154,6 @@ match x {
 
 This prints `Got an int!`.
 
-If you’re using `if` with multiple patterns, the `if` applies to both sides:
-
-```rust
-let x = 4;
-let y = false;
-
-match x {
-    4 | 5 if y => println!("yes"),
-    _ => println!("no"),
-}
-```
-
-This prints `no`, because the `if` applies to the whole of `4 | 5`, and not to
-just the `5`, In other words, the the precedence of `if` behaves like this:
-
-```text
-(4 | 5) if y => ...
-```
-
-not this:
-
-```text
-4 | (5 if y) => ...
-```
-
 # ref and ref mut
 
 If you want to get a [reference][ref], use the `ref` keyword:

branches/auto/src/doc/trpl/references-and-borrowing.md

@@ -151,9 +151,9 @@ As it turns out, there are rules.
 
 Here’s the rules about borrowing in Rust:
 
-First, any borrow must last for a scope no greater than that of the owner.
-Second, you may have one or the other of these two kinds of borrows, but not
-both at the same time:
+First, any borrow must last for a smaller scope than the owner. Second, you may
+have one or the other of these two kinds of borrows, but not both at the same
+time:
 
 * one or more references (`&T`) to a resource.
 * exactly one mutable reference (`&mut T`)