std: Stabilize APIs for the 1.6 release

This commit is the standard API stabilization commit for the 1.6 release cycle.
The list of issues and APIs below have all been through their cycle-long FCP and
the libs team decisions are listed below

Stabilized APIs

* `Read::read_exact`
* `ErrorKind::UnexpectedEof` (renamed from `UnexpectedEOF`)
* libcore -- this was a bit of a nuanced stabilization, the crate itself is now
  marked as `#[stable]` and the methods appearing via traits for primitives like
  `char` and `str` are now also marked as stable. Note that the extension traits
  themeselves are marked as unstable as they're imported via the prelude. The
  `try!` macro was also moved from the standard library into libcore to have the
  same interface. Otherwise the functions all have copied stability from the
  standard library now.
* The `#![no_std]` attribute
* `fs::DirBuilder`
* `fs::DirBuilder::new`
* `fs::DirBuilder::recursive`
* `fs::DirBuilder::create`
* `os::unix::fs::DirBuilderExt`
* `os::unix::fs::DirBuilderExt::mode`
* `vec::Drain`
* `vec::Vec::drain`
* `string::Drain`
* `string::String::drain`
* `vec_deque::Drain`
* `vec_deque::VecDeque::drain`
* `collections::hash_map::Drain`
* `collections::hash_map::HashMap::drain`
* `collections::hash_set::Drain`
* `collections::hash_set::HashSet::drain`
* `collections::binary_heap::Drain`
* `collections::binary_heap::BinaryHeap::drain`
* `Vec::extend_from_slice` (renamed from `push_all`)
* `Mutex::get_mut`
* `Mutex::into_inner`
* `RwLock::get_mut`
* `RwLock::into_inner`
* `Iterator::min_by_key` (renamed from `min_by`)
* `Iterator::max_by_key` (renamed from `max_by`)

Deprecated APIs

* `ErrorKind::UnexpectedEOF` (renamed to `UnexpectedEof`)
* `OsString::from_bytes`
* `OsStr::to_cstring`
* `OsStr::to_bytes`
* `fs::walk_dir` and `fs::WalkDir`
* `path::Components::peek`
* `slice::bytes::MutableByteVector`
* `slice::bytes::copy_memory`
* `Vec::push_all` (renamed to `extend_from_slice`)
* `Duration::span`
* `IpAddr`
* `SocketAddr::ip`
* `Read::tee`
* `io::Tee`
* `Write::broadcast`
* `io::Broadcast`
* `Iterator::min_by` (renamed to `min_by_key`)
* `Iterator::max_by` (renamed to `max_by_key`)
* `net::lookup_addr`

New APIs (still unstable)

* `<[T]>::sort_by_key` (added to mirror `min_by_key`)

Closes #27585
Closes #27704
Closes #27707
Closes #27710
Closes #27711
Closes #27727
Closes #27740
Closes #27744
Closes #27799
Closes #27801
cc #27801 (doesn't close as `Chars` is still unstable)
Closes #28968

4 files changed, 52 insertions, 20 deletions

diff --git a/src/libstd/io/cursor.rs b/src/libstd/io/cursor.rs
index e4f00c4874e..de09451e7c0 100644
--- a/src/libstd/io/cursor.rs
+++ b/src/libstd/io/cursor.rs
@@ -13,7 +13,6 @@ use io::prelude::*;
 
 use cmp;
 use io::{self, SeekFrom, Error, ErrorKind};
-use slice;
 
 /// A `Cursor` wraps another type and provides it with a
 /// [`Seek`](trait.Seek.html) implementation.
