---

yaml
---
r: 195699
b: refs/heads/auto
c: 5872ae4
h: refs/heads/master
i:
  195697: 45ea570
  195695: defb8ab
v: v3

Author: frewsxcv

[refs]

@@ -10,7 +10,7 @@ refs/tags/release-0.3: b5f0d0f648d9a6153664837026ba1be43d3e2503
 refs/tags/release-0.3.1: 495bae036dfe5ec6ceafd3312b4dca48741e845b
 refs/tags/release-0.4: e828ea2080499553b97dfe33b3f4d472b4562ad7
 refs/tags/release-0.5: 7e3bcfbf21278251ee936ad53e92e9b719702d73
-refs/heads/auto: 6d2c640cf00aad6345bd93b0b64c8b3d3d2fcf50
+refs/heads/auto: 5872ae4a7a76ba67e702323d2de09a86fb5ba692
 refs/heads/servo: af82457af293e2a842ba6b7759b70288da276167
 refs/tags/release-0.6: b4ebcfa1812664df5e142f0134a5faea3918544c
 refs/tags/0.1: b19db808c2793fe2976759b85a355c3ad8c8b336

branches/auto/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/auto/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/auto/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/auto/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;
 

branches/auto/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/auto/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 {

branches/auto/src/libcollections/enum_set.rs

@@ -16,6 +16,7 @@
 use core::prelude::*;
 use core::marker;
 use core::fmt;
+use core::num::Int;
 use core::iter::{FromIterator, IntoIterator};
 use core::ops::{Sub, BitOr, BitAnd, BitXor};
 

branches/auto/src/libcollections/slice.rs

@@ -89,7 +89,6 @@ use core::iter::MultiplicativeIterator;
 use core::marker::Sized;
 use core::mem::size_of;
 use core::mem;
-#[cfg(stage0)]
 use core::num::wrapping::WrappingOps;
 use core::ops::FnMut;
 use core::option::Option::{self, Some, None};
@@ -557,6 +556,7 @@ impl<T> [T] {
     /// ```rust
     /// # #![feature(core)]
     /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+    /// let s = s.as_slice();
     ///
     /// let seek = 13;
     /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
@@ -923,6 +923,7 @@ impl<T> [T] {
     /// ```rust
     /// # #![feature(core)]
     /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
+    /// let s = s.as_slice();
     ///
     /// assert_eq!(s.binary_search(&13),  Ok(9));
     /// assert_eq!(s.binary_search(&4),   Err(7));

branches/auto/src/libcollections/str.rs

@@ -18,6 +18,9 @@
 //! (see below). It is not possible to move out of borrowed strings because they
 //! are owned elsewhere.
 //!
+//! Basic operations are implemented directly by the compiler, but more advanced
+//! operations are defined as methods on the `str` type.
+//!
 //! # Examples
 //!
 //! Here's some code that uses a `&str`:
@@ -1470,12 +1473,12 @@ impl str {
     /// let gr1 = "a\u{310}e\u{301}o\u{308}\u{332}".graphemes(true).collect::<Vec<&str>>();
     /// let b: &[_] = &["a\u{310}", "e\u{301}", "o\u{308}\u{332}"];
     ///
-    /// assert_eq!(&gr1[..], b);
+    /// assert_eq!(gr1.as_slice(), b);
     ///
     /// let gr2 = "a\r\nb🇷🇺🇸🇹".graphemes(true).collect::<Vec<&str>>();
     /// let b: &[_] = &["a", "\r\n", "b", "🇷🇺🇸🇹"];
     ///
-    /// assert_eq!(&gr2[..], b);
+    /// assert_eq!(gr2.as_slice(), b);
     /// ```
     #[unstable(feature = "unicode",
                reason = "this functionality may only be provided by libunicode")]
@@ -1493,7 +1496,7 @@ impl str {
     /// let gr_inds = "a̐éö̲\r\n".grapheme_indices(true).collect::<Vec<(usize, &str)>>();
     /// let b: &[_] = &[(0, "a̐"), (3, "é"), (6, "ö̲"), (11, "\r\n")];
     ///
-    /// assert_eq!(&gr_inds[..], b);
+    /// assert_eq!(gr_inds.as_slice(), b);
     /// ```
     #[unstable(feature = "unicode",
                reason = "this functionality may only be provided by libunicode")]

branches/auto/src/libcollections/string.rs

@@ -93,7 +93,7 @@ impl String {
     /// ```
     /// # #![feature(collections, core)]
     /// let s = String::from_str("hello");
-    /// assert_eq!(&s[..], "hello");
+    /// assert_eq!(s.as_slice(), "hello");
     /// ```
     #[inline]
     #[unstable(feature = "collections",

branches/auto/src/libcollections/vec.rs

@@ -823,13 +823,13 @@ impl<T> Vec<T> {
     /// # #![feature(collections, core)]
     /// let v = vec![0, 1, 2];
     /// let w = v.map_in_place(|i| i + 3);
-    /// assert_eq!(&w[..], &[3, 4, 5]);
+    /// assert_eq!(w.as_slice(), [3, 4, 5].as_slice());
     ///
     /// #[derive(PartialEq, Debug)]
     /// struct Newtype(u8);
     /// let bytes = vec![0x11, 0x22];
     /// let newtyped_bytes = bytes.map_in_place(|x| Newtype(x));
-    /// assert_eq!(&newtyped_bytes[..], &[Newtype(0x11), Newtype(0x22)]);
+    /// assert_eq!(newtyped_bytes.as_slice(), [Newtype(0x11), Newtype(0x22)].as_slice());
     /// ```
     #[unstable(feature = "collections",
                reason = "API may change to provide stronger guarantees")]

branches/auto/src/libcollections/vec_deque.rs

@@ -25,7 +25,6 @@ use core::default::Default;
 use core::fmt;
 use core::iter::{self, repeat, FromIterator, IntoIterator, RandomAccessIterator};
 use core::mem;
-#[cfg(stage0)]
 use core::num::wrapping::WrappingOps;
 use core::ops::{Index, IndexMut};
 use core::ptr::{self, Unique};
@@ -527,8 +526,7 @@ impl<T> VecDeque<T> {
     /// buf.push_back(3);
     /// buf.push_back(4);
     /// let b: &[_] = &[&5, &3, &4];
-    /// let c: Vec<&i32> = buf.iter().collect();
-    /// assert_eq!(&c[..], b);
+    /// assert_eq!(buf.iter().collect::<Vec<&i32>>().as_slice(), b);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn iter(&self) -> Iter<T> {

branches/auto/src/libcollectionstest/fmt.rs

@@ -13,5 +13,5 @@ use std::fmt;
 #[test]
 fn test_format() {
     let s = fmt::format(format_args!("Hello, {}!", "world"));
-    assert_eq!(&s[..], "Hello, world!");
+    assert_eq!(s.as_slice(), "Hello, world!");
 }

branches/auto/src/libcollectionstest/slice.rs

@@ -59,7 +59,7 @@ fn test_from_elem() {
     // Test on-heap from_elem.
     v = vec![20; 6];
     {
-        let v = &v[..];
+        let v = v.as_slice();
         assert_eq!(v[0], 20);
         assert_eq!(v[1], 20);
         assert_eq!(v[2], 20);

branches/auto/src/libcollectionstest/str.rs

@@ -1470,9 +1470,9 @@ fn test_split_strator() {
 fn test_str_default() {
     use std::default::Default;
 
-    fn t<S: Default + AsRef<str>>() {
+    fn t<S: Default + Str>() {
         let s: S = Default::default();
-        assert_eq!(s.as_ref(), "");
+        assert_eq!(s.as_slice(), "");
     }
 
     t::<&str>();

branches/auto/src/libcore/any.rs

@@ -202,7 +202,8 @@ pub struct TypeId {
 impl TypeId {
     /// Returns the `TypeId` of the type this generic function has been
     /// instantiated with
-    #[stable(feature = "rust1", since = "1.0.0")]
+    #[unstable(feature = "core",
+               reason = "may grow a `Reflect` bound soon via marker traits")]
     pub fn of<T: ?Sized + Any>() -> TypeId {
         TypeId {
             t: unsafe { intrinsics::type_id::<T>() },

branches/auto/src/libcore/cmp.rs

@@ -20,6 +20,8 @@
 //!
 //! ```
 //! # #![feature(core)]
+//! use std::num::SignedInt;
+//!
 //! struct FuzzyNum {
 //!     num: i32,
 //! }
@@ -360,8 +362,6 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
 
 /// Compare and return the minimum of two values.
 ///
-/// Returns the first argument if the comparison determines them to be equal.
-///
 /// # Examples
 ///
 /// ```
@@ -373,13 +373,11 @@ pub trait PartialOrd<Rhs: ?Sized = Self>: PartialEq<Rhs> {
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn min<T: Ord>(v1: T, v2: T) -> T {
-    if v1 <= v2 { v1 } else { v2 }
+    if v1 < v2 { v1 } else { v2 }
 }
 
 /// Compare and return the maximum of two values.
 ///
-/// Returns the second argument if the comparison determines them to be equal.
-///
 /// # Examples
 ///
 /// ```
@@ -391,7 +389,7 @@ pub fn min<T: Ord>(v1: T, v2: T) -> T {
 #[inline]
 #[stable(feature = "rust1", since = "1.0.0")]
 pub fn max<T: Ord>(v1: T, v2: T) -> T {
-    if v2 >= v1 { v2 } else { v1 }
+    if v1 > v2 { v1 } else { v2 }
 }
 
 /// Compare and return the minimum of two values if there is one.
@@ -429,7 +427,7 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 
 /// Compare and return the maximum of two values if there is one.
 ///
-/// Returns the second argument if the comparison determines them to be equal.
+/// Returns the first argument if the comparison determines them to be equal.
 ///
 /// # Examples
 ///
@@ -454,8 +452,8 @@ pub fn partial_min<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
 #[unstable(feature = "core")]
 pub fn partial_max<T: PartialOrd>(v1: T, v2: T) -> Option<T> {
     match v1.partial_cmp(&v2) {
-        Some(Equal) | Some(Less) => Some(v2),
-        Some(Greater) => Some(v1),
+        Some(Less) => Some(v2),
+        Some(Equal) | Some(Greater) => Some(v1),
         None => None
     }
 }

branches/auto/src/libcore/fmt/num.rs

@@ -33,7 +33,6 @@ trait GenericRadix {
     fn digit(&self, x: u8) -> u8;
 
     /// Format an integer using the radix using a formatter.
-    #[allow(deprecated)] // Int
     fn fmt_int<T: Int>(&self, mut x: T, f: &mut fmt::Formatter) -> fmt::Result {
         // The radix can be as low as 2, so we need a buffer of at least 64
         // characters for a base 2 number.