---

yaml
---
r: 226302
b: refs/heads/snap-stage3
c: 40eb53c
h: refs/heads/master
v: v3

Author: Dave Huseby

[refs]

@@ -1,6 +1,6 @@
 ---
 refs/heads/master: e5d90d98402475b6e154ce216f9efcb80da1a747
-refs/heads/snap-stage3: 5aa76509da4b45248ef1a1dcb74939de9bb08c1a
+refs/heads/snap-stage3: 40eb53c409b7a6cd49e092e99c35bb8625767644
 refs/heads/try: b53c0f93eedcdedd4fd89bccc5a3a09d1c5cd23e
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/tags/release-0.2: c870d2dffb391e14efb05aa27898f1f6333a9596

branches/snap-stage3/.gitattributes

@@ -6,4 +6,6 @@
 *.rs rust
 src/etc/pkg/rust-logo.ico binary
 src/etc/pkg/rust-logo.png binary
+src/rt/msvc/* -whitespace
+src/rt/valgrind/* -whitespace
 *.woff binary

branches/snap-stage3/configure

@@ -1005,11 +1005,9 @@ then
         (''|*clang)
         CFG_CLANG_REPORTED_VERSION=$($CFG_CC --version | grep version)
 
-        if [[ $CFG_CLANG_REPORTED_VERSION == *"(based on LLVM "* ]]
-        then
+        if echo $CFG_CLANG_REPORTED_VERSION | grep -q "(based on LLVM "; then
             CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*(based on LLVM \(.*\))/\1/')
-        elif [[ $CFG_CLANG_REPORTED_VERSION == "Apple LLVM"* ]]
-        then
+        elif echo $CFG_CLANG_REPORTED_VERSION | grep -q "Apple LLVM"; then
             CFG_OSX_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')
         else
             CFG_CLANG_VERSION=$(echo $CFG_CLANG_REPORTED_VERSION | sed 's/.*version \(.*\) .*/\1/')

branches/snap-stage3/src/doc/trpl/choosing-your-guarantees.md

@@ -42,7 +42,7 @@ allowed to share references to this by the regular borrowing rules, checked at c
 
 ## `&T` and `&mut T` 
 
-These are immutable and mutable references respectively. They follow the “read-write lock”
+These are immutable and mutable references respectively. They follow the &lquo;read-write lock&rquo;
 pattern, such that one may either have only one mutable reference to some data, or any number of
 immutable ones, but not both. This guarantee is enforced at compile time, and has no visible cost at
 runtime. In most cases these two pointer types suffice for sharing cheap references between sections
@@ -108,7 +108,7 @@ increment the inner reference count and return a copy of the `Rc<T>`.
 
 # Cell types
 
-`Cell`s provide interior mutability. In other words, they contain data which can be manipulated even
+&lquo;Cell&rquo;s provide interior mutability. In other words, they contain data which can be manipulated even
 if the type cannot be obtained in a mutable form (for example, when it is behind an `&`-ptr or
 `Rc<T>`).
 
@@ -127,8 +127,7 @@ If a field is wrapped in `Cell`, it's a nice indicator that the chunk of data is
 stay the same between the time you first read it and when you intend to use it.
 
 ```rust
-use std::cell::Cell;
-
+# use std::cell::Cell;
 let x = Cell::new(1);
 let y = &x;
 let z = &x;
@@ -186,8 +185,7 @@ any other borrows active when a mutable borrow is active. If the programmer atte
 borrow, the thread will panic.
 
 ```rust
