---

yaml
---
r: 185085
b: refs/heads/snap-stage3
c: a1396d2
h: refs/heads/master
i:
  185083: de7c207
v: v3

Author: edwardw

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: f0f7ca27de6b4e03f30012656dad270cda55a363
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 13efa529462a0f12bb0ffba7ed1ea58925e6a1b7
+refs/heads/snap-stage3: a1396d250ad5b1b7e9143a6a844ed7ba40bd0e55
 refs/heads/try: ccf8fedf1cffcb8f6f3581d53d220039e192fe77
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

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

@@ -2165,7 +2165,7 @@ fn needs_foo_or_bar() {
 
 // This function is only included when compiling for a unixish OS with a 32-bit
 // architecture
-#[cfg(all(unix, target_pointer_width = "32"))]
+#[cfg(all(unix, target_word_size = "32"))]
 fn on_32bit_unix() {
   // ...
 }
@@ -2193,9 +2193,9 @@ The following configurations must be defined by the implementation:
 * `target_os = "..."`. Operating system of the target, examples include
   `"win32"`, `"macos"`, `"linux"`, `"android"`, `"freebsd"`, `"dragonfly"`,
   `"bitrig"` or `"openbsd"`.
-* `target_pointer_width = "..."`. Target pointer width in bits. This is set
-  to `"32"` for targets with 32-bit pointers, and likewise set to `"64"` for
-  64-bit pointers.
+* `target_word_size = "..."`. Target word size in bits. This is set to `"32"`
+  for targets with 32-bit pointers, and likewise set to `"64"` for 64-bit
+  pointers.
 * `unix`. See `target_family`.
 * `windows`. See `target_family`.
 

branches/snap-stage3/src/doc/rust.css

@@ -56,7 +56,6 @@
 /* General structure */
 
 body {
-    background-color: white;
     margin: 0 auto;
     padding: 0 15px;
     font-family: "Source Serif Pro", Georgia, Times, "Times New Roman", serif;

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

@@ -361,16 +361,16 @@ duration a *lifetime*. Let's try a more complex example:
 
 ```{rust}
 fn main() {
-    let mut x = 5;
+    let x = &mut 5;
 
-    if x < 10 {
+    if *x < 10 {
         let y = &x;
 
         println!("Oh no: {}", y);
         return;
     }
 
-    x -= 1;
+    *x -= 1;
 
     println!("Oh no: {}", x);
 }
@@ -382,18 +382,17 @@ mutated, and therefore, lets us pass. This wouldn't work:
 
 ```{rust,ignore}
 fn main() {
-    let mut x = 5;
+    let x = &mut 5;
 
-    if x < 10 {
+    if *x < 10 {
         let y = &x;
-
-        x -= 1;
+        *x -= 1;
 
         println!("Oh no: {}", y);
         return;
     }
 
-    x -= 1;
+    *x -= 1;
 
     println!("Oh no: {}", x);
 }
@@ -402,12 +401,12 @@ fn main() {
 It gives this error:
 
 ```text
-test.rs:7:9: 7:15 error: cannot assign to `x` because it is borrowed
-test.rs:7         x -= 1;
-                  ^~~~~~
-test.rs:5:18: 5:19 note: borrow of `x` occurs here
-test.rs:5         let y = &x;
-                           ^
+test.rs:5:8: 5:10 error: cannot assign to `*x` because it is borrowed
+test.rs:5         *x -= 1;
+                  ^~
+test.rs:4:16: 4:18 note: borrow of `*x` occurs here
+test.rs:4         let y = &x;
+                          ^~
 ```
 
 As you might guess, this kind of analysis is complex for a human, and therefore

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

@@ -93,8 +93,8 @@ dynamic dispatch is sometimes more efficient.
 
 However, the common case is that it is more efficient to use static dispatch,
 and one can always have a thin statically-dispatched wrapper function that does
-a dynamic dispatch, but not vice versa, meaning static calls are more flexible.
-The standard library tries to be statically dispatched where possible for this
+a dynamic, but not vice versa, meaning static calls are more flexible. The
+standard library tries to be statically dispatched where possible for this
 reason. 
 
 ## Dynamic dispatch

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

@@ -132,7 +132,7 @@ impl<T> ToOwned for T where T: Clone {
 /// ```rust
 /// use std::borrow::Cow;
 ///
-/// fn abs_all(input: &mut Cow<[i32]>) {
+/// fn abs_all(input: &mut Cow<[int]>) {
 ///     for i in 0..input.len() {
 ///         let v = input[i];
 ///         if v < 0 {

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

@@ -404,7 +404,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 pub use core::fmt::{Formatter, Result, Write, rt};
-pub use core::fmt::{Octal, Binary};
+pub use core::fmt::{Show, String, Octal, Binary};
 pub use core::fmt::{Display, Debug};
 pub use core::fmt::{LowerHex, UpperHex, Pointer};
 pub use core::fmt::{LowerExp, UpperExp};

branches/snap-stage3/src/libcore/fmt/float.rs

@@ -40,10 +40,10 @@ pub enum ExponentFormat {
 pub enum SignificantDigits {
     /// At most the given number of digits will be printed, truncating any
     /// trailing zeroes.
-    DigMax(usize),
+    DigMax(uint),
 
     /// Precisely the given number of digits will be printed.
-    DigExact(usize)
+    DigExact(uint)
 }
 
 /// How to emit the sign of a number.
@@ -240,27 +240,27 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
                     // If reached left end of number, have to
                     // insert additional digit:
                     if i < 0
-                    || buf[i as usize] == b'-'
-                    || buf[i as usize] == b'+' {
-                        for j in (i as usize + 1..end).rev() {
+                    || buf[i as uint] == b'-'
+                    || buf[i as uint] == b'+' {
+                        for j in (i as uint + 1..end).rev() {
                             buf[j + 1] = buf[j];
                         }
-                        buf[(i + 1) as usize] = value2ascii(1);
+                        buf[(i + 1) as uint] = value2ascii(1);
                         end += 1;
                         break;
                     }
 
                     // Skip the '.'
-                    if buf[i as usize] == b'.' { i -= 1; continue; }
+                    if buf[i as uint] == b'.' { i -= 1; continue; }
 
                     // Either increment the digit,
                     // or set to 0 if max and carry the 1.
-                    let current_digit = ascii2value(buf[i as usize]);
+                    let current_digit = ascii2value(buf[i as uint]);
                     if current_digit < (radix - 1) {
-                        buf[i as usize] = value2ascii(current_digit+1);
+                        buf[i as uint] = value2ascii(current_digit+1);
                         break;
                     } else {
-                        buf[i as usize] = value2ascii(0);
+                        buf[i as uint] = value2ascii(0);
                         i -= 1;
                     }
                 }
@@ -311,7 +311,7 @@ pub fn float_to_str_bytes_common<T: Float, U, F>(
 
             struct Filler<'a> {
                 buf: &'a mut [u8],
-                end: &'a mut usize,
+                end: &'a mut uint,
             }
 
             impl<'a> fmt::Write for Filler<'a> {