---

yaml
---
r: 208601
b: refs/heads/snap-stage3
c: 6a045b9
h: refs/heads/master
i:
  208599: 162c30e
v: v3

Author: eddyb

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2da9efefca51b1ba2e173ad3136812eacc0c1ce7
+refs/heads/snap-stage3: 6a045b9d1c3c6419d1e4f9cfcd1d81359d0859f8
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/README.md

@@ -1,11 +1,9 @@
 # The Rust Programming Language
 
-Rust is a systems programming language that is fast, memory safe and
-multithreaded, but does not employ a garbage collector or otherwise
-impose significant runtime overhead.
-
-This repo contains the code for `rustc`, the Rust compiler, as well
-as standard libraries, tools and documentation for Rust.
+This is a compiler for Rust, including standard libraries, tools and
+documentation. Rust is a systems programming language that is fast,
+memory safe and multithreaded, but does not employ a garbage collector
+or otherwise impose significant runtime overhead.
 
 ## Quick Start
 

branches/snap-stage3/configure

@@ -106,8 +106,8 @@ probe() {
         T=$(command -v $P 2>&1)
         if [ $? -eq 0 ]
         then
-            VER0=$($P --version 2>/dev/null \
-                |  grep -o '[vV]\?[0-9][0-9.][a-z0-9.-]*' | head -1 )
+            VER0=$($P --version 2>/dev/null | head -1 \
+                |  sed -e 's/[^0-9]*\([vV]\?[0-9.]\+[^ ]*\).*/\1/' )
             if [ $? -eq 0 -a "x${VER0}" != "x" ]
             then
               VER="($VER0)"
@@ -711,20 +711,6 @@ else
     probe_need CFG_GIT     git
 fi
 
-# Use `md5sum` on GNU platforms, or `md5 -q` on BSD
-probe CFG_MD5              md5
-probe CFG_MD5SUM           md5sum
-if [ -n "$CFG_MD5" ]
-then
-    CFG_HASH_COMMAND="$CFG_MD5 -q | head -c 8"
-elif [ -n "$CFG_MD5SUM" ]
-then
-    CFG_HASH_COMMAND="$CFG_MD5SUM | head -c 8"
-else
-    err 'could not find one of: md5 md5sum'
-fi
-putvar CFG_HASH_COMMAND
-
 probe CFG_CLANG            clang++
 probe CFG_CCACHE           ccache
 probe CFG_GCC              gcc

branches/snap-stage3/mk/main.mk

@@ -13,16 +13,14 @@
 ######################################################################
 
 # The version number
-CFG_RELEASE_NUM=1.2.0
+CFG_RELEASE_NUM=1.1.0
 
 # An optional number to put after the label, e.g. '.2' -> '-beta.2'
 # NB Make sure it starts with a dot to conform to semver pre-release
 # versions (section 9)
 CFG_PRERELEASE_VERSION=.1
 
-# Append a version-dependent hash to each library, so we can install different
-# versions in the same place
-CFG_FILENAME_EXTRA=$(shell printf '%s' $(CFG_RELEASE) | $(CFG_HASH_COMMAND))
+CFG_FILENAME_EXTRA=4e7c5e5c
 
 ifeq ($(CFG_RELEASE_CHANNEL),stable)
 # This is the normal semver version string, e.g. "0.12.0", "0.12.0-nightly"

branches/snap-stage3/src/doc/complement-design-faq.md

@@ -79,7 +79,7 @@ feature.
 A nice replacement is the [lazy constructor macro][lcm] by [Marvin
 Löbel][kim].
 
-[fqa]: http://yosefk.com/c++fqa/ctors.html#fqa-10.12
+[fqa]: https://mail.mozilla.org/pipermail/rust-dev/2013-April/003815.html
 [elp]: http://ericlippert.com/2013/02/06/static-constructors-part-one/
 [lcm]: https://gist.github.com/Kimundi/8782487
 [kim]: https://github.com/Kimundi

branches/snap-stage3/src/doc/reference.md

@@ -1346,8 +1346,6 @@ vtable when the trait is used as a [trait object](#trait-objects).
 Traits are implemented for specific types through separate
 [implementations](#implementations).
 
-Consider the following trait:
-
 ```
 # type Surface = i32;
 # type BoundingBox = i32;
@@ -1362,20 +1360,6 @@ This defines a trait with two methods. All values that have
 `draw` and `bounding_box` methods called, using `value.bounding_box()`
 [syntax](#method-call-expressions).
 
-Traits can include default implementations of methods, as in:
-
-```
-trait Foo {
-    fn bar(&self);
-
-    fn baz(&self) { println!("We called baz."); }
-}
-```
-
-Here the `baz` method has a default implementation, so types that implement
-`Foo` need only implement `bar`. It is also possible for implementing types
-to override a method that has a default implementation.
-
 Type parameters can be specified for a trait to make it generic. These appear
 after the trait name, using the same syntax used in [generic
 functions](#generic-functions).
@@ -1388,35 +1372,6 @@ trait Seq<T> {
 }
 ```
 
-It is also possible to define associated types for a trait. Consider the
-following example of a `Container` trait. Notice how the type is available
-for use in the method signatures:
-
-```
-trait Container {
-    type E;
-    fn empty() -> Self;
-    fn insert(&mut self, Self::E);
-}
-```
-
-In order for a type to implement this trait, it must not only provide
-implementations for every method, but it must specify the type `E`. Here's
-an implementation of `Container` for the standard library type `Vec`:
-
-```
-# trait Container {
-#     type E;
-#     fn empty() -> Self;
-#     fn insert(&mut self, Self::E);
-# }
-impl<T> Container for Vec<T> {
-    type E = T;
-    fn empty() -> Vec<T> { Vec::new() }
-    fn insert(&mut self, x: T) { self.push(x); }
-}
-```
-
 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, and within the generic function, the methods of the trait can be
@@ -3515,23 +3470,13 @@ more of the closure traits:
 
 ### Trait objects
 
-In Rust, a type like `&SomeTrait` or `Box<SomeTrait>` is called a _trait object_.
-Each instance of a trait object includes:
-
- - a pointer to an instance of a type `T` that implements `SomeTrait`
- - a _virtual method table_, often just called a _vtable_, which contains, for
-   each method of `SomeTrait` that `T` implements, a pointer to `T`'s
-   implementation (i.e. a function pointer).
-
-The purpose of trait objects is to permit "late binding" of methods. A call to
-a method on a trait object is only resolved to a vtable entry at compile time.
-The actual implementation for each vtable entry can vary on an object-by-object
-basis.
-
-Note that for a trait object to be instantiated, the trait must be
-_object-safe_. Object safety rules are defined in [RFC 255].
-
-[RFC 255]: https://github.com/rust-lang/rfcs/blob/master/text/0255-object-safety.md
+Every trait item (see [traits](#traits)) defines a type with the same name as
+the trait. This type is called the _trait object_ of the trait. Trait objects
+permit "late binding" of methods, dispatched using _virtual method tables_
+("vtables"). Whereas most calls to trait methods are "early bound" (statically
+resolved) to specific implementations at compile time, a call to a method on an
+trait objects is only resolved to a vtable entry at compile time. The actual
+implementation for each vtable entry can vary on an object-by-object basis.
 
 Given a pointer-typed expression `E` of type `&T` or `Box<T>`, where `T`
 implements trait `R`, casting `E` to the corresponding pointer type `&R` or

branches/snap-stage3/src/doc/trpl/README.md

@@ -175,7 +175,7 @@ data, we call the `clone()` method. In this example, `y` is no longer a referenc
 to the vector stored in `x`, but a copy of its first element, `"Hello"`. Now
 that we don’t have a reference, our `push()` works just fine.
 
-[move]: ownership.html#move-semantics
+[move]: move-semantics.html
 
 If we truly want a reference, we need the other option: ensure that our reference
 goes out of scope before we try to do the mutation. That looks like this:

branches/snap-stage3/src/doc/trpl/concurrency.md

@@ -6,7 +6,7 @@ and more cores, yet many programmers aren't prepared to fully utilize them.
 
 Rust's memory safety features also apply to its concurrency story too. Even
 concurrent Rust programs must be memory safe, having no data races. Rust's type
-system is up to the task, and gives you powerful ways to reason about
+system is up to the thread, and gives you powerful ways to reason about
 concurrent code at compile time.
 
 Before we talk about the concurrency features that come with Rust, it's important

branches/snap-stage3/src/doc/trpl/const-and-static.md

@@ -31,8 +31,10 @@ static N: i32 = 5;
 
 Unlike [`let`][let] bindings, you must annotate the type of a `static`.
 
+[let]: variable-bindings.html
+
 Statics live for the entire lifetime of a program, and therefore any
-reference stored in a constant has a [`'static` lifetime][lifetimes]:
+reference stored in a constant has a [`’static` lifetime][lifetimes]:
 
 ```rust
 static NAME: &'static str = "Steve";

branches/snap-stage3/src/doc/trpl/dining-philosophers.md

@@ -73,9 +73,6 @@ a name is all we need. We choose the [`String`][string] type for the name,
 rather than `&str`. Generally speaking, working with a type which owns its
 data is easier than working with one that uses references.
 
-[struct]: structs.html
-[string]: strings.html
-
 Let’s continue:
 
 ```rust
@@ -396,7 +393,7 @@ let handles: Vec<_> = philosophers.into_iter().map(|p| {
 }).collect();
 ```
 
-While this is only five lines, they’re a dense five. Let’s break it down.
+While this is only five lines, they’re a dense four. Let’s break it down.
 
 ```rust,ignore
 let handles: Vec<_> = 
@@ -453,7 +450,7 @@ which blocks execution until the thread has completed execution. This ensures
 that the threads complete their work before the program exits.
 
 If you run this program, you’ll see that the philosophers eat out of order!
-We have multi-threading!
+We have mult-threading!
 
 ```text
 Gilles Deleuze is eating.

branches/snap-stage3/src/doc/trpl/enums.md

@@ -55,6 +55,9 @@ fn process_color_change(msg: Message) {
 }
 ```
 
+Both variants are named `Digit`, but since they’re scoped to the `enum` name
+there's no ambiguity.
+
 Not supporting these operations may seem rather limiting, but it’s a limitation
 which we can overcome. There are two ways: by implementing equality ourselves,
 or by pattern matching variants with [`match`][match] expressions, which you’ll
@@ -63,4 +66,3 @@ equality yet, but we’ll find out in the [`traits`][traits] section.
 
 [match]: match.html
 [if-let]: if-let.html
-[traits]: traits.html

branches/snap-stage3/src/doc/trpl/error-handling.md

@@ -181,8 +181,6 @@ match version {
 This function makes use of an enum, `ParseError`, to enumerate the various
 errors that can occur.
 
-The [`Debug`](../std/fmt/trait.Debug.html) trait is what lets us print the enum value using the `{:?}` format operation.
-
 # Non-recoverable errors with `panic!`
 
 In the case of an error that is unexpected and not recoverable, the `panic!`

branches/snap-stage3/src/doc/trpl/guessing-game.md

@@ -27,7 +27,7 @@ Check out the generated `Cargo.toml`:
 [package]
 
 name = "guessing_game"
-version = "0.1.0"
+version = "0.0.1"
 authors = ["Your Name <[email protected]>"]
 ```
 
@@ -46,7 +46,7 @@ Let’s try compiling what Cargo gave us:
 
 ```{bash}
 $ cargo build
-   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
 ```
 
 Excellent! Open up your `src/main.rs` again. We’ll be writing all of
@@ -58,7 +58,7 @@ Try it out:
 
 ```bash
 $ cargo run
-   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
      Running `target/debug/guessing_game`
 Hello, world!
 ```
@@ -213,12 +213,12 @@ The next part will use this handle to get input from the user:
 ```
 
 Here, we call the [`read_line()`][read_line] method on our handle.
-[Methods][method] are like associated functions, but are only available on a
+[Method][method]s are like associated functions, but are only available on a
 particular instance of a type, rather than the type itself. We’re also passing
 one argument to `read_line()`: `&mut guess`.
 
 [read_line]: ../std/io/struct.Stdin.html#method.read_line
-[method]: method-syntax.html
+[method]: methods.html
 
 Remember how we bound `guess` above? We said it was mutable. However,
 `read_line` doesn’t take a `String` as an argument: it takes a `&mut String`.
@@ -727,7 +727,7 @@ Let’s try our program out!
 
 ```bash
 $ cargo run
-   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
      Running `target/guessing_game`
 Guess the number!
 The secret number is: 58
@@ -792,7 +792,7 @@ and quit. Observe:
 
 ```bash
 $ cargo run
-   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
      Running `target/guessing_game`
 Guess the number!
 The secret number is: 59
@@ -929,7 +929,7 @@ Now we should be good! Let’s try:
 
 ```bash
 $ cargo run
-   Compiling guessing_game v0.1.0 (file:///home/you/projects/guessing_game)
+   Compiling guessing_game v0.0.1 (file:///home/you/projects/guessing_game)
      Running `target/guessing_game`
 Guess the number!
 The secret number is: 61

branches/snap-stage3/src/doc/trpl/iterators.md

@@ -42,7 +42,7 @@ loop is just a handy way to write this `loop`/`match`/`break` construct.
 `for` loops aren't the only thing that uses iterators, however. Writing your
 own iterator involves implementing the `Iterator` trait. While doing that is
 outside of the scope of this guide, Rust provides a number of useful iterators
-to accomplish various tasks. Before we talk about those, we should talk about a
+to accomplish various threads. Before we talk about those, we should talk about a
 Rust anti-pattern. And that's using ranges like this.
 
 Yes, we just talked about how ranges are cool. But ranges are also very

branches/snap-stage3/src/doc/trpl/match.md

@@ -97,4 +97,4 @@ Unlike the previous uses of `match`, you can’t use the normal `if`
 statement to do this. You can use the [`if let`][if-let] statement,
 which can be seen as an abbreviated form of `match`.
 
-[if-let]: if-let.html
+[if-let][if-let.html]

branches/snap-stage3/src/doc/trpl/method-syntax.md

@@ -156,7 +156,7 @@ fn main() {
 
 This ‘associated function’ builds a new `Circle` for us. Note that associated
 functions are called with the `Struct::function()` syntax, rather than the
-`ref.method()` syntax. Some other languages call associated functions ‘static
+`ref.method()` syntax. Some other langauges call associated functions ‘static
 methods’.
 
 # Builder Pattern

branches/snap-stage3/src/doc/trpl/mutability.md

@@ -35,7 +35,7 @@ let y = &mut x;
 
 `y` is an immutable binding to a mutable reference, which means that you can’t
 bind `y` to something else (`y = &mut z`), but you can mutate the thing that’s
-bound to `y` (`*y = 5`). A subtle distinction.
+bound to `y`. (`*y = 5`) A subtle distinction.
 
 Of course, if you need both:
 

branches/snap-stage3/src/doc/trpl/nightly-rust.md

@@ -26,8 +26,8 @@ $ sh rustup.sh --channel=nightly
 If you're on Windows, please download either the [32-bit installer][win32] or
 the [64-bit installer][win64] and run it.
 
-[win32]: https://static.rust-lang.org/dist/rust-nightly-i686-pc-windows-gnu.msi
-[win64]: https://static.rust-lang.org/dist/rust-nightly-x86_64-pc-windows-gnu.msi
+[win32]: https://static.rust-lang.org/dist/rust-1.0.0-beta-i686-pc-windows-gnu.msi
+[win64]: https://static.rust-lang.org/dist/rust-1.0.0-beta-x86_64-pc-windows-gnu.msi
 
 ## Uninstalling
 

branches/snap-stage3/src/doc/trpl/patterns.md

@@ -66,7 +66,7 @@ match x {
 }
 ```
 
-This prints `something else`.
+This prints `something else`
 
 # Bindings
 
@@ -152,7 +152,7 @@ match x {
 }
 ```
 
-This prints `Got an int!`.
+This prints `Got an int!`
 
 # ref and ref mut