---

yaml
---
r: 193585
b: refs/heads/beta
c: 509c6fc
h: refs/heads/master
i:
  193583: 48c7440
v: v3

Author: Manishearth

[refs]

@@ -31,7 +31,7 @@ refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/issue-18208-method-dispatch-3-quick-reject: 2009f85b9f99dedcec4404418eda9ddba90258a2
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: 36c3612f5ceae0fb9df4127bc94a5b443874d1ca
+refs/heads/beta: 509c6fc9c172fefaeeabb815a4b8feac6e0d075d
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: de8a23bbc3a7b9cbd7574b5b91a34af59bf030e6

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

branches/beta/src/libsyntax/ast.rs

@@ -1264,7 +1264,7 @@ pub struct BareFnTy {
 /// The different kinds of types recognized by the compiler
 pub enum Ty_ {
     TyVec(P<Ty>),
-    /// A fixed length array (`[T; n]`)
+    /// A fixed length array (`[T, ..n]`)
     TyFixedLengthVec(P<Ty>, P<Expr>),
     /// A raw pointer (`*const T` or `*mut T`)
     TyPtr(MutTy),

branches/beta/src/snapshots.txt

@@ -1,12 +1,3 @@
-S 2015-03-07 270a677
-  freebsd-x86_64 3c147d8e4cfdcb02c2569f5aca689a1d8920d17b
-  linux-i386 50a47ef247610fb089d2c4f24e4b641eb0ba4afb
-  linux-x86_64 ccb20709b3c984f960ddde996451be8ce2268d7c
-  macos-i386 ad263bdeadcf9bf1889426e0c1391a7cf277364e
-  macos-x86_64 01c8275828042264206b7acd8e86dc719a2f27aa
-  winnt-i386 cb73ac7a9bf408e8b5cdb92d595082a537a90794
-  winnt-x86_64 b9b47e80101f726ae4f5919373ea20b92d827f3c
-
 S 2015-02-25 880fb89
   bitrig-x86_64 8cdc4ca0a80103100f46cbf8caa9fe497df048c5
   freebsd-x86_64 f4cbe4227739de986444211f8ee8d74745ab8f7f