---

yaml
---
r: 273406
b: refs/heads/beta
c: 06d8b21
h: refs/heads/master

Author: tclfs

[refs]

@@ -23,7 +23,7 @@ refs/tags/0.9: 36870b185fc5f5486636d4515f0e22677493f225
 refs/tags/0.10: ac33f2b15782272ae348dbd7b14b8257b2148b5a
 refs/tags/0.11.0: e1247cb1d0d681be034adb4b558b5a0c0d5720f9
 refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
-refs/heads/beta: 3c3b9ad76ac16e1a0709aa161432b73f64b7a26e
+refs/heads/beta: 06d8b21372742234c95e1ea842e4d66aa9ee9dd5
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: e06d2ad9fcd5027bcaac5b08fc9aa39a49d0ecd3
 refs/tags/1.0.0-alpha.2: 4c705f6bc559886632d3871b04f58aab093bfa2f

branches/beta/src/doc/book/error-handling.md

@@ -2019,16 +2019,6 @@ impl Error for CliError {
             CliError::NotFound => "not found",
         }
     }
-
-    fn cause(&self) -> Option<&error::Error> {
-        match *self {            
-            CliError::Io(ref err) => Some(err),
-            CliError::Parse(ref err) => Some(err),
-            // Our custom error doesn't have an underlying cause, but we could
-            // modify it so that it does.
-            CliError::NotFound() => None,
-        }
-    }
 }
 ```
 

branches/beta/src/doc/book/primitive-types.md

@@ -7,7 +7,7 @@ of these ones, as well, but these are the most primitive.
 
 # Booleans
 
-Rust has a built-in boolean type, named `bool`. It has two values, `true` and `false`:
+Rust has a built in boolean type, named `bool`. It has two values, `true` and `false`:
 
 ```rust
 let x = true;
@@ -89,13 +89,13 @@ Unsigned types use a `u` for their category, and signed types use `i`. The `i`
 is for ‘integer’. So `u8` is an eight-bit unsigned number, and `i8` is an
 eight-bit signed number.
 
-## Fixed-size types
+## Fixed size types
 
-Fixed-size types have a specific number of bits in their representation. Valid
+Fixed size types have a specific number of bits in their representation. Valid
 bit sizes are `8`, `16`, `32`, and `64`. So, `u32` is an unsigned, 32-bit integer,
 and `i64` is a signed, 64-bit integer.
 
-## Variable-size types
+## Variable sized types
 
 Rust also provides types whose size depends on the size of a pointer of the
 underlying machine. These types have ‘size’ as the category, and come in signed

branches/beta/src/doc/book/references-and-borrowing.md

