std: Clean out deprecated APIs

Removes all unstable and deprecated APIs prior to the 1.8 release. All APIs that
are deprecated in the 1.8 release are sticking around for the rest of this
cycle.

Some notable changes are:

* The `dynamic_lib` module was moved into `rustc_back` as the compiler still
  relies on a few bits and pieces.
* The `DebugTuple` formatter now special-cases an empty struct name with only
  one field to append a trailing comma.

src/test/auxiliary/linkage-visibility.rs

@@ -8,13 +8,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(dynamic_lib)]
+#![feature(rustc_private)]
 
 // We're testing linkage visibility; the compiler warns us, but we want to
 // do the runtime check that these functions aren't exported.
 #![allow(private_no_mangle_fns)]
 
-use std::dynamic_lib::DynamicLibrary;
+extern crate rustc_back;
+
+use rustc_back::dynamic_lib::DynamicLibrary;
 
 #[no_mangle]
 pub fn foo() { bar(); }

src/test/compile-fail/ufcs-qpath-missing-params.rs

@@ -8,7 +8,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::borrow::IntoCow;
+use std::borrow::Cow;
+
+pub trait IntoCow<'a, B: ?Sized> where B: ToOwned {
+    fn into_cow(self) -> Cow<'a, B>;
+}
+
+impl<'a> IntoCow<'a, str> for String {
+    fn into_cow(self) -> Cow<'a, str> {
+        Cow::Owned(self)
+    }
+}
 
 fn main() {
     <String as IntoCow>::into_cow("foo".to_string());

src/test/run-make/extern-fn-reachable/main.rs

@@ -8,9 +8,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(dynamic_lib)]
+#![feature(rustc_private)]
 
-use std::dynamic_lib::DynamicLibrary;
+extern crate rustc_back;
+
+use rustc_back::dynamic_lib::DynamicLibrary;
 use std::path::Path;
 
 pub fn main() {

src/test/run-pass-fulldeps/placement-new-arena.rs

@@ -1,22 +0,0 @@
-// Copyright 2012-2014 The Rust Project Developers. See the COPYRIGHT
-// file at the top-level directory of this distribution and at
-// http://rust-lang.org/COPYRIGHT.
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(rustc_private)]
-
-extern crate arena;
-use arena::Arena;
-
-pub fn main() {
-    let mut arena = Arena::new();
-    let p = &mut arena;
-    let x = p.alloc(|| 4_usize);
-    println!("{}", *x);
-    assert_eq!(*x, 4_usize);
-}

src/test/run-pass/env-funky-keys.rs

@@ -15,7 +15,6 @@
 // ignore-emscripten
 // no-prefer-dynamic
 
-#![feature(convert)]
 #![feature(libc)]
 
 extern crate libc;
@@ -23,7 +22,8 @@ extern crate libc;
 use libc::c_char;
 use libc::execve;
 use std::env;
-use std::ffi::OsStr;
+use std::ffi::CString;
+use std::os::unix::prelude::*;
 use std::ptr;
 
 fn main() {
@@ -34,8 +34,11 @@ fn main() {
         return;
     }
 
-    let current_exe = env::current_exe().unwrap().into_os_string().to_cstring().unwrap();
-    let new_env_var = OsStr::new("FOOBAR").to_cstring().unwrap();
+    let current_exe = CString::new(env::current_exe()
+                                       .unwrap()
+                                       .as_os_str()
+                                       .as_bytes()).unwrap();
+    let new_env_var = CString::new("FOOBAR").unwrap();
     let filename: *const c_char = current_exe.as_ptr();
     let argv: &[*const c_char] = &[filename, filename, ptr::null()];
     let envp: &[*const c_char] = &[new_env_var.as_ptr(), ptr::null()];

src/test/run-pass/issue-13763.rs

@@ -10,15 +10,14 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(num_bits_bytes)]
-
-use std::u8;
+mod u8 {
+    pub const BITS: usize = 8;
+}
 
 const NUM: usize = u8::BITS;
 
 struct MyStruct { nums: [usize; 8] }
 
-
 fn main() {
     let _s = MyStruct { nums: [0; NUM] };
 }

src/test/run-pass/issue-22577.rs

@@ -10,7 +10,7 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(fs, net, fs_walk)]
+#![feature(fs, net)]
 
 use std::{fs, net};
 
@@ -22,7 +22,6 @@ fn main() {
     assert_both::<fs::Metadata>();
     assert_both::<fs::ReadDir>();
     assert_both::<fs::DirEntry>();
-    assert_send::<fs::WalkDir>();
     assert_both::<fs::OpenOptions>();
     assert_both::<fs::Permissions>();
 

src/test/run-pass/minmax-stability-issue-23687.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(iter_min_max, cmp_partial, iter_cmp)]
-
 use std::fmt::Debug;
 use std::cmp::{self, PartialOrd, Ordering};
 
