---

yaml
---
r: 208851
b: refs/heads/snap-stage3
c: 0b1976c
h: refs/heads/master
i:
  208849: dd24172
  208847: 60f4d36
v: v3

Author: steveklabnik

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 38a97becdf3e6a6157f6f7ec2d98ade8d8edc193
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 962b132fe33e9227c1458cc56c4a0bd04ca9ea3e
+refs/heads/snap-stage3: 0b1976c2c2426812f2acad60edc520b2646040e3
 refs/heads/try: 7b4ef47b7805a402d756fb8157101f64880a522f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

branches/snap-stage3/configure

@@ -1,7 +1,7 @@
 #!/bin/sh
 
 msg() {
-    echo "configure: $*"
+    echo "configure: $1"
 }
 
 step_msg() {
@@ -33,8 +33,8 @@ need_ok() {
 
 need_cmd() {
     if command -v $1 >/dev/null 2>&1
-    then msg "found program '$1'"
-    else err "program '$1' is missing, please install it"
+    then msg "found program $1"
+    else err "need program $1"
     fi
 }
 

branches/snap-stage3/mk/dist.mk

@@ -123,7 +123,7 @@ dist-install-dir-$(1): PREPARE_BIN_CMD=$(DEFAULT_PREPARE_BIN_CMD)
 dist-install-dir-$(1): PREPARE_LIB_CMD=$(DEFAULT_PREPARE_LIB_CMD)
 dist-install-dir-$(1): PREPARE_MAN_CMD=$(DEFAULT_PREPARE_MAN_CMD)
 dist-install-dir-$(1): PREPARE_CLEAN=true
-dist-install-dir-$(1): prepare-base-dir-$(1) docs
+dist-install-dir-$(1): prepare-base-dir-$(1) docs compiler-docs
 	$$(Q)mkdir -p $$(PREPARE_DEST_DIR)/share/doc/rust
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)COPYRIGHT $$(PREPARE_DEST_DIR)/share/doc/rust
 	$$(Q)$$(PREPARE_MAN_CMD) $$(S)LICENSE-APACHE $$(PREPARE_DEST_DIR)/share/doc/rust
@@ -163,7 +163,7 @@ endif
 		--legacy-manifest-dirs=rustlib,cargo
 	$$(Q)rm -R tmp/dist/$$(PKG_NAME)-$(1)-image
 
-dist-doc-install-dir-$(1): docs
+dist-doc-install-dir-$(1): docs compiler-docs
 	$$(Q)mkdir -p tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust
 	$$(Q)cp -r doc tmp/dist/$$(DOC_PKG_NAME)-$(1)-image/share/doc/rust/html
 
@@ -251,7 +251,7 @@ distcheck-tar-bins: dist-tar-bins
 
 # Just copy the docs to a folder under dist with the appropriate name
 # for uploading to S3
-dist-docs: docs
+dist-docs: docs compiler-docs
 	$(Q) rm -Rf dist/doc
 	$(Q) mkdir -p dist/doc/
 	$(Q) cp -r doc dist/doc/$(CFG_PACKAGE_VERS)

branches/snap-stage3/mk/docs.mk

@@ -77,8 +77,7 @@ ERR_IDX_GEN = $(RPATH_VAR2_T_$(CFG_BUILD)_H_$(CFG_BUILD)) $(ERR_IDX_GEN_EXE)
 
 D := $(S)src/doc
 
-# FIXME (#25705) eventually may want to put error-index target back here.
-DOC_TARGETS := trpl style
+DOC_TARGETS := trpl style error-index
 COMPILER_DOC_TARGETS :=
 DOC_L10N_TARGETS :=
 

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

@@ -2003,10 +2003,6 @@ arbitrarily complex configurations through nesting.
 
 The following configurations must be defined by the implementation:
 
-* `debug_assertions`. Enabled by default when compiling without optimizations.
-  This can be used to enable extra debugging code in development but not in
-  production.  For example, it controls the behavior of the standard library's
-  `debug_assert!` macro.
 * `target_arch = "..."`. Target CPU architecture, such as `"x86"`, `"x86_64"`
   `"mips"`, `"powerpc"`, `"arm"`, or `"aarch64"`.
 * `target_endian = "..."`. Endianness of the target CPU, either `"little"` or
@@ -3626,14 +3622,6 @@ The `Sized` trait indicates that the size of this type is known at compile-time.
 The `Drop` trait provides a destructor, to be run whenever a value of this type
 is to be destroyed.
 
-## The `Deref` trait
-
-The `Deref<Target = U>` trait allows a type to implicitly implement all the methods
-of the type `U`. When attempting to resolve a method call, the compiler will search
-the top-level type for the implementation of the called method. If no such method is
-found, `.deref()` is called and the compiler continues to search for the method
-implementation in the returned type `U`.
-
 # Memory model
 
 A Rust program's memory consists of a static set of *items* and a *heap*.

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

@@ -150,8 +150,8 @@ of those times. As the error explains, while we made our binding mutable, we
 still cannot call `push`. This is because we already have a reference to an
 element of the vector, `y`. Mutating something while another reference exists
 is dangerous, because we may invalidate the reference. In this specific case,
-when we create the vector, we may have only allocated space for two elements.
-Adding a third would mean allocating a new chunk of memory for all those elements,
+when we create the vector, we may have only allocated space for three elements.
+Adding a fourth would mean allocating a new chunk of memory for all those elements,
 copying the old values over, and updating the internal pointer to that memory.
 That all works just fine. The problem is that `y` wouldn’t get updated, and so
 we’d have a ‘dangling pointer’. That’s bad. Any use of `y` would be an error in

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

@@ -2,28 +2,26 @@
 
 For our second project, let’s look at a classic concurrency problem. It’s
 called ‘the dining philosophers’. It was originally conceived by Dijkstra in
-1965, but we’ll use a lightly adapted version from [this paper][paper] by Tony
-Hoare in 1985.
+1965, but we’ll use the version from [this paper][paper] by Tony Hoare in 1985.
 
 [paper]: http://www.usingcsp.com/cspbook.pdf
 
 > In ancient times, a wealthy philanthropist endowed a College to accommodate
-> five eminent philosophers. Each philosopher had a room in which they could
-> engage in their professional activity of thinking; there was also a common
+> five eminent philosophers. Each philosopher had a room in which she could
+> engage in her professional activity of thinking; there was also a common
 > dining room, furnished with a circular table, surrounded by five chairs, each
 > labelled by the name of the philosopher who was to sit in it. They sat
 > anticlockwise around the table. To the left of each philosopher there was
 > laid a golden fork, and in the centre stood a large bowl of spaghetti, which
-> was constantly replenished. A philosopher was expected to spend most of
-> their time thinking; but when they felt hungry, they went to the dining
-> room, sat down in their own chair, picked up their own fork on their left,
-> and plunged it into the spaghetti. But such is the tangled nature of
-> spaghetti that a second fork is required to carry it to the mouth. The
-> philosopher therefore had also to pick up the fork on their right. When
-> they were finished they would put down both their forks, get up from their
-> chair, and continue thinking. Of course, a fork can be used by only one
-> philosopher at a time. If the other philosopher wants it, they just have
-> to wait until the fork is available again.
+> was constantly replenished. A philosopher was expected to spend most of her
+> time thinking; but when she felt hungry, she went to the dining room, sat down
+> in her own chair, picked up her own fork on her left, and plunged it into the
+> spaghetti. But such is the tangled nature of spaghetti that a second fork is
+> required to carry it to the mouth. The philosopher therefore had also to pick
+> up the fork on her right. When she was finished she would put down both her
+> forks, get up from her chair, and continue thinking. Of course, a fork can be
+> used by only one philosopher at a time. If the other philosopher wants it, she
+> just has to wait until the fork is available again.
 
 This classic problem shows off a few different elements of concurrency. The
 reason is that it's actually slightly tricky to implement: a simple
@@ -62,10 +60,10 @@ impl Philosopher {
 }
 
 fn main() {
-    let p1 = Philosopher::new("Judith Butler");
+    let p1 = Philosopher::new("Baruch Spinoza");
     let p2 = Philosopher::new("Gilles Deleuze");
     let p3 = Philosopher::new("Karl Marx");
-    let p4 = Philosopher::new("Emma Goldman");
+    let p4 = Philosopher::new("Friedrich Nietzsche");
     let p5 = Philosopher::new("Michel Foucault");
 }
 ```
@@ -161,10 +159,10 @@ look at `main()` again:
 # }
 # 
 fn main() {
-    let p1 = Philosopher::new("Judith Butler");
+    let p1 = Philosopher::new("Baruch Spinoza");
     let p2 = Philosopher::new("Gilles Deleuze");
     let p3 = Philosopher::new("Karl Marx");
-    let p4 = Philosopher::new("Emma Goldman");
+    let p4 = Philosopher::new("Friedrich Nietzsche");
     let p5 = Philosopher::new("Michel Foucault");
 }
 ```
@@ -178,10 +176,10 @@ that `new()` function, it would look like this:
 #     name: String,
 # }
 fn main() {
-    let p1 = Philosopher { name: "Judith Butler".to_string() };
+    let p1 = Philosopher { name: "Baruch Spinoza".to_string() };
     let p2 = Philosopher { name: "Gilles Deleuze".to_string() };
     let p3 = Philosopher { name: "Karl Marx".to_string() };
-    let p4 = Philosopher { name: "Emma Goldman".to_string() };
+    let p4 = Philosopher { name: "Friedrich Nietzche".to_string() };
     let p5 = Philosopher { name: "Michel Foucault".to_string() };
 }
 ```
@@ -213,10 +211,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -249,10 +247,10 @@ mention they’re done eating. Running this program should give you the followin
 output:
 
 ```text
-Judith Butler is done eating.
+Baruch Spinoza is done eating.
 Gilles Deleuze is done eating.
 Karl Marx is done eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is done eating.
 ```
 
@@ -287,10 +285,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -325,14 +323,14 @@ simulate the time it takes a philosopher to eat.
 If you run this program, you should see each philosopher eat in turn:
 
 ```text
-Judith Butler is eating.
-Judith Butler is done eating.
+Baruch Spinoza is eating.
+Baruch Spinoza is done eating.
 Gilles Deleuze is eating.
 Gilles Deleuze is done eating.
 Karl Marx is eating.
 Karl Marx is done eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is eating.
 Michel Foucault is done eating.
 ```
@@ -368,10 +366,10 @@ impl Philosopher {
 
 fn main() {
     let philosophers = vec![
-        Philosopher::new("Judith Butler"),
+        Philosopher::new("Baruch Spinoza"),
         Philosopher::new("Gilles Deleuze"),
         Philosopher::new("Karl Marx"),
-        Philosopher::new("Emma Goldman"),
+        Philosopher::new("Friedrich Nietzsche"),
         Philosopher::new("Michel Foucault"),
     ];
 
@@ -460,11 +458,11 @@ We have multi-threading!
 ```text
 Gilles Deleuze is eating.
 Gilles Deleuze is done eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Michel Foucault is eating.
-Judith Butler is eating.
-Judith Butler is done eating.
+Baruch Spinoza is eating.
+Baruch Spinoza is done eating.
 Karl Marx is eating.
 Karl Marx is done eating.
 Michel Foucault is done eating.
@@ -534,10 +532,10 @@ fn main() {
     ]});
 
     let philosophers = vec![
-        Philosopher::new("Judith Butler", 0, 1),
+        Philosopher::new("Baruch Spinoza", 0, 1),
         Philosopher::new("Gilles Deleuze", 1, 2),
         Philosopher::new("Karl Marx", 2, 3),
-        Philosopher::new("Emma Goldman", 3, 4),
+        Philosopher::new("Friedrich Nietzsche", 3, 4),
         Philosopher::new("Michel Foucault", 0, 4),
     ];
 