@@ -255,8 +254,8 @@ impl Write for Cursor<Vec<u8>> {
         // there (left), and what will be appended on the end (right)
         let space = self.inner.len() - pos as usize;
         let (left, right) = buf.split_at(cmp::min(space, buf.len()));
-        slice::bytes::copy_memory(left, &mut self.inner[(pos as usize)..]);
-        self.inner.push_all(right);
+        self.inner[(pos as usize)..].clone_from_slice(left);
+        self.inner.extend_from_slice(right);
 
         // Bump us forward
         self.set_position(pos + buf.len() as u64);
diff --git a/src/libstd/io/error.rs b/src/libstd/io/error.rs
index 6f18aad6235..4af9596d6d0 100644
--- a/src/libstd/io/error.rs
+++ b/src/libstd/io/error.rs
@@ -79,6 +79,7 @@ struct Custom {
 /// exhaustively match against it.
 #[derive(Copy, PartialEq, Eq, Clone, Debug)]
 #[stable(feature = "rust1", since = "1.0.0")]
+#[allow(deprecated)]
 pub enum ErrorKind {
     /// An entity was not found, often a file.
     #[stable(feature = "rust1", since = "1.0.0")]
@@ -155,9 +156,20 @@ pub enum ErrorKind {
     /// This typically means that an operation could only succeed if it read a
     /// particular number of bytes but only a smaller number of bytes could be
     /// read.
-    #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")]
+    #[unstable(feature = "read_exact_old", reason = "recently added",
+               issue = "0")]
+    #[rustc_deprecated(since = "1.6.0", reason = "renamed to UnexpectedEof")]
     UnexpectedEOF,
 
+    /// An error returned when an operation could not be completed because an
+    /// "end of file" was reached prematurely.
+    ///
+    /// This typically means that an operation could only succeed if it read a
+    /// particular number of bytes but only a smaller number of bytes could be
+    /// read.
+    #[stable(feature = "read_exact", since = "1.6.0")]
+    UnexpectedEof,
+
     /// Any I/O error not part of this list.
     #[unstable(feature = "io_error_internals",
                reason = "better expressed through extensible enums that this \
diff --git a/src/libstd/io/impls.rs b/src/libstd/io/impls.rs
index 5b587dd921b..95f630c9658 100644
--- a/src/libstd/io/impls.rs
+++ b/src/libstd/io/impls.rs
@@ -13,7 +13,6 @@ use cmp;
 use io::{self, SeekFrom, Read, Write, Seek, BufRead, Error, ErrorKind};
 use fmt;
 use mem;
-use slice;
 use string::String;
 use vec::Vec;
 
@@ -157,7 +156,7 @@ impl<'a> Read for &'a [u8] {
     fn read(&mut self, buf: &mut [u8]) -> io::Result<usize> {
         let amt = cmp::min(buf.len(), self.len());
         let (a, b) = self.split_at(amt);
-        slice::bytes::copy_memory(a, buf);
+        buf.clone_from_slice(a);
         *self = b;
         Ok(amt)
     }
@@ -165,10 +164,11 @@ impl<'a> Read for &'a [u8] {
     #[inline]
     fn read_exact(&mut self, buf: &mut [u8]) -> io::Result<()> {
         if buf.len() > self.len() {
-            return Err(Error::new(ErrorKind::UnexpectedEOF, "failed to fill whole buffer"));
+            return Err(Error::new(ErrorKind::UnexpectedEof,
+                                  "failed to fill whole buffer"));
         }
         let (a, b) = self.split_at(buf.len());
-        slice::bytes::copy_memory(a, buf);
+        buf.clone_from_slice(a);
         *self = b;
         Ok(())
     }
@@ -189,7 +189,7 @@ impl<'a> Write for &'a mut [u8] {
     fn write(&mut self, data: &[u8]) -> io::Result<usize> {
         let amt = cmp::min(data.len(), self.len());
         let (a, b) = mem::replace(self, &mut []).split_at_mut(amt);
-        slice::bytes::copy_memory(&data[..amt], a);
+        a.clone_from_slice(&data[..amt]);
         *self = b;
         Ok(amt)
     }
@@ -211,13 +211,13 @@ impl<'a> Write for &'a mut [u8] {
 impl Write for Vec<u8> {
     #[inline]
     fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
-        self.push_all(buf);
+        self.extend_from_slice(buf);
         Ok(buf.len())
     }
 
     #[inline]
     fn write_all(&mut self, buf: &[u8]) -> io::Result<()> {
-        self.push_all(buf);
+        self.extend_from_slice(buf);
         Ok(())
     }
 
diff --git a/src/libstd/io/mod.rs b/src/libstd/io/mod.rs
index ebf322fab4d..e957297bf62 100644
--- a/src/libstd/io/mod.rs
+++ b/src/libstd/io/mod.rs
@@ -593,7 +593,6 @@ pub trait Read {
     /// [file]: ../std/fs/struct.File.html
     ///
     /// ```
-    /// #![feature(read_exact)]
     /// use std::io;
     /// use std::io::prelude::*;
     /// use std::fs::File;
@@ -607,7 +606,7 @@ pub trait Read {
     /// # Ok(())
     /// # }
     /// ```
-    #[unstable(feature = "read_exact", reason = "recently added", issue = "27585")]
+    #[stable(feature = "read_exact", since = "1.6.0")]
     fn read_exact(&mut self, mut buf: &mut [u8]) -> Result<()> {
         while !buf.is_empty() {
             match self.read(buf) {
@@ -618,7 +617,7 @@ pub trait Read {
             }
         }
         if !buf.is_empty() {
-            Err(Error::new(ErrorKind::UnexpectedEOF,
+            Err(Error::new(ErrorKind::UnexpectedEof,
                            "failed to fill whole buffer"))
         } else {
             Ok(())
@@ -838,6 +837,10 @@ pub trait Read {
                                          of where errors happen is currently \
                                          unclear and may change",
                issue = "27802")]
+    #[rustc_deprecated(reason = "error handling semantics unclear and \
+                                 don't seem to have an ergonomic resolution",
+                       since = "1.6.0")]
+    #[allow(deprecated)]
     fn tee<W: Write>(self, out: W) -> Tee<Self, W> where Self: Sized {
         Tee { reader: self, writer: out }
     }
@@ -1101,6 +1104,10 @@ pub trait Write {
                                          of where errors happen is currently \
                                          unclear and may change",
                issue = "27802")]
+    #[rustc_deprecated(reason = "error handling semantics unclear and \
+                                 don't seem to have an ergonomic resolution",
+                       since = "1.6.0")]
+    #[allow(deprecated)]
     fn broadcast<W: Write>(self, other: W) -> Broadcast<Self, W>
         where Self: Sized
     {
@@ -1189,11 +1196,11 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
             };
             match available.iter().position(|x| *x == delim) {
                 Some(i) => {
-                    buf.push_all(&available[..i + 1]);
+                    buf.extend_from_slice(&available[..i + 1]);
                     (true, i + 1)
                 }
                 None => {
-                    buf.push_all(available);
+                    buf.extend_from_slice(available);
                     (false, available.len())
                 }
             }
@@ -1484,6 +1491,9 @@ pub trait BufRead: Read {
 /// [broadcast]: trait.Write.html#method.broadcast
 #[unstable(feature = "io", reason = "awaiting stability of Write::broadcast",
            issue = "27802")]
+#[rustc_deprecated(reason = "error handling semantics unclear and \
+                             don't seem to have an ergonomic resolution",
+                   since = "1.6.0")]
 pub struct Broadcast<T, U> {
     first: T,
     second: U,
@@ -1491,6 +1501,10 @@ pub struct Broadcast<T, U> {
 
 #[unstable(feature = "io", reason = "awaiting stability of Write::broadcast",
            issue = "27802")]
+#[rustc_deprecated(reason = "error handling semantics unclear and \
+                             don't seem to have an ergonomic resolution",
+                   since = "1.6.0")]
+#[allow(deprecated)]
 impl<T: Write, U: Write> Write for Broadcast<T, U> {
     fn write(&mut self, data: &[u8]) -> Result<usize> {
         let n = try!(self.first.write(data));
@@ -1593,6 +1607,9 @@ impl<T: BufRead> BufRead for Take<T> {
 /// [tee]: trait.Read.html#method.tee
 #[unstable(feature = "io", reason = "awaiting stability of Read::tee",
            issue = "27802")]
+#[rustc_deprecated(reason = "error handling semantics unclear and \
+                             don't seem to have an ergonomic resolution",
+                   since = "1.6.0")]
 pub struct Tee<R, W> {
     reader: R,
     writer: W,
@@ -1600,6 +1617,10 @@ pub struct Tee<R, W> {
 
 #[unstable(feature = "io", reason = "awaiting stability of Read::tee",
            issue = "27802")]
+#[rustc_deprecated(reason = "error handling semantics unclear and \
+                             don't seem to have an ergonomic resolution",
+                   since = "1.6.0")]
+#[allow(deprecated)]
 impl<R: Read, W: Write> Read for Tee<R, W> {
     fn read(&mut self, buf: &mut [u8]) -> Result<usize> {
         let n = try!(self.reader.read(buf));
@@ -1907,7 +1928,7 @@ mod tests {
 
         let mut c = Cursor::new(&b""[..]);
         assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEOF);
+                   io::ErrorKind::UnexpectedEof);
 
         let mut c = Cursor::new(&b"123"[..]).chain(Cursor::new(&b"456789"[..]));
         c.read_exact(&mut buf).unwrap();
@@ -1915,7 +1936,7 @@ mod tests {
         c.read_exact(&mut buf).unwrap();
         assert_eq!(&buf, b"5678");
         assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEOF);
+                   io::ErrorKind::UnexpectedEof);
     }
 
     #[test]
@@ -1924,11 +1945,11 @@ mod tests {
 
         let mut c = &b""[..];
         assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEOF);
+                   io::ErrorKind::UnexpectedEof);
 
         let mut c = &b"123"[..];
         assert_eq!(c.read_exact(&mut buf).unwrap_err().kind(),
-                   io::ErrorKind::UnexpectedEOF);
+                   io::ErrorKind::UnexpectedEof);
         // make sure the optimized (early returning) method is being used
         assert_eq!(&buf, &[0; 4]);