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

9 files changed, 32 insertions, 30 deletions

diff --git a/src/libstd/sys/common/gnu/libbacktrace.rs b/src/libstd/sys/common/gnu/libbacktrace.rs
index 3b846fd462e..f8463388384 100644
--- a/src/libstd/sys/common/gnu/libbacktrace.rs
+++ b/src/libstd/sys/common/gnu/libbacktrace.rs
@@ -134,9 +134,9 @@ pub fn print(w: &mut Write, idx: isize, addr: *mut libc::c_void,
             } else {
                 None
             };
-        let filename = match selfname.as_ref().and_then(|s| s.as_os_str().to_bytes()) {
+        let filename = match selfname.as_ref().and_then(|s| s.to_str()) {
             Some(path) => {
-                let bytes = path;
+                let bytes = path.as_bytes();
                 if bytes.len() < LAST_FILENAME.len() {
                     let i = bytes.iter();
                     for (slot, val) in LAST_FILENAME.iter_mut().zip(i) {
diff --git a/src/libstd/sys/common/net.rs b/src/libstd/sys/common/net.rs
index 449cd9d8c97..7e05895b2cc 100644
--- a/src/libstd/sys/common/net.rs
+++ b/src/libstd/sys/common/net.rs
@@ -15,6 +15,7 @@ use fmt;
 use io::{self, Error, ErrorKind};
 use libc::{c_int, c_char, c_void};
 use mem;
+#[allow(deprecated)]
 use net::{SocketAddr, Shutdown, IpAddr};
 use ptr;
 use str::from_utf8;
@@ -129,6 +130,7 @@ pub fn lookup_host(host: &str) -> io::Result<LookupHost> {
 // lookup_addr
 ////////////////////////////////////////////////////////////////////////////////
 
+#[allow(deprecated)]
 pub fn lookup_addr(addr: &IpAddr) -> io::Result<String> {
     init();
 
diff --git a/src/libstd/sys/common/wtf8.rs b/src/libstd/sys/common/wtf8.rs
index 702a34633dc..2e092d5f770 100644
--- a/src/libstd/sys/common/wtf8.rs
+++ b/src/libstd/sys/common/wtf8.rs
@@ -243,7 +243,7 @@ impl Wtf8Buf {
     /// Append a UTF-8 slice at the end of the string.
     #[inline]
     pub fn push_str(&mut self, other: &str) {
-        self.bytes.push_all(other.as_bytes())
+        self.bytes.extend_from_slice(other.as_bytes())
     }
 
     /// Append a WTF-8 slice at the end of the string.
@@ -262,9 +262,9 @@ impl Wtf8Buf {
                 // 4 bytes for the supplementary code point
                 self.bytes.reserve(4 + other_without_trail_surrogate.len());
                 self.push_char(decode_surrogate_pair(lead, trail));
-                self.bytes.push_all(other_without_trail_surrogate);
+                self.bytes.extend_from_slice(other_without_trail_surrogate);
             }
-            _ => self.bytes.push_all(&other.bytes)
+            _ => self.bytes.extend_from_slice(&other.bytes)
         }
     }
 
@@ -331,10 +331,8 @@ impl Wtf8Buf {
             match self.next_surrogate(pos) {
                 Some((surrogate_pos, _)) => {
                     pos = surrogate_pos + 3;
-                    slice::bytes::copy_memory(
-                        UTF8_REPLACEMENT_CHARACTER,
-                        &mut self.bytes[surrogate_pos .. pos],
-                    );
+                    self.bytes[surrogate_pos..pos]
+                        .clone_from_slice(UTF8_REPLACEMENT_CHARACTER);
                 },
                 None => return unsafe { String::from_utf8_unchecked(self.bytes) }
             }
@@ -493,18 +491,18 @@ impl Wtf8 {
         };
         let wtf8_bytes = &self.bytes;
         let mut utf8_bytes = Vec::with_capacity(self.len());
-        utf8_bytes.push_all(&wtf8_bytes[..surrogate_pos]);
-        utf8_bytes.push_all(UTF8_REPLACEMENT_CHARACTER);
+        utf8_bytes.extend_from_slice(&wtf8_bytes[..surrogate_pos]);
+        utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER);
         let mut pos = surrogate_pos + 3;
         loop {
             match self.next_surrogate(pos) {
                 Some((surrogate_pos, _)) => {
-                    utf8_bytes.push_all(&wtf8_bytes[pos .. surrogate_pos]);
-                    utf8_bytes.push_all(UTF8_REPLACEMENT_CHARACTER);
+                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos .. surrogate_pos]);
+                    utf8_bytes.extend_from_slice(UTF8_REPLACEMENT_CHARACTER);
                     pos = surrogate_pos + 3;
                 },
                 None => {
-                    utf8_bytes.push_all(&wtf8_bytes[pos..]);
+                    utf8_bytes.extend_from_slice(&wtf8_bytes[pos..]);
                     return Cow::Owned(unsafe { String::from_utf8_unchecked(utf8_bytes) })
                 }
             }
diff --git a/src/libstd/sys/unix/ext/fs.rs b/src/libstd/sys/unix/ext/fs.rs
index d2a16b5de97..16e1578296d 100644
--- a/src/libstd/sys/unix/ext/fs.rs
+++ b/src/libstd/sys/unix/ext/fs.rs
@@ -246,17 +246,16 @@ pub fn symlink<P: AsRef<Path>, Q: AsRef<Path>>(src: P, dst: Q) -> io::Result<()>
     sys::fs::symlink(src.as_ref(), dst.as_ref())
 }
 
-#[unstable(feature = "dir_builder", reason = "recently added API",
-           issue = "27710")]
+#[stable(feature = "dir_builder", since = "1.6.0")]
 /// An extension trait for `fs::DirBuilder` for unix-specific options.
 pub trait DirBuilderExt {
     /// Sets the mode to create new directories with. This option defaults to
     /// 0o777.
+    #[stable(feature = "dir_builder", since = "1.6.0")]
     fn mode(&mut self, mode: raw::mode_t) -> &mut Self;
 }
 
-#[unstable(feature = "dir_builder", reason = "recently added API",
-           issue = "27710")]
+#[stable(feature = "dir_builder", since = "1.6.0")]
 impl DirBuilderExt for fs::DirBuilder {
     fn mode(&mut self, mode: raw::mode_t) -> &mut fs::DirBuilder {
         self.as_inner_mut().set_mode(mode);
diff --git a/src/libstd/sys/unix/fs.rs b/src/libstd/sys/unix/fs.rs
index 018c9100288..8ea8f0c6c77 100644
--- a/src/libstd/sys/unix/fs.rs
+++ b/src/libstd/sys/unix/fs.rs
@@ -355,8 +355,7 @@ impl DirBuilder {
 }
 
 fn cstr(path: &Path) -> io::Result<CString> {
-    path.as_os_str().to_cstring().ok_or(
-        io::Error::new(io::ErrorKind::InvalidInput, "path contained a null"))
+    Ok(try!(CString::new(path.as_os_str().as_bytes())))
 }
 
 impl FromInner<c_int> for File {
diff --git a/src/libstd/sys/unix/os.rs b/src/libstd/sys/unix/os.rs
index dabc8090270..c2bf0651cff 100644
--- a/src/libstd/sys/unix/os.rs
+++ b/src/libstd/sys/unix/os.rs
@@ -149,7 +149,7 @@ pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
         if path.contains(&sep) {
             return Err(JoinPathsError)
         }
-        joined.push_all(path);
+        joined.extend_from_slice(path);
     }
     Ok(OsStringExt::from_vec(joined))
 }
diff --git a/src/libstd/sys/unix/os_str.rs b/src/libstd/sys/unix/os_str.rs
index f0f08a72ed8..0524df218a1 100644
--- a/src/libstd/sys/unix/os_str.rs
+++ b/src/libstd/sys/unix/os_str.rs
@@ -53,7 +53,7 @@ impl Buf {
     }
 
     pub fn push_slice(&mut self, s: &Slice) {
-        self.inner.push_all(&s.inner)
+        self.inner.extend_from_slice(&s.inner)
     }
 }
 
