---

yaml
---
r: 190405
b: refs/heads/snap-stage3
c: 4398461
h: refs/heads/master
i:
  190403: 075ec66
v: v3

Author: Manishearth

[refs]

@@ -1,7 +1,7 @@
 ---
 refs/heads/master: 857ac28867722111249b5c3ef68e32499bd11ea0
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
-refs/heads/snap-stage3: 2574009af0ff70dc233beab246db8f2d715be2cb
+refs/heads/snap-stage3: 43984618eb5c56d69ef1659fd506e26a0fd2d9bb
 refs/heads/try: 1c28ab65017d74fc13d003f7c7a73d1a48e5406f
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105
 refs/heads/dist-snap: ba4081a5a8573875fed17545846f6f6902c8ba8d

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

@@ -514,7 +514,7 @@ field_expr : expr '.' ident ;
 ### Array expressions
 
 ```antlr
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ',' ".." expr] ;
 ```

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

@@ -2847,7 +2847,7 @@ automatically dereferenced to make the field access possible.
 ### Array expressions
 
 ```{.ebnf .gram}
-array_expr : '[' "mut" ? array_elems? ']' ;
+array_expr : '[' "mut" ? vec_elems? ']' ;
 
 array_elems : [expr [',' expr]*] | [expr ';' expr] ;
 ```

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

@@ -16,11 +16,11 @@
     * [Standard Input](standard-input.md)
     * [Guessing Game](guessing-game.md)
 * [II: Intermediate Rust](intermediate.md)
+    * [More Strings](more-strings.md)
     * [Crates and Modules](crates-and-modules.md)
     * [Testing](testing.md)
     * [Pointers](pointers.md)
     * [Ownership](ownership.md)
-    * [More Strings](more-strings.md)
     * [Patterns](patterns.md)
     * [Method Syntax](method-syntax.md)
     * [Closures](closures.md)

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

@@ -223,8 +223,15 @@ method which has this signature:
 fn lock(&self) -> LockResult<MutexGuard<T>>
 ```
 
-Because `Send` is not implemented for `MutexGuard<T>`, we can't transfer the
-guard across thread boundaries, which gives us our error.
+If we [look at the code for MutexGuard](https://github.com/rust-lang/rust/blob/ca4b9674c26c1de07a2042cb68e6a062d7184cef/src/libstd/sync/mutex.rs#L172), we'll see
+this:
+
+```ignore
+__marker: marker::NoSend,
+```
+
+Because our guard is `NoSend`, it's not `Send`. Which means we can't actually
+transfer the guard across thread boundaries, which gives us our error.
 
 We can use `Arc<T>` to fix this. Here's the working version:
 

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

@@ -50,29 +50,7 @@ You can think of this first parameter as being the `x` in `x.foo()`. The three
 variants correspond to the three kinds of thing `x` could be: `self` if it's
 just a value on the stack, `&self` if it's a reference, and `&mut self` if it's
 a mutable reference. We should default to using `&self`, as it's the most
-common. Here's an example of all three variants:
-
-```rust
-struct Circle {
-    x: f64,
-    y: f64,
-    radius: f64,
-}
-
-impl Circle {
-    fn reference(&self) {
-       println!("taking self by reference!"); 
-    }
-
-    fn mutable_reference(&mut self) {
-       println!("taking self by mutable reference!"); 
-    }
-
-    fn takes_ownership(self) {
-       println!("taking ownership of self!"); 
-    }
-}
-```
+common.
 
 Finally, as you may remember, the value of the area of a circle is `π*r²`.
 Because we took the `&self` parameter to `area`, we can use it just like any

branches/snap-stage3/src/doc/trpl/more-strings.md

@@ -278,18 +278,7 @@ This will print:
 
 Many more bytes than graphemes!
 
-# `Deref` coercions
+# Other Documentation
 
-References to `String`s will automatically coerce into `&str`s. Like this:
-
-```
-fn hello(s: &str) {
-   println!("Hello, {}!", s);
-}
-
-let slice = "Steve";
-let string = "Steve".to_string();
-
-hello(slice);
-hello(&string);
-```
+* [the `&str` API documentation](../std/str/index.html)
+* [the `String` API documentation](../std/string/index.html)

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

@@ -634,8 +634,8 @@ use-case for boxes.
 ### Returning data
 
 This is important enough to have its own section entirely. The TL;DR is this:
-you don't want to return pointers, even when you might in a language like C or
-C++.
+you don't generally want to return pointers, even when you might in a language
+like C or C++.
 
 See [Returning Pointers](#returning-pointers) below for more.
 

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

@@ -435,46 +435,3 @@ println!("the inverse of {} is {:?}", 2.0f64, inverse(2.0f64));
 println!("the inverse of {} is {:?}", 0.0f32, inverse(0.0f32));
 println!("the inverse of {} is {:?}", 0.0f64, inverse(0.0f64));
 ```
