Auto merge of #30187 - alexcrichton:stabilize-1.6, r=aturon

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.
* `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: bors

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;