diff --git a/src/libstd/sys/unix/process.rs b/src/libstd/sys/unix/process.rs
index 8d80296ab03..407fcb0a1b8 100644
--- a/src/libstd/sys/unix/process.rs
+++ b/src/libstd/sys/unix/process.rs
@@ -43,7 +43,7 @@ pub struct Command {
 impl Command {
     pub fn new(program: &OsStr) -> Command {
         Command {
-            program: program.to_cstring().unwrap(),
+            program: os2c(program),
             args: Vec::new(),
             env: None,
             cwd: None,
@@ -54,10 +54,10 @@ impl Command {
     }
 
     pub fn arg(&mut self, arg: &OsStr) {
-        self.args.push(arg.to_cstring().unwrap())
+        self.args.push(os2c(arg));
     }
     pub fn args<'a, I: Iterator<Item = &'a OsStr>>(&mut self, args: I) {
-        self.args.extend(args.map(|s| s.to_cstring().unwrap()))
+        self.args.extend(args.map(os2c));
     }
     fn init_env_map(&mut self) {
         if self.env.is_none() {
@@ -76,10 +76,14 @@ impl Command {
         self.env = Some(HashMap::new())
     }
     pub fn cwd(&mut self, dir: &OsStr) {
-        self.cwd = Some(dir.to_cstring().unwrap())
+        self.cwd = Some(os2c(dir));
     }
 }
 
+fn os2c(s: &OsStr) -> CString {
+    CString::new(s.as_bytes()).unwrap()
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 // Processes
 ////////////////////////////////////////////////////////////////////////////////
@@ -430,9 +434,9 @@ fn make_envp(env: Option<&HashMap<OsString, OsString>>)
 
         for pair in env {
             let mut kv = Vec::new();
-            kv.push_all(pair.0.as_bytes());
+            kv.extend_from_slice(pair.0.as_bytes());
             kv.push('=' as u8);
-            kv.push_all(pair.1.as_bytes());
+            kv.extend_from_slice(pair.1.as_bytes());
             kv.push(0); // terminating null
             tmps.push(kv);
         }
diff --git a/src/libstd/sys/windows/os.rs b/src/libstd/sys/windows/os.rs
index 4396b90a5ce..48c9b70dce4 100644
--- a/src/libstd/sys/windows/os.rs
+++ b/src/libstd/sys/windows/os.rs
@@ -196,10 +196,10 @@ pub fn join_paths<I, T>(paths: I) -> Result<OsString, JoinPathsError>
             return Err(JoinPathsError)
         } else if v.contains(&sep) {
             joined.push(b'"' as u16);
-            joined.push_all(&v[..]);
+            joined.extend_from_slice(&v[..]);
             joined.push(b'"' as u16);
         } else {
-            joined.push_all(&v[..]);
+            joined.extend_from_slice(&v[..]);
         }
     }