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

Author: alexcrichton

src/compiletest/compiletest.rs

@@ -16,8 +16,6 @@
 #![feature(rustc_private)]
 #![feature(str_char)]
 #![feature(test)]
-#![feature(vec_push_all)]
-#![feature(path_components_peek)]
 
 #![deny(warnings)]
 

src/compiletest/runtest.rs

@@ -1009,15 +1009,12 @@ fn check_expected_errors(expected_errors: Vec<errors::ExpectedError>,
     }
 }
 
-fn is_compiler_error_or_warning(mut line: &str) -> bool {
-    // Remove initial prefix which may contain a colon
-    let mut components = Path::new(line).components();
-    if let Some(Component::Prefix(_)) = components.peek() {
-        components.next();
-    }
-
-    // Safe as path was originally constructed from a &str ^
-    line = components.as_path().to_str().unwrap();
+fn is_compiler_error_or_warning(line: &str) -> bool {
+    let mut c = Path::new(line).components();
+    let line = match c.next() {
+        Some(Component::Prefix(_)) => c.as_path().to_str().unwrap(),
+        _ => line,
+    };
 
     let mut i = 0;
     return
@@ -1314,7 +1311,7 @@ fn make_compile_args<F>(config: &Config,
                         "-L".to_owned(),
                         config.build_base.to_str().unwrap().to_owned(),
                         format!("--target={}", target));
-    args.push_all(&extras);
+    args.extend_from_slice(&extras);
     if !props.no_prefer_dynamic {
         args.push("-C".to_owned());
         args.push("prefer-dynamic".to_owned());

src/doc/book/custom-allocators.md

@@ -83,7 +83,6 @@ annotated version of `alloc_system`
 // Allocators are not allowed to depend on the standard library which in turn
 // requires an allocator in order to avoid circular dependencies. This crate,
 // however, can use all of libcore.
-#![feature(no_std)]
 #![no_std]
 
 // Let's give a unique name to our custom allocator

src/doc/book/lang-items.md

@@ -16,7 +16,7 @@ and one for deallocation. A freestanding program that uses the `Box`
 sugar for dynamic allocations via `malloc` and `free`:
 
 ```rust
-#![feature(lang_items, box_syntax, start, no_std, libc)]
+#![feature(lang_items, box_syntax, start, libc)]
 #![no_std]
 
 extern crate libc;

src/doc/book/no-stdlib.md

@@ -16,7 +16,6 @@ in the same format as C:
 # #![feature(libc)]
 #![feature(lang_items)]
 #![feature(start)]
-#![feature(no_std)]
 #![no_std]
 
 // Pull in the system libc library for what crt0.o likely requires
@@ -46,7 +45,6 @@ compiler's name mangling too:
 
 ```rust
 # #![feature(libc)]
-#![feature(no_std)]
 #![feature(lang_items)]
 #![feature(start)]
 #![no_std]
@@ -104,9 +102,6 @@ vectors provided from C, using idiomatic Rust practices.
 # #![feature(libc)]
 #![feature(lang_items)]
 #![feature(start)]
-#![feature(no_std)]
-#![feature(core)]
-#![feature(core_slice_ext)]
 #![feature(raw)]
 #![no_std]
 

src/etc/unicode.py

@@ -315,7 +315,6 @@ def emit_bsearch_range_table(f):
     f.write("""
 fn bsearch_range_table(c: char, r: &'static [(char, char)]) -> bool {
     use core::cmp::Ordering::{Equal, Less, Greater};
-    use core::slice::SliceExt;
     r.binary_search_by(|&(lo, hi)| {
          if lo <= c && c <= hi {
              Equal
@@ -358,7 +357,6 @@ def emit_conversions_module(f, to_upper, to_lower, to_title):
     f.write("pub mod conversions {")
     f.write("""
     use core::cmp::Ordering::{Equal, Less, Greater};
-    use core::slice::SliceExt;
     use core::option::Option;
     use core::option::Option::{Some, None};
     use core::result::Result::{Ok, Err};
@@ -404,7 +402,6 @@ def emit_charwidth_module(f, width_table):
     f.write("pub mod charwidth {\n")
     f.write("    use core::option::Option;\n")
     f.write("    use core::option::Option::{Some, None};\n")
-    f.write("    use core::slice::SliceExt;\n")
     f.write("    use core::result::Result::{Ok, Err};\n")
     f.write("""
     fn bsearch_range_value_table(c: char, is_cjk: bool, r: &'static [(char, char, u8, u8)]) -> u8 {

src/liballoc/boxed.rs

@@ -104,7 +104,6 @@ pub struct ExchangeHeapSingleton {
 /// See the [module-level documentation](../../std/boxed/index.html) for more.
 #[lang = "owned_box"]
 #[stable(feature = "rust1", since = "1.0.0")]
-#[fundamental]
 pub struct Box<T: ?Sized>(Unique<T>);
 
 /// `IntermediateBox` represents uninitialized backing storage for `Box`.

src/liballoc/lib.rs

@@ -75,17 +75,15 @@
 #![cfg_attr(not(stage0), needs_allocator)]
 
 #![cfg_attr(stage0, feature(rustc_attrs))]
+#![cfg_attr(stage0, feature(no_std))]
 #![cfg_attr(stage0, allow(unused_attributes))]
 #![feature(allocator)]
 #![feature(box_syntax)]
 #![feature(coerce_unsized)]
-#![feature(core)]
 #![feature(core_intrinsics)]
-#![feature(core_slice_ext)]
 #![feature(custom_attribute)]
 #![feature(fundamental)]
 #![feature(lang_items)]
-#![feature(no_std)]
 #![feature(nonzero)]
 #![feature(num_bits_bytes)]
 #![feature(optin_builtin_traits)]
@@ -103,9 +101,8 @@
 #![allow(unused_attributes)]
 #![feature(dropck_parametricity)]
 #![feature(unsize)]
-#![feature(core_slice_ext)]
-#![feature(core_str_ext)]
 #![feature(drop_in_place)]
+#![feature(fn_traits)]
 
 #![cfg_attr(stage0, feature(alloc_system))]
 #![cfg_attr(not(stage0), feature(needs_allocator))]

src/liballoc/raw_vec.rs

@@ -10,7 +10,7 @@
 
 use core::ptr::Unique;
 use core::mem;
-use core::slice::{self, SliceExt};
+use core::slice;
 use heap;
 use super::oom;
 use super::boxed::Box;

src/liballoc_jemalloc/lib.rs

@@ -21,8 +21,8 @@
             issue = "27783")]
 #![feature(allocator)]
 #![feature(libc)]
-#![feature(no_std)]
 #![feature(staged_api)]
+#![cfg_attr(stage0, feature(no_std))]
 
 extern crate libc;