---

yaml
---
r: 195947
b: refs/heads/beta
c: 606f50c
h: refs/heads/master
i:
  195945: fab2136
  195943: 2adf1ce
v: v3

Author: huonw

[refs]

@@ -29,7 +29,7 @@ refs/tags/0.12.0: f0c419429ef30723ceaf6b42f9b5a2aeb5d2e2d1
 refs/heads/automation-fail: 1bf06495443584539b958873e04cc2f864ab10e4
 refs/heads/batch: b7fd822592a4fb577552d93010c4a4e14f314346
 refs/heads/building: 126db549b038c84269a1e4fe46f051b2c15d6970
-refs/heads/beta: acdb0f9c788dca961d2b6cd5ca5304d4c63768a0
+refs/heads/beta: 606f50c46dd9a3852d36456d2015e1ccf832642e
 refs/heads/windistfix: 7608dbad651f02e837ed05eef3d74a6662a6e928
 refs/tags/1.0.0-alpha: e42bd6d93a1d3433c486200587f8f9e12590a4d7
 refs/heads/tmp: 9de34a84bb300bab1bf0227f577331620cd60511

branches/beta/configure

@@ -526,8 +526,7 @@ VAL_OPTIONS=""
 opt valgrind 0 "run tests with valgrind (memcheck by default)"
 opt helgrind 0 "run tests with helgrind instead of memcheck"
 opt valgrind-rpass 1 "run rpass-valgrind tests with valgrind"
-opt docs     1 "build standard library documentation"
-opt compiler-docs     0 "build compiler documentation"
+opt docs     1 "build documentation"
 opt optimize 1 "build optimized rust code"
 opt optimize-cxx 1 "build optimized C++ code"
 opt optimize-llvm 1 "build optimized LLVM"

branches/beta/mk/crates.mk

@@ -122,34 +122,17 @@ ONLY_RLIB_rustc_bitflags := 1
 # You should not need to edit below this line
 ################################################################################
 
-# On channels where the only usable crate is std, only build documentation for
-# std. This keeps distributions small and doesn't clutter up the API docs with
-# confusing internal details from the crates behind the facade.
-#
-# (Disabled while cmr figures out how to change rustdoc to make reexports work
-# slightly nicer. Otherwise, all cross-crate links to Vec will go to
-# libcollections, breaking them, and [src] links for anything reexported will
-# not work.)
-
-#ifeq ($(CFG_RELEASE_CHANNEL),stable)
-#DOC_CRATES := std
-#else
-#ifeq ($(CFG_RELEASE_CHANNEL),beta)
-#DOC_CRATES := std
-#else
 DOC_CRATES := $(filter-out rustc, \
-	   $(filter-out rustc_trans, \
-	   $(filter-out rustc_typeck, \
-	   $(filter-out rustc_borrowck, \
-	   $(filter-out rustc_resolve, \
-	   $(filter-out rustc_driver, \
-	   $(filter-out rustc_privacy, \
-	   $(filter-out rustc_lint, \
-	   $(filter-out log, \
-	   $(filter-out getopts, \
-	   $(filter-out syntax, $(CRATES))))))))))))
-#endif
-#endif
+              $(filter-out rustc_trans, \
+              $(filter-out rustc_typeck, \
+              $(filter-out rustc_borrowck, \
+              $(filter-out rustc_resolve, \
+              $(filter-out rustc_driver, \
+              $(filter-out rustc_privacy, \
+              $(filter-out rustc_lint, \
+              $(filter-out log, \
+              $(filter-out getopts, \
+              $(filter-out syntax, $(CRATES))))))))))))
 COMPILER_DOC_CRATES := rustc rustc_trans rustc_borrowck rustc_resolve \
                        rustc_typeck rustc_driver syntax rustc_privacy \
                        rustc_lint

branches/beta/mk/docs.mk

@@ -259,10 +259,7 @@ doc/$(1)/index.html: $$(LIB_DOC_DEP_$(1)) doc/$(1)/
 endef
 
 $(foreach crate,$(DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),DOC_TARGETS)))