@@ -645,10 +643,10 @@ count will go up, and when each thread ends, it will go back down.
 
 ```rust,ignore
 let philosophers = vec![
-    Philosopher::new("Judith Butler", 0, 1),
+    Philosopher::new("Baruch Spinoza", 0, 1),
     Philosopher::new("Gilles Deleuze", 1, 2),
     Philosopher::new("Karl Marx", 2, 3),
-    Philosopher::new("Emma Goldman", 3, 4),
+    Philosopher::new("Friedrich Nietzsche", 3, 4),
     Philosopher::new("Michel Foucault", 0, 4),
 ];
 ```
@@ -681,12 +679,12 @@ and so you’ll get some output like this:
 
 ```text
 Gilles Deleuze is eating.
-Emma Goldman is eating.
-Emma Goldman is done eating.
+Friedrich Nietzsche is eating.
+Friedrich Nietzsche is done eating.
 Gilles Deleuze is done eating.
-Judith Butler is eating.
+Baruch Spinoza is eating.
 Karl Marx is eating.
-Judith Butler is done eating.
+Baruch Spinoza is done eating.
 Michel Foucault is eating.
 Karl Marx is done eating.
 Michel Foucault is done eating.

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

@@ -148,7 +148,7 @@ a few tricks up their sleeves.
 For example, they’re [immutable][immutable] by default. That’s why our example
 uses `mut`: it makes a binding mutable, rather than immutable. `let` doesn’t
 take a name on the left hand side, it actually accepts a
-‘[pattern][patterns]’. We’ll use patterns later. It’s easy enough
+‘[pattern][patterns]’. We’ll use patterns more later. It’s easy enough
 to use for now:
 
 ```rust