@@ -212,7 +212,7 @@ fn main() {
 
 In other words, the mutable borrow is held through the rest of our example. What
 we want is for the mutable borrow by `y` to end so that the resource can be
-returned to the owner, `x`. `x` can then provide a mutable borrow to `println!`.
+returned to the owner, `x`. `x` can then provide a immutable borrow to `println!`.
 In Rust, borrowing is tied to the scope that the borrow is valid for. And our
 scopes look like this:
 

branches/beta/src/libcore/Cargo.toml

@@ -2,7 +2,6 @@
 authors = ["The Rust Project Developers"]
 name = "core"
 version = "0.0.0"
-build = "build.rs"
 
 [lib]
 name = "core"

branches/beta/src/libcore/build.rs

@@ -416,14 +416,14 @@ pub fn encode_utf16_raw(mut ch: u32, dst: &mut [u16]) -> Option<usize> {
 ///
 /// [`escape_unicode()`]: ../../std/primitive.char.html#method.escape_unicode
 /// [`char`]: ../../std/primitive.char.html
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct EscapeUnicode {
     c: char,
     state: EscapeUnicodeState
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 enum EscapeUnicodeState {
     Backslash,
     Type,
@@ -496,13 +496,13 @@ impl Iterator for EscapeUnicode {
 ///
 /// [`escape_default()`]: ../../std/primitive.char.html#method.escape_default
 /// [`char`]: ../../std/primitive.char.html
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct EscapeDefault {
     state: EscapeDefaultState
 }
 
-#[derive(Clone, Debug)]
+#[derive(Clone)]
 enum EscapeDefaultState {
     Backslash(char),
     Char(char),

branches/beta/src/libcore/char.rs

@@ -14,21 +14,6 @@
 //! by the compiler to implement comparison operators. Rust programs may
 //! implement `PartialOrd` to overload the `<`, `<=`, `>`, and `>=` operators,
 //! and may implement `PartialEq` to overload the `==` and `!=` operators.
-//!
-//! # Examples
-//!
-//! ```
-//! let x: u32 = 0;
-//! let y: u32 = 1;
-//!
-//! // these two lines are equivalent
-//! assert_eq!(x < y, true);
-//! assert_eq!(x.lt(&y), true);
-//!
-//! // these two lines are also equivalent
-//! assert_eq!(x == y, false);
-//! assert_eq!(x.eq(&y), false);
-//! ```
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
@@ -59,16 +44,6 @@ use option::Option::{self, Some};
 /// only if `a != b`.
 ///
 /// This trait can be used with `#[derive]`.
-///
-/// # Examples
-///
-/// ```
-/// let x: u32 = 0;
-/// let y: u32 = 1;
-///
-/// assert_eq!(x == y, false);
-/// assert_eq!(x.eq(&y), false);
-/// ```
 #[lang = "eq"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PartialEq<Rhs: ?Sized = Self> {
@@ -251,16 +226,6 @@ impl PartialOrd for Ordering {
 ///
 /// This trait can be used with `#[derive]`. When `derive`d, it will produce an ordering
 /// based on the top-to-bottom declaration order of the struct's members.
-///
-/// # Examples
-///
-/// ```
-/// let x : u32 = 0;
-/// let y : u32 = 1;
-///
-/// assert_eq!(x < y, true);
-/// assert_eq!(x.lt(&y), true);
-/// ```
 #[lang = "ord"]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {

branches/beta/src/libcore/cmp.rs

@@ -54,7 +54,6 @@ impl<'a, 'b: 'a> fmt::Write for PadAdapter<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_struct` method.
 #[must_use]
-#[allow(missing_debug_implementations)]
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugStruct<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,
@@ -121,7 +120,6 @@ impl<'a, 'b: 'a> DebugStruct<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_tuple` method.
 #[must_use]
-#[allow(missing_debug_implementations)]
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugTuple<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,
@@ -233,7 +231,6 @@ impl<'a, 'b: 'a> DebugInner<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_set` method.
 #[must_use]
-#[allow(missing_debug_implementations)]
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugSet<'a, 'b: 'a> {
     inner: DebugInner<'a, 'b>,
@@ -282,7 +279,6 @@ impl<'a, 'b: 'a> DebugSet<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_list` method.
 #[must_use]
-#[allow(missing_debug_implementations)]
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugList<'a, 'b: 'a> {
     inner: DebugInner<'a, 'b>,
@@ -331,7 +327,6 @@ impl<'a, 'b: 'a> DebugList<'a, 'b> {
 ///
 /// Constructed by the `Formatter::debug_map` method.
 #[must_use]
-#[allow(missing_debug_implementations)]
 #[stable(feature = "debug_builders", since = "1.2.0")]
 pub struct DebugMap<'a, 'b: 'a> {
     fmt: &'a mut fmt::Formatter<'b>,

branches/beta/src/libcore/fmt/builders.rs

@@ -14,7 +14,7 @@
 
 use prelude::v1::*;
 
-use cell::{UnsafeCell, Cell, RefCell, Ref, RefMut, BorrowState};
+use cell::{Cell, RefCell, Ref, RefMut, BorrowState};
 use marker::PhantomData;
 use mem;
 use num::flt2dec;
@@ -25,7 +25,6 @@ use str;
 
 #[unstable(feature = "fmt_flags_align", issue = "27726")]
 /// Possible alignments returned by `Formatter::align`
-#[derive(Debug)]
 pub enum Alignment {
     /// Indication that contents should be left-aligned.
     Left,
@@ -153,7 +152,6 @@ impl<'a, W: Write + ?Sized> Write for &'a mut W {
 /// A struct to represent both where to emit formatting strings to and how they
 /// should be formatted. A mutable version of this is passed to all formatting
 /// traits.
-#[allow(missing_debug_implementations)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct Formatter<'a> {
     flags: u32,
@@ -177,7 +175,6 @@ enum Void {}
 /// compile time it is ensured that the function and the value have the correct
 /// types, and then this struct is used to canonicalize arguments to one type.
 #[derive(Copy)]
-#[allow(missing_debug_implementations)]
 #[unstable(feature = "fmt_internals", reason = "internal to format_args!",
            issue = "0")]
 #[doc(hidden)]
@@ -1588,9 +1585,7 @@ impl<T: ?Sized> Debug for PhantomData<T> {
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T: Copy + Debug> Debug for Cell<T> {
     fn fmt(&self, f: &mut Formatter) -> Result {
-        f.debug_struct("Cell")
-            .field("value", &self.get())
-            .finish()
+        write!(f, "Cell {{ value: {:?} }}", self.get())
     }
 }
 
@@ -1599,15 +1594,9 @@ impl<T: ?Sized + Debug> Debug for RefCell<T> {
     fn fmt(&self, f: &mut Formatter) -> Result {
         match self.borrow_state() {
             BorrowState::Unused | BorrowState::Reading => {
-                f.debug_struct("RefCell")
-                    .field("value", &self.borrow())
-                    .finish()
-            }
-            BorrowState::Writing => {
-                f.debug_struct("RefCell")
-                    .field("value", &"<borrowed>")
-                    .finish()
+                write!(f, "RefCell {{ value: {:?} }}", self.borrow())
             }
+            BorrowState::Writing => write!(f, "RefCell {{ <borrowed> }}"),
         }
     }
 }
@@ -1626,12 +1615,5 @@ impl<'b, T: ?Sized + Debug> Debug for RefMut<'b, T> {
     }
 }
 
-#[stable(feature = "core_impl_debug", since = "1.9.0")]
-impl<T: ?Sized + Debug> Debug for UnsafeCell<T> {
-    fn fmt(&self, f: &mut Formatter) -> Result {
-        f.pad("UnsafeCell")
-    }
-}
-
 // If you expected tests to be here, look instead at the run-pass/ifmt.rs test,
 // it's a lot easier than creating all of the rt::Piece structures here.

branches/beta/src/libcore/fmt/mod.rs

@@ -13,7 +13,6 @@
 //!
 //! These definitions are similar to their `ct` equivalents, but differ in that
 //! these can be statically allocated and are slightly optimized for the runtime
-#![allow(missing_debug_implementations)]
 
 #[derive(Copy, Clone)]
 pub struct Argument {

branches/beta/src/libcore/fmt/rt/v1.rs

@@ -73,7 +73,6 @@
 
 use prelude::v1::*;
 
-use fmt;
 use marker;
 use mem;
 
@@ -216,13 +215,6 @@ pub trait BuildHasher {
 #[stable(since = "1.7.0", feature = "build_hasher")]
 pub struct BuildHasherDefault<H>(marker::PhantomData<H>);
 
-#[stable(since = "1.9.0", feature = "core_impl_debug")]
-impl<H> fmt::Debug for BuildHasherDefault<H> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("BuildHasherDefault")
-    }
-}
-
 #[stable(since = "1.7.0", feature = "build_hasher")]
 impl<H: Default + Hasher> BuildHasher for BuildHasherDefault<H> {
     type Hasher = H;

branches/beta/src/libcore/hash/mod.rs

@@ -30,7 +30,6 @@ use super::Hasher;
 /// Although the SipHash algorithm is considered to be generally strong,
 /// it is not intended for cryptographic purposes. As such, all
 /// cryptographic uses of this implementation are _strongly discouraged_.
-#[derive(Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub struct SipHasher {
     k0: u64,

branches/beta/src/libcore/hash/sip.rs

@@ -53,44 +53,53 @@ extern "rust-intrinsic" {
     // NB: These intrinsics take raw pointers because they mutate aliased
     // memory, which is not valid for either `&` or `&mut`.
 
-    #[cfg(all(stage0, not(cargobuild)))]
+    #[cfg(stage0)]
     pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(all(stage0, not(cargobuild)))]
+    #[cfg(stage0)]
     pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(all(stage0, not(cargobuild)))]
+    #[cfg(stage0)]
     pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(all(stage0, not(cargobuild)))]
+    #[cfg(stage0)]
     pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> T;
-    #[cfg(all(stage0, not(cargobuild)))]
+    #[cfg(stage0)]
     pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> T;
 
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
-    #[cfg(any(not(stage0), cargobuild))]
+    #[cfg(not(stage0))]
     pub fn atomic_cxchg_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
 
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_acq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_rel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_acqrel<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_relaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_failacq<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_acq_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
+    #[cfg(not(stage0))]
     pub fn atomic_cxchgweak_acqrel_failrelaxed<T>(dst: *mut T, old: T, src: T) -> (T, bool);
 
     pub fn atomic_load<T>(src: *const T) -> T;