---

yaml
---
r: 195478
b: refs/heads/master
c: 80bf31d
h: refs/heads/master
v: v3

Author: bors

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: e10ee2c8572421c056ea68e6656fee936e0330d8
+refs/heads/master: 80bf31dd514055177b22c3dc66836d39eb5b1648
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: b3317d68910900f135f9f38e43a7a699bc736b4a
 refs/heads/try: 961e0358e1a5c0faaef606e31e9965742c1643bf

trunk/src/compiletest/compiletest.rs

@@ -18,6 +18,7 @@
 #![feature(std_misc)]
 #![feature(test)]
 #![feature(path_ext)]
+#![feature(convert)]
 #![feature(str_char)]
 
 #![deny(warnings)]

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

trunk/src/liballoc/boxed.rs

@@ -51,7 +51,7 @@ use core::prelude::*;
 use core::any::Any;
 use core::cmp::Ordering;
 use core::default::Default;
-use core::error::Error;
+use core::error::{Error, FromError};
 use core::fmt;
 use core::hash::{self, Hash};
 use core::mem;
@@ -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)
     }
 }
@@ -308,8 +322,8 @@ impl<I: DoubleEndedIterator + ?Sized> DoubleEndedIterator for Box<I> {
 impl<I: ExactSizeIterator + ?Sized> ExactSizeIterator for Box<I> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, E: Error + 'a> From<E> for Box<Error + 'a> {
-    fn from(err: E) -> Box<Error + 'a> {
+impl<'a, E: Error + 'a> FromError<E> for Box<Error + 'a> {
+    fn from_error(err: E) -> Box<Error + 'a> {
         Box::new(err)
     }
 }

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

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

trunk/src/libcollections/lib.rs

@@ -38,6 +38,7 @@
 #![feature(unsafe_no_drop_flag, filling_drop)]
 #![feature(step_by)]
 #![feature(str_char)]
+#![feature(convert)]
 #![feature(slice_patterns)]
 #![feature(debug_builders)]
 #![cfg_attr(test, feature(rand, rustc_private, test, hash, collections))]

trunk/src/libcollections/slice.rs

@@ -89,6 +89,8 @@ 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};
 use core::ptr;
@@ -555,6 +557,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));
@@ -921,6 +924,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));

trunk/src/libcollections/str.rs

@@ -1470,12 +1470,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 +1493,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")]

trunk/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",
@@ -364,14 +364,6 @@ impl String {
         self.vec
     }
 
-    /// Extract a string slice containing the entire string.
-    #[inline]
-    #[unstable(feature = "convert",
-               reason = "waiting on RFC revision")]
-    pub fn as_str(&self) -> &str {
-        self
-    }
-
     /// Pushes the given string onto this string buffer.
     ///
     /// # Examples
@@ -856,6 +848,7 @@ impl<'a, 'b> PartialEq<Cow<'a, str>> for &'b str {
 #[allow(deprecated)]
 impl Str for String {
     #[inline]
+    #[stable(feature = "rust1", since = "1.0.0")]
     fn as_slice(&self) -> &str {
         unsafe { mem::transmute(&*self.vec) }
     }

trunk/src/libcollections/vec.rs

@@ -425,18 +425,11 @@ impl<T> Vec<T> {
         }
     }
 
-    /// Extract a slice containing the entire vector.
-    #[inline]
-    #[unstable(feature = "convert",
-               reason = "waiting on RFC revision")]
-    pub fn as_slice(&self) -> &[T] {
-        self
-    }
-
     /// Deprecated: use `&mut s[..]` instead.
     #[inline]
-    #[unstable(feature = "convert",
-               reason = "waiting on RFC revision")]
+    #[unstable(feature = "collections",
+               reason = "will be replaced by slice syntax")]
+    #[deprecated(since = "1.0.0", reason = "use &mut s[..] instead")]
     pub fn as_mut_slice(&mut self) -> &mut [T] {
         &mut self[..]
     }
@@ -830,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")]
@@ -1649,6 +1642,13 @@ impl<T> AsRef<Vec<T>> for Vec<T> {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T> Into<Vec<T>> for Vec<T> {
+    fn into(self) -> Vec<T> {
+        self
+    }
+}
+
 #[stable(feature = "rust1", since = "1.0.0")]
 impl<T> AsRef<[T]> for Vec<T> {
     fn as_ref(&self) -> &[T] {

trunk/src/libcollections/vec_deque.rs

@@ -25,6 +25,8 @@ 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};
 use core::slice;
@@ -525,8 +527,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> {

trunk/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!");
 }

trunk/src/libcollectionstest/lib.rs

@@ -21,7 +21,6 @@
 #![feature(unicode)]
 #![feature(unsafe_destructor)]
 #![feature(into_cow)]
-#![feature(convert)]
 #![cfg_attr(test, feature(str_char))]
 
 #[macro_use] extern crate log;

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

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

trunk/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>() },