---

yaml
---
r: 189366
b: refs/heads/master
c: d65064d
h: refs/heads/master
v: v3

Author: steveklabnik

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: c7d5354567e596c578b1ff656f52fae80a93b48a
+refs/heads/master: d65064da349f1f7182180549628fb0ee650771b7
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 270a677d4d698916f5ad103f0afc3c070b8dbeb4
 refs/heads/try: 649d35e4d830b27806705dc5352c86ab6d6fd1a1

trunk/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] ;
 ```

trunk/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] ;
 ```

trunk/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)

trunk/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:
 

trunk/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)

trunk/src/doc/trpl/plugins.md

@@ -63,7 +63,7 @@ that implements Roman numeral integer literals.
 
 ```ignore
 #![crate_type="dylib"]
-#![feature(plugin_registrar, rustc_private)]
+#![feature(plugin_registrar)]
 
 extern crate syntax;
 extern crate rustc;
@@ -92,13 +92,13 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     };
 
-    let mut text = &*text;
+    let mut text = &text;
     let mut total = 0;
     while !text.is_empty() {
         match NUMERALS.iter().find(|&&(rn, _)| text.starts_with(rn)) {
             Some(&(rn, val)) => {
                 total += val;
-                text = &text[rn.len()..];
+                text = text.slice_from(rn.len());
             }
             None => {
                 cx.span_err(sp, "invalid Roman numeral");
@@ -107,7 +107,7 @@ fn expand_rn(cx: &mut ExtCtxt, sp: Span, args: &[TokenTree])
         }
     }
 
-    MacEager::expr(cx.expr_u32(sp, total))
+    MacEager::expr(cx.expr_usize(sp, total))
 }
 
 #[plugin_registrar]

trunk/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!"
-```

trunk/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.

trunk/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")]

trunk/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

trunk/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")]