-
-ifdef CFG_COMPILER_DOCS
-  $(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
-endif
+$(foreach crate,$(COMPILER_DOC_CRATES),$(eval $(call DEF_LIB_DOC,$(crate),COMPILER_DOC_TARGETS)))
 
 ifdef CFG_DISABLE_DOCS
   $(info cfg: disabling doc build (CFG_DISABLE_DOCS))

branches/beta/src/doc/reference.md

@@ -1188,15 +1188,12 @@ the guarantee that these issues are never caused by safe code.
 
 * Data races
 * Dereferencing a null/dangling raw pointer
+* Mutating an immutable value/reference without `UnsafeCell`
 * Reads of [undef](http://llvm.org/docs/LangRef.html#undefined-values)
   (uninitialized) memory
 * Breaking the [pointer aliasing
   rules](http://llvm.org/docs/LangRef.html#pointer-aliasing-rules)
   with raw pointers (a subset of the rules used by C)
-* `&mut` and `&` follow LLVM’s scoped [noalias] model, except if the `&T`
-  contains an `UnsafeCell<U>`. Unsafe code must not violate these aliasing
-  guarantees.
-* Mutating an immutable value/reference without `UnsafeCell<U>`
 * Invoking undefined behavior via compiler intrinsics:
   * Indexing outside of the bounds of an object with `std::ptr::offset`
     (`offset` intrinsic), with
@@ -1213,8 +1210,6 @@ the guarantee that these issues are never caused by safe code.
   code. Rust's failure system is not compatible with exception handling in
   other languages. Unwinding must be caught and handled at FFI boundaries.
 
-[noalias]: http://llvm.org/docs/LangRef.html#noalias
-
 ##### Behaviour not considered unsafe
 
 This is a list of behaviour not considered *unsafe* in Rust terms, but that may

branches/beta/src/doc/trpl/method-syntax.md

@@ -50,9 +50,9 @@ parameter, of which there are three variants: `self`, `&self`, and `&mut self`.
 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 you should prefer
-borrowing over taking ownership, as well as taking immutable references
-over mutable ones. Here's an example of all three variants:
+a mutable reference. We should default to using `&self`, as it's the most
+common, as Rustaceans prefer borrowing over taking ownership, and references 
+over mutable references. Here's an example of all three variants:
 
 ```rust
 struct Circle {
@@ -181,23 +181,17 @@ impl Circle {
 }
 
 struct CircleBuilder {
-    x: f64,
-    y: f64,
+    coordinate: f64,
     radius: f64,
 }
 
 impl CircleBuilder {
     fn new() -> CircleBuilder {
-        CircleBuilder { x: 0.0, y: 0.0, radius: 0.0, }
-    }
-
-    fn x(&mut self, coordinate: f64) -> &mut CircleBuilder {
-        self.x = coordinate;
-        self
+        CircleBuilder { coordinate: 0.0, radius: 0.0, }
     }
 
-    fn y(&mut self, coordinate: f64) -> &mut CircleBuilder {
-        self.x = coordinate;
+    fn coordinate(&mut self, coordinate: f64) -> &mut CircleBuilder {
+        self.coordinate = coordinate;
         self
     }
 
@@ -207,20 +201,18 @@ impl CircleBuilder {
     }
 
     fn finalize(&self) -> Circle {
-        Circle { x: self.x, y: self.y, radius: self.radius }
+        Circle { x: self.coordinate, y: self.coordinate, radius: self.radius }
     }
 }
 
 fn main() {
     let c = CircleBuilder::new()
-                .x(1.0)
-                .y(2.0)
-                .radius(2.0)
+                .coordinate(10.0)
+                .radius(5.0)
                 .finalize();
 
+
     println!("area: {}", c.area());
-    println!("x: {}", c.x);
-    println!("y: {}", c.y);
 }
 ```
 

branches/beta/src/doc/trpl/ownership.md

@@ -472,15 +472,10 @@ thread-safe counterpart of `Rc<T>`.
 
 ## Lifetime Elision
 
-Rust supports powerful local type inference in function bodies, but it’s
-forbidden in item signatures to allow reasoning about the types just based in
-the item signature alone. However, for ergonomic reasons a very restricted
-secondary inference algorithm called “lifetime elision” applies in function
-signatures. It infers only based on the signature components themselves and not
-based on the body of the function, only infers lifetime paramters, and does
-this with only three easily memorizable and unambiguous rules. This makes
-lifetime elision a shorthand for writing an item signature, while not hiding
-away the actual types involved as full local inference would if applied to it.
+Earlier, we mentioned *lifetime elision*, a feature of Rust which allows you to
+not write lifetime annotations in certain circumstances. All references have a
+lifetime, and so if you elide a lifetime (like `&T` instead of `&'a T`), Rust
+will do three things to determine what those lifetimes should be.
 
 When talking about lifetime elision, we use the term *input lifetime* and
 *output lifetime*. An *input lifetime* is a lifetime associated with a parameter

branches/beta/src/doc/trpl/testing.md

@@ -231,7 +231,7 @@ pub fn add_two(a: i32) -> i32 {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::add_two;
 
     #[test]
@@ -241,7 +241,7 @@ mod test {
 }
 ```
 
-There's a few changes here. The first is the introduction of a `mod test` with
+There's a few changes here. The first is the introduction of a `mod tests` with
 a `cfg` attribute. The module allows us to group all of our tests together, and
 to also define helper functions if needed, that don't become a part of the rest
 of our crate. The `cfg` attribute only compiles our test code if we're
@@ -260,7 +260,7 @@ pub fn add_two(a: i32) -> i32 {
 }
 
 #[cfg(test)]
-mod test {
+mod tests {
     use super::*;
 
     #[test]

branches/beta/src/liballoc/arc.rs

@@ -110,7 +110,7 @@ use heap::deallocate;
 ///         let child_numbers = shared_numbers.clone();
 ///
 ///         thread::spawn(move || {
-///             let local_numbers = &child_numbers[..];
+///             let local_numbers = child_numbers.as_slice();
 ///
 ///             // Work with the local numbers
 ///         });

branches/beta/src/liballoc/boxed.rs

@@ -233,10 +233,24 @@ impl<T: ?Sized + Hash> Hash for Box<T> {
     }
 }
 
-impl Box<Any> {
-    #[inline]
+/// Extension methods for an owning `Any` trait object.
+#[unstable(feature = "alloc",
+           reason = "this trait will likely disappear once compiler bugs blocking \
+                     a direct impl on `Box<Any>` have been fixed ")]
+// FIXME(#18737): this should be a direct impl on `Box<Any>`. If you're
+//                removing this please make sure that you can downcase on
+//                `Box<Any + Send>` as well as `Box<Any>`
+pub trait BoxAny {
+    /// Returns the boxed value if it is of type `T`, or
+    /// `Err(Self)` if it isn't.
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>>;
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BoxAny for Box<Any> {
+    #[inline]
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         if self.is::<T>() {
             unsafe {
                 // Get the raw representation of the trait object
@@ -253,10 +267,10 @@ impl Box<Any> {
     }
 }
 
-impl Box<Any+Send> {
+#[stable(feature = "rust1", since = "1.0.0")]
+impl BoxAny for Box<Any+Send> {
     #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
+    fn downcast<T: Any>(self) -> Result<Box<T>, Box<Any>> {
         <Box<Any>>::downcast(self)
     }
 }

branches/beta/src/liballoc/boxed_test.rs

@@ -17,6 +17,7 @@ use core::clone::Clone;
 
 use std::boxed;
 use std::boxed::Box;
+use std::boxed::BoxAny;
 
 #[test]
 fn test_owned_clone() {

branches/beta/src/liballoc/heap.rs

@@ -189,6 +189,7 @@ mod imp {
     use core::option::Option;
     use core::option::Option::None;
     use core::ptr::{null_mut, null};
+    use core::num::Int;
     use libc::{c_char, c_int, c_void, size_t};
     use super::MIN_ALIGN;
 
@@ -300,7 +301,7 @@ mod imp {
             libc::realloc(ptr as *mut libc::c_void, size as libc::size_t) as *mut u8
         } else {
             let new_ptr = allocate(size, align);
-            ptr::copy(ptr, new_ptr, cmp::min(size, old_size));
+            ptr::copy(new_ptr, ptr, cmp::min(size, old_size));
             deallocate(ptr, old_size, align);
             new_ptr
         }

branches/beta/src/libcollections/bit.rs

@@ -91,6 +91,7 @@ use core::hash;
 use core::iter::RandomAccessIterator;
 use core::iter::{Chain, Enumerate, Repeat, Skip, Take, repeat, Cloned};
 use core::iter::{self, FromIterator, IntoIterator};
+use core::num::Int;
 use core::ops::Index;
 use core::slice;
 use core::{u8, u32, usize};

branches/beta/src/libcollections/borrow.rs

@@ -40,24 +40,6 @@ use self::Cow::*;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait Borrow<Borrowed: ?Sized> {
     /// Immutably borrow from an owned value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Borrow;
-    ///
-    /// fn check<T: Borrow<str>>(s: T) {
-    ///     assert_eq!("Hello", s.borrow());
-    /// }
-    ///
-    /// let s = "Hello".to_string();
-    ///
-    /// check(s);
-    ///
-    /// let s = "Hello";
-    ///
-    /// check(s);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn borrow(&self) -> &Borrowed;
 }
@@ -68,20 +50,6 @@ pub trait Borrow<Borrowed: ?Sized> {
 #[stable(feature = "rust1", since = "1.0.0")]
 pub trait BorrowMut<Borrowed: ?Sized> : Borrow<Borrowed> {
     /// Mutably borrow from an owned value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::BorrowMut;
-    ///
-    /// fn check<T: BorrowMut<[i32]>>(mut v: T) {
-    ///     assert_eq!(&mut [1, 2, 3], v.borrow_mut());
-    /// }
-    ///
-    /// let v = vec![1, 2, 3];
-    ///
-    /// check(v);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     fn borrow_mut(&mut self) -> &mut Borrowed;
 }
@@ -203,18 +171,6 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Acquire a mutable reference to the owned form of the data.
     ///
     /// Copies the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let mut cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);
-    ///
-    /// let hello = cow.to_mut();
-    ///
-    /// assert_eq!(&[1, 2, 3], hello);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
         match *self {
@@ -229,18 +185,6 @@ impl<'a, B: ?Sized> Cow<'a, B> where B: ToOwned {
     /// Extract the owned data.
     ///
     /// Copies the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let cow: Cow<[_]> = Cow::Owned(vec![1, 2, 3]);
-    ///
-    /// let hello = cow.into_owned();
-    ///
-    /// assert_eq!(vec![1, 2, 3], hello);
-    /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn into_owned(self) -> <B as ToOwned>::Owned {
         match self {