@@ -43,13 +41,13 @@ fn main() {
 
     // `min` should return the left when the values are equal
     assert_eq!(data.iter().min(), Some(&a));
-    assert_eq!(data.iter().min_by(|a| a.n), Some(&a));
+    assert_eq!(data.iter().min_by_key(|a| a.n), Some(&a));
     assert_eq!(cmp::min(a, b), a);
     assert_eq!(cmp::min(b, a), b);
 
     // `max` should return the right when the values are equal
     assert_eq!(data.iter().max(), Some(&f));
-    assert_eq!(data.iter().max_by(|a| a.n), Some(&f));
+    assert_eq!(data.iter().max_by_key(|a| a.n), Some(&f));
     assert_eq!(cmp::max(e, f), f);
     assert_eq!(cmp::max(f, e), e);
 

src/test/run-pass/num-wrapping.rs

@@ -12,7 +12,7 @@
 //
 // Test std::num::Wrapping<T> for {uN, iN, usize, isize}
 
-#![feature(num_bits_bytes, test)]
+#![feature(test)]
 
 extern crate test;
 
@@ -22,9 +22,40 @@ use std::ops::{
     AddAssign, SubAssign, MulAssign, DivAssign, RemAssign, BitXorAssign, BitOrAssign, BitAndAssign,
     Shl, Shr, ShlAssign, ShrAssign
 };
-use std::{i8, i16, i32, i64, isize, u8, u16, u32, u64, usize};
 use test::black_box;
 
+macro_rules! int_modules {
+    ($(($name:ident, $size:expr),)*) => ($(
+        mod $name {
+            pub const BITS: usize = $size;
+            pub use std::$name::*;
+        }
+    )*)
+}
+
+int_modules! {
+    (i8, 8),
+    (i16, 16),
+    (i32, 32),
+    (i64, 64),
+    (u8, 8),
+    (u16, 16),
+    (u32, 32),
+    (u64, 64),
+}
+
+#[cfg(target_pointer_width = "32")]
+int_modules! {
+    (isize, 32),
+    (usize, 32),
+}
+
+#[cfg(target_pointer_width = "64")]
+int_modules! {
+    (isize, 64),
+    (usize, 64),
+}
+
 fn main() {
     test_ops();
     test_op_assigns();

src/test/run-pass/send_str_hashmap.rs

@@ -8,57 +8,55 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-
-#![feature(collections, into_cow)]
-
-extern crate collections;
-
 use std::collections::HashMap;
-use std::borrow::{Cow, IntoCow};
+use std::borrow::Cow;
+
+use std::borrow::Cow::Borrowed as B;
+use std::borrow::Cow::Owned as O;
 
 type SendStr = Cow<'static, str>;
 
-pub fn main() {
+fn main() {
     let mut map: HashMap<SendStr, usize> = HashMap::new();
-    assert!(map.insert("foo".into_cow(), 42).is_none());
-    assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
-    assert!(map.insert("foo".into_cow(), 42).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
+    assert!(map.insert(B("foo"), 42).is_none());
+    assert!(map.insert(O("foo".to_string()), 42).is_some());
+    assert!(map.insert(B("foo"), 42).is_some());
+    assert!(map.insert(O("foo".to_string()), 42).is_some());
 
-    assert!(map.insert("foo".into_cow(), 43).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 44).is_some());
-    assert!(map.insert("foo".into_cow(), 45).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 46).is_some());
+    assert!(map.insert(B("foo"), 43).is_some());
+    assert!(map.insert(O("foo".to_string()), 44).is_some());
+    assert!(map.insert(B("foo"), 45).is_some());
+    assert!(map.insert(O("foo".to_string()), 46).is_some());
 
     let v = 46;
 
-    assert_eq!(map.get(&"foo".to_string().into_cow()), Some(&v));
-    assert_eq!(map.get(&"foo".into_cow()), Some(&v));
+    assert_eq!(map.get(&O("foo".to_string())), Some(&v));
+    assert_eq!(map.get(&B("foo")), Some(&v));
 
     let (a, b, c, d) = (50, 51, 52, 53);
 
-    assert!(map.insert("abc".into_cow(), a).is_none());
-    assert!(map.insert("bcd".to_string().into_cow(), b).is_none());
-    assert!(map.insert("cde".into_cow(), c).is_none());
-    assert!(map.insert("def".to_string().into_cow(), d).is_none());
+    assert!(map.insert(B("abc"), a).is_none());
+    assert!(map.insert(O("bcd".to_string()), b).is_none());
+    assert!(map.insert(B("cde"), c).is_none());
+    assert!(map.insert(O("def".to_string()), d).is_none());
 
-    assert!(map.insert("abc".into_cow(), a).is_some());
-    assert!(map.insert("bcd".to_string().into_cow(), b).is_some());
-    assert!(map.insert("cde".into_cow(), c).is_some());
-    assert!(map.insert("def".to_string().into_cow(), d).is_some());
+    assert!(map.insert(B("abc"), a).is_some());
+    assert!(map.insert(O("bcd".to_string()), b).is_some());
+    assert!(map.insert(B("cde"), c).is_some());
+    assert!(map.insert(O("def".to_string()), d).is_some());
 
-    assert!(map.insert("abc".to_string().into_cow(), a).is_some());
-    assert!(map.insert("bcd".into_cow(), b).is_some());
-    assert!(map.insert("cde".to_string().into_cow(), c).is_some());
-    assert!(map.insert("def".into_cow(), d).is_some());
+    assert!(map.insert(O("abc".to_string()), a).is_some());
+    assert!(map.insert(B("bcd"), b).is_some());
+    assert!(map.insert(O("cde".to_string()), c).is_some());
+    assert!(map.insert(B("def"), d).is_some());
 
     assert_eq!(map.get("abc"), Some(&a));
     assert_eq!(map.get("bcd"), Some(&b));
     assert_eq!(map.get("cde"), Some(&c));
     assert_eq!(map.get("def"), Some(&d));
 
-    assert_eq!(map.get(&"abc".into_cow()), Some(&a));
-    assert_eq!(map.get(&"bcd".into_cow()), Some(&b));
-    assert_eq!(map.get(&"cde".into_cow()), Some(&c));
-    assert_eq!(map.get(&"def".into_cow()), Some(&d));
+    assert_eq!(map.get(&B("abc")), Some(&a));
+    assert_eq!(map.get(&B("bcd")), Some(&b));
+    assert_eq!(map.get(&B("cde")), Some(&c));
+    assert_eq!(map.get(&B("def")), Some(&d));
 }

src/test/run-pass/send_str_treemap.rs

@@ -8,61 +8,58 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use std::collections::BTreeMap;
+use std::borrow::Cow;
 
-#![feature(collections, into_cow)]
-
-extern crate collections;
-
-use self::collections::BTreeMap;
-use std::borrow::{Cow, IntoCow};
+use std::borrow::Cow::{Owned as O, Borrowed as B};
 
 type SendStr = Cow<'static, str>;
 
-pub fn main() {
+fn main() {
     let mut map: BTreeMap<SendStr, usize> = BTreeMap::new();
-    assert!(map.insert("foo".into_cow(), 42).is_none());
-    assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
-    assert!(map.insert("foo".into_cow(), 42).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 42).is_some());
+    assert!(map.insert(B("foo"), 42).is_none());
+    assert!(map.insert(O("foo".to_string()), 42).is_some());
+    assert!(map.insert(B("foo"), 42).is_some());
+    assert!(map.insert(O("foo".to_string()), 42).is_some());
 
-    assert!(map.insert("foo".into_cow(), 43).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 44).is_some());
-    assert!(map.insert("foo".into_cow(), 45).is_some());
-    assert!(map.insert("foo".to_string().into_cow(), 46).is_some());
+    assert!(map.insert(B("foo"), 43).is_some());
+    assert!(map.insert(O("foo".to_string()), 44).is_some());
+    assert!(map.insert(B("foo"), 45).is_some());
+    assert!(map.insert(O("foo".to_string()), 46).is_some());
 
     let v = 46;
 
-    assert_eq!(map.get(&"foo".to_string().into_cow()), Some(&v));
-    assert_eq!(map.get(&"foo".into_cow()), Some(&v));
+    assert_eq!(map.get(&O("foo".to_string())), Some(&v));
+    assert_eq!(map.get(&B("foo")), Some(&v));
 
     let (a, b, c, d) = (50, 51, 52, 53);
 
-    assert!(map.insert("abc".into_cow(), a).is_none());
-    assert!(map.insert("bcd".to_string().into_cow(), b).is_none());
-    assert!(map.insert("cde".into_cow(), c).is_none());
-    assert!(map.insert("def".to_string().into_cow(), d).is_none());
+    assert!(map.insert(B("abc"), a).is_none());
+    assert!(map.insert(O("bcd".to_string()), b).is_none());
+    assert!(map.insert(B("cde"), c).is_none());
+    assert!(map.insert(O("def".to_string()), d).is_none());
 
-    assert!(map.insert("abc".into_cow(), a).is_some());
-    assert!(map.insert("bcd".to_string().into_cow(), b).is_some());
-    assert!(map.insert("cde".into_cow(), c).is_some());
-    assert!(map.insert("def".to_string().into_cow(), d).is_some());
+    assert!(map.insert(B("abc"), a).is_some());
+    assert!(map.insert(O("bcd".to_string()), b).is_some());
+    assert!(map.insert(B("cde"), c).is_some());
+    assert!(map.insert(O("def".to_string()), d).is_some());
 
-    assert!(map.insert("abc".to_string().into_cow(), a).is_some());
-    assert!(map.insert("bcd".into_cow(), b).is_some());
-    assert!(map.insert("cde".to_string().into_cow(), c).is_some());
-    assert!(map.insert("def".into_cow(), d).is_some());
+    assert!(map.insert(O("abc".to_string()), a).is_some());
+    assert!(map.insert(B("bcd"), b).is_some());
+    assert!(map.insert(O("cde".to_string()), c).is_some());
+    assert!(map.insert(B("def"), d).is_some());
 
-    assert_eq!(map.get(&"abc".into_cow()), Some(&a));
-    assert_eq!(map.get(&"bcd".into_cow()), Some(&b));
-    assert_eq!(map.get(&"cde".into_cow()), Some(&c));
-    assert_eq!(map.get(&"def".into_cow()), Some(&d));
+    assert_eq!(map.get(&B("abc")), Some(&a));
+    assert_eq!(map.get(&B("bcd")), Some(&b));
+    assert_eq!(map.get(&B("cde")), Some(&c));
+    assert_eq!(map.get(&B("def")), Some(&d));
 
-    assert_eq!(map.get(&"abc".to_string().into_cow()), Some(&a));
-    assert_eq!(map.get(&"bcd".to_string().into_cow()), Some(&b));
-    assert_eq!(map.get(&"cde".to_string().into_cow()), Some(&c));
-    assert_eq!(map.get(&"def".to_string().into_cow()), Some(&d));
+    assert_eq!(map.get(&O("abc".to_string())), Some(&a));
+    assert_eq!(map.get(&O("bcd".to_string())), Some(&b));
+    assert_eq!(map.get(&O("cde".to_string())), Some(&c));
+    assert_eq!(map.get(&O("def".to_string())), Some(&d));
 
-    assert!(map.remove(&"foo".into_cow()).is_some());
+    assert!(map.remove(&B("foo")).is_some());
     assert_eq!(map.into_iter().map(|(k, v)| format!("{}{}", k, v))
                               .collect::<Vec<String>>()
                               .concat(),

src/test/run-pass/std-sync-right-kind-impls.rs

@@ -24,7 +24,6 @@ fn main() {
     assert_both::<sync::Mutex<()>>();
     assert_both::<sync::Condvar>();
     assert_both::<sync::RwLock<()>>();
-    assert_both::<sync::Semaphore>();
     assert_both::<sync::Barrier>();
     assert_both::<sync::Arc<()>>();
     assert_both::<sync::Weak<()>>();

src/test/run-pass/ufcs-polymorphic-paths.rs

@@ -8,9 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(into_cow)]
-
-use std::borrow::{Cow, IntoCow};
+use std::borrow::{Cow, ToOwned};
 use std::default::Default;
 use std::iter::FromIterator;
 use std::ops::Add;
@@ -25,6 +23,16 @@ pub trait Rand: Default + Sized {
 }
 impl Rand for i32 { }
 
+pub trait IntoCow<'a, B: ?Sized> where B: ToOwned {
+    fn into_cow(self) -> Cow<'a, B>;
+}
+
+impl<'a> IntoCow<'a, str> for String {
+    fn into_cow(self) -> Cow<'a, str> {
+        Cow::Owned(self)
+    }
+}
+
 #[derive(PartialEq, Eq)]
 struct Newt<T>(T);
 

src/test/run-pass/vec-concat.rs

@@ -8,15 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(vec_push_all)]
-
 use std::vec;
 
 pub fn main() {
     let a: Vec<isize> = vec!(1, 2, 3, 4, 5);
     let b: Vec<isize> = vec!(6, 7, 8, 9, 0);
     let mut v: Vec<isize> = a;
-    v.push_all(&b);
+    v.extend_from_slice(&b);
     println!("{}", v[9]);
     assert_eq!(v[0], 1);
     assert_eq!(v[7], 8);

src/test/run-pass/vector-sort-panic-safe.rs

@@ -10,7 +10,7 @@
 
 // ignore-emscripten no threads support
 
-#![feature(rand, num_bits_bytes)]
+#![feature(rand)]
 #![feature(const_fn)]
 
 use std::sync::atomic::{AtomicUsize, Ordering};
@@ -47,7 +47,6 @@ impl Drop for DropCounter {
 }
 
 pub fn main() {
-    assert!(MAX_LEN <= std::usize::BITS);
     // len can't go above 64.
     for len in 2..MAX_LEN {
         for _ in 0..REPEATS {