@@ -637,7 +637,7 @@ When we wrote `let guess = String::new()`, Rust was able to infer that `guess`
 should be a `String`, and so it doesn’t make us write out the type. And with
 our `secret_number`, there are a number of types which can have a value
 between one and a hundred: `i32`, a thirty-two-bit number, or `u32`, an
-unsigned thirty-two-bit number, or `i64`, a sixty-four-bit number or others.
+unsigned thirty-two-bit number, or `i64`, a sixty-four-bit number. Or others.
 So far, that hasn’t mattered, and so Rust defaults to an `i32`. However, here,
 Rust doesn’t know how to compare the `guess` and the `secret_number`. They
 need to be the same type. Ultimately, we want to convert the `String` we

branches/snap-stage3/src/doc/trpl/the-stack-and-the-heap.md

@@ -277,9 +277,9 @@ allocated on the heap:
 | 0       | x    | ?????? |
 
 [drop]: drop.html
-[^moving]: We can make the memory live longer by transferring ownership,
-           sometimes called ‘moving out of the box’. More complex examples will
-           be covered later.
+[moving]: We can make the memory live longer by transferring ownership,
+          sometimes called ‘moving out of the box’. More complex examples will
+          be covered later.
 
 
 And then the stack frame goes away, freeing all of our memory.