-use std::cell::RefCell;
-
+# use std::cell::RefCell;
 let x = RefCell::new(vec![1,2,3,4]);
 {
     println!("{:?}", *x.borrow())

branches/snap-stage3/src/doc/trpl/crates-and-modules.md

@@ -355,10 +355,6 @@ Hello in English: Hello!
 Goodbye in English: Goodbye.
 ```
 
-`pub` also applies to `struct`s and their member fields. In keeping with Rust’s
-tendency toward safety, simply making a `struct` public won't automatically
-make its members public: you must mark the fields individually with `pub`.
-
 Now that our functions are public, we can use them. Great! However, typing out
 `phrases::english::greetings::hello()` is very long and repetitive. Rust has
 another keyword for importing names into the current scope, so that you can
@@ -521,6 +517,9 @@ of `foo` relative to where we are. If that’s prefixed with `::`, as in
 `::foo::bar()`, it refers to a different `foo`, an absolute path from your
 crate root.
 
+Also, note that we `pub use`d before we declared our `mod`s. Rust requires that
+`use` declarations go first.
+
 This will build and run:
 
 ```bash

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

@@ -499,7 +499,7 @@ generator, which is local to the particular [thread][concurrency] of execution
 we’re in. Because we `use rand::Rng`’d above, it has a `gen_range()` method
 available. This method takes two arguments, and generates a number between
 them. It’s inclusive on the lower bound, but exclusive on the upper bound,
-so we need `1` and `101` to get a number ranging from one to a hundred.
+so we need `1` and `101` to get a number between one and a hundred.
 
 [concurrency]: concurrency.html
 

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

@@ -11,7 +11,7 @@ perform efficient pointer arithmetic, one would import those functions
 via a declaration like
 
 ```rust
-#![feature(intrinsics)]
+# #![feature(intrinsics)]
 # fn main() {}
 
 extern "rust-intrinsic" {

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

@@ -200,8 +200,7 @@ impl<T: ?Sized> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_weak)]
-    ///
+    /// # #![feature(arc_weak)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
@@ -338,8 +337,7 @@ impl<T: Clone> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_unique)]
-    ///
+    /// # #![feature(arc_unique)]
     /// use std::sync::Arc;
     ///
     /// let mut five = Arc::new(5);
@@ -410,8 +408,7 @@ impl<T: ?Sized> Arc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_unique, alloc)]
-    ///
+    /// # #![feature(arc_unique, alloc)]
     /// extern crate alloc;
     /// # fn main() {
     /// use alloc::arc::Arc;
@@ -558,8 +555,7 @@ impl<T: ?Sized> Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_weak)]
-    ///
+    /// # #![feature(arc_weak)]
     /// use std::sync::Arc;
     ///
     /// let five = Arc::new(5);
@@ -603,8 +599,7 @@ impl<T: ?Sized> Clone for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_weak)]
-    ///
+    /// # #![feature(arc_weak)]
     /// use std::sync::Arc;
     ///
     /// let weak_five = Arc::new(5).downgrade();
@@ -631,8 +626,7 @@ impl<T: ?Sized> Drop for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(arc_weak)]
-    ///
+    /// # #![feature(arc_weak)]
     /// use std::sync::Arc;
     ///
     /// {

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

@@ -75,8 +75,7 @@ use core::raw::{TraitObject};
 /// The following two examples are equivalent:
 ///
 /// ```
-/// #![feature(box_heap)]
-///
+/// # #![feature(box_heap)]
 /// #![feature(box_syntax, placement_in_syntax)]
 /// use std::boxed::HEAP;
 ///
@@ -242,8 +241,7 @@ impl<T : ?Sized> Box<T> {
     ///
     /// # Examples
     /// ```
-    /// #![feature(box_raw)]
-    ///
+    /// # #![feature(box_raw)]
     /// let seventeen = Box::new(17u32);
     /// let raw = Box::into_raw(seventeen);
     /// let boxed_again = unsafe { Box::from_raw(raw) };
@@ -266,8 +264,7 @@ impl<T : ?Sized> Box<T> {
 ///
 /// # Examples
 /// ```
-/// #![feature(box_raw)]
-///
+/// # #![feature(box_raw)]
 /// use std::boxed;
 ///
 /// let seventeen = Box::new(17u32);
@@ -310,8 +307,7 @@ impl<T: Clone> Clone for Box<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(box_raw)]
-    ///
+    /// # #![feature(box_raw)]
     /// let x = Box::new(5);
     /// let mut y = Box::new(10);
     ///

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

@@ -91,8 +91,7 @@
 //! documentation for more details on interior mutability.
 //!
 //! ```rust
-//! #![feature(rc_weak)]
-//!
+//! # #![feature(rc_weak)]
 //! use std::rc::Rc;
 //! use std::rc::Weak;
 //! use std::cell::RefCell;
@@ -228,8 +227,7 @@ impl<T> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_unique)]
-    ///
+    /// # #![feature(rc_unique)]
     /// use std::rc::Rc;
     ///
     /// let x = Rc::new(3);
@@ -264,8 +262,7 @@ impl<T: ?Sized> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_weak)]
-    ///
+    /// # #![feature(rc_weak)]
     /// use std::rc::Rc;
     ///
     /// let five = Rc::new(5);
@@ -295,8 +292,7 @@ impl<T: ?Sized> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_unique)]
-    ///
+    /// # #![feature(rc_unique)]
     /// use std::rc::Rc;
     ///
     /// let five = Rc::new(5);
@@ -317,8 +313,7 @@ impl<T: ?Sized> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_unique)]
-    ///
+    /// # #![feature(rc_unique)]
     /// use std::rc::Rc;
     ///
     /// let mut x = Rc::new(3);
@@ -358,8 +353,7 @@ pub fn strong_count<T: ?Sized>(this: &Rc<T>) -> usize { Rc::strong_count(this) }
 /// # Examples
 ///
 /// ```
-/// #![feature(rc_unique)]
-///
+/// # #![feature(rc_unique)]
 /// use std::rc;
 /// use std::rc::Rc;
 ///
@@ -379,8 +373,7 @@ pub fn is_unique<T>(rc: &Rc<T>) -> bool { Rc::is_unique(rc) }
 /// # Examples
 ///
 /// ```
-/// #![feature(rc_unique)]
-///
+/// # #![feature(rc_unique)]
 /// use std::rc::{self, Rc};
 ///
 /// let x = Rc::new(3);
@@ -402,8 +395,7 @@ pub fn try_unwrap<T>(rc: Rc<T>) -> Result<T, Rc<T>> { Rc::try_unwrap(rc) }
 /// # Examples
 ///
 /// ```
-/// #![feature(rc_unique)]
-///
+/// # #![feature(rc_unique)]
 /// use std::rc::{self, Rc};
 ///
 /// let mut x = Rc::new(3);
@@ -427,8 +419,7 @@ impl<T: Clone> Rc<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_unique)]
-    ///
+    /// # #![feature(rc_unique)]
     /// use std::rc::Rc;
     ///
     /// let mut five = Rc::new(5);
@@ -759,8 +750,7 @@ impl<T: ?Sized> Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_weak)]
-    ///
+    /// # #![feature(rc_weak)]
     /// use std::rc::Rc;
     ///
     /// let five = Rc::new(5);
@@ -788,8 +778,7 @@ impl<T: ?Sized> Drop for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_weak)]
-    ///
+    /// # #![feature(rc_weak)]
     /// use std::rc::Rc;
     ///
     /// {
@@ -836,8 +825,7 @@ impl<T: ?Sized> Clone for Weak<T> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(rc_weak)]
-    ///
+    /// # #![feature(rc_weak)]
     /// use std::rc::Rc;
     ///
     /// let weak_five = Rc::new(5).downgrade();