-
-## Default methods
-
-There's one last feature of traits we should cover: default methods. It's
-easiest just to show an example:
-
-```rust
-trait Foo {
-    fn bar(&self);
-
-    fn baz(&self) { println!("We called baz."); }
-}
-```
-
-Implementors of the `Foo` trait need to implement `bar()`, but they don't
-need to implement `baz()`. They'll get this default behavior. They can
-override the default if they so choose:
-
-```rust
-# trait Foo {
-# fn bar(&self);
-# fn baz(&self) { println!("We called baz."); }
-# }
-struct UseDefault;
-
-impl Foo for UseDefault {
-    fn bar(&self) { println!("We called bar."); }
-}
-
-struct OverrideDefault;
-
-impl Foo for OverrideDefault {
-    fn bar(&self) { println!("We called bar."); }
-
-    fn baz(&self) { println!("Override baz!"); }
-}
-
-let default = UseDefault;
-default.baz(); // prints "We called bar."
-
-let over = OverrideDefault;
-over.baz(); // prints "Override baz!"
-```

branches/snap-stage3/src/libcore/intrinsics.rs

@@ -545,7 +545,11 @@ extern "rust-intrinsic" {
     pub fn u32_mul_with_overflow(x: u32, y: u32) -> (u32, bool);
     /// Performs checked `u64` multiplication.
     pub fn u64_mul_with_overflow(x: u64, y: u64) -> (u64, bool);
+}
 
+// SNAP 880fb89
+#[cfg(not(stage0))]
+extern "rust-intrinsic" {
     /// Returns (a + b) mod 2^N, where N is the width of N in bits.
     pub fn overflowing_add<T>(a: T, b: T) -> T;
     /// Returns (a - b) mod 2^N, where N is the width of N in bits.

branches/snap-stage3/src/libcore/iter.rs

@@ -611,7 +611,7 @@ pub trait IteratorExt: Iterator + Sized {
     ///
     /// ```
     /// let a = [1, 2, 3, 4, 5];
-    /// assert!(a.iter().fold(0, |acc, &item| acc + item) == 15);
+    /// assert!(a.iter().fold(0, |a, &b| a + b) == 15);
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]

branches/snap-stage3/src/libcore/marker.rs

@@ -351,45 +351,7 @@ pub trait PhantomFn<A:?Sized,R:?Sized=()> { }
 /// instance, it will behave *as if* an instance of the type `T` were
 /// present for the purpose of various automatic analyses.
 ///
-/// # Examples
-///
-/// When handling external resources over a foreign function interface, `PhantomData<T>` can
-/// prevent mismatches by enforcing types in the method implementations, although the struct
-/// doesn't actually contain values of the resource type.
-///
-/// ```
-/// # trait ResType { fn foo(&self); };
-/// # struct ParamType;
-/// # mod foreign_lib {
-/// # pub fn new(_: usize) -> *mut () { 42 as *mut () }
-/// # pub fn do_stuff(_: *mut (), _: usize) {}
-/// # }
-/// # fn convert_params(_: ParamType) -> usize { 42 }
-/// use std::marker::PhantomData;
-/// use std::mem;
-///
-/// struct ExternalResource<R> {
-///    resource_handle: *mut (),
-///    resource_type: PhantomData<R>,
-/// }
-///
-/// impl<R: ResType> ExternalResource<R> {
-///     fn new() -> ExternalResource<R> {
-///         let size_of_res = mem::size_of::<R>();
-///         ExternalResource {
-///             resource_handle: foreign_lib::new(size_of_res),
-///             resource_type: PhantomData,
-///         }
-///     }
-///
-///     fn do_stuff(&self, param: ParamType) {
-///         let foreign_params = convert_params(param);
-///         foreign_lib::do_stuff(self.resource_handle, foreign_params);
-///     }
-/// }
-/// ```
-///
-/// Another example: embedding a `PhantomData<T>` will inform the compiler
+/// For example, embedding a `PhantomData<T>` will inform the compiler
 /// that one or more instances of the type `T` could be dropped when
 /// instances of the type itself is dropped, though that may not be
 /// apparent from the other structure of the type itself. This is

branches/snap-stage3/src/libcore/num/wrapping.rs

@@ -11,6 +11,7 @@
 
 use ops::*;
 
+#[cfg(not(stage0))]
 use intrinsics::{overflowing_add, overflowing_sub, overflowing_mul};
 
 use intrinsics::{i8_add_with_overflow, u8_add_with_overflow};
@@ -39,6 +40,7 @@ pub trait OverflowingOps {
     fn overflowing_mul(self, rhs: Self) -> (Self, bool);
 }
 
+#[cfg(not(stage0))]
 macro_rules! wrapping_impl {
     ($($t:ty)*) => ($(
         impl WrappingOps for $t {
@@ -64,6 +66,26 @@ macro_rules! wrapping_impl {
     )*)
 }
 
+#[cfg(stage0)]
+macro_rules! wrapping_impl {
+    ($($t:ty)*) => ($(
+        impl WrappingOps for $t {
+            #[inline(always)]
+            fn wrapping_add(self, rhs: $t) -> $t {
+                self + rhs
+            }
+            #[inline(always)]
+            fn wrapping_sub(self, rhs: $t) -> $t {
+                self - rhs
+            }
+            #[inline(always)]
+            fn wrapping_mul(self, rhs: $t) -> $t {
+                self * rhs
+            }
+        }
+    )*)
+}
+
 wrapping_impl! { uint u8 u16 u32 u64 int i8 i16 i32 i64 }
 
 #[unstable(feature = "core", reason = "may be removed, renamed, or relocated")]