branches/snap-stage3/src/liballoc/rc.rs

@@ -144,7 +144,7 @@
 //!     // At the end of the method, gadget_owner, gadget1 and gadget2 get
 //!     // destroyed. There are now no strong (`Rc<T>`) references to the gadgets.
 //!     // Once they get destroyed, the Gadgets get destroyed. This zeroes the
-//!     // reference count on Gadget Man, they get destroyed as well.
+//!     // reference count on Gadget Man, so he gets destroyed as well.
 //! }
 //! ```
 

branches/snap-stage3/src/libcollections/lib.rs

@@ -39,6 +39,7 @@
 #![feature(str_char)]
 #![feature(str_words)]
 #![feature(slice_patterns)]
+#![feature(debug_builders)]
 #![feature(utf8_error)]
 #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections,
                           collections_drain, collections_range))]

branches/snap-stage3/src/libcollections/str.rs

@@ -1110,9 +1110,8 @@ impl str {
     /// such as leaving a combining character as the first code point of the
     /// string.
     ///
-    /// Due to the design of UTF-8, this operation is `O(end)`. See `slice`,
-    /// `slice_to` and `slice_from` for `O(1)` variants that use byte indices
-    /// rather than code point indices.
+    /// Due to the design of UTF-8, this operation is `O(end)`. Use slicing
+    /// syntax if you want to use byte indices rather than codepoint indices.
     ///
     /// # Panics
     ///

branches/snap-stage3/src/libcollections/vec.rs

@@ -11,8 +11,7 @@
 //! A growable list type with heap-allocated contents, written `Vec<T>` but
 //! pronounced 'vector.'
 //!
-//! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and
-//! `O(1)` pop (from the end).
+//! Vectors have `O(1)` indexing, push (to the end) and pop (from the end).
 //!
 //! # Examples
 //!