Merge crate `collections` into `alloc`

40 files changed, 0 insertions, 29899 deletions

diff --git a/src/libcollections/Cargo.toml b/src/libcollections/Cargo.toml
deleted file mode 100644
index 7e92404bc0d..00000000000
--- a/src/libcollections/Cargo.toml
+++ /dev/null
@@ -1,21 +0,0 @@
-[package]
-authors = ["The Rust Project Developers"]
-name = "collections"
-version = "0.0.0"
-
-[lib]
-name = "collections"
-path = "lib.rs"
-
-[dependencies]
-alloc = { path = "../liballoc" }
-core = { path = "../libcore" }
-std_unicode = { path = "../libstd_unicode" }
-
-[[test]]
-name = "collectionstests"
-path = "../libcollections/tests/lib.rs"
-
-[[bench]]
-name = "collectionsbenches"
-path = "../libcollections/benches/lib.rs"
diff --git a/src/libcollections/benches/btree/map.rs b/src/libcollections/benches/btree/map.rs
deleted file mode 100644
index 744afb991b0..00000000000
--- a/src/libcollections/benches/btree/map.rs
+++ /dev/null
@@ -1,157 +0,0 @@
-// Copyright 2017 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.
-
-
-use std::iter::Iterator;
-use std::vec::Vec;
-use std::collections::BTreeMap;
-use std::__rand::{Rng, thread_rng};
-use test::{Bencher, black_box};
-
-macro_rules! map_insert_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let n: usize = $n;
-            let mut map = $map::new();
-            // setup
-            let mut rng = thread_rng();
-
-            for _ in 0..n {
-                let i = rng.gen::<usize>() % n;
-                map.insert(i, i);
-            }
-
-            // measure
-            b.iter(|| {
-                let k = rng.gen::<usize>() % n;
-                map.insert(k, k);
-                map.remove(&k);
-            });
-            black_box(map);
-        }
-    )
-}
-
-macro_rules! map_insert_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-            // setup
-            for i in 0..n {
-                map.insert(i * 2, i * 2);
-            }
-
-            // measure
-            let mut i = 1;
-            b.iter(|| {
-                map.insert(i, i);
-                map.remove(&i);
-                i = (i + 2) % n;
-            });
-            black_box(map);
-        }
-    )
-}
-
-macro_rules! map_find_rand_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            let mut rng = thread_rng();
-            let mut keys: Vec<_> = (0..n).map(|_| rng.gen::<usize>() % n).collect();
-
-            for &k in &keys {
-                map.insert(k, k);
-            }
-
-            rng.shuffle(&mut keys);
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let t = map.get(&keys[i]);
-                i = (i + 1) % n;
-                black_box(t);
-            })
-        }
-    )
-}
-
-macro_rules! map_find_seq_bench {
-    ($name: ident, $n: expr, $map: ident) => (
-        #[bench]
-        pub fn $name(b: &mut Bencher) {
-            let mut map = $map::new();
-            let n: usize = $n;
-
-            // setup
-            for i in 0..n {
-                map.insert(i, i);
-            }
-
-            // measure
-            let mut i = 0;
-            b.iter(|| {
-                let x = map.get(&i);
-                i = (i + 1) % n;
-                black_box(x);
-            })
-        }
-    )
-}
-
-map_insert_rand_bench!{insert_rand_100,    100,    BTreeMap}
-map_insert_rand_bench!{insert_rand_10_000, 10_000, BTreeMap}
-
-map_insert_seq_bench!{insert_seq_100,    100,    BTreeMap}
-map_insert_seq_bench!{insert_seq_10_000, 10_000, BTreeMap}
-
-map_find_rand_bench!{find_rand_100,    100,    BTreeMap}
-map_find_rand_bench!{find_rand_10_000, 10_000, BTreeMap}
-
-map_find_seq_bench!{find_seq_100,    100,    BTreeMap}
-map_find_seq_bench!{find_seq_10_000, 10_000, BTreeMap}
-
-fn bench_iter(b: &mut Bencher, size: i32) {
-    let mut map = BTreeMap::<i32, i32>::new();
-    let mut rng = thread_rng();
-
-    for _ in 0..size {
-        map.insert(rng.gen(), rng.gen());
-    }
-
-    b.iter(|| {
-        for entry in &map {
-            black_box(entry);
-        }
-    });
-}
-
-#[bench]
-pub fn iter_20(b: &mut Bencher) {
-    bench_iter(b, 20);
-}
-
-#[bench]
-pub fn iter_1000(b: &mut Bencher) {
-    bench_iter(b, 1000);
-}
-
-#[bench]
-pub fn iter_100000(b: &mut Bencher) {
-    bench_iter(b, 100000);
-}
diff --git a/src/libcollections/benches/btree/mod.rs b/src/libcollections/benches/btree/mod.rs
deleted file mode 100644
index f436b0ac0c0..00000000000
--- a/src/libcollections/benches/btree/mod.rs
+++ /dev/null
@@ -1,11 +0,0 @@
-// Copyright 2017 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.
-
-mod map;
diff --git a/src/libcollections/benches/lib.rs b/src/libcollections/benches/lib.rs
deleted file mode 100644
index 958020d0b0e..00000000000
--- a/src/libcollections/benches/lib.rs
+++ /dev/null
@@ -1,28 +0,0 @@
-// Copyright 2017 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.
-
-#![deny(warnings)]
-
-#![feature(i128_type)]
-#![feature(rand)]
-#![feature(repr_simd)]
-#![feature(slice_rotate)]
-#![feature(sort_unstable)]
-#![feature(test)]
-
-extern crate test;
-
-mod btree;
-mod linked_list;
-mod string;
-mod str;
-mod slice;
-mod vec;
-mod vec_deque;
diff --git a/src/libcollections/benches/linked_list.rs b/src/libcollections/benches/linked_list.rs
deleted file mode 100644
index bbac44553f1..00000000000
--- a/src/libcollections/benches/linked_list.rs
+++ /dev/null
@@ -1,87 +0,0 @@
-// Copyright 2017 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.
-
-use std::collections::LinkedList;
-use test::Bencher;
-
-#[bench]
-fn bench_collect_into(b: &mut Bencher) {
-    let v = &[0; 64];
-    b.iter(|| {
-        let _: LinkedList<_> = v.iter().cloned().collect();
-    })
-}
-
-#[bench]
-fn bench_push_front(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_front(0);
-    })
-}
-
-#[bench]
-fn bench_push_back(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_back(0);
-    })
-}
-
-#[bench]
-fn bench_push_back_pop_back(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_back(0);
-        m.pop_back();
-    })
-}
-
-#[bench]
-fn bench_push_front_pop_front(b: &mut Bencher) {
-    let mut m: LinkedList<_> = LinkedList::new();
-    b.iter(|| {
-        m.push_front(0);
-        m.pop_front();
-    })
-}
-
-#[bench]
-fn bench_iter(b: &mut Bencher) {
-    let v = &[0; 128];
-    let m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_mut(b: &mut Bencher) {
-    let v = &[0; 128];
-    let mut m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter_mut().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_rev(b: &mut Bencher) {
-    let v = &[0; 128];
-    let m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter().rev().count() == 128);
-    })
-}
-#[bench]
-fn bench_iter_mut_rev(b: &mut Bencher) {
-    let v = &[0; 128];
-    let mut m: LinkedList<_> = v.iter().cloned().collect();
-    b.iter(|| {
-        assert!(m.iter_mut().rev().count() == 128);
-    })
-}
diff --git a/src/libcollections/benches/slice.rs b/src/libcollections/benches/slice.rs
deleted file mode 100644
index aa5a438b35e..00000000000
--- a/src/libcollections/benches/slice.rs
+++ /dev/null
@@ -1,358 +0,0 @@
-// Copyright 2017 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.
-
-use std::{mem, ptr};
-use std::__rand::{Rng, thread_rng};
-
-use test::{Bencher, black_box};
-
-#[bench]
-fn iterator(b: &mut Bencher) {
-    // peculiar numbers to stop LLVM from optimising the summation
-    // out.
-    let v: Vec<_> = (0..100).map(|i| i ^ (i << 1) ^ (i >> 1)).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for x in &v {
-            sum += *x;
-        }
-        // sum == 11806, to stop dead code elimination.
-        if sum == 0 {
-            panic!()
-        }
-    })
-}
-
-#[bench]
-fn mut_iterator(b: &mut Bencher) {
-    let mut v = vec![0; 100];
-
-    b.iter(|| {
-        let mut i = 0;
-        for x in &mut v {
-            *x = i;
-            i += 1;
-        }
-    })
-}
-
-#[bench]
-fn concat(b: &mut Bencher) {
-    let xss: Vec<Vec<i32>> = (0..100).map(|i| (0..i).collect()).collect();
-    b.iter(|| {
-        xss.concat();
-    });
-}
-
-#[bench]
-fn join(b: &mut Bencher) {
-    let xss: Vec<Vec<i32>> = (0..100).map(|i| (0..i).collect()).collect();
-    b.iter(|| xss.join(&0));
-}
-
-#[bench]
-fn push(b: &mut Bencher) {
-    let mut vec = Vec::<i32>::new();
-    b.iter(|| {
-        vec.push(0);
-        black_box(&vec);
-    });
-}
-
-#[bench]
-fn starts_with_same_vector(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.starts_with(&vec))
-}
-
-#[bench]
-fn starts_with_single_element(b: &mut Bencher) {
-    let vec: Vec<_> = vec![0];
-    b.iter(|| vec.starts_with(&vec))
-}
-
-#[bench]
-fn starts_with_diff_one_element_at_end(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    let mut match_vec: Vec<_> = (0..99).collect();
-    match_vec.push(0);
-    b.iter(|| vec.starts_with(&match_vec))
-}
-
-#[bench]
-fn ends_with_same_vector(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.ends_with(&vec))
-}
-
-#[bench]
-fn ends_with_single_element(b: &mut Bencher) {
-    let vec: Vec<_> = vec![0];
-    b.iter(|| vec.ends_with(&vec))
-}
-
-#[bench]
-fn ends_with_diff_one_element_at_beginning(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    let mut match_vec: Vec<_> = (0..100).collect();
-    match_vec[0] = 200;
-    b.iter(|| vec.starts_with(&match_vec))
-}
-
-#[bench]
-fn contains_last_element(b: &mut Bencher) {
-    let vec: Vec<_> = (0..100).collect();
-    b.iter(|| vec.contains(&99))
-}
-
-#[bench]
-fn zero_1kb_from_elem(b: &mut Bencher) {
-    b.iter(|| vec![0u8; 1024]);
-}
-
-#[bench]
-fn zero_1kb_set_memory(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            let vp = v.as_mut_ptr();
-            ptr::write_bytes(vp, 0, 1024);
-            v.set_len(1024);
-        }
-        v
-    });
-}
-
-#[bench]
-fn zero_1kb_loop_set(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            v.set_len(1024);
-        }
-        for i in 0..1024 {
-            v[i] = 0;
-        }
-    });
-}
-
-#[bench]
-fn zero_1kb_mut_iter(b: &mut Bencher) {
-    b.iter(|| {
-        let mut v = Vec::<u8>::with_capacity(1024);
-        unsafe {
-            v.set_len(1024);
-        }
-        for x in &mut v {
-            *x = 0;
-        }
-        v
-    });
-}
-
-#[bench]
-fn random_inserts(b: &mut Bencher) {
-    let mut rng = thread_rng();
-    b.iter(|| {
-        let mut v = vec![(0, 0); 30];
-        for _ in 0..100 {
-            let l = v.len();
-            v.insert(rng.gen::<usize>() % (l + 1), (1, 1));
-        }
-    })
-}
-
-#[bench]
-fn random_removes(b: &mut Bencher) {
-    let mut rng = thread_rng();
-    b.iter(|| {
-        let mut v = vec![(0, 0); 130];
-        for _ in 0..100 {
-            let l = v.len();
-            v.remove(rng.gen::<usize>() % l);
-        }
-    })
-}
-
-fn gen_ascending(len: usize) -> Vec<u64> {
-    (0..len as u64).collect()
-}
-
-fn gen_descending(len: usize) -> Vec<u64> {
-    (0..len as u64).rev().collect()
-}
-
-fn gen_random(len: usize) -> Vec<u64> {
-    let mut rng = thread_rng();
-    rng.gen_iter::<u64>().take(len).collect()
-}
-
-fn gen_random_bytes(len: usize) -> Vec<u8> {
-    let mut rng = thread_rng();
-    rng.gen_iter::<u8>().take(len).collect()
-}
-
-fn gen_mostly_ascending(len: usize) -> Vec<u64> {
-    let mut rng = thread_rng();
-    let mut v = gen_ascending(len);
-    for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
-        v.swap(x, y);
-    }
-    v
-}
-
-fn gen_mostly_descending(len: usize) -> Vec<u64> {
-    let mut rng = thread_rng();
-    let mut v = gen_descending(len);
-    for _ in (0usize..).take_while(|x| x * x <= len) {
-        let x = rng.gen::<usize>() % len;
-        let y = rng.gen::<usize>() % len;
-        v.swap(x, y);
-    }
-    v
-}
-
-fn gen_strings(len: usize) -> Vec<String> {
-    let mut rng = thread_rng();
-    let mut v = vec![];
-    for _ in 0..len {
-        let n = rng.gen::<usize>() % 20 + 1;
-        v.push(rng.gen_ascii_chars().take(n).collect());
-    }
-    v
-}
-
-fn gen_big_random(len: usize) -> Vec<[u64; 16]> {
-    let mut rng = thread_rng();
-    rng.gen_iter().map(|x| [x; 16]).take(len).collect()
-}
-
-macro_rules! sort {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            b.iter(|| $gen($len).$f());
-            b.bytes = $len * mem::size_of_val(&$gen(1)[0]) as u64;
-        }
-    }
-}
-
-macro_rules! sort_expensive {
-    ($f:ident, $name:ident, $gen:expr, $len:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            b.iter(|| {
-                let mut v = $gen($len);
-                let mut count = 0;
-                v.$f(|a: &u64, b: &u64| {
-                    count += 1;
-                    if count % 1_000_000_000 == 0 {
-                        panic!("should not happen");
-                    }
-                    (*a as f64).cos().partial_cmp(&(*b as f64).cos()).unwrap()
-                });
-                black_box(count);
-            });
-            b.bytes = $len as u64 * mem::size_of::<u64>() as u64;
-        }
-    }
-}
-
-sort!(sort, sort_small_ascending, gen_ascending, 10);
-sort!(sort, sort_small_descending, gen_descending, 10);
-sort!(sort, sort_small_random, gen_random, 10);
-sort!(sort, sort_small_big_random, gen_big_random, 10);
-sort!(sort, sort_medium_random, gen_random, 100);
-sort!(sort, sort_large_ascending, gen_ascending, 10000);
-sort!(sort, sort_large_descending, gen_descending, 10000);
-sort!(sort, sort_large_mostly_ascending, gen_mostly_ascending, 10000);
-sort!(sort, sort_large_mostly_descending, gen_mostly_descending, 10000);
-sort!(sort, sort_large_random, gen_random, 10000);
-sort!(sort, sort_large_big_random, gen_big_random, 10000);
-sort!(sort, sort_large_strings, gen_strings, 10000);
-sort_expensive!(sort_by, sort_large_random_expensive, gen_random, 10000);
-
-sort!(sort_unstable, sort_unstable_small_ascending, gen_ascending, 10);
-sort!(sort_unstable, sort_unstable_small_descending, gen_descending, 10);
-sort!(sort_unstable, sort_unstable_small_random, gen_random, 10);
-sort!(sort_unstable, sort_unstable_small_big_random, gen_big_random, 10);
-sort!(sort_unstable, sort_unstable_medium_random, gen_random, 100);
-sort!(sort_unstable, sort_unstable_large_ascending, gen_ascending, 10000);
-sort!(sort_unstable, sort_unstable_large_descending, gen_descending, 10000);
-sort!(sort_unstable, sort_unstable_large_mostly_ascending, gen_mostly_ascending, 10000);
-sort!(sort_unstable, sort_unstable_large_mostly_descending, gen_mostly_descending, 10000);
-sort!(sort_unstable, sort_unstable_large_random, gen_random, 10000);
-sort!(sort_unstable, sort_unstable_large_big_random, gen_big_random, 10000);
-sort!(sort_unstable, sort_unstable_large_strings, gen_strings, 10000);
-sort_expensive!(sort_unstable_by, sort_unstable_large_random_expensive, gen_random, 10000);
-
-macro_rules! reverse {
-    ($name:ident, $ty:ty, $f:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            // odd length and offset by 1 to be as unaligned as possible
-            let n = 0xFFFFF;
-            let mut v: Vec<_> =
-                (0..1+(n / mem::size_of::<$ty>() as u64))
-                .map($f)
-                .collect();
-            b.iter(|| black_box(&mut v[1..]).reverse());
-            b.bytes = n;
-        }
-    }
-}
-
-reverse!(reverse_u8, u8, |x| x as u8);
-reverse!(reverse_u16, u16, |x| x as u16);
-reverse!(reverse_u8x3, [u8;3], |x| [x as u8, (x>>8) as u8, (x>>16) as u8]);
-reverse!(reverse_u32, u32, |x| x as u32);
-reverse!(reverse_u64, u64, |x| x as u64);
-reverse!(reverse_u128, u128, |x| x as u128);
-#[repr(simd)] struct F64x4(f64, f64, f64, f64);
-reverse!(reverse_simd_f64x4, F64x4, |x| { let x = x as f64; F64x4(x,x,x,x) });
-
-macro_rules! rotate {
-    ($name:ident, $gen:expr, $len:expr, $mid:expr) => {
-        #[bench]
-        fn $name(b: &mut Bencher) {
-            let size = mem::size_of_val(&$gen(1)[0]);
-            let mut v = $gen($len * 8 / size);
-            b.iter(|| black_box(&mut v).rotate(($mid*8+size-1)/size));
-            b.bytes = (v.len() * size) as u64;
-        }
-    }
-}
-
-rotate!(rotate_tiny_by1, gen_random, 16, 1);
-rotate!(rotate_tiny_half, gen_random, 16, 16/2);
-rotate!(rotate_tiny_half_plus_one, gen_random, 16, 16/2+1);
-
-rotate!(rotate_medium_by1, gen_random, 9158, 1);
-rotate!(rotate_medium_by727_u64, gen_random, 9158, 727);
-rotate!(rotate_medium_by727_bytes, gen_random_bytes, 9158, 727);
-rotate!(rotate_medium_by727_strings, gen_strings, 9158, 727);
-rotate!(rotate_medium_half, gen_random, 9158, 9158/2);
-rotate!(rotate_medium_half_plus_one, gen_random, 9158, 9158/2+1);
-
-// Intended to use more RAM than the machine has cache
-rotate!(rotate_huge_by1, gen_random, 5*1024*1024, 1);
-rotate!(rotate_huge_by9199_u64, gen_random, 5*1024*1024, 9199);
-rotate!(rotate_huge_by9199_bytes, gen_random_bytes, 5*1024*1024, 9199);
-rotate!(rotate_huge_by9199_strings, gen_strings, 5*1024*1024, 9199);
-rotate!(rotate_huge_by9199_big, gen_big_random, 5*1024*1024, 9199);
-rotate!(rotate_huge_by1234577_u64, gen_random, 5*1024*1024, 1234577);
-rotate!(rotate_huge_by1234577_bytes, gen_random_bytes, 5*1024*1024, 1234577);
-rotate!(rotate_huge_by1234577_strings, gen_strings, 5*1024*1024, 1234577);
-rotate!(rotate_huge_by1234577_big, gen_big_random, 5*1024*1024, 1234577);
-rotate!(rotate_huge_half, gen_random, 5*1024*1024, 5*1024*1024/2);
-rotate!(rotate_huge_half_plus_one, gen_random, 5*1024*1024, 5*1024*1024/2+1);
diff --git a/src/libcollections/benches/str.rs b/src/libcollections/benches/str.rs
deleted file mode 100644
index fc4063fae92..00000000000
--- a/src/libcollections/benches/str.rs
+++ /dev/null
@@ -1,309 +0,0 @@
-// Copyright 2017 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.
-
-use test::{Bencher, black_box};
-
-#[bench]
-fn char_iterator(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().count());
-}
-
-#[bench]
-fn char_iterator_for(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| {
-        for ch in s.chars() { black_box(ch); }
-    });
-}
-
-#[bench]
-fn char_iterator_ascii(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb
-    Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().count());
-}
-
-#[bench]
-fn char_iterator_rev(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| s.chars().rev().count());
-}
-
-#[bench]
-fn char_iterator_rev_for(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-
-    b.iter(|| {
-        for ch in s.chars().rev() { black_box(ch); }
-    });
-}
-
-#[bench]
-fn char_indicesator(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let len = s.chars().count();
-
-    b.iter(|| assert_eq!(s.char_indices().count(), len));
-}
-
-#[bench]
-fn char_indicesator_rev(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let len = s.chars().count();
-
-    b.iter(|| assert_eq!(s.char_indices().rev().count(), len));
-}
-
-#[bench]
-fn split_unicode_ascii(b: &mut Bencher) {
-    let s = "ประเทศไทย中华Việt Namประเทศไทย中华Việt Nam";
-
-    b.iter(|| assert_eq!(s.split('V').count(), 3));
-}
-
-#[bench]
-fn split_ascii(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    b.iter(|| assert_eq!(s.split(' ').count(), len));
-}
-
-#[bench]
-fn split_extern_fn(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-    fn pred(c: char) -> bool { c == ' ' }
-
-    b.iter(|| assert_eq!(s.split(pred).count(), len));
-}
-
-#[bench]
-fn split_closure(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    b.iter(|| assert_eq!(s.split(|c: char| c == ' ').count(), len));
-}
-
-#[bench]
-fn split_slice(b: &mut Bencher) {
-    let s = "Mary had a little lamb, Little lamb, little-lamb.";
-    let len = s.split(' ').count();
-
-    let c: &[char] = &[' '];
-    b.iter(|| assert_eq!(s.split(c).count(), len));
-}
-
-#[bench]
-fn bench_join(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    let sep = "→";
-    let v = vec![s, s, s, s, s, s, s, s, s, s];
-    b.iter(|| {
-        assert_eq!(v.join(sep).len(), s.len() * 10 + sep.len() * 9);
-    })
-}
-
-#[bench]
-fn bench_contains_short_short(b: &mut Bencher) {
-    let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-    let needle = "sit";
-
-    b.iter(|| {
-        assert!(haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_short_long(b: &mut Bencher) {
-    let haystack = "\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.
-
-In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
-sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
-diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
-lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
-eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
-interdum. Curabitur ut nisi justo.
-
-Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
-mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
-lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
-est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
-felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
-ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
-feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-Aliquam sit amet placerat lorem.
-
-Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
-mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
-Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
-lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
-suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
-cursus accumsan.
-
-Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
-feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
-vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
-leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
-malesuada sollicitudin quam eu fermentum.";
-    let needle = "english";
-
-    b.iter(|| {
-        assert!(!haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_bad_naive(b: &mut Bencher) {
-    let haystack = "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa";
-    let needle = "aaaaaaaab";
-
-    b.iter(|| {
-        assert!(!haystack.contains(needle));
-    })
-}
-
-#[bench]
-fn bench_contains_equal(b: &mut Bencher) {
-    let haystack = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-    let needle = "Lorem ipsum dolor sit amet, consectetur adipiscing elit.";
-
-    b.iter(|| {
-        assert!(haystack.contains(needle));
-    })
-}
-
-
-macro_rules! make_test_inner {
-    ($s:ident, $code:expr, $name:ident, $str:expr, $iters:expr) => {
-        #[bench]
-        fn $name(bencher: &mut Bencher) {
-            let mut $s = $str;
-            black_box(&mut $s);
-            bencher.iter(|| for _ in 0..$iters { black_box($code); });
-        }
-    }
-}
-
-macro_rules! make_test {
-    ($name:ident, $s:ident, $code:expr) => {
-        make_test!($name, $s, $code, 1);
-    };
-    ($name:ident, $s:ident, $code:expr, $iters:expr) => {
-        mod $name {
-            use test::Bencher;
-            use test::black_box;
-
-            // Short strings: 65 bytes each
-            make_test_inner!($s, $code, short_ascii,
-                "Mary had a little lamb, Little lamb Mary had a littl lamb, lamb!", $iters);
-            make_test_inner!($s, $code, short_mixed,
-                "ศไทย中华Việt Nam; Mary had a little lamb, Little lam!", $iters);
-            make_test_inner!($s, $code, short_pile_of_poo,
-                "💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩!", $iters);
-            make_test_inner!($s, $code, long_lorem_ipsum,"\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.
-
-In est dui, tincidunt sed tempus interdum, adipiscing laoreet ante. Etiam tempor, tellus quis \
-sagittis interdum, nulla purus mattis sem, quis auctor erat odio ac tellus. In nec nunc sit amet \
-diam volutpat molestie at sed ipsum. Vestibulum laoreet consequat vulputate. Integer accumsan \
-lorem ac dignissim placerat. Suspendisse convallis faucibus lorem. Aliquam erat volutpat. In vel \
-eleifend felis. Sed suscipit nulla lorem, sed mollis est sollicitudin et. Nam fermentum egestas \
-interdum. Curabitur ut nisi justo.
-
-Sed sollicitudin ipsum tellus, ut condimentum leo eleifend nec. Cras ut velit ante. Phasellus nec \
-mollis odio. Mauris molestie erat in arcu mattis, at aliquet dolor vehicula. Quisque malesuada \
-lectus sit amet nisi pretium, a condimentum ipsum porta. Morbi at dapibus diam. Praesent egestas \
-est sed risus elementum, eu rutrum metus ultrices. Etiam fermentum consectetur magna, id rutrum \
-felis accumsan a. Aliquam ut pellentesque libero. Sed mi nulla, lobortis eu tortor id, suscipit \
-ultricies neque. Morbi iaculis sit amet risus at iaculis. Praesent eget ligula quis turpis \
-feugiat suscipit vel non arcu. Interdum et malesuada fames ac ante ipsum primis in faucibus. \
-Aliquam sit amet placerat lorem.
-
-Cras a lacus vel ante posuere elementum. Nunc est leo, bibendum ut facilisis vel, bibendum at \
-mauris. Nullam adipiscing diam vel odio ornare, luctus adipiscing mi luctus. Nulla facilisi. \
-Mauris adipiscing bibendum neque, quis adipiscing lectus tempus et. Sed feugiat erat et nisl \
-lobortis pharetra. Donec vitae erat enim. Nullam sit amet felis et quam lacinia tincidunt. Aliquam \
-suscipit dapibus urna. Sed volutpat urna in magna pulvinar volutpat. Phasellus nec tellus ac diam \
-cursus accumsan.
-
-Nam lectus enim, dapibus non nisi tempor, consectetur convallis massa. Maecenas eleifend dictum \
-feugiat. Etiam quis mauris vel risus luctus mattis a a nunc. Nullam orci quam, imperdiet id \
-vehicula in, porttitor ut nibh. Duis sagittis adipiscing nisl vitae congue. Donec mollis risus eu \
-leo suscipit, varius porttitor nulla porta. Pellentesque ut sem nec nisi euismod vehicula. Nulla \
-malesuada sollicitudin quam eu fermentum!", $iters);
-        }
-    }
-}
-
-make_test!(chars_count, s, s.chars().count());
-
-make_test!(contains_bang_str, s, s.contains("!"));
-make_test!(contains_bang_char, s, s.contains('!'));
-
-make_test!(match_indices_a_str, s, s.match_indices("a").count());
-
-make_test!(split_a_str, s, s.split("a").count());
-
-make_test!(trim_ascii_char, s, {
-    use std::ascii::AsciiExt;
-    s.trim_matches(|c: char| c.is_ascii())
-});
-make_test!(trim_left_ascii_char, s, {
-    use std::ascii::AsciiExt;
-    s.trim_left_matches(|c: char| c.is_ascii())
-});
-make_test!(trim_right_ascii_char, s, {
-    use std::ascii::AsciiExt;
-    s.trim_right_matches(|c: char| c.is_ascii())
-});
-
-make_test!(find_underscore_char, s, s.find('_'));
-make_test!(rfind_underscore_char, s, s.rfind('_'));
-make_test!(find_underscore_str, s, s.find("_"));
-
-make_test!(find_zzz_char, s, s.find('\u{1F4A4}'));
-make_test!(rfind_zzz_char, s, s.rfind('\u{1F4A4}'));
-make_test!(find_zzz_str, s, s.find("\u{1F4A4}"));
-
-make_test!(starts_with_ascii_char, s, s.starts_with('/'), 1024);
-make_test!(ends_with_ascii_char, s, s.ends_with('/'), 1024);
-make_test!(starts_with_unichar, s, s.starts_with('\u{1F4A4}'), 1024);
-make_test!(ends_with_unichar, s, s.ends_with('\u{1F4A4}'), 1024);
-make_test!(starts_with_str, s, s.starts_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024);
-make_test!(ends_with_str, s, s.ends_with("💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩💩"), 1024);
-
-make_test!(split_space_char, s, s.split(' ').count());
-make_test!(split_terminator_space_char, s, s.split_terminator(' ').count());
-
-make_test!(splitn_space_char, s, s.splitn(10, ' ').count());
-make_test!(rsplitn_space_char, s, s.rsplitn(10, ' ').count());
-
-make_test!(split_space_str, s, s.split(" ").count());
-make_test!(split_ad_str, s, s.split("ad").count());
diff --git a/src/libcollections/benches/string.rs b/src/libcollections/benches/string.rs
deleted file mode 100644
index 36be21d978e..00000000000
--- a/src/libcollections/benches/string.rs
+++ /dev/null
@@ -1,134 +0,0 @@
-// Copyright 2017 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.
-
-use std::iter::repeat;
-use test::Bencher;
-
-#[bench]
-fn bench_with_capacity(b: &mut Bencher) {
-    b.iter(|| String::with_capacity(100));
-}
-
-#[bench]
-fn bench_push_str(b: &mut Bencher) {
-    let s = "ศไทย中华Việt Nam; Mary had a little lamb, Little lamb";
-    b.iter(|| {
-        let mut r = String::new();
-        r.push_str(s);
-    });
-}
-
-const REPETITIONS: u64 = 10_000;
-
-#[bench]
-fn bench_push_str_one_byte(b: &mut Bencher) {
-    b.bytes = REPETITIONS;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push_str("a")
-        }
-    });
-}
-
-#[bench]
-fn bench_push_char_one_byte(b: &mut Bencher) {
-    b.bytes = REPETITIONS;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push('a')
-        }
-    });
-}
-
-#[bench]
-fn bench_push_char_two_bytes(b: &mut Bencher) {
-    b.bytes = REPETITIONS * 2;
-    b.iter(|| {
-        let mut r = String::new();
-        for _ in 0..REPETITIONS {
-            r.push('â')
-        }
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_ascii(b: &mut Bencher) {
-    let s = b"Hello there, the quick brown fox jumped over the lazy dog! \
-              Lorem ipsum dolor sit amet, consectetur. ";
-
-    assert_eq!(100, s.len());
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_multibyte(b: &mut Bencher) {
-    let s = "𐌀𐌖𐌋𐌄𐌑𐌉ปรدولة الكويتทศไทย中华𐍅𐌿𐌻𐍆𐌹𐌻𐌰".as_bytes();
-    assert_eq!(100, s.len());
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_invalid(b: &mut Bencher) {
-    let s = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(s);
-    });
-}
-
-#[bench]
-fn from_utf8_lossy_100_invalid(b: &mut Bencher) {
-    let s = repeat(0xf5).take(100).collect::<Vec<_>>();
-    b.iter(|| {
-        let _ = String::from_utf8_lossy(&s);
-    });
-}
-
-#[bench]
-fn bench_exact_size_shrink_to_fit(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    // ensure our operation produces an exact-size string before we benchmark it
-    let mut r = String::with_capacity(s.len());
-    r.push_str(s);
-    assert_eq!(r.len(), r.capacity());
-    b.iter(|| {
-        let mut r = String::with_capacity(s.len());
-        r.push_str(s);
-        r.shrink_to_fit();
-        r
-    });
-}
-
-#[bench]
-fn bench_from_str(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| String::from(s))
-}
-
-#[bench]
-fn bench_from(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| String::from(s))
-}
-
-#[bench]
-fn bench_to_string(b: &mut Bencher) {
-    let s = "Hello there, the quick brown fox jumped over the lazy dog! \
-             Lorem ipsum dolor sit amet, consectetur. ";
-    b.iter(|| s.to_string())
-}
diff --git a/src/libcollections/benches/vec.rs b/src/libcollections/benches/vec.rs
deleted file mode 100644
index 41490117068..00000000000
--- a/src/libcollections/benches/vec.rs
+++ /dev/null
@@ -1,492 +0,0 @@
-// Copyright 2017 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.
-
-use test::Bencher;
-use std::iter::{FromIterator, repeat};
-
-#[bench]
-fn bench_new(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u32> = Vec::new();
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), 0);
-    })
-}
-
-fn do_bench_with_capacity(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let v: Vec<u32> = Vec::with_capacity(src_len);
-        assert_eq!(v.len(), 0);
-        assert_eq!(v.capacity(), src_len);
-    })
-}
-
-#[bench]
-fn bench_with_capacity_0000(b: &mut Bencher) {
-    do_bench_with_capacity(b, 0)
-}
-
-#[bench]
-fn bench_with_capacity_0010(b: &mut Bencher) {
-    do_bench_with_capacity(b, 10)
-}
-
-#[bench]
-fn bench_with_capacity_0100(b: &mut Bencher) {
-    do_bench_with_capacity(b, 100)
-}
-
-#[bench]
-fn bench_with_capacity_1000(b: &mut Bencher) {
-    do_bench_with_capacity(b, 1000)
-}
-
-fn do_bench_from_fn(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = (0..src_len).collect::<Vec<_>>();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    })
-}
-
-#[bench]
-fn bench_from_fn_0000(b: &mut Bencher) {
-    do_bench_from_fn(b, 0)
-}
-
-#[bench]
-fn bench_from_fn_0010(b: &mut Bencher) {
-    do_bench_from_fn(b, 10)
-}
-
-#[bench]
-fn bench_from_fn_0100(b: &mut Bencher) {
-    do_bench_from_fn(b, 100)
-}
-
-#[bench]
-fn bench_from_fn_1000(b: &mut Bencher) {
-    do_bench_from_fn(b, 1000)
-}
-
-fn do_bench_from_elem(b: &mut Bencher, src_len: usize) {
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst: Vec<usize> = repeat(5).take(src_len).collect();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().all(|x| *x == 5));
-    })
-}
-
-#[bench]
-fn bench_from_elem_0000(b: &mut Bencher) {
-    do_bench_from_elem(b, 0)
-}
-
-#[bench]
-fn bench_from_elem_0010(b: &mut Bencher) {
-    do_bench_from_elem(b, 10)
-}
-
-#[bench]
-fn bench_from_elem_0100(b: &mut Bencher) {
-    do_bench_from_elem(b, 100)
-}
-
-#[bench]
-fn bench_from_elem_1000(b: &mut Bencher) {
-    do_bench_from_elem(b, 1000)
-}
-
-fn do_bench_from_slice(b: &mut Bencher, src_len: usize) {
-    let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = src.clone()[..].to_vec();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_from_slice_0000(b: &mut Bencher) {
-    do_bench_from_slice(b, 0)
-}
-
-#[bench]
-fn bench_from_slice_0010(b: &mut Bencher) {
-    do_bench_from_slice(b, 10)
-}
-
-#[bench]
-fn bench_from_slice_0100(b: &mut Bencher) {
-    do_bench_from_slice(b, 100)
-}
-
-#[bench]
-fn bench_from_slice_1000(b: &mut Bencher) {
-    do_bench_from_slice(b, 1000)
-}
-
-fn do_bench_from_iter(b: &mut Bencher, src_len: usize) {
-    let src: Vec<_> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst: Vec<_> = FromIterator::from_iter(src.clone());
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_from_iter_0000(b: &mut Bencher) {
-    do_bench_from_iter(b, 0)
-}
-
-#[bench]
-fn bench_from_iter_0010(b: &mut Bencher) {
-    do_bench_from_iter(b, 10)
-}
-
-#[bench]
-fn bench_from_iter_0100(b: &mut Bencher) {
-    do_bench_from_iter(b, 100)
-}
-
-#[bench]
-fn bench_from_iter_1000(b: &mut Bencher) {
-    do_bench_from_iter(b, 1000)
-}
-
-fn do_bench_extend(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend(src.clone());
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_extend_0000_0000(b: &mut Bencher) {
-    do_bench_extend(b, 0, 0)
-}
-
-#[bench]
-fn bench_extend_0000_0010(b: &mut Bencher) {
-    do_bench_extend(b, 0, 10)
-}
-
-#[bench]
-fn bench_extend_0000_0100(b: &mut Bencher) {
-    do_bench_extend(b, 0, 100)
-}
-
-#[bench]
-fn bench_extend_0000_1000(b: &mut Bencher) {
-    do_bench_extend(b, 0, 1000)
-}
-
-#[bench]
-fn bench_extend_0010_0010(b: &mut Bencher) {
-    do_bench_extend(b, 10, 10)
-}
-
-#[bench]
-fn bench_extend_0100_0100(b: &mut Bencher) {
-    do_bench_extend(b, 100, 100)
-}
-
-#[bench]
-fn bench_extend_1000_1000(b: &mut Bencher) {
-    do_bench_extend(b, 1000, 1000)
-}
-
-fn do_bench_push_all(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend_from_slice(&src);
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_push_all_0000_0000(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 0)
-}
-
-#[bench]
-fn bench_push_all_0000_0010(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 10)
-}
-
-#[bench]
-fn bench_push_all_0000_0100(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 100)
-}
-
-#[bench]
-fn bench_push_all_0000_1000(b: &mut Bencher) {
-    do_bench_push_all(b, 0, 1000)
-}
-
-#[bench]
-fn bench_push_all_0010_0010(b: &mut Bencher) {
-    do_bench_push_all(b, 10, 10)
-}
-
-#[bench]
-fn bench_push_all_0100_0100(b: &mut Bencher) {
-    do_bench_push_all(b, 100, 100)
-}
-
-#[bench]
-fn bench_push_all_1000_1000(b: &mut Bencher) {
-    do_bench_push_all(b, 1000, 1000)
-}
-
-fn do_bench_push_all_move(b: &mut Bencher, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..dst_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-        dst.extend(src.clone());
-        assert_eq!(dst.len(), dst_len + src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_push_all_move_0000_0000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 0)
-}
-
-#[bench]
-fn bench_push_all_move_0000_0010(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 10)
-}
-
-#[bench]
-fn bench_push_all_move_0000_0100(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 100)
-}
-
-#[bench]
-fn bench_push_all_move_0000_1000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 0, 1000)
-}
-
-#[bench]
-fn bench_push_all_move_0010_0010(b: &mut Bencher) {
-    do_bench_push_all_move(b, 10, 10)
-}
-
-#[bench]
-fn bench_push_all_move_0100_0100(b: &mut Bencher) {
-    do_bench_push_all_move(b, 100, 100)
-}
-
-#[bench]
-fn bench_push_all_move_1000_1000(b: &mut Bencher) {
-    do_bench_push_all_move(b, 1000, 1000)
-}
-
-fn do_bench_clone(b: &mut Bencher, src_len: usize) {
-    let src: Vec<usize> = FromIterator::from_iter(0..src_len);
-
-    b.bytes = src_len as u64;
-
-    b.iter(|| {
-        let dst = src.clone();
-        assert_eq!(dst.len(), src_len);
-        assert!(dst.iter().enumerate().all(|(i, x)| i == *x));
-    });
-}
-
-#[bench]
-fn bench_clone_0000(b: &mut Bencher) {
-    do_bench_clone(b, 0)
-}
-
-#[bench]
-fn bench_clone_0010(b: &mut Bencher) {
-    do_bench_clone(b, 10)
-}
-
-#[bench]
-fn bench_clone_0100(b: &mut Bencher) {
-    do_bench_clone(b, 100)
-}
-
-#[bench]
-fn bench_clone_1000(b: &mut Bencher) {
-    do_bench_clone(b, 1000)
-}
-
-fn do_bench_clone_from(b: &mut Bencher, times: usize, dst_len: usize, src_len: usize) {
-    let dst: Vec<_> = FromIterator::from_iter(0..src_len);
-    let src: Vec<_> = FromIterator::from_iter(dst_len..dst_len + src_len);
-
-    b.bytes = (times * src_len) as u64;
-
-    b.iter(|| {
-        let mut dst = dst.clone();
-
-        for _ in 0..times {
-            dst.clone_from(&src);
-
-            assert_eq!(dst.len(), src_len);
-            assert!(dst.iter().enumerate().all(|(i, x)| dst_len + i == *x));
-        }
-    });
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 0)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_0000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 0, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_1000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 1000, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 100)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 1000)
-}
-
-#[bench]
-fn bench_clone_from_01_0010_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 10, 0)
-}
-
-#[bench]
-fn bench_clone_from_01_0100_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 100, 10)
-}
-
-#[bench]
-fn bench_clone_from_01_1000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 1, 1000, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 0)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 0, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_1000_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 1000, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 100)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_1000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 1000)
-}
-
-#[bench]
-fn bench_clone_from_10_0010_0000(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 10, 0)
-}
-
-#[bench]
-fn bench_clone_from_10_0100_0010(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 100, 10)
-}
-
-#[bench]
-fn bench_clone_from_10_1000_0100(b: &mut Bencher) {
-    do_bench_clone_from(b, 10, 1000, 100)
-}
diff --git a/src/libcollections/benches/vec_deque.rs b/src/libcollections/benches/vec_deque.rs
deleted file mode 100644
index 380645e7cd0..00000000000
--- a/src/libcollections/benches/vec_deque.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2017 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.
-
-use std::collections::VecDeque;
-use test::{Bencher, black_box};
-
-#[bench]
-fn bench_new(b: &mut Bencher) {
-    b.iter(|| {
-        let ring: VecDeque<i32> = VecDeque::new();
-        black_box(ring);
-    })
-}
-
-#[bench]
-fn bench_grow_1025(b: &mut Bencher) {
-    b.iter(|| {
-        let mut deq = VecDeque::new();
-        for i in 0..1025 {
-            deq.push_front(i);
-        }
-        black_box(deq);
-    })
-}
-
-#[bench]
-fn bench_iter_1000(b: &mut Bencher) {
-    let ring: VecDeque<_> = (0..1000).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for &i in &ring {
-            sum += i;
-        }
-        black_box(sum);
-    })
-}
-
-#[bench]
-fn bench_mut_iter_1000(b: &mut Bencher) {
-    let mut ring: VecDeque<_> = (0..1000).collect();
-
-    b.iter(|| {
-        let mut sum = 0;
-        for i in &mut ring {
-            sum += *i;
-        }
-        black_box(sum);
-    })
-}
diff --git a/src/libcollections/binary_heap.rs b/src/libcollections/binary_heap.rs
deleted file mode 100644
index 988f8851625..00000000000
--- a/src/libcollections/binary_heap.rs
+++ /dev/null
@@ -1,1236 +0,0 @@
-// Copyright 2013-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.
-
-//! A priority queue implemented with a binary heap.
-//!
-//! Insertion and popping the largest element have `O(log n)` time complexity.
-//! Checking the largest element is `O(1)`. Converting a vector to a binary heap
-//! can be done in-place, and has `O(n)` complexity. A binary heap can also be
-//! converted to a sorted vector in-place, allowing it to be used for an `O(n
-//! log n)` in-place heapsort.
-//!
-//! # Examples
-//!
-//! This is a larger example that implements [Dijkstra's algorithm][dijkstra]
-//! to solve the [shortest path problem][sssp] on a [directed graph][dir_graph].
-//! It shows how to use [`BinaryHeap`] with custom types.
-//!
-//! [dijkstra]: http://en.wikipedia.org/wiki/Dijkstra%27s_algorithm
-//! [sssp]: http://en.wikipedia.org/wiki/Shortest_path_problem
-//! [dir_graph]: http://en.wikipedia.org/wiki/Directed_graph
-//! [`BinaryHeap`]: struct.BinaryHeap.html
-//!
-//! ```
-//! use std::cmp::Ordering;
-//! use std::collections::BinaryHeap;
-//! use std::usize;
-//!
-//! #[derive(Copy, Clone, Eq, PartialEq)]
-//! struct State {
-//!     cost: usize,
-//!     position: usize,
-//! }
-//!
-//! // The priority queue depends on `Ord`.
-//! // Explicitly implement the trait so the queue becomes a min-heap
-//! // instead of a max-heap.
-//! impl Ord for State {
-//!     fn cmp(&self, other: &State) -> Ordering {
-//!         // Notice that the we flip the ordering on costs.
-//!         // In case of a tie we compare positions - this step is necessary
-//!         // to make implementations of `PartialEq` and `Ord` consistent.
-//!         other.cost.cmp(&self.cost)
-//!             .then_with(|| self.position.cmp(&other.position))
-//!     }
-//! }
-//!
-//! // `PartialOrd` needs to be implemented as well.
-//! impl PartialOrd for State {
-//!     fn partial_cmp(&self, other: &State) -> Option<Ordering> {
-//!         Some(self.cmp(other))
-//!     }
-//! }
-//!
-//! // Each node is represented as an `usize`, for a shorter implementation.
-//! struct Edge {
-//!     node: usize,
-//!     cost: usize,
-//! }
-//!
-//! // Dijkstra's shortest path algorithm.
-//!
-//! // Start at `start` and use `dist` to track the current shortest distance
-//! // to each node. This implementation isn't memory-efficient as it may leave duplicate
-//! // nodes in the queue. It also uses `usize::MAX` as a sentinel value,
-//! // for a simpler implementation.
-//! fn shortest_path(adj_list: &Vec<Vec<Edge>>, start: usize, goal: usize) -> Option<usize> {
-//!     // dist[node] = current shortest distance from `start` to `node`
-//!     let mut dist: Vec<_> = (0..adj_list.len()).map(|_| usize::MAX).collect();
-//!
-//!     let mut heap = BinaryHeap::new();
-//!
-//!     // We're at `start`, with a zero cost
-//!     dist[start] = 0;
-//!     heap.push(State { cost: 0, position: start });
-//!
-//!     // Examine the frontier with lower cost nodes first (min-heap)
-//!     while let Some(State { cost, position }) = heap.pop() {
-//!         // Alternatively we could have continued to find all shortest paths
-//!         if position == goal { return Some(cost); }
-//!
-//!         // Important as we may have already found a better way
-//!         if cost > dist[position] { continue; }
-//!
-//!         // For each node we can reach, see if we can find a way with
-//!         // a lower cost going through this node
-//!         for edge in &adj_list[position] {
-//!             let next = State { cost: cost + edge.cost, position: edge.node };
-//!
-//!             // If so, add it to the frontier and continue
-//!             if next.cost < dist[next.position] {
-//!                 heap.push(next);
-//!                 // Relaxation, we have now found a better way
-//!                 dist[next.position] = next.cost;
-//!             }
-//!         }
-//!     }
-//!
-//!     // Goal not reachable
-//!     None
-//! }
-//!
-//! fn main() {
-//!     // This is the directed graph we're going to use.
-//!     // The node numbers correspond to the different states,
-//!     // and the edge weights symbolize the cost of moving
-//!     // from one node to another.
-//!     // Note that the edges are one-way.
-//!     //
-//!     //                  7
-//!     //          +-----------------+
-//!     //          |                 |
-//!     //          v   1        2    |  2
-//!     //          0 -----> 1 -----> 3 ---> 4
-//!     //          |        ^        ^      ^
-//!     //          |        | 1      |      |
-//!     //          |        |        | 3    | 1
-//!     //          +------> 2 -------+      |
-//!     //           10      |               |
-//!     //                   +---------------+
-//!     //
-//!     // The graph is represented as an adjacency list where each index,
-//!     // corresponding to a node value, has a list of outgoing edges.
-//!     // Chosen for its efficiency.
-//!     let graph = vec![
-//!         // Node 0
-//!         vec![Edge { node: 2, cost: 10 },
-//!              Edge { node: 1, cost: 1 }],
-//!         // Node 1
-//!         vec![Edge { node: 3, cost: 2 }],
-//!         // Node 2
-//!         vec![Edge { node: 1, cost: 1 },
-//!              Edge { node: 3, cost: 3 },
-//!              Edge { node: 4, cost: 1 }],
-//!         // Node 3
-//!         vec![Edge { node: 0, cost: 7 },
-//!              Edge { node: 4, cost: 2 }],
-//!         // Node 4
-//!         vec![]];
-//!
-//!     assert_eq!(shortest_path(&graph, 0, 1), Some(1));
-//!     assert_eq!(shortest_path(&graph, 0, 3), Some(3));
-//!     assert_eq!(shortest_path(&graph, 3, 0), Some(7));
-//!     assert_eq!(shortest_path(&graph, 0, 4), Some(5));
-//!     assert_eq!(shortest_path(&graph, 4, 0), None);
-//! }
-//! ```
-
-#![allow(missing_docs)]
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use core::ops::{Deref, DerefMut, Place, Placer, InPlace};
-use core::iter::{FromIterator, FusedIterator};
-use core::mem::{swap, size_of};
-use core::ptr;
-use core::fmt;
-
-use slice;
-use vec::{self, Vec};
-
-use super::SpecExtend;
-
-/// A priority queue implemented with a binary heap.
-///
-/// This will be a max-heap.
-///
-/// It is a logic error for an item to be modified in such a way that the
-/// item's ordering relative to any other item, as determined by the `Ord`
-/// trait, changes while it is in the heap. This is normally only possible
-/// through `Cell`, `RefCell`, global state, I/O, or unsafe code.
-///
-/// # Examples
-///
-/// ```
-/// use std::collections::BinaryHeap;
-///
-/// // Type inference lets us omit an explicit type signature (which
-/// // would be `BinaryHeap<i32>` in this example).
-/// let mut heap = BinaryHeap::new();
-///
-/// // We can use peek to look at the next item in the heap. In this case,
-/// // there's no items in there yet so we get None.
-/// assert_eq!(heap.peek(), None);
-///
-/// // Let's add some scores...
-/// heap.push(1);
-/// heap.push(5);
-/// heap.push(2);
-///
-/// // Now peek shows the most important item in the heap.
-/// assert_eq!(heap.peek(), Some(&5));
-///
-/// // We can check the length of a heap.
-/// assert_eq!(heap.len(), 3);
-///
-/// // We can iterate over the items in the heap, although they are returned in
-/// // a random order.
-/// for x in &heap {
-///     println!("{}", x);
-/// }
-///
-/// // If we instead pop these scores, they should come back in order.
-/// assert_eq!(heap.pop(), Some(5));
-/// assert_eq!(heap.pop(), Some(2));
-/// assert_eq!(heap.pop(), Some(1));
-/// assert_eq!(heap.pop(), None);
-///
-/// // We can clear the heap of any remaining items.
-/// heap.clear();
-///
-/// // The heap should now be empty.
-/// assert!(heap.is_empty())
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct BinaryHeap<T> {
-    data: Vec<T>,
-}
-
-/// Structure wrapping a mutable reference to the greatest item on a
-/// `BinaryHeap`.
-///
-/// This `struct` is created by the [`peek_mut`] method on [`BinaryHeap`]. See
-/// its documentation for more.
-///
-/// [`peek_mut`]: struct.BinaryHeap.html#method.peek_mut
-/// [`BinaryHeap`]: struct.BinaryHeap.html
-#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-pub struct PeekMut<'a, T: 'a + Ord> {
-    heap: &'a mut BinaryHeap<T>,
-    sift: bool,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: Ord + fmt::Debug> fmt::Debug for PeekMut<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("PeekMut")
-         .field(&self.heap.data[0])
-         .finish()
-    }
-}
-
-#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-impl<'a, T: Ord> Drop for PeekMut<'a, T> {
-    fn drop(&mut self) {
-        if self.sift {
-            self.heap.sift_down(0);
-        }
-    }
-}
-
-#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-impl<'a, T: Ord> Deref for PeekMut<'a, T> {
-    type Target = T;
-    fn deref(&self) -> &T {
-        &self.heap.data[0]
-    }
-}
-
-#[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-impl<'a, T: Ord> DerefMut for PeekMut<'a, T> {
-    fn deref_mut(&mut self) -> &mut T {
-        &mut self.heap.data[0]
-    }
-}
-
-impl<'a, T: Ord> PeekMut<'a, T> {
-    /// Removes the peeked value from the heap and returns it.
-    #[stable(feature = "binary_heap_peek_mut_pop", since = "1.18.0")]
-    pub fn pop(mut this: PeekMut<'a, T>) -> T {
-        let value = this.heap.pop().unwrap();
-        this.sift = false;
-        value
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> Clone for BinaryHeap<T> {
-    fn clone(&self) -> Self {
-        BinaryHeap { data: self.data.clone() }
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        self.data.clone_from(&source.data);
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Default for BinaryHeap<T> {
-    /// Creates an empty `BinaryHeap<T>`.
-    #[inline]
-    fn default() -> BinaryHeap<T> {
-        BinaryHeap::new()
-    }
-}
-
-#[stable(feature = "binaryheap_debug", since = "1.4.0")]
-impl<T: fmt::Debug + Ord> fmt::Debug for BinaryHeap<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.iter()).finish()
-    }
-}
-
-impl<T: Ord> BinaryHeap<T> {
-    /// Creates an empty `BinaryHeap` as a max-heap.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// heap.push(4);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> BinaryHeap<T> {
-        BinaryHeap { data: vec![] }
-    }
-
-    /// Creates an empty `BinaryHeap` with a specific capacity.
-    /// This preallocates enough memory for `capacity` elements,
-    /// so that the `BinaryHeap` does not have to be reallocated
-    /// until it contains at least that many values.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::with_capacity(10);
-    /// heap.push(4);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: usize) -> BinaryHeap<T> {
-        BinaryHeap { data: Vec::with_capacity(capacity) }
-    }
-
-    /// Returns an iterator visiting all values in the underlying vector, in
-    /// arbitrary order.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]);
-    ///
-    /// // Print 1, 2, 3, 4 in arbitrary order
-    /// for x in heap.iter() {
-    ///     println!("{}", x);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter(&self) -> Iter<T> {
-        Iter { iter: self.data.iter() }
-    }
-
-    /// Returns the greatest item in the binary heap, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// assert_eq!(heap.peek(), None);
-    ///
-    /// heap.push(1);
-    /// heap.push(5);
-    /// heap.push(2);
-    /// assert_eq!(heap.peek(), Some(&5));
-    ///
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn peek(&self) -> Option<&T> {
-        self.data.get(0)
-    }
-
-    /// Returns a mutable reference to the greatest item in the binary heap, or
-    /// `None` if it is empty.
-    ///
-    /// Note: If the `PeekMut` value is leaked, the heap may be in an
-    /// inconsistent state.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// assert!(heap.peek_mut().is_none());
-    ///
-    /// heap.push(1);
-    /// heap.push(5);
-    /// heap.push(2);
-    /// {
-    ///     let mut val = heap.peek_mut().unwrap();
-    ///     *val = 0;
-    /// }
-    /// assert_eq!(heap.peek(), Some(&2));
-    /// ```
-    #[stable(feature = "binary_heap_peek_mut", since = "1.12.0")]
-    pub fn peek_mut(&mut self) -> Option<PeekMut<T>> {
-        if self.is_empty() {
-            None
-        } else {
-            Some(PeekMut {
-                heap: self,
-                sift: true,
-            })
-        }
-    }
-
-    /// Returns the number of elements the binary heap can hold without reallocating.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::with_capacity(100);
-    /// assert!(heap.capacity() >= 100);
-    /// heap.push(4);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> usize {
-        self.data.capacity()
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
-    /// given `BinaryHeap`. Does nothing if the capacity is already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it requests. Therefore
-    /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future
-    /// insertions are expected.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// heap.reserve_exact(100);
-    /// assert!(heap.capacity() >= 100);
-    /// heap.push(4);
-    /// ```
-    ///
-    /// [`reserve`]: #method.reserve
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.data.reserve_exact(additional);
-    }
-
-    /// Reserves capacity for at least `additional` more elements to be inserted in the
-    /// `BinaryHeap`. The collection may reserve more space to avoid frequent reallocations.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// heap.reserve(100);
-    /// assert!(heap.capacity() >= 100);
-    /// heap.push(4);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: usize) {
-        self.data.reserve(additional);
-    }
-
-    /// Discards as much additional capacity as possible.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap: BinaryHeap<i32> = BinaryHeap::with_capacity(100);
-    ///
-    /// assert!(heap.capacity() >= 100);
-    /// heap.shrink_to_fit();
-    /// assert!(heap.capacity() == 0);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn shrink_to_fit(&mut self) {
-        self.data.shrink_to_fit();
-    }
-
-    /// Removes the greatest item from the binary heap and returns it, or `None` if it
-    /// is empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::from(vec![1, 3]);
-    ///
-    /// assert_eq!(heap.pop(), Some(3));
-    /// assert_eq!(heap.pop(), Some(1));
-    /// assert_eq!(heap.pop(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop(&mut self) -> Option<T> {
-        self.data.pop().map(|mut item| {
-            if !self.is_empty() {
-                swap(&mut item, &mut self.data[0]);
-                self.sift_down_to_bottom(0);
-            }
-            item
-        })
-    }
-
-    /// Pushes an item onto the binary heap.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    /// heap.push(3);
-    /// heap.push(5);
-    /// heap.push(1);
-    ///
-    /// assert_eq!(heap.len(), 3);
-    /// assert_eq!(heap.peek(), Some(&5));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push(&mut self, item: T) {
-        let old_len = self.len();
-        self.data.push(item);
-        self.sift_up(0, old_len);
-    }
-
-    /// Consumes the `BinaryHeap` and returns the underlying vector
-    /// in arbitrary order.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let heap = BinaryHeap::from(vec![1, 2, 3, 4, 5, 6, 7]);
-    /// let vec = heap.into_vec();
-    ///
-    /// // Will print in some order
-    /// for x in vec {
-    ///     println!("{}", x);
-    /// }
-    /// ```
-    #[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
-    pub fn into_vec(self) -> Vec<T> {
-        self.into()
-    }
-
-    /// Consumes the `BinaryHeap` and returns a vector in sorted
-    /// (ascending) order.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    ///
-    /// let mut heap = BinaryHeap::from(vec![1, 2, 4, 5, 7]);
-    /// heap.push(6);
-    /// heap.push(3);
-    ///
-    /// let vec = heap.into_sorted_vec();
-    /// assert_eq!(vec, [1, 2, 3, 4, 5, 6, 7]);
-    /// ```
-    #[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
-    pub fn into_sorted_vec(mut self) -> Vec<T> {
-        let mut end = self.len();
-        while end > 1 {
-            end -= 1;
-            self.data.swap(0, end);
-            self.sift_down_range(0, end);
-        }
-        self.into_vec()
-    }
-
-    // The implementations of sift_up and sift_down use unsafe blocks in
-    // order to move an element out of the vector (leaving behind a
-    // hole), shift along the others and move the removed element back into the
-    // vector at the final location of the hole.
-    // The `Hole` type is used to represent this, and make sure
-    // the hole is filled back at the end of its scope, even on panic.
-    // Using a hole reduces the constant factor compared to using swaps,
-    // which involves twice as many moves.
-    fn sift_up(&mut self, start: usize, pos: usize) -> usize {
-        unsafe {
-            // Take out the value at `pos` and create a hole.
-            let mut hole = Hole::new(&mut self.data, pos);
-
-            while hole.pos() > start {
-                let parent = (hole.pos() - 1) / 2;
-                if hole.element() <= hole.get(parent) {
-                    break;
-                }
-                hole.move_to(parent);
-            }
-            hole.pos()
-        }
-    }
-
-    /// Take an element at `pos` and move it down the heap,
-    /// while its children are larger.
-    fn sift_down_range(&mut self, pos: usize, end: usize) {
-        unsafe {
-            let mut hole = Hole::new(&mut self.data, pos);
-            let mut child = 2 * pos + 1;
-            while child < end {
-                let right = child + 1;
-                // compare with the greater of the two children
-                if right < end && !(hole.get(child) > hole.get(right)) {
-                    child = right;
-                }
-                // if we are already in order, stop.
-                if hole.element() >= hole.get(child) {
-                    break;
-                }
-                hole.move_to(child);
-                child = 2 * hole.pos() + 1;
-            }
-        }
-    }
-
-    fn sift_down(&mut self, pos: usize) {
-        let len = self.len();
-        self.sift_down_range(pos, len);
-    }
-
-    /// Take an element at `pos` and move it all the way down the heap,
-    /// then sift it up to its position.
-    ///
-    /// Note: This is faster when the element is known to be large / should
-    /// be closer to the bottom.
-    fn sift_down_to_bottom(&mut self, mut pos: usize) {
-        let end = self.len();
-        let start = pos;
-        unsafe {
-            let mut hole = Hole::new(&mut self.data, pos);
-            let mut child = 2 * pos + 1;
-            while child < end {
-                let right = child + 1;
-                // compare with the greater of the two children
-                if right < end && !(hole.get(child) > hole.get(right)) {
-                    child = right;
-                }
-                hole.move_to(child);
-                child = 2 * hole.pos() + 1;
-            }
-            pos = hole.pos;
-        }
-        self.sift_up(start, pos);
-    }
-
-    /// Returns the length of the binary heap.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let heap = BinaryHeap::from(vec![1, 3]);
-    ///
-    /// assert_eq!(heap.len(), 2);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.data.len()
-    }
-
-    /// Checks if the binary heap is empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::new();
-    ///
-    /// assert!(heap.is_empty());
-    ///
-    /// heap.push(3);
-    /// heap.push(5);
-    /// heap.push(1);
-    ///
-    /// assert!(!heap.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Clears the binary heap, returning an iterator over the removed elements.
-    ///
-    /// The elements are removed in arbitrary order.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::from(vec![1, 3]);
-    ///
-    /// assert!(!heap.is_empty());
-    ///
-    /// for x in heap.drain() {
-    ///     println!("{}", x);
-    /// }
-    ///
-    /// assert!(heap.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain(&mut self) -> Drain<T> {
-        Drain { iter: self.data.drain(..) }
-    }
-
-    /// Drops all items from the binary heap.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let mut heap = BinaryHeap::from(vec![1, 3]);
-    ///
-    /// assert!(!heap.is_empty());
-    ///
-    /// heap.clear();
-    ///
-    /// assert!(heap.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        self.drain();
-    }
-
-    fn rebuild(&mut self) {
-        let mut n = self.len() / 2;
-        while n > 0 {
-            n -= 1;
-            self.sift_down(n);
-        }
-    }
-
-    /// Moves all the elements of `other` into `self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    ///
-    /// let v = vec![-10, 1, 2, 3, 3];
-    /// let mut a = BinaryHeap::from(v);
-    ///
-    /// let v = vec![-20, 5, 43];
-    /// let mut b = BinaryHeap::from(v);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]);
-    /// assert!(b.is_empty());
-    /// ```
-    #[stable(feature = "binary_heap_append", since = "1.11.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        if self.len() < other.len() {
-            swap(self, other);
-        }
-
-        if other.is_empty() {
-            return;
-        }
-
-        #[inline(always)]
-        fn log2_fast(x: usize) -> usize {
-            8 * size_of::<usize>() - (x.leading_zeros() as usize) - 1
-        }
-
-        // `rebuild` takes O(len1 + len2) operations
-        // and about 2 * (len1 + len2) comparisons in the worst case
-        // while `extend` takes O(len2 * log_2(len1)) operations
-        // and about 1 * len2 * log_2(len1) comparisons in the worst case,
-        // assuming len1 >= len2.
-        #[inline]
-        fn better_to_rebuild(len1: usize, len2: usize) -> bool {
-            2 * (len1 + len2) < len2 * log2_fast(len1)
-        }
-
-        if better_to_rebuild(self.len(), other.len()) {
-            self.data.append(&mut other.data);
-            self.rebuild();
-        } else {
-            self.extend(other.drain());
-        }
-    }
-}
-
-/// Hole represents a hole in a slice i.e. an index without valid value
-/// (because it was moved from or duplicated).
-/// In drop, `Hole` will restore the slice by filling the hole
-/// position with the value that was originally removed.
-struct Hole<'a, T: 'a> {
-    data: &'a mut [T],
-    /// `elt` is always `Some` from new until drop.
-    elt: Option<T>,
-    pos: usize,
-}
-
-impl<'a, T> Hole<'a, T> {
-    /// Create a new Hole at index `pos`.
-    ///
-    /// Unsafe because pos must be within the data slice.
-    #[inline]
-    unsafe fn new(data: &'a mut [T], pos: usize) -> Self {
-        debug_assert!(pos < data.len());
-        let elt = ptr::read(&data[pos]);
-        Hole {
-            data: data,
-            elt: Some(elt),
-            pos: pos,
-        }
-    }
-
-    #[inline]
-    fn pos(&self) -> usize {
-        self.pos
-    }
-
-    /// Returns a reference to the element removed.
-    #[inline]
-    fn element(&self) -> &T {
-        self.elt.as_ref().unwrap()
-    }
-
-    /// Returns a reference to the element at `index`.
-    ///
-    /// Unsafe because index must be within the data slice and not equal to pos.
-    #[inline]
-    unsafe fn get(&self, index: usize) -> &T {
-        debug_assert!(index != self.pos);
-        debug_assert!(index < self.data.len());
-        self.data.get_unchecked(index)
-    }
-
-    /// Move hole to new location
-    ///
-    /// Unsafe because index must be within the data slice and not equal to pos.
-    #[inline]
-    unsafe fn move_to(&mut self, index: usize) {
-        debug_assert!(index != self.pos);
-        debug_assert!(index < self.data.len());
-        let index_ptr: *const _ = self.data.get_unchecked(index);
-        let hole_ptr = self.data.get_unchecked_mut(self.pos);
-        ptr::copy_nonoverlapping(index_ptr, hole_ptr, 1);
-        self.pos = index;
-    }
-}
-
-impl<'a, T> Drop for Hole<'a, T> {
-    #[inline]
-    fn drop(&mut self) {
-        // fill the hole again
-        unsafe {
-            let pos = self.pos;
-            ptr::write(self.data.get_unchecked_mut(pos), self.elt.take().unwrap());
-        }
-    }
-}
-
-/// An iterator over the elements of a `BinaryHeap`.
-///
-/// This `struct` is created by the [`iter`] method on [`BinaryHeap`]. See its
-/// documentation for more.
-///
-/// [`iter`]: struct.BinaryHeap.html#method.iter
-/// [`BinaryHeap`]: struct.BinaryHeap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
-    iter: slice::Iter<'a, T>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Iter")
-         .field(&self.iter.as_slice())
-         .finish()
-    }
-}
-
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Iter<'a, T> {
-    fn clone(&self) -> Iter<'a, T> {
-        Iter { iter: self.iter.clone() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a T> {
-        self.iter.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a T> {
-        self.iter.next_back()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-    fn is_empty(&self) -> bool {
-        self.iter.is_empty()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Iter<'a, T> {}
-
-/// An owning iterator over the elements of a `BinaryHeap`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`BinaryHeap`][`BinaryHeap`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`into_iter`]: struct.BinaryHeap.html#method.into_iter
-/// [`BinaryHeap`]: struct.BinaryHeap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Clone)]
-pub struct IntoIter<T> {
-    iter: vec::IntoIter<T>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IntoIter")
-         .field(&self.iter.as_slice())
-         .finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.iter.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.iter.next_back()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn is_empty(&self) -> bool {
-        self.iter.is_empty()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<T> FusedIterator for IntoIter<T> {}
-
-/// A draining iterator over the elements of a `BinaryHeap`.
-///
-/// This `struct` is created by the [`drain`] method on [`BinaryHeap`]. See its
-/// documentation for more.
-///
-/// [`drain`]: struct.BinaryHeap.html#method.drain
-/// [`BinaryHeap`]: struct.BinaryHeap.html
-#[stable(feature = "drain", since = "1.6.0")]
-#[derive(Debug)]
-pub struct Drain<'a, T: 'a> {
-    iter: vec::Drain<'a, T>,
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> Iterator for Drain<'a, T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.iter.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.iter.next_back()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {
-    fn is_empty(&self) -> bool {
-        self.iter.is_empty()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: 'a> FusedIterator for Drain<'a, T> {}
-
-#[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
-impl<T: Ord> From<Vec<T>> for BinaryHeap<T> {
-    fn from(vec: Vec<T>) -> BinaryHeap<T> {
-        let mut heap = BinaryHeap { data: vec };
-        heap.rebuild();
-        heap
-    }
-}
-
-#[stable(feature = "binary_heap_extras_15", since = "1.5.0")]
-impl<T> From<BinaryHeap<T>> for Vec<T> {
-    fn from(heap: BinaryHeap<T>) -> Vec<T> {
-        heap.data
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> FromIterator<T> for BinaryHeap<T> {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BinaryHeap<T> {
-        BinaryHeap::from(iter.into_iter().collect::<Vec<_>>())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> IntoIterator for BinaryHeap<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    /// Creates a consuming iterator, that is, one that moves each value out of
-    /// the binary heap in arbitrary order. The binary heap cannot be used
-    /// after calling this.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BinaryHeap;
-    /// let heap = BinaryHeap::from(vec![1, 2, 3, 4]);
-    ///
-    /// // Print 1, 2, 3, 4 in arbitrary order
-    /// for x in heap.into_iter() {
-    ///     // x has type i32, not &i32
-    ///     println!("{}", x);
-    /// }
-    /// ```
-    fn into_iter(self) -> IntoIter<T> {
-        IntoIter { iter: self.data.into_iter() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a BinaryHeap<T>
-    where T: Ord
-{
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Extend<T> for BinaryHeap<T> {
-    #[inline]
-    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        <Self as SpecExtend<I>>::spec_extend(self, iter);
-    }
-}
-
-impl<T: Ord, I: IntoIterator<Item = T>> SpecExtend<I> for BinaryHeap<T> {
-    default fn spec_extend(&mut self, iter: I) {
-        self.extend_desugared(iter.into_iter());
-    }
-}
-
-impl<T: Ord> SpecExtend<BinaryHeap<T>> for BinaryHeap<T> {
-    fn spec_extend(&mut self, ref mut other: BinaryHeap<T>) {
-        self.append(other);
-    }
-}
-
-impl<T: Ord> BinaryHeap<T> {
-    fn extend_desugared<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        let iterator = iter.into_iter();
-        let (lower, _) = iterator.size_hint();
-
-        self.reserve(lower);
-
-        for elem in iterator {
-            self.push(elem);
-        }
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BinaryHeap<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-pub struct BinaryHeapPlace<'a, T: 'a>
-where T: Clone + Ord {
-    heap: *mut BinaryHeap<T>,
-    place: vec::PlaceBack<'a, T>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T: Clone + Ord + fmt::Debug> fmt::Debug for BinaryHeapPlace<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("BinaryHeapPlace")
-         .field(&self.place)
-         .finish()
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T: 'a> Placer<T> for &'a mut BinaryHeap<T>
-where T: Clone + Ord {
-    type Place = BinaryHeapPlace<'a, T>;
-
-    fn make_place(self) -> Self::Place {
-        let ptr = self as *mut BinaryHeap<T>;
-        let place = Placer::make_place(self.data.place_back());
-        BinaryHeapPlace {
-            heap: ptr,
-            place: place,
-        }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for BinaryHeapPlace<'a, T>
-where T: Clone + Ord {
-    fn pointer(&mut self) -> *mut T {
-        self.place.pointer()
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for BinaryHeapPlace<'a, T>
-where T: Clone + Ord {
-    type Owner = &'a T;
-
-    unsafe fn finalize(self) -> &'a T {
-        self.place.finalize();
-
-        let heap: &mut BinaryHeap<T> = &mut *self.heap;
-        let len = heap.len();
-        let i = heap.sift_up(0, len - 1);
-        heap.data.get_unchecked(i)
-    }
-}
diff --git a/src/libcollections/borrow.rs b/src/libcollections/borrow.rs
deleted file mode 100644
index a662e4b1f4f..00000000000
--- a/src/libcollections/borrow.rs
+++ /dev/null
@@ -1,421 +0,0 @@
-// Copyright 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.
-
-//! A module for working with borrowed data.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use core::cmp::Ordering;
-use core::hash::{Hash, Hasher};
-use core::ops::{Add, AddAssign, Deref};
-
-use fmt;
-use string::String;
-
-use self::Cow::*;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::borrow::{Borrow, BorrowMut};
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Borrow<B> for Cow<'a, B>
-    where B: ToOwned,
-          <B as ToOwned>::Owned: 'a
-{
-    fn borrow(&self) -> &B {
-        &**self
-    }
-}
-
-/// A generalization of `Clone` to borrowed data.
-///
-/// Some types make it possible to go from borrowed to owned, usually by
-/// implementing the `Clone` trait. But `Clone` works only for going from `&T`
-/// to `T`. The `ToOwned` trait generalizes `Clone` to construct owned data
-/// from any borrow of a given type.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait ToOwned {
-    #[stable(feature = "rust1", since = "1.0.0")]
-    type Owned: Borrow<Self>;
-
-    /// Creates owned data from borrowed data, usually by cloning.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s: &str = "a";
-    /// let ss: String = s.to_owned();
-    ///
-    /// let v: &[i32] = &[1, 2];
-    /// let vv: Vec<i32> = v.to_owned();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn to_owned(&self) -> Self::Owned;
-
-    /// Uses borrowed data to replace owned data, usually by cloning.
-    ///
-    /// This is borrow-generalized version of `Clone::clone_from`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// # #![feature(toowned_clone_into)]
-    /// let mut s: String = String::new();
-    /// "hello".clone_into(&mut s);
-    ///
-    /// let mut v: Vec<i32> = Vec::new();
-    /// [1, 2][..].clone_into(&mut v);
-    /// ```
-    #[unstable(feature = "toowned_clone_into",
-               reason = "recently added",
-               issue = "41263")]
-    fn clone_into(&self, target: &mut Self::Owned) {
-        *target = self.to_owned();
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ToOwned for T
-    where T: Clone
-{
-    type Owned = T;
-    fn to_owned(&self) -> T {
-        self.clone()
-    }
-
-    fn clone_into(&self, target: &mut T) {
-        target.clone_from(self);
-    }
-}
-
-/// A clone-on-write smart pointer.
-///
-/// The type `Cow` is a smart pointer providing clone-on-write functionality: it
-/// can enclose and provide immutable access to borrowed data, and clone the
-/// data lazily when mutation or ownership is required. The type is designed to
-/// work with general borrowed data via the `Borrow` trait.
-///
-/// `Cow` implements `Deref`, which means that you can call
-/// non-mutating methods directly on the data it encloses. If mutation
-/// is desired, `to_mut` will obtain a mutable reference to an owned
-/// value, cloning if necessary.
-///
-/// # Examples
-///
-/// ```
-/// use std::borrow::Cow;
-///
-/// fn abs_all(input: &mut Cow<[i32]>) {
-///     for i in 0..input.len() {
-///         let v = input[i];
-///         if v < 0 {
-///             // Clones into a vector if not already owned.
-///             input.to_mut()[i] = -v;
-///         }
-///     }
-/// }
-///
-/// // No clone occurs because `input` doesn't need to be mutated.
-/// let slice = [0, 1, 2];
-/// let mut input = Cow::from(&slice[..]);
-/// abs_all(&mut input);
-///
-/// // Clone occurs because `input` needs to be mutated.
-/// let slice = [-1, 0, 1];
-/// let mut input = Cow::from(&slice[..]);
-/// abs_all(&mut input);
-///
-/// // No clone occurs because `input` is already owned.
-/// let mut input = Cow::from(vec![-1, 0, 1]);
-/// abs_all(&mut input);
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-pub enum Cow<'a, B: ?Sized + 'a>
-    where B: ToOwned
-{
-    /// Borrowed data.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    Borrowed(#[stable(feature = "rust1", since = "1.0.0")]
-             &'a B),
-
-    /// Owned data.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    Owned(#[stable(feature = "rust1", since = "1.0.0")]
-          <B as ToOwned>::Owned),
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Clone for Cow<'a, B>
-    where B: ToOwned
-{
-    fn clone(&self) -> Cow<'a, B> {
-        match *self {
-            Borrowed(b) => Borrowed(b),
-            Owned(ref o) => {
-                let b: &B = o.borrow();
-                Owned(b.to_owned())
-            }
-        }
-    }
-
-    fn clone_from(&mut self, source: &Cow<'a, B>) {
-        if let Owned(ref mut dest) = *self {
-            if let Owned(ref o) = *source {
-                o.borrow().clone_into(dest);
-                return;
-            }
-        }
-
-        *self = source.clone();
-    }
-}
-
-impl<'a, B: ?Sized> Cow<'a, B>
-    where B: ToOwned
-{
-    /// Acquires a mutable reference to the owned form of the data.
-    ///
-    /// Clones the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    /// use std::borrow::Cow;
-    ///
-    /// let mut cow = Cow::Borrowed("foo");
-    /// cow.to_mut().make_ascii_uppercase();
-    ///
-    /// assert_eq!(
-    ///   cow,
-    ///   Cow::Owned(String::from("FOO")) as Cow<str>
-    /// );
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn to_mut(&mut self) -> &mut <B as ToOwned>::Owned {
-        match *self {
-            Borrowed(borrowed) => {
-                *self = Owned(borrowed.to_owned());
-                match *self {
-                    Borrowed(..) => unreachable!(),
-                    Owned(ref mut owned) => owned,
-                }
-            }
-            Owned(ref mut owned) => owned,
-        }
-    }
-
-    /// Extracts the owned data.
-    ///
-    /// Clones the data if it is not already owned.
-    ///
-    /// # Examples
-    ///
-    /// Calling `into_owned` on a `Cow::Borrowed` clones the underlying data
-    /// and becomes a `Cow::Owned`:
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let s = "Hello world!";
-    /// let cow = Cow::Borrowed(s);
-    ///
-    /// assert_eq!(
-    ///   cow.into_owned(),
-    ///   Cow::Owned(String::from(s))
-    /// );
-    /// ```
-    ///
-    /// Calling `into_owned` on a `Cow::Owned` is a no-op:
-    ///
-    /// ```
-    /// use std::borrow::Cow;
-    ///
-    /// let s = "Hello world!";
-    /// let cow: Cow<str> = Cow::Owned(String::from(s));
-    ///
-    /// assert_eq!(
-    ///   cow.into_owned(),
-    ///   Cow::Owned(String::from(s))
-    /// );
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_owned(self) -> <B as ToOwned>::Owned {
-        match self {
-            Borrowed(borrowed) => borrowed.to_owned(),
-            Owned(owned) => owned,
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Deref for Cow<'a, B>
-    where B: ToOwned
-{
-    type Target = B;
-
-    fn deref(&self) -> &B {
-        match *self {
-            Borrowed(borrowed) => borrowed,
-            Owned(ref owned) => owned.borrow(),
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Eq for Cow<'a, B> where B: Eq + ToOwned {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Ord for Cow<'a, B>
-    where B: Ord + ToOwned
-{
-    #[inline]
-    fn cmp(&self, other: &Cow<'a, B>) -> Ordering {
-        Ord::cmp(&**self, &**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, B: ?Sized, C: ?Sized> PartialEq<Cow<'b, C>> for Cow<'a, B>
-    where B: PartialEq<C> + ToOwned,
-          C: ToOwned
-{
-    #[inline]
-    fn eq(&self, other: &Cow<'b, C>) -> bool {
-        PartialEq::eq(&**self, &**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> PartialOrd for Cow<'a, B>
-    where B: PartialOrd + ToOwned
-{
-    #[inline]
-    fn partial_cmp(&self, other: &Cow<'a, B>) -> Option<Ordering> {
-        PartialOrd::partial_cmp(&**self, &**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> fmt::Debug for Cow<'a, B>
-    where B: fmt::Debug + ToOwned,
-          <B as ToOwned>::Owned: fmt::Debug
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Borrowed(ref b) => fmt::Debug::fmt(b, f),
-            Owned(ref o) => fmt::Debug::fmt(o, f),
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> fmt::Display for Cow<'a, B>
-    where B: fmt::Display + ToOwned,
-          <B as ToOwned>::Owned: fmt::Display
-{
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Borrowed(ref b) => fmt::Display::fmt(b, f),
-            Owned(ref o) => fmt::Display::fmt(o, f),
-        }
-    }
-}
-
-#[stable(feature = "default", since = "1.11.0")]
-impl<'a, B: ?Sized> Default for Cow<'a, B>
-    where B: ToOwned,
-          <B as ToOwned>::Owned: Default
-{
-    /// Creates an owned Cow<'a, B> with the default value for the contained owned value.
-    fn default() -> Cow<'a, B> {
-        Owned(<B as ToOwned>::Owned::default())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, B: ?Sized> Hash for Cow<'a, B>
-    where B: Hash + ToOwned
-{
-    #[inline]
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        Hash::hash(&**self, state)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow(deprecated)]
-impl<'a, T: ?Sized + ToOwned> AsRef<T> for Cow<'a, T> {
-    fn as_ref(&self) -> &T {
-        self
-    }
-}
-
-#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<&'a str> for Cow<'a, str> {
-    type Output = Cow<'a, str>;
-
-    #[inline]
-    fn add(mut self, rhs: &'a str) -> Self::Output {
-        self += rhs;
-        self
-    }
-}
-
-#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> Add<Cow<'a, str>> for Cow<'a, str> {
-    type Output = Cow<'a, str>;
-
-    #[inline]
-    fn add(mut self, rhs: Cow<'a, str>) -> Self::Output {
-        self += rhs;
-        self
-    }
-}
-
-#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<&'a str> for Cow<'a, str> {
-    fn add_assign(&mut self, rhs: &'a str) {
-        if self.is_empty() {
-            *self = Cow::Borrowed(rhs)
-        } else if rhs.is_empty() {
-            return;
-        } else {
-            if let Cow::Borrowed(lhs) = *self {
-                let mut s = String::with_capacity(lhs.len() + rhs.len());
-                s.push_str(lhs);
-                *self = Cow::Owned(s);
-            }
-            self.to_mut().push_str(rhs);
-        }
-    }
-}
-
-#[stable(feature = "cow_add", since = "1.14.0")]
-impl<'a> AddAssign<Cow<'a, str>> for Cow<'a, str> {
-    fn add_assign(&mut self, rhs: Cow<'a, str>) {
-        if self.is_empty() {
-            *self = rhs
-        } else if rhs.is_empty() {
-            return;
-        } else {
-            if let Cow::Borrowed(lhs) = *self {
-                let mut s = String::with_capacity(lhs.len() + rhs.len());
-                s.push_str(lhs);
-                *self = Cow::Owned(s);
-            }
-            self.to_mut().push_str(&rhs);
-        }
-    }
-}
diff --git a/src/libcollections/btree/map.rs b/src/libcollections/btree/map.rs
deleted file mode 100644
index d73c0254a74..00000000000
--- a/src/libcollections/btree/map.rs
+++ /dev/null
@@ -1,2460 +0,0 @@
-// Copyright 2015 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.
-
-use core::cmp::Ordering;
-use core::fmt::Debug;
-use core::hash::{Hash, Hasher};
-use core::iter::{FromIterator, Peekable, FusedIterator};
-use core::marker::PhantomData;
-use core::ops::Index;
-use core::{fmt, intrinsics, mem, ptr};
-
-use borrow::Borrow;
-use Bound::{Excluded, Included, Unbounded};
-use range::RangeArgument;
-
-use super::node::{self, Handle, NodeRef, marker};
-use super::search;
-
-use super::node::InsertResult::*;
-use super::node::ForceResult::*;
-use super::search::SearchResult::*;
-use self::UnderflowResult::*;
-use self::Entry::*;
-
-/// A map based on a B-Tree.
-///
-/// B-Trees represent a fundamental compromise between cache-efficiency and actually minimizing
-/// the amount of work performed in a search. In theory, a binary search tree (BST) is the optimal
-/// choice for a sorted map, as a perfectly balanced BST performs the theoretical minimum amount of
-/// comparisons necessary to find an element (log<sub>2</sub>n). However, in practice the way this
-/// is done is *very* inefficient for modern computer architectures. In particular, every element
-/// is stored in its own individually heap-allocated node. This means that every single insertion
-/// triggers a heap-allocation, and every single comparison should be a cache-miss. Since these
-/// are both notably expensive things to do in practice, we are forced to at very least reconsider
-/// the BST strategy.
-///
-/// A B-Tree instead makes each node contain B-1 to 2B-1 elements in a contiguous array. By doing
-/// this, we reduce the number of allocations by a factor of B, and improve cache efficiency in
-/// searches. However, this does mean that searches will have to do *more* comparisons on average.
-/// The precise number of comparisons depends on the node search strategy used. For optimal cache
-/// efficiency, one could search the nodes linearly. For optimal comparisons, one could search
-/// the node using binary search. As a compromise, one could also perform a linear search
-/// that initially only checks every i<sup>th</sup> element for some choice of i.
-///
-/// Currently, our implementation simply performs naive linear search. This provides excellent
-/// performance on *small* nodes of elements which are cheap to compare. However in the future we
-/// would like to further explore choosing the optimal search strategy based on the choice of B,
-/// and possibly other factors. Using linear search, searching for a random element is expected
-/// to take O(B log<sub>B</sub>n) comparisons, which is generally worse than a BST. In practice,
-/// however, performance is excellent.
-///
-/// It is a logic error for a key to be modified in such a way that the key's ordering relative to
-/// any other key, as determined by the [`Ord`] trait, changes while it is in the map. This is
-/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.
-///
-/// [`Ord`]: ../../std/cmp/trait.Ord.html
-/// [`Cell`]: ../../std/cell/struct.Cell.html
-/// [`RefCell`]: ../../std/cell/struct.RefCell.html
-///
-/// # Examples
-///
-/// ```
-/// use std::collections::BTreeMap;
-///
-/// // type inference lets us omit an explicit type signature (which
-/// // would be `BTreeMap<&str, &str>` in this example).
-/// let mut movie_reviews = BTreeMap::new();
-///
-/// // review some movies.
-/// movie_reviews.insert("Office Space",       "Deals with real issues in the workplace.");
-/// movie_reviews.insert("Pulp Fiction",       "Masterpiece.");
-/// movie_reviews.insert("The Godfather",      "Very enjoyable.");
-/// movie_reviews.insert("The Blues Brothers", "Eye lyked it alot.");
-///
-/// // check for a specific one.
-/// if !movie_reviews.contains_key("Les Misérables") {
-///     println!("We've got {} reviews, but Les Misérables ain't one.",
-///              movie_reviews.len());
-/// }
-///
-/// // oops, this review has a lot of spelling mistakes, let's delete it.
-/// movie_reviews.remove("The Blues Brothers");
-///
-/// // look up the values associated with some keys.
-/// let to_find = ["Up!", "Office Space"];
-/// for book in &to_find {
-///     match movie_reviews.get(book) {
-///        Some(review) => println!("{}: {}", book, review),
-///        None => println!("{} is unreviewed.", book)
-///     }
-/// }
-///
-/// // iterate over everything.
-/// for (movie, review) in &movie_reviews {
-///     println!("{}: \"{}\"", movie, review);
-/// }
-/// ```
-///
-/// `BTreeMap` also implements an [`Entry API`](#method.entry), which allows
-/// for more complex methods of getting, setting, updating and removing keys and
-/// their values:
-///
-/// ```
-/// use std::collections::BTreeMap;
-///
-/// // type inference lets us omit an explicit type signature (which
-/// // would be `BTreeMap<&str, u8>` in this example).
-/// let mut player_stats = BTreeMap::new();
-///
-/// fn random_stat_buff() -> u8 {
-///     // could actually return some random value here - let's just return
-///     // some fixed value for now
-///     42
-/// }
-///
-/// // insert a key only if it doesn't already exist
-/// player_stats.entry("health").or_insert(100);
-///
-/// // insert a key using a function that provides a new value only if it
-/// // doesn't already exist
-/// player_stats.entry("defence").or_insert_with(random_stat_buff);
-///
-/// // update a key, guarding against the key possibly not being set
-/// let stat = player_stats.entry("attack").or_insert(100);
-/// *stat += random_stat_buff();
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct BTreeMap<K, V> {
-    root: node::Root<K, V>,
-    length: usize,
-}
-
-#[stable(feature = "btree_drop", since = "1.7.0")]
-unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {
-    fn drop(&mut self) {
-        unsafe {
-            drop(ptr::read(self).into_iter());
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Clone, V: Clone> Clone for BTreeMap<K, V> {
-    fn clone(&self) -> BTreeMap<K, V> {
-        fn clone_subtree<K: Clone, V: Clone>(node: node::NodeRef<marker::Immut,
-                                                                 K,
-                                                                 V,
-                                                                 marker::LeafOrInternal>)
-                                             -> BTreeMap<K, V> {
-
-            match node.force() {
-                Leaf(leaf) => {
-                    let mut out_tree = BTreeMap {
-                        root: node::Root::new_leaf(),
-                        length: 0,
-                    };
-
-                    {
-                        let mut out_node = match out_tree.root.as_mut().force() {
-                            Leaf(leaf) => leaf,
-                            Internal(_) => unreachable!(),
-                        };
-
-                        let mut in_edge = leaf.first_edge();
-                        while let Ok(kv) = in_edge.right_kv() {
-                            let (k, v) = kv.into_kv();
-                            in_edge = kv.right_edge();
-
-                            out_node.push(k.clone(), v.clone());
-                            out_tree.length += 1;
-                        }
-                    }
-
-                    out_tree
-                }
-                Internal(internal) => {
-                    let mut out_tree = clone_subtree(internal.first_edge().descend());
-
-                    {
-                        let mut out_node = out_tree.root.push_level();
-                        let mut in_edge = internal.first_edge();
-                        while let Ok(kv) = in_edge.right_kv() {
-                            let (k, v) = kv.into_kv();
-                            in_edge = kv.right_edge();
-
-                            let k = (*k).clone();
-                            let v = (*v).clone();
-                            let subtree = clone_subtree(in_edge.descend());
-
-                            // We can't destructure subtree directly
-                            // because BTreeMap implements Drop
-                            let (subroot, sublength) = unsafe {
-                                let root = ptr::read(&subtree.root);
-                                let length = subtree.length;
-                                mem::forget(subtree);
-                                (root, length)
-                            };
-
-                            out_node.push(k, v, subroot);
-                            out_tree.length += 1 + sublength;
-                        }
-                    }
-
-                    out_tree
-                }
-            }
-        }
-
-        clone_subtree(self.root.as_ref())
-    }
-}
-
-impl<K, Q: ?Sized> super::Recover<Q> for BTreeMap<K, ()>
-    where K: Borrow<Q> + Ord,
-          Q: Ord
-{
-    type Key = K;
-
-    fn get(&self, key: &Q) -> Option<&K> {
-        match search::search_tree(self.root.as_ref(), key) {
-            Found(handle) => Some(handle.into_kv().0),
-            GoDown(_) => None,
-        }
-    }
-
-    fn take(&mut self, key: &Q) -> Option<K> {
-        match search::search_tree(self.root.as_mut(), key) {
-            Found(handle) => {
-                Some(OccupiedEntry {
-                         handle: handle,
-                         length: &mut self.length,
-                         _marker: PhantomData,
-                     }
-                     .remove_kv()
-                     .0)
-            }
-            GoDown(_) => None,
-        }
-    }
-
-    fn replace(&mut self, key: K) -> Option<K> {
-        match search::search_tree::<marker::Mut, K, (), K>(self.root.as_mut(), &key) {
-            Found(handle) => Some(mem::replace(handle.into_kv_mut().0, key)),
-            GoDown(handle) => {
-                VacantEntry {
-                    key: key,
-                    handle: handle,
-                    length: &mut self.length,
-                    _marker: PhantomData,
-                }
-                .insert(());
-                None
-            }
-        }
-    }
-}
-
-/// An iterator over the entries of a `BTreeMap`.
-///
-/// This `struct` is created by the [`iter`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`iter`]: struct.BTreeMap.html#method.iter
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, K: 'a, V: 'a> {
-    range: Range<'a, K, V>,
-    length: usize,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Iter<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.clone()).finish()
-    }
-}
-
-/// A mutable iterator over the entries of a `BTreeMap`.
-///
-/// This `struct` is created by the [`iter_mut`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`iter_mut`]: struct.BTreeMap.html#method.iter_mut
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Debug)]
-pub struct IterMut<'a, K: 'a, V: 'a> {
-    range: RangeMut<'a, K, V>,
-    length: usize,
-}
-
-/// An owning iterator over the entries of a `BTreeMap`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`BTreeMap`][`BTreeMap`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`into_iter`]: struct.BTreeMap.html#method.into_iter
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<K, V> {
-    front: Handle<NodeRef<marker::Owned, K, V, marker::Leaf>, marker::Edge>,
-    back: Handle<NodeRef<marker::Owned, K, V, marker::Leaf>, marker::Edge>,
-    length: usize,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for IntoIter<K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let range = Range {
-            front: self.front.reborrow(),
-            back: self.back.reborrow(),
-        };
-        f.debug_list().entries(range).finish()
-    }
-}
-
-/// An iterator over the keys of a `BTreeMap`.
-///
-/// This `struct` is created by the [`keys`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`keys`]: struct.BTreeMap.html#method.keys
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Keys<'a, K: 'a, V: 'a> {
-    inner: Iter<'a, K, V>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Keys<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.inner.clone()).finish()
-    }
-}
-
-/// An iterator over the values of a `BTreeMap`.
-///
-/// This `struct` is created by the [`values`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`values`]: struct.BTreeMap.html#method.values
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Values<'a, K: 'a, V: 'a> {
-    inner: Iter<'a, K, V>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Values<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.inner.clone()).finish()
-    }
-}
-
-/// A mutable iterator over the values of a `BTreeMap`.
-///
-/// This `struct` is created by the [`values_mut`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`values_mut`]: struct.BTreeMap.html#method.values_mut
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "map_values_mut", since = "1.10.0")]
-#[derive(Debug)]
-pub struct ValuesMut<'a, K: 'a, V: 'a> {
-    inner: IterMut<'a, K, V>,
-}
-
-/// An iterator over a sub-range of entries in a `BTreeMap`.
-///
-/// This `struct` is created by the [`range`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`range`]: struct.BTreeMap.html#method.range
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "btree_range", since = "1.17.0")]
-pub struct Range<'a, K: 'a, V: 'a> {
-    front: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,
-    back: Handle<NodeRef<marker::Immut<'a>, K, V, marker::Leaf>, marker::Edge>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for Range<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self.clone()).finish()
-    }
-}
-
-/// A mutable iterator over a sub-range of entries in a `BTreeMap`.
-///
-/// This `struct` is created by the [`range_mut`] method on [`BTreeMap`]. See its
-/// documentation for more.
-///
-/// [`range_mut`]: struct.BTreeMap.html#method.range_mut
-/// [`BTreeMap`]: struct.BTreeMap.html
-#[stable(feature = "btree_range", since = "1.17.0")]
-pub struct RangeMut<'a, K: 'a, V: 'a> {
-    front: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,
-    back: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,
-
-    // Be invariant in `K` and `V`
-    _marker: PhantomData<&'a mut (K, V)>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, K: 'a + fmt::Debug, V: 'a + fmt::Debug> fmt::Debug for RangeMut<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        let range = Range {
-            front: self.front.reborrow(),
-            back: self.back.reborrow(),
-        };
-        f.debug_list().entries(range).finish()
-    }
-}
-
-/// A view into a single entry in a map, which may either be vacant or occupied.
-///
-/// This `enum` is constructed from the [`entry`] method on [`BTreeMap`].
-///
-/// [`BTreeMap`]: struct.BTreeMap.html
-/// [`entry`]: struct.BTreeMap.html#method.entry
-#[stable(feature = "rust1", since = "1.0.0")]
-pub enum Entry<'a, K: 'a, V: 'a> {
-    /// A vacant entry.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    Vacant(#[stable(feature = "rust1", since = "1.0.0")]
-           VacantEntry<'a, K, V>),
-
-    /// An occupied entry.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    Occupied(#[stable(feature = "rust1", since = "1.0.0")]
-             OccupiedEntry<'a, K, V>),
-}
-
-#[stable(feature= "debug_btree_map", since = "1.12.0")]
-impl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for Entry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        match *self {
-            Vacant(ref v) => f.debug_tuple("Entry")
-                              .field(v)
-                              .finish(),
-            Occupied(ref o) => f.debug_tuple("Entry")
-                                .field(o)
-                                .finish(),
-        }
-    }
-}
-
-/// A view into a vacant entry in a `BTreeMap`.
-/// It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct VacantEntry<'a, K: 'a, V: 'a> {
-    key: K,
-    handle: Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>,
-    length: &'a mut usize,
-
-    // Be invariant in `K` and `V`
-    _marker: PhantomData<&'a mut (K, V)>,
-}
-
-#[stable(feature= "debug_btree_map", since = "1.12.0")]
-impl<'a, K: 'a + Debug + Ord, V: 'a> Debug for VacantEntry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("VacantEntry")
-         .field(self.key())
-         .finish()
-    }
-}
-
-/// A view into an occupied entry in a `BTreeMap`.
-/// It is part of the [`Entry`] enum.
-///
-/// [`Entry`]: enum.Entry.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
-    handle: Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::KV>,
-
-    length: &'a mut usize,
-
-    // Be invariant in `K` and `V`
-    _marker: PhantomData<&'a mut (K, V)>,
-}
-
-#[stable(feature= "debug_btree_map", since = "1.12.0")]
-impl<'a, K: 'a + Debug + Ord, V: 'a + Debug> Debug for OccupiedEntry<'a, K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_struct("OccupiedEntry")
-         .field("key", self.key())
-         .field("value", self.get())
-         .finish()
-    }
-}
-
-// An iterator for merging two sorted sequences into one
-struct MergeIter<K, V, I: Iterator<Item = (K, V)>> {
-    left: Peekable<I>,
-    right: Peekable<I>,
-}
-
-impl<K: Ord, V> BTreeMap<K, V> {
-    /// Makes a new empty BTreeMap with a reasonable choice for B.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    ///
-    /// // entries can now be inserted into the empty map
-    /// map.insert(1, "a");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> BTreeMap<K, V> {
-        BTreeMap {
-            root: node::Root::new_leaf(),
-            length: 0,
-        }
-    }
-
-    /// Clears the map, removing all values.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, "a");
-    /// a.clear();
-    /// assert!(a.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        // FIXME(gereeter) .clear() allocates
-        *self = BTreeMap::new();
-    }
-
-    /// Returns a reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(1, "a");
-    /// assert_eq!(map.get(&1), Some(&"a"));
-    /// assert_eq!(map.get(&2), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get<Q: ?Sized>(&self, key: &Q) -> Option<&V>
-        where K: Borrow<Q>,
-              Q: Ord
-    {
-        match search::search_tree(self.root.as_ref(), key) {
-            Found(handle) => Some(handle.into_kv().1),
-            GoDown(_) => None,
-        }
-    }
-
-    /// Returns `true` if the map contains a value for the specified key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(1, "a");
-    /// assert_eq!(map.contains_key(&1), true);
-    /// assert_eq!(map.contains_key(&2), false);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains_key<Q: ?Sized>(&self, key: &Q) -> bool
-        where K: Borrow<Q>,
-              Q: Ord
-    {
-        self.get(key).is_some()
-    }
-
-    /// Returns a mutable reference to the value corresponding to the key.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(1, "a");
-    /// if let Some(x) = map.get_mut(&1) {
-    ///     *x = "b";
-    /// }
-    /// assert_eq!(map[&1], "b");
-    /// ```
-    // See `get` for implementation notes, this is basically a copy-paste with mut's added
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut<Q: ?Sized>(&mut self, key: &Q) -> Option<&mut V>
-        where K: Borrow<Q>,
-              Q: Ord
-    {
-        match search::search_tree(self.root.as_mut(), key) {
-            Found(handle) => Some(handle.into_kv_mut().1),
-            GoDown(_) => None,
-        }
-    }
-
-    /// Inserts a key-value pair into the map.
-    ///
-    /// If the map did not have this key present, `None` is returned.
-    ///
-    /// If the map did have this key present, the value is updated, and the old
-    /// value is returned. The key is not updated, though; this matters for
-    /// types that can be `==` without being identical. See the [module-level
-    /// documentation] for more.
-    ///
-    /// [module-level documentation]: index.html#insert-and-complex-keys
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// assert_eq!(map.insert(37, "a"), None);
-    /// assert_eq!(map.is_empty(), false);
-    ///
-    /// map.insert(37, "b");
-    /// assert_eq!(map.insert(37, "c"), Some("b"));
-    /// assert_eq!(map[&37], "c");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, key: K, value: V) -> Option<V> {
-        match self.entry(key) {
-            Occupied(mut entry) => Some(entry.insert(value)),
-            Vacant(entry) => {
-                entry.insert(value);
-                None
-            }
-        }
-    }
-
-    /// Removes a key from the map, returning the value at the key if the key
-    /// was previously in the map.
-    ///
-    /// The key may be any borrowed form of the map's key type, but the ordering
-    /// on the borrowed form *must* match the ordering on the key type.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(1, "a");
-    /// assert_eq!(map.remove(&1), Some("a"));
-    /// assert_eq!(map.remove(&1), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove<Q: ?Sized>(&mut self, key: &Q) -> Option<V>
-        where K: Borrow<Q>,
-              Q: Ord
-    {
-        match search::search_tree(self.root.as_mut(), key) {
-            Found(handle) => {
-                Some(OccupiedEntry {
-                         handle: handle,
-                         length: &mut self.length,
-                         _marker: PhantomData,
-                     }
-                     .remove())
-            }
-            GoDown(_) => None,
-        }
-    }
-
-    /// Moves all elements from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, "a");
-    /// a.insert(2, "b");
-    /// a.insert(3, "c");
-    ///
-    /// let mut b = BTreeMap::new();
-    /// b.insert(3, "d");
-    /// b.insert(4, "e");
-    /// b.insert(5, "f");
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 5);
-    /// assert_eq!(b.len(), 0);
-    ///
-    /// assert_eq!(a[&1], "a");
-    /// assert_eq!(a[&2], "b");
-    /// assert_eq!(a[&3], "d");
-    /// assert_eq!(a[&4], "e");
-    /// assert_eq!(a[&5], "f");
-    /// ```
-    #[stable(feature = "btree_append", since = "1.11.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        // Do we have to append anything at all?
-        if other.len() == 0 {
-            return;
-        }
-
-        // We can just swap `self` and `other` if `self` is empty.
-        if self.len() == 0 {
-            mem::swap(self, other);
-            return;
-        }
-
-        // First, we merge `self` and `other` into a sorted sequence in linear time.
-        let self_iter = mem::replace(self, BTreeMap::new()).into_iter();
-        let other_iter = mem::replace(other, BTreeMap::new()).into_iter();
-        let iter = MergeIter {
-            left: self_iter.peekable(),
-            right: other_iter.peekable(),
-        };
-
-        // Second, we build a tree from the sorted sequence in linear time.
-        self.from_sorted_iter(iter);
-        self.fix_right_edge();
-    }
-
-    /// Constructs a double-ended iterator over a sub-range of elements in the map.
-    /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will
-    /// yield elements from min (inclusive) to max (exclusive).
-    /// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example
-    /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
-    /// range from 4 to 10.
-    ///
-    /// # Panics
-    ///
-    /// Panics if range `start > end`.
-    /// Panics if range `start == end` and both bounds are `Excluded`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::Bound::Included;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(3, "a");
-    /// map.insert(5, "b");
-    /// map.insert(8, "c");
-    /// for (&key, &value) in map.range((Included(&4), Included(&8))) {
-    ///     println!("{}: {}", key, value);
-    /// }
-    /// assert_eq!(Some((&5, &"b")), map.range(4..).next());
-    /// ```
-    #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range<T: ?Sized, R>(&self, range: R) -> Range<K, V>
-        where T: Ord, K: Borrow<T>, R: RangeArgument<T>
-    {
-        let root1 = self.root.as_ref();
-        let root2 = self.root.as_ref();
-        let (f, b) = range_search(root1, root2, range);
-
-        Range { front: f, back: b}
-    }
-
-    /// Constructs a mutable double-ended iterator over a sub-range of elements in the map.
-    /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will
-    /// yield elements from min (inclusive) to max (exclusive).
-    /// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example
-    /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
-    /// range from 4 to 10.
-    ///
-    /// # Panics
-    ///
-    /// Panics if range `start > end`.
-    /// Panics if range `start == end` and both bounds are `Excluded`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, i32> = ["Alice", "Bob", "Carol", "Cheryl"].iter()
-    ///                                                                       .map(|&s| (s, 0))
-    ///                                                                       .collect();
-    /// for (_, balance) in map.range_mut("B".."Cheryl") {
-    ///     *balance += 100;
-    /// }
-    /// for (name, balance) in &map {
-    ///     println!("{} => {}", name, balance);
-    /// }
-    /// ```
-    #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range_mut<T: ?Sized, R>(&mut self, range: R) -> RangeMut<K, V>
-        where T: Ord, K: Borrow<T>, R: RangeArgument<T>
-    {
-        let root1 = self.root.as_mut();
-        let root2 = unsafe { ptr::read(&root1) };
-        let (f, b) = range_search(root1, root2, range);
-
-        RangeMut {
-            front: f,
-            back: b,
-            _marker: PhantomData,
-        }
-    }
-
-    /// Gets the given key's corresponding entry in the map for in-place manipulation.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
-    ///
-    /// // count the number of occurrences of letters in the vec
-    /// for x in vec!["a","b","a","c","a","b"] {
-    ///     *count.entry(x).or_insert(0) += 1;
-    /// }
-    ///
-    /// assert_eq!(count["a"], 3);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn entry(&mut self, key: K) -> Entry<K, V> {
-        match search::search_tree(self.root.as_mut(), &key) {
-            Found(handle) => {
-                Occupied(OccupiedEntry {
-                    handle: handle,
-                    length: &mut self.length,
-                    _marker: PhantomData,
-                })
-            }
-            GoDown(handle) => {
-                Vacant(VacantEntry {
-                    key: key,
-                    handle: handle,
-                    length: &mut self.length,
-                    _marker: PhantomData,
-                })
-            }
-        }
-    }
-
-    fn from_sorted_iter<I: Iterator<Item = (K, V)>>(&mut self, iter: I) {
-        let mut cur_node = last_leaf_edge(self.root.as_mut()).into_node();
-        // Iterate through all key-value pairs, pushing them into nodes at the right level.
-        for (key, value) in iter {
-            // Try to push key-value pair into the current leaf node.
-            if cur_node.len() < node::CAPACITY {
-                cur_node.push(key, value);
-            } else {
-                // No space left, go up and push there.
-                let mut open_node;
-                let mut test_node = cur_node.forget_type();
-                loop {
-                    match test_node.ascend() {
-                        Ok(parent) => {
-                            let parent = parent.into_node();
-                            if parent.len() < node::CAPACITY {
-                                // Found a node with space left, push here.
-                                open_node = parent;
-                                break;
-                            } else {
-                                // Go up again.
-                                test_node = parent.forget_type();
-                            }
-                        }
-                        Err(node) => {
-                            // We are at the top, create a new root node and push there.
-                            open_node = node.into_root_mut().push_level();
-                            break;
-                        }
-                    }
-                }
-
-                // Push key-value pair and new right subtree.
-                let tree_height = open_node.height() - 1;
-                let mut right_tree = node::Root::new_leaf();
-                for _ in 0..tree_height {
-                    right_tree.push_level();
-                }
-                open_node.push(key, value, right_tree);
-
-                // Go down to the right-most leaf again.
-                cur_node = last_leaf_edge(open_node.forget_type()).into_node();
-            }
-
-            self.length += 1;
-        }
-    }
-
-    fn fix_right_edge(&mut self) {
-        // Handle underfull nodes, start from the top.
-        let mut cur_node = self.root.as_mut();
-        while let Internal(internal) = cur_node.force() {
-            // Check if right-most child is underfull.
-            let mut last_edge = internal.last_edge();
-            let right_child_len = last_edge.reborrow().descend().len();
-            if right_child_len < node::MIN_LEN {
-                // We need to steal.
-                let mut last_kv = match last_edge.left_kv() {
-                    Ok(left) => left,
-                    Err(_) => unreachable!(),
-                };
-                last_kv.bulk_steal_left(node::MIN_LEN - right_child_len);
-                last_edge = last_kv.right_edge();
-            }
-
-            // Go further down.
-            cur_node = last_edge.descend();
-        }
-    }
-
-    /// Splits the collection into two at the given key. Returns everything after the given key,
-    /// including the key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, "a");
-    /// a.insert(2, "b");
-    /// a.insert(3, "c");
-    /// a.insert(17, "d");
-    /// a.insert(41, "e");
-    ///
-    /// let b = a.split_off(&3);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 3);
-    ///
-    /// assert_eq!(a[&1], "a");
-    /// assert_eq!(a[&2], "b");
-    ///
-    /// assert_eq!(b[&3], "c");
-    /// assert_eq!(b[&17], "d");
-    /// assert_eq!(b[&41], "e");
-    /// ```
-    #[stable(feature = "btree_split_off", since = "1.11.0")]
-    pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self
-        where K: Borrow<Q>
-    {
-        if self.is_empty() {
-            return Self::new();
-        }
-
-        let total_num = self.len();
-
-        let mut right = Self::new();
-        for _ in 0..(self.root.as_ref().height()) {
-            right.root.push_level();
-        }
-
-        {
-            let mut left_node = self.root.as_mut();
-            let mut right_node = right.root.as_mut();
-
-            loop {
-                let mut split_edge = match search::search_node(left_node, key) {
-                    // key is going to the right tree
-                    Found(handle) => handle.left_edge(),
-                    GoDown(handle) => handle,
-                };
-
-                split_edge.move_suffix(&mut right_node);
-
-                match (split_edge.force(), right_node.force()) {
-                    (Internal(edge), Internal(node)) => {
-                        left_node = edge.descend();
-                        right_node = node.first_edge().descend();
-                    }
-                    (Leaf(_), Leaf(_)) => {
-                        break;
-                    }
-                    _ => {
-                        unreachable!();
-                    }
-                }
-            }
-        }
-
-        self.fix_right_border();
-        right.fix_left_border();
-
-        if self.root.as_ref().height() < right.root.as_ref().height() {
-            self.recalc_length();
-            right.length = total_num - self.len();
-        } else {
-            right.recalc_length();
-            self.length = total_num - right.len();
-        }
-
-        right
-    }
-
-    /// Calculates the number of elements if it is incorrect.
-    fn recalc_length(&mut self) {
-        fn dfs<K, V>(node: NodeRef<marker::Immut, K, V, marker::LeafOrInternal>) -> usize {
-            let mut res = node.len();
-
-            if let Internal(node) = node.force() {
-                let mut edge = node.first_edge();
-                loop {
-                    res += dfs(edge.reborrow().descend());
-                    match edge.right_kv() {
-                        Ok(right_kv) => {
-                            edge = right_kv.right_edge();
-                        }
-                        Err(_) => {
-                            break;
-                        }
-                    }
-                }
-            }
-
-            res
-        }
-
-        self.length = dfs(self.root.as_ref());
-    }
-
-    /// Removes empty levels on the top.
-    fn fix_top(&mut self) {
-        loop {
-            {
-                let node = self.root.as_ref();
-                if node.height() == 0 || node.len() > 0 {
-                    break;
-                }
-            }
-            self.root.pop_level();
-        }
-    }
-
-    fn fix_right_border(&mut self) {
-        self.fix_top();
-
-        {
-            let mut cur_node = self.root.as_mut();
-
-            while let Internal(node) = cur_node.force() {
-                let mut last_kv = node.last_kv();
-
-                if last_kv.can_merge() {
-                    cur_node = last_kv.merge().descend();
-                } else {
-                    let right_len = last_kv.reborrow().right_edge().descend().len();
-                    // `MINLEN + 1` to avoid readjust if merge happens on the next level.
-                    if right_len < node::MIN_LEN + 1 {
-                        last_kv.bulk_steal_left(node::MIN_LEN + 1 - right_len);
-                    }
-                    cur_node = last_kv.right_edge().descend();
-                }
-            }
-        }
-
-        self.fix_top();
-    }
-
-    /// The symmetric clone of `fix_right_border`.
-    fn fix_left_border(&mut self) {
-        self.fix_top();
-
-        {
-            let mut cur_node = self.root.as_mut();
-
-            while let Internal(node) = cur_node.force() {
-                let mut first_kv = node.first_kv();
-
-                if first_kv.can_merge() {
-                    cur_node = first_kv.merge().descend();
-                } else {
-                    let left_len = first_kv.reborrow().left_edge().descend().len();
-                    if left_len < node::MIN_LEN + 1 {
-                        first_kv.bulk_steal_right(node::MIN_LEN + 1 - left_len);
-                    }
-                    cur_node = first_kv.left_edge().descend();
-                }
-            }
-        }
-
-        self.fix_top();
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> IntoIterator for &'a BTreeMap<K, V> {
-    type Item = (&'a K, &'a V);
-    type IntoIter = Iter<'a, K, V>;
-
-    fn into_iter(self) -> Iter<'a, K, V> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> Iterator for Iter<'a, K, V> {
-    type Item = (&'a K, &'a V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.length == 0 {
-            None
-        } else {
-            self.length -= 1;
-            unsafe { Some(self.range.next_unchecked()) }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.length, Some(self.length))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for Iter<'a, K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> DoubleEndedIterator for Iter<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.length == 0 {
-            None
-        } else {
-            self.length -= 1;
-            unsafe { Some(self.range.next_back_unchecked()) }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> ExactSizeIterator for Iter<'a, K, V> {
-    fn len(&self) -> usize {
-        self.length
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> Clone for Iter<'a, K, V> {
-    fn clone(&self) -> Iter<'a, K, V> {
-        Iter {
-            range: self.range.clone(),
-            length: self.length,
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> IntoIterator for &'a mut BTreeMap<K, V> {
-    type Item = (&'a K, &'a mut V);
-    type IntoIter = IterMut<'a, K, V>;
-
-    fn into_iter(self) -> IterMut<'a, K, V> {
-        self.iter_mut()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> Iterator for IterMut<'a, K, V> {
-    type Item = (&'a K, &'a mut V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.length == 0 {
-            None
-        } else {
-            self.length -= 1;
-            unsafe { Some(self.range.next_unchecked()) }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.length, Some(self.length))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> DoubleEndedIterator for IterMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.length == 0 {
-            None
-        } else {
-            self.length -= 1;
-            unsafe { Some(self.range.next_back_unchecked()) }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: 'a, V: 'a> ExactSizeIterator for IterMut<'a, K, V> {
-    fn len(&self) -> usize {
-        self.length
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for IterMut<'a, K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> IntoIterator for BTreeMap<K, V> {
-    type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
-
-    fn into_iter(self) -> IntoIter<K, V> {
-        let root1 = unsafe { ptr::read(&self.root).into_ref() };
-        let root2 = unsafe { ptr::read(&self.root).into_ref() };
-        let len = self.length;
-        mem::forget(self);
-
-        IntoIter {
-            front: first_leaf_edge(root1),
-            back: last_leaf_edge(root2),
-            length: len,
-        }
-    }
-}
-
-#[stable(feature = "btree_drop", since = "1.7.0")]
-impl<K, V> Drop for IntoIter<K, V> {
-    fn drop(&mut self) {
-        for _ in &mut *self {
-        }
-        unsafe {
-            let leaf_node = ptr::read(&self.front).into_node();
-            if let Some(first_parent) = leaf_node.deallocate_and_ascend() {
-                let mut cur_node = first_parent.into_node();
-                while let Some(parent) = cur_node.deallocate_and_ascend() {
-                    cur_node = parent.into_node()
-                }
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> Iterator for IntoIter<K, V> {
-    type Item = (K, V);
-
-    fn next(&mut self) -> Option<(K, V)> {
-        if self.length == 0 {
-            return None;
-        } else {
-            self.length -= 1;
-        }
-
-        let handle = unsafe { ptr::read(&self.front) };
-
-        let mut cur_handle = match handle.right_kv() {
-            Ok(kv) => {
-                let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };
-                let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };
-                self.front = kv.right_edge();
-                return Some((k, v));
-            }
-            Err(last_edge) => unsafe {
-                unwrap_unchecked(last_edge.into_node().deallocate_and_ascend())
-            },
-        };
-
-        loop {
-            match cur_handle.right_kv() {
-                Ok(kv) => {
-                    let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };
-                    let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };
-                    self.front = first_leaf_edge(kv.right_edge().descend());
-                    return Some((k, v));
-                }
-                Err(last_edge) => unsafe {
-                    cur_handle = unwrap_unchecked(last_edge.into_node().deallocate_and_ascend());
-                },
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.length, Some(self.length))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> DoubleEndedIterator for IntoIter<K, V> {
-    fn next_back(&mut self) -> Option<(K, V)> {
-        if self.length == 0 {
-            return None;
-        } else {
-            self.length -= 1;
-        }
-
-        let handle = unsafe { ptr::read(&self.back) };
-
-        let mut cur_handle = match handle.left_kv() {
-            Ok(kv) => {
-                let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };
-                let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };
-                self.back = kv.left_edge();
-                return Some((k, v));
-            }
-            Err(last_edge) => unsafe {
-                unwrap_unchecked(last_edge.into_node().deallocate_and_ascend())
-            },
-        };
-
-        loop {
-            match cur_handle.left_kv() {
-                Ok(kv) => {
-                    let k = unsafe { ptr::read(kv.reborrow().into_kv().0) };
-                    let v = unsafe { ptr::read(kv.reborrow().into_kv().1) };
-                    self.back = last_leaf_edge(kv.left_edge().descend());
-                    return Some((k, v));
-                }
-                Err(last_edge) => unsafe {
-                    cur_handle = unwrap_unchecked(last_edge.into_node().deallocate_and_ascend());
-                },
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> ExactSizeIterator for IntoIter<K, V> {
-    fn len(&self) -> usize {
-        self.length
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<K, V> FusedIterator for IntoIter<K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> Iterator for Keys<'a, K, V> {
-    type Item = &'a K;
-
-    fn next(&mut self) -> Option<&'a K> {
-        self.inner.next().map(|(k, _)| k)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> DoubleEndedIterator for Keys<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a K> {
-        self.inner.next_back().map(|(k, _)| k)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> ExactSizeIterator for Keys<'a, K, V> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for Keys<'a, K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> Clone for Keys<'a, K, V> {
-    fn clone(&self) -> Keys<'a, K, V> {
-        Keys { inner: self.inner.clone() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> Iterator for Values<'a, K, V> {
-    type Item = &'a V;
-
-    fn next(&mut self) -> Option<&'a V> {
-        self.inner.next().map(|(_, v)| v)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> DoubleEndedIterator for Values<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a V> {
-        self.inner.next_back().map(|(_, v)| v)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> ExactSizeIterator for Values<'a, K, V> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for Values<'a, K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V> Clone for Values<'a, K, V> {
-    fn clone(&self) -> Values<'a, K, V> {
-        Values { inner: self.inner.clone() }
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, K, V> Iterator for Range<'a, K, V> {
-    type Item = (&'a K, &'a V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.front == self.back {
-            None
-        } else {
-            unsafe { Some(self.next_unchecked()) }
-        }
-    }
-}
-
-#[stable(feature = "map_values_mut", since = "1.10.0")]
-impl<'a, K, V> Iterator for ValuesMut<'a, K, V> {
-    type Item = &'a mut V;
-
-    fn next(&mut self) -> Option<&'a mut V> {
-        self.inner.next().map(|(_, v)| v)
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.inner.size_hint()
-    }
-}
-
-#[stable(feature = "map_values_mut", since = "1.10.0")]
-impl<'a, K, V> DoubleEndedIterator for ValuesMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<&'a mut V> {
-        self.inner.next_back().map(|(_, v)| v)
-    }
-}
-
-#[stable(feature = "map_values_mut", since = "1.10.0")]
-impl<'a, K, V> ExactSizeIterator for ValuesMut<'a, K, V> {
-    fn len(&self) -> usize {
-        self.inner.len()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for ValuesMut<'a, K, V> {}
-
-
-impl<'a, K, V> Range<'a, K, V> {
-    unsafe fn next_unchecked(&mut self) -> (&'a K, &'a V) {
-        let handle = self.front;
-
-        let mut cur_handle = match handle.right_kv() {
-            Ok(kv) => {
-                let ret = kv.into_kv();
-                self.front = kv.right_edge();
-                return ret;
-            }
-            Err(last_edge) => {
-                let next_level = last_edge.into_node().ascend().ok();
-                unwrap_unchecked(next_level)
-            }
-        };
-
-        loop {
-            match cur_handle.right_kv() {
-                Ok(kv) => {
-                    let ret = kv.into_kv();
-                    self.front = first_leaf_edge(kv.right_edge().descend());
-                    return ret;
-                }
-                Err(last_edge) => {
-                    let next_level = last_edge.into_node().ascend().ok();
-                    cur_handle = unwrap_unchecked(next_level);
-                }
-            }
-        }
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, K, V> DoubleEndedIterator for Range<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a V)> {
-        if self.front == self.back {
-            None
-        } else {
-            unsafe { Some(self.next_back_unchecked()) }
-        }
-    }
-}
-
-impl<'a, K, V> Range<'a, K, V> {
-    unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a V) {
-        let handle = self.back;
-
-        let mut cur_handle = match handle.left_kv() {
-            Ok(kv) => {
-                let ret = kv.into_kv();
-                self.back = kv.left_edge();
-                return ret;
-            }
-            Err(last_edge) => {
-                let next_level = last_edge.into_node().ascend().ok();
-                unwrap_unchecked(next_level)
-            }
-        };
-
-        loop {
-            match cur_handle.left_kv() {
-                Ok(kv) => {
-                    let ret = kv.into_kv();
-                    self.back = last_leaf_edge(kv.left_edge().descend());
-                    return ret;
-                }
-                Err(last_edge) => {
-                    let next_level = last_edge.into_node().ascend().ok();
-                    cur_handle = unwrap_unchecked(next_level);
-                }
-            }
-        }
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for Range<'a, K, V> {}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, K, V> Clone for Range<'a, K, V> {
-    fn clone(&self) -> Range<'a, K, V> {
-        Range {
-            front: self.front,
-            back: self.back,
-        }
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, K, V> Iterator for RangeMut<'a, K, V> {
-    type Item = (&'a K, &'a mut V);
-
-    fn next(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.front == self.back {
-            None
-        } else {
-            unsafe { Some(self.next_unchecked()) }
-        }
-    }
-}
-
-impl<'a, K, V> RangeMut<'a, K, V> {
-    unsafe fn next_unchecked(&mut self) -> (&'a K, &'a mut V) {
-        let handle = ptr::read(&self.front);
-
-        let mut cur_handle = match handle.right_kv() {
-            Ok(kv) => {
-                let (k, v) = ptr::read(&kv).into_kv_mut();
-                self.front = kv.right_edge();
-                return (k, v);
-            }
-            Err(last_edge) => {
-                let next_level = last_edge.into_node().ascend().ok();
-                unwrap_unchecked(next_level)
-            }
-        };
-
-        loop {
-            match cur_handle.right_kv() {
-                Ok(kv) => {
-                    let (k, v) = ptr::read(&kv).into_kv_mut();
-                    self.front = first_leaf_edge(kv.right_edge().descend());
-                    return (k, v);
-                }
-                Err(last_edge) => {
-                    let next_level = last_edge.into_node().ascend().ok();
-                    cur_handle = unwrap_unchecked(next_level);
-                }
-            }
-        }
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, K, V> DoubleEndedIterator for RangeMut<'a, K, V> {
-    fn next_back(&mut self) -> Option<(&'a K, &'a mut V)> {
-        if self.front == self.back {
-            None
-        } else {
-            unsafe { Some(self.next_back_unchecked()) }
-        }
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, K, V> FusedIterator for RangeMut<'a, K, V> {}
-
-impl<'a, K, V> RangeMut<'a, K, V> {
-    unsafe fn next_back_unchecked(&mut self) -> (&'a K, &'a mut V) {
-        let handle = ptr::read(&self.back);
-
-        let mut cur_handle = match handle.left_kv() {
-            Ok(kv) => {
-                let (k, v) = ptr::read(&kv).into_kv_mut();
-                self.back = kv.left_edge();
-                return (k, v);
-            }
-            Err(last_edge) => {
-                let next_level = last_edge.into_node().ascend().ok();
-                unwrap_unchecked(next_level)
-            }
-        };
-
-        loop {
-            match cur_handle.left_kv() {
-                Ok(kv) => {
-                    let (k, v) = ptr::read(&kv).into_kv_mut();
-                    self.back = last_leaf_edge(kv.left_edge().descend());
-                    return (k, v);
-                }
-                Err(last_edge) => {
-                    let next_level = last_edge.into_node().ascend().ok();
-                    cur_handle = unwrap_unchecked(next_level);
-                }
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, V> FromIterator<(K, V)> for BTreeMap<K, V> {
-    fn from_iter<T: IntoIterator<Item = (K, V)>>(iter: T) -> BTreeMap<K, V> {
-        let mut map = BTreeMap::new();
-        map.extend(iter);
-        map
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, V> Extend<(K, V)> for BTreeMap<K, V> {
-    #[inline]
-    fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
-        for (k, v) in iter {
-            self.insert(k, v);
-        }
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, K: Ord + Copy, V: Copy> Extend<(&'a K, &'a V)> for BTreeMap<K, V> {
-    fn extend<I: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().map(|(&key, &value)| (key, value)));
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Hash, V: Hash> Hash for BTreeMap<K, V> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        for elt in self {
-            elt.hash(state);
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, V> Default for BTreeMap<K, V> {
-    /// Creates an empty `BTreeMap<K, V>`.
-    fn default() -> BTreeMap<K, V> {
-        BTreeMap::new()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: PartialEq, V: PartialEq> PartialEq for BTreeMap<K, V> {
-    fn eq(&self, other: &BTreeMap<K, V>) -> bool {
-        self.len() == other.len() && self.iter().zip(other).all(|(a, b)| a == b)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Eq, V: Eq> Eq for BTreeMap<K, V> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: PartialOrd, V: PartialOrd> PartialOrd for BTreeMap<K, V> {
-    #[inline]
-    fn partial_cmp(&self, other: &BTreeMap<K, V>) -> Option<Ordering> {
-        self.iter().partial_cmp(other.iter())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Ord, V: Ord> Ord for BTreeMap<K, V> {
-    #[inline]
-    fn cmp(&self, other: &BTreeMap<K, V>) -> Ordering {
-        self.iter().cmp(other.iter())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<K: Debug, V: Debug> Debug for BTreeMap<K, V> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_map().entries(self.iter()).finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K: Ord, Q: ?Sized, V> Index<&'a Q> for BTreeMap<K, V>
-    where K: Borrow<Q>,
-          Q: Ord
-{
-    type Output = V;
-
-    #[inline]
-    fn index(&self, key: &Q) -> &V {
-        self.get(key).expect("no entry found for key")
-    }
-}
-
-fn first_leaf_edge<BorrowType, K, V>
-    (mut node: NodeRef<BorrowType, K, V, marker::LeafOrInternal>)
-     -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge> {
-    loop {
-        match node.force() {
-            Leaf(leaf) => return leaf.first_edge(),
-            Internal(internal) => {
-                node = internal.first_edge().descend();
-            }
-        }
-    }
-}
-
-fn last_leaf_edge<BorrowType, K, V>
-    (mut node: NodeRef<BorrowType, K, V, marker::LeafOrInternal>)
-     -> Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge> {
-    loop {
-        match node.force() {
-            Leaf(leaf) => return leaf.last_edge(),
-            Internal(internal) => {
-                node = internal.last_edge().descend();
-            }
-        }
-    }
-}
-
-fn range_search<BorrowType, K, V, Q: ?Sized, R: RangeArgument<Q>>(
-    root1: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
-    root2: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
-    range: R
-)-> (Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>,
-     Handle<NodeRef<BorrowType, K, V, marker::Leaf>, marker::Edge>)
-        where Q: Ord, K: Borrow<Q>
-{
-    match (range.start(), range.end()) {
-        (Excluded(s), Excluded(e)) if s==e =>
-            panic!("range start and end are equal and excluded in BTreeMap"),
-        (Included(s), Included(e)) |
-        (Included(s), Excluded(e)) |
-        (Excluded(s), Included(e)) |
-        (Excluded(s), Excluded(e)) if s>e =>
-            panic!("range start is greater than range end in BTreeMap"),
-        _ => {},
-    };
-
-    let mut min_node = root1;
-    let mut max_node = root2;
-    let mut min_found = false;
-    let mut max_found = false;
-    let mut diverged = false;
-
-    loop {
-        let min_edge = match (min_found, range.start()) {
-            (false, Included(key)) => match search::search_linear(&min_node, key) {
-                (i, true) => { min_found = true; i },
-                (i, false) => i,
-            },
-            (false, Excluded(key)) => match search::search_linear(&min_node, key) {
-                (i, true) => { min_found = true; i+1 },
-                (i, false) => i,
-            },
-            (_, Unbounded) => 0,
-            (true, Included(_)) => min_node.keys().len(),
-            (true, Excluded(_)) => 0,
-        };
-
-        let max_edge = match (max_found, range.end()) {
-            (false, Included(key)) => match search::search_linear(&max_node, key) {
-                (i, true) => { max_found = true; i+1 },
-                (i, false) => i,
-            },
-            (false, Excluded(key)) => match search::search_linear(&max_node, key) {
-                (i, true) => { max_found = true; i },
-                (i, false) => i,
-            },
-            (_, Unbounded) => max_node.keys().len(),
-            (true, Included(_)) => 0,
-            (true, Excluded(_)) => max_node.keys().len(),
-        };
-
-        if !diverged {
-            if max_edge < min_edge { panic!("Ord is ill-defined in BTreeMap range") }
-            if min_edge != max_edge { diverged = true; }
-        }
-
-        let front = Handle::new_edge(min_node, min_edge);
-        let back = Handle::new_edge(max_node, max_edge);
-        match (front.force(), back.force()) {
-            (Leaf(f), Leaf(b)) => {
-                return (f, b);
-            },
-            (Internal(min_int), Internal(max_int)) => {
-                min_node = min_int.descend();
-                max_node = max_int.descend();
-            },
-            _ => unreachable!("BTreeMap has different depths"),
-        };
-    }
-}
-
-#[inline(always)]
-unsafe fn unwrap_unchecked<T>(val: Option<T>) -> T {
-    val.unwrap_or_else(|| {
-        if cfg!(debug_assertions) {
-            panic!("'unchecked' unwrap on None in BTreeMap");
-        } else {
-            intrinsics::unreachable();
-        }
-    })
-}
-
-impl<K, V> BTreeMap<K, V> {
-    /// Gets an iterator over the entries of the map, sorted by key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert(3, "c");
-    /// map.insert(2, "b");
-    /// map.insert(1, "a");
-    ///
-    /// for (key, value) in map.iter() {
-    ///     println!("{}: {}", key, value);
-    /// }
-    ///
-    /// let (first_key, first_value) = map.iter().next().unwrap();
-    /// assert_eq!((*first_key, *first_value), (1, "a"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter(&self) -> Iter<K, V> {
-        Iter {
-            range: Range {
-                front: first_leaf_edge(self.root.as_ref()),
-                back: last_leaf_edge(self.root.as_ref()),
-            },
-            length: self.length,
-        }
-    }
-
-    /// Gets a mutable iterator over the entries of the map, sorted by key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map = BTreeMap::new();
-    /// map.insert("a", 1);
-    /// map.insert("b", 2);
-    /// map.insert("c", 3);
-    ///
-    /// // add 10 to the value if the key isn't "a"
-    /// for (key, value) in map.iter_mut() {
-    ///     if key != &"a" {
-    ///         *value += 10;
-    ///     }
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter_mut(&mut self) -> IterMut<K, V> {
-        let root1 = self.root.as_mut();
-        let root2 = unsafe { ptr::read(&root1) };
-        IterMut {
-            range: RangeMut {
-                front: first_leaf_edge(root1),
-                back: last_leaf_edge(root2),
-                _marker: PhantomData,
-            },
-            length: self.length,
-        }
-    }
-
-    /// Gets an iterator over the keys of the map, in sorted order.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(2, "b");
-    /// a.insert(1, "a");
-    ///
-    /// let keys: Vec<_> = a.keys().cloned().collect();
-    /// assert_eq!(keys, [1, 2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn keys<'a>(&'a self) -> Keys<'a, K, V> {
-        Keys { inner: self.iter() }
-    }
-
-    /// Gets an iterator over the values of the map, in order by key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, "hello");
-    /// a.insert(2, "goodbye");
-    ///
-    /// let values: Vec<&str> = a.values().cloned().collect();
-    /// assert_eq!(values, ["hello", "goodbye"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn values<'a>(&'a self) -> Values<'a, K, V> {
-        Values { inner: self.iter() }
-    }
-
-    /// Gets a mutable iterator over the values of the map, in order by key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, String::from("hello"));
-    /// a.insert(2, String::from("goodbye"));
-    ///
-    /// for value in a.values_mut() {
-    ///     value.push_str("!");
-    /// }
-    ///
-    /// let values: Vec<String> = a.values().cloned().collect();
-    /// assert_eq!(values, [String::from("hello!"),
-    ///                     String::from("goodbye!")]);
-    /// ```
-    #[stable(feature = "map_values_mut", since = "1.10.0")]
-    pub fn values_mut(&mut self) -> ValuesMut<K, V> {
-        ValuesMut { inner: self.iter_mut() }
-    }
-
-    /// Returns the number of elements in the map.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// assert_eq!(a.len(), 0);
-    /// a.insert(1, "a");
-    /// assert_eq!(a.len(), 1);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.length
-    }
-
-    /// Returns `true` if the map contains no elements.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// assert!(a.is_empty());
-    /// a.insert(1, "a");
-    /// assert!(!a.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-}
-
-impl<'a, K: Ord, V> Entry<'a, K, V> {
-    /// Ensures a value is in the entry by inserting the default if empty, and returns
-    /// a mutable reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// assert_eq!(map["poneyland"], 12);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn or_insert(self, default: V) -> &'a mut V {
-        match self {
-            Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(default),
-        }
-    }
-
-    /// Ensures a value is in the entry by inserting the result of the default function if empty,
-    /// and returns a mutable reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, String> = BTreeMap::new();
-    /// let s = "hoho".to_string();
-    ///
-    /// map.entry("poneyland").or_insert_with(|| s);
-    ///
-    /// assert_eq!(map["poneyland"], "hoho".to_string());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn or_insert_with<F: FnOnce() -> V>(self, default: F) -> &'a mut V {
-        match self {
-            Occupied(entry) => entry.into_mut(),
-            Vacant(entry) => entry.insert(default()),
-        }
-    }
-
-    /// Returns a reference to this entry's key.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// assert_eq!(map.entry("poneyland").key(), &"poneyland");
-    /// ```
-    #[stable(feature = "map_entry_keys", since = "1.10.0")]
-    pub fn key(&self) -> &K {
-        match *self {
-            Occupied(ref entry) => entry.key(),
-            Vacant(ref entry) => entry.key(),
-        }
-    }
-}
-
-impl<'a, K: Ord, V> VacantEntry<'a, K, V> {
-    /// Gets a reference to the key that would be used when inserting a value
-    /// through the VacantEntry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// assert_eq!(map.entry("poneyland").key(), &"poneyland");
-    /// ```
-    #[stable(feature = "map_entry_keys", since = "1.10.0")]
-    pub fn key(&self) -> &K {
-        &self.key
-    }
-
-    /// Take ownership of the key.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    ///
-    /// if let Entry::Vacant(v) = map.entry("poneyland") {
-    ///     v.into_key();
-    /// }
-    /// ```
-    #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
-    pub fn into_key(self) -> K {
-        self.key
-    }
-
-    /// Sets the value of the entry with the `VacantEntry`'s key,
-    /// and returns a mutable reference to it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut count: BTreeMap<&str, usize> = BTreeMap::new();
-    ///
-    /// // count the number of occurrences of letters in the vec
-    /// for x in vec!["a","b","a","c","a","b"] {
-    ///     *count.entry(x).or_insert(0) += 1;
-    /// }
-    ///
-    /// assert_eq!(count["a"], 3);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(self, value: V) -> &'a mut V {
-        *self.length += 1;
-
-        let out_ptr;
-
-        let mut ins_k;
-        let mut ins_v;
-        let mut ins_edge;
-
-        let mut cur_parent = match self.handle.insert(self.key, value) {
-            (Fit(handle), _) => return handle.into_kv_mut().1,
-            (Split(left, k, v, right), ptr) => {
-                ins_k = k;
-                ins_v = v;
-                ins_edge = right;
-                out_ptr = ptr;
-                left.ascend().map_err(|n| n.into_root_mut())
-            }
-        };
-
-        loop {
-            match cur_parent {
-                Ok(parent) => {
-                    match parent.insert(ins_k, ins_v, ins_edge) {
-                        Fit(_) => return unsafe { &mut *out_ptr },
-                        Split(left, k, v, right) => {
-                            ins_k = k;
-                            ins_v = v;
-                            ins_edge = right;
-                            cur_parent = left.ascend().map_err(|n| n.into_root_mut());
-                        }
-                    }
-                }
-                Err(root) => {
-                    root.push_level().push(ins_k, ins_v, ins_edge);
-                    return unsafe { &mut *out_ptr };
-                }
-            }
-        }
-    }
-}
-
-impl<'a, K: Ord, V> OccupiedEntry<'a, K, V> {
-    /// Gets a reference to the key in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    /// assert_eq!(map.entry("poneyland").key(), &"poneyland");
-    /// ```
-    #[stable(feature = "map_entry_keys", since = "1.10.0")]
-    pub fn key(&self) -> &K {
-        self.handle.reborrow().into_kv().0
-    }
-
-    /// Take ownership of the key and value from the map.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// if let Entry::Occupied(o) = map.entry("poneyland") {
-    ///     // We delete the entry from the map.
-    ///     o.remove_entry();
-    /// }
-    ///
-    /// // If now try to get the value, it will panic:
-    /// // println!("{}", map["poneyland"]);
-    /// ```
-    #[stable(feature = "map_entry_recover_keys2", since = "1.12.0")]
-    pub fn remove_entry(self) -> (K, V) {
-        self.remove_kv()
-    }
-
-    /// Gets a reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// if let Entry::Occupied(o) = map.entry("poneyland") {
-    ///     assert_eq!(o.get(), &12);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self) -> &V {
-        self.handle.reborrow().into_kv().1
-    }
-
-    /// Gets a mutable reference to the value in the entry.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// assert_eq!(map["poneyland"], 12);
-    /// if let Entry::Occupied(mut o) = map.entry("poneyland") {
-    ///      *o.get_mut() += 10;
-    /// }
-    /// assert_eq!(map["poneyland"], 22);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut(&mut self) -> &mut V {
-        self.handle.kv_mut().1
-    }
-
-    /// Converts the entry into a mutable reference to its value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// assert_eq!(map["poneyland"], 12);
-    /// if let Entry::Occupied(o) = map.entry("poneyland") {
-    ///     *o.into_mut() += 10;
-    /// }
-    /// assert_eq!(map["poneyland"], 22);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_mut(self) -> &'a mut V {
-        self.handle.into_kv_mut().1
-    }
-
-    /// Sets the value of the entry with the `OccupiedEntry`'s key,
-    /// and returns the entry's old value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// if let Entry::Occupied(mut o) = map.entry("poneyland") {
-    ///     assert_eq!(o.insert(15), 12);
-    /// }
-    /// assert_eq!(map["poneyland"], 15);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, value: V) -> V {
-        mem::replace(self.get_mut(), value)
-    }
-
-    /// Takes the value of the entry out of the map, and returns it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    /// use std::collections::btree_map::Entry;
-    ///
-    /// let mut map: BTreeMap<&str, usize> = BTreeMap::new();
-    /// map.entry("poneyland").or_insert(12);
-    ///
-    /// if let Entry::Occupied(o) = map.entry("poneyland") {
-    ///     assert_eq!(o.remove(), 12);
-    /// }
-    /// // If we try to get "poneyland"'s value, it'll panic:
-    /// // println!("{}", map["poneyland"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(self) -> V {
-        self.remove_kv().1
-    }
-
-    fn remove_kv(self) -> (K, V) {
-        *self.length -= 1;
-
-        let (small_leaf, old_key, old_val) = match self.handle.force() {
-            Leaf(leaf) => {
-                let (hole, old_key, old_val) = leaf.remove();
-                (hole.into_node(), old_key, old_val)
-            }
-            Internal(mut internal) => {
-                let key_loc = internal.kv_mut().0 as *mut K;
-                let val_loc = internal.kv_mut().1 as *mut V;
-
-                let to_remove = first_leaf_edge(internal.right_edge().descend()).right_kv().ok();
-                let to_remove = unsafe { unwrap_unchecked(to_remove) };
-
-                let (hole, key, val) = to_remove.remove();
-
-                let old_key = unsafe { mem::replace(&mut *key_loc, key) };
-                let old_val = unsafe { mem::replace(&mut *val_loc, val) };
-
-                (hole.into_node(), old_key, old_val)
-            }
-        };
-
-        // Handle underflow
-        let mut cur_node = small_leaf.forget_type();
-        while cur_node.len() < node::CAPACITY / 2 {
-            match handle_underfull_node(cur_node) {
-                AtRoot => break,
-                EmptyParent(_) => unreachable!(),
-                Merged(parent) => {
-                    if parent.len() == 0 {
-                        // We must be at the root
-                        parent.into_root_mut().pop_level();
-                        break;
-                    } else {
-                        cur_node = parent.forget_type();
-                    }
-                }
-                Stole(_) => break,
-            }
-        }
-
-        (old_key, old_val)
-    }
-}
-
-enum UnderflowResult<'a, K, V> {
-    AtRoot,
-    EmptyParent(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),
-    Merged(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),
-    Stole(NodeRef<marker::Mut<'a>, K, V, marker::Internal>),
-}
-
-fn handle_underfull_node<'a, K, V>(node: NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>)
-                                   -> UnderflowResult<'a, K, V> {
-    let parent = if let Ok(parent) = node.ascend() {
-        parent
-    } else {
-        return AtRoot;
-    };
-
-    let (is_left, mut handle) = match parent.left_kv() {
-        Ok(left) => (true, left),
-        Err(parent) => {
-            match parent.right_kv() {
-                Ok(right) => (false, right),
-                Err(parent) => {
-                    return EmptyParent(parent.into_node());
-                }
-            }
-        }
-    };
-
-    if handle.can_merge() {
-        Merged(handle.merge().into_node())
-    } else {
-        if is_left {
-            handle.steal_left();
-        } else {
-            handle.steal_right();
-        }
-        Stole(handle.into_node())
-    }
-}
-
-impl<K: Ord, V, I: Iterator<Item = (K, V)>> Iterator for MergeIter<K, V, I> {
-    type Item = (K, V);
-
-    fn next(&mut self) -> Option<(K, V)> {
-        let res = match (self.left.peek(), self.right.peek()) {
-            (Some(&(ref left_key, _)), Some(&(ref right_key, _))) => left_key.cmp(right_key),
-            (Some(_), None) => Ordering::Less,
-            (None, Some(_)) => Ordering::Greater,
-            (None, None) => return None,
-        };
-
-        // Check which elements comes first and only advance the corresponding iterator.
-        // If two keys are equal, take the value from `right`.
-        match res {
-            Ordering::Less => self.left.next(),
-            Ordering::Greater => self.right.next(),
-            Ordering::Equal => {
-                self.left.next();
-                self.right.next()
-            }
-        }
-    }
-}
diff --git a/src/libcollections/btree/mod.rs b/src/libcollections/btree/mod.rs
deleted file mode 100644
index 087c9f228d4..00000000000
--- a/src/libcollections/btree/mod.rs
+++ /dev/null
@@ -1,23 +0,0 @@
-// Copyright 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.
-
-mod node;
-mod search;
-pub mod map;
-pub mod set;
-
-#[doc(hidden)]
-trait Recover<Q: ?Sized> {
-    type Key;
-
-    fn get(&self, key: &Q) -> Option<&Self::Key>;
-    fn take(&mut self, key: &Q) -> Option<Self::Key>;
-    fn replace(&mut self, key: Self::Key) -> Option<Self::Key>;
-}
diff --git a/src/libcollections/btree/node.rs b/src/libcollections/btree/node.rs
deleted file mode 100644
index 52cdd39d8f9..00000000000
--- a/src/libcollections/btree/node.rs
+++ /dev/null
@@ -1,1556 +0,0 @@
-// Copyright 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.
-
-// This is an attempt at an implementation following the ideal
-//
-// ```
-// struct BTreeMap<K, V> {
-//     height: usize,
-//     root: Option<Box<Node<K, V, height>>>
-// }
-//
-// struct Node<K, V, height: usize> {
-//     keys: [K; 2 * B - 1],
-//     vals: [V; 2 * B - 1],
-//     edges: if height > 0 {
-//         [Box<Node<K, V, height - 1>>; 2 * B]
-//     } else { () },
-//     parent: *const Node<K, V, height + 1>,
-//     parent_idx: u16,
-//     len: u16,
-// }
-// ```
-//
-// Since Rust doesn't actually have dependent types and polymorphic recursion,
-// we make do with lots of unsafety.
-
-// A major goal of this module is to avoid complexity by treating the tree as a generic (if
-// weirdly shaped) container and avoiding dealing with most of the B-Tree invariants. As such,
-// this module doesn't care whether the entries are sorted, which nodes can be underfull, or
-// even what underfull means. However, we do rely on a few invariants:
-//
-// - Trees must have uniform depth/height. This means that every path down to a leaf from a
-//   given node has exactly the same length.
-// - A node of length `n` has `n` keys, `n` values, and (in an internal node) `n + 1` edges.
-//   This implies that even an empty internal node has at least one edge.
-
-use alloc::heap;
-use core::marker::PhantomData;
-use core::mem;
-use core::nonzero::NonZero;
-use core::ptr::{self, Unique};
-use core::slice;
-
-use boxed::Box;
-
-const B: usize = 6;
-pub const MIN_LEN: usize = B - 1;
-pub const CAPACITY: usize = 2 * B - 1;
-
-/// The underlying representation of leaf nodes. Note that it is often unsafe to actually store
-/// these, since only the first `len` keys and values are assumed to be initialized. As such,
-/// these should always be put behind pointers, and specifically behind `BoxedNode` in the owned
-/// case.
-///
-/// See also rust-lang/rfcs#197, which would make this structure significantly more safe by
-/// avoiding accidentally dropping unused and uninitialized keys and values.
-struct LeafNode<K, V> {
-    /// The arrays storing the actual data of the node. Only the first `len` elements of each
-    /// array are initialized and valid.
-    keys: [K; CAPACITY],
-    vals: [V; CAPACITY],
-
-    /// We use `*const` as opposed to `*mut` so as to be covariant in `K` and `V`.
-    /// This either points to an actual node or is null.
-    parent: *const InternalNode<K, V>,
-
-    /// This node's index into the parent node's `edges` array.
-    /// `*node.parent.edges[node.parent_idx]` should be the same thing as `node`.
-    /// This is only guaranteed to be initialized when `parent` is nonnull.
-    parent_idx: u16,
-
-    /// The number of keys and values this node stores.
-    ///
-    /// This is at the end of the node's representation and next to `parent_idx` to encourage
-    /// the compiler to join `len` and `parent_idx` into the same 32-bit word, reducing space
-    /// overhead.
-    len: u16,
-}
-
-impl<K, V> LeafNode<K, V> {
-    /// Creates a new `LeafNode`. Unsafe because all nodes should really be hidden behind
-    /// `BoxedNode`, preventing accidental dropping of uninitialized keys and values.
-    unsafe fn new() -> Self {
-        LeafNode {
-            // As a general policy, we leave fields uninitialized if they can be, as this should
-            // be both slightly faster and easier to track in Valgrind.
-            keys: mem::uninitialized(),
-            vals: mem::uninitialized(),
-            parent: ptr::null(),
-            parent_idx: mem::uninitialized(),
-            len: 0
-        }
-    }
-}
-
-/// The underlying representation of internal nodes. As with `LeafNode`s, these should be hidden
-/// behind `BoxedNode`s to prevent dropping uninitialized keys and values. Any pointer to an
-/// `InternalNode` can be directly casted to a pointer to the underlying `LeafNode` portion of the
-/// node, allowing code to act on leaf and internal nodes generically without having to even check
-/// which of the two a pointer is pointing at. This property is enabled by the use of `repr(C)`.
-#[repr(C)]
-struct InternalNode<K, V> {
-    data: LeafNode<K, V>,
-
-    /// The pointers to the children of this node. `len + 1` of these are considered
-    /// initialized and valid.
-    edges: [BoxedNode<K, V>; 2 * B],
-}
-
-impl<K, V> InternalNode<K, V> {
-    /// Creates a new `InternalNode`.
-    ///
-    /// This is unsafe for two reasons. First, it returns an `InternalNode` by value, risking
-    /// dropping of uninitialized fields. Second, an invariant of internal nodes is that `len + 1`
-    /// edges are initialized and valid, meaning that even when the node is empty (having a
-    /// `len` of 0), there must be one initialized and valid edge. This function does not set up
-    /// such an edge.
-    unsafe fn new() -> Self {
-        InternalNode {
-            data: LeafNode::new(),
-            edges: mem::uninitialized()
-        }
-    }
-}
-
-/// An owned pointer to a node. This basically is either `Box<LeafNode<K, V>>` or
-/// `Box<InternalNode<K, V>>`. However, it contains no information as to which of the two types
-/// of nodes is acutally behind the box, and, partially due to this lack of information, has no
-/// destructor.
-struct BoxedNode<K, V> {
-    ptr: Unique<LeafNode<K, V>>
-}
-
-impl<K, V> BoxedNode<K, V> {
-    fn from_leaf(node: Box<LeafNode<K, V>>) -> Self {
-        unsafe {
-            BoxedNode { ptr: Unique::new(Box::into_raw(node)) }
-        }
-    }
-
-    fn from_internal(node: Box<InternalNode<K, V>>) -> Self {
-        unsafe {
-            BoxedNode { ptr: Unique::new(Box::into_raw(node) as *mut LeafNode<K, V>) }
-        }
-    }
-
-    unsafe fn from_ptr(ptr: NonZero<*const LeafNode<K, V>>) -> Self {
-        BoxedNode { ptr: Unique::new(ptr.get() as *mut LeafNode<K, V>) }
-    }
-
-    fn as_ptr(&self) -> NonZero<*const LeafNode<K, V>> {
-        unsafe {
-            NonZero::new(self.ptr.as_ptr())
-        }
-    }
-}
-
-/// An owned tree. Note that despite being owned, this does not have a destructor,
-/// and must be cleaned up manually.
-pub struct Root<K, V> {
-    node: BoxedNode<K, V>,
-    height: usize
-}
-
-unsafe impl<K: Sync, V: Sync> Sync for Root<K, V> { }
-unsafe impl<K: Send, V: Send> Send for Root<K, V> { }
-
-impl<K, V> Root<K, V> {
-    pub fn new_leaf() -> Self {
-        Root {
-            node: BoxedNode::from_leaf(Box::new(unsafe { LeafNode::new() })),
-            height: 0
-        }
-    }
-
-    pub fn as_ref(&self)
-            -> NodeRef<marker::Immut, K, V, marker::LeafOrInternal> {
-        NodeRef {
-            height: self.height,
-            node: self.node.as_ptr(),
-            root: self as *const _ as *mut _,
-            _marker: PhantomData,
-        }
-    }
-
-    pub fn as_mut(&mut self)
-            -> NodeRef<marker::Mut, K, V, marker::LeafOrInternal> {
-        NodeRef {
-            height: self.height,
-            node: self.node.as_ptr(),
-            root: self as *mut _,
-            _marker: PhantomData,
-        }
-    }
-
-    pub fn into_ref(self)
-            -> NodeRef<marker::Owned, K, V, marker::LeafOrInternal> {
-        NodeRef {
-            height: self.height,
-            node: self.node.as_ptr(),
-            root: ptr::null_mut(), // FIXME: Is there anything better to do here?
-            _marker: PhantomData,
-        }
-    }
-
-    /// Adds a new internal node with a single edge, pointing to the previous root, and make that
-    /// new node the root. This increases the height by 1 and is the opposite of `pop_level`.
-    pub fn push_level(&mut self)
-            -> NodeRef<marker::Mut, K, V, marker::Internal> {
-        let mut new_node = Box::new(unsafe { InternalNode::new() });
-        new_node.edges[0] = unsafe { BoxedNode::from_ptr(self.node.as_ptr()) };
-
-        self.node = BoxedNode::from_internal(new_node);
-        self.height += 1;
-
-        let mut ret = NodeRef {
-            height: self.height,
-            node: self.node.as_ptr(),
-            root: self as *mut _,
-            _marker: PhantomData
-        };
-
-        unsafe {
-            ret.reborrow_mut().first_edge().correct_parent_link();
-        }
-
-        ret
-    }
-
-    /// Removes the root node, using its first child as the new root. This cannot be called when
-    /// the tree consists only of a leaf node. As it is intended only to be called when the root
-    /// has only one edge, no cleanup is done on any of the other children are elements of the root.
-    /// This decreases the height by 1 and is the opposite of `push_level`.
-    pub fn pop_level(&mut self) {
-        debug_assert!(self.height > 0);
-
-        let top = self.node.ptr.as_ptr() as *mut u8;
-
-        self.node = unsafe {
-            BoxedNode::from_ptr(self.as_mut()
-                                    .cast_unchecked::<marker::Internal>()
-                                    .first_edge()
-                                    .descend()
-                                    .node)
-        };
-        self.height -= 1;
-        self.as_mut().as_leaf_mut().parent = ptr::null();
-
-        unsafe {
-            heap::deallocate(
-                top,
-                mem::size_of::<InternalNode<K, V>>(),
-                mem::align_of::<InternalNode<K, V>>()
-            );
-        }
-    }
-}
-
-// N.B. `NodeRef` is always covariant in `K` and `V`, even when the `BorrowType`
-// is `Mut`. This is technically wrong, but cannot result in any unsafety due to
-// internal use of `NodeRef` because we stay completely generic over `K` and `V`.
-// However, whenever a public type wraps `NodeRef`, make sure that it has the
-// correct variance.
-/// A reference to a node.
-///
-/// This type has a number of paramaters that controls how it acts:
-/// - `BorrowType`: This can be `Immut<'a>` or `Mut<'a>` for some `'a` or `Owned`.
-///    When this is `Immut<'a>`, the `NodeRef` acts roughly like `&'a Node`,
-///    when this is `Mut<'a>`, the `NodeRef` acts roughly like `&'a mut Node`,
-///    and when this is `Owned`, the `NodeRef` acts roughly like `Box<Node>`.
-/// - `K` and `V`: These control what types of things are stored in the nodes.
-/// - `Type`: This can be `Leaf`, `Internal`, or `LeafOrInternal`. When this is
-///   `Leaf`, the `NodeRef` points to a leaf node, when this is `Internal` the
-///   `NodeRef` points to an internal node, and when this is `LeafOrInternal` the
-///   `NodeRef` could be pointing to either type of node.
-pub struct NodeRef<BorrowType, K, V, Type> {
-    height: usize,
-    node: NonZero<*const LeafNode<K, V>>,
-    // This is null unless the borrow type is `Mut`
-    root: *const Root<K, V>,
-    _marker: PhantomData<(BorrowType, Type)>
-}
-
-impl<'a, K: 'a, V: 'a, Type> Copy for NodeRef<marker::Immut<'a>, K, V, Type> { }
-impl<'a, K: 'a, V: 'a, Type> Clone for NodeRef<marker::Immut<'a>, K, V, Type> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-unsafe impl<BorrowType, K: Sync, V: Sync, Type> Sync
-    for NodeRef<BorrowType, K, V, Type> { }
-
-unsafe impl<'a, K: Sync + 'a, V: Sync + 'a, Type> Send
-   for NodeRef<marker::Immut<'a>, K, V, Type> { }
-unsafe impl<'a, K: Send + 'a, V: Send + 'a, Type> Send
-   for NodeRef<marker::Mut<'a>, K, V, Type> { }
-unsafe impl<K: Send, V: Send, Type> Send
-   for NodeRef<marker::Owned, K, V, Type> { }
-
-impl<BorrowType, K, V> NodeRef<BorrowType, K, V, marker::Internal> {
-    fn as_internal(&self) -> &InternalNode<K, V> {
-        unsafe {
-            &*(self.node.get() as *const InternalNode<K, V>)
-        }
-    }
-}
-
-impl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Internal> {
-    fn as_internal_mut(&mut self) -> &mut InternalNode<K, V> {
-        unsafe {
-            &mut *(self.node.get() as *mut InternalNode<K, V>)
-        }
-    }
-}
-
-
-impl<BorrowType, K, V, Type> NodeRef<BorrowType, K, V, Type> {
-    /// Finds the length of the node. This is the number of keys or values. In an
-    /// internal node, the number of edges is `len() + 1`.
-    pub fn len(&self) -> usize {
-        self.as_leaf().len as usize
-    }
-
-    /// Returns the height of this node in the whole tree. Zero height denotes the
-    /// leaf level.
-    pub fn height(&self) -> usize {
-        self.height
-    }
-
-    /// Removes any static information about whether this node is a `Leaf` or an
-    /// `Internal` node.
-    pub fn forget_type(self) -> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {
-        NodeRef {
-            height: self.height,
-            node: self.node,
-            root: self.root,
-            _marker: PhantomData
-        }
-    }
-
-    /// Temporarily takes out another, immutable reference to the same node.
-    fn reborrow<'a>(&'a self) -> NodeRef<marker::Immut<'a>, K, V, Type> {
-        NodeRef {
-            height: self.height,
-            node: self.node,
-            root: self.root,
-            _marker: PhantomData
-        }
-    }
-
-    fn as_leaf(&self) -> &LeafNode<K, V> {
-        unsafe {
-            &*self.node.get()
-        }
-    }
-
-    pub fn keys(&self) -> &[K] {
-        self.reborrow().into_slices().0
-    }
-
-    pub fn vals(&self) -> &[V] {
-        self.reborrow().into_slices().1
-    }
-
-    /// Finds the parent of the current node. Returns `Ok(handle)` if the current
-    /// node actually has a parent, where `handle` points to the edge of the parent
-    /// that points to the current node. Returns `Err(self)` if the current node has
-    /// no parent, giving back the original `NodeRef`.
-    ///
-    /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should
-    /// both, upon success, do nothing.
-    pub fn ascend(self) -> Result<
-        Handle<
-            NodeRef<
-                BorrowType,
-                K, V,
-                marker::Internal
-            >,
-            marker::Edge
-        >,
-        Self
-    > {
-        if self.as_leaf().parent.is_null() {
-            Err(self)
-        } else {
-            Ok(Handle {
-                node: NodeRef {
-                    height: self.height + 1,
-                    node: unsafe {
-                        NonZero::new(self.as_leaf().parent as *mut LeafNode<K, V>)
-                    },
-                    root: self.root,
-                    _marker: PhantomData
-                },
-                idx: self.as_leaf().parent_idx as usize,
-                _marker: PhantomData
-            })
-        }
-    }
-
-    pub fn first_edge(self) -> Handle<Self, marker::Edge> {
-        Handle::new_edge(self, 0)
-    }
-
-    pub fn last_edge(self) -> Handle<Self, marker::Edge> {
-        let len = self.len();
-        Handle::new_edge(self, len)
-    }
-
-    /// Note that `self` must be nonempty.
-    pub fn first_kv(self) -> Handle<Self, marker::KV> {
-        debug_assert!(self.len() > 0);
-        Handle::new_kv(self, 0)
-    }
-
-    /// Note that `self` must be nonempty.
-    pub fn last_kv(self) -> Handle<Self, marker::KV> {
-        let len = self.len();
-        debug_assert!(len > 0);
-        Handle::new_kv(self, len - 1)
-    }
-}
-
-impl<K, V> NodeRef<marker::Owned, K, V, marker::Leaf> {
-    /// Similar to `ascend`, gets a reference to a node's parent node, but also
-    /// deallocate the current node in the process. This is unsafe because the
-    /// current node will still be accessible despite being deallocated.
-    pub unsafe fn deallocate_and_ascend(self) -> Option<
-        Handle<
-            NodeRef<
-                marker::Owned,
-                K, V,
-                marker::Internal
-            >,
-            marker::Edge
-        >
-    > {
-        let ptr = self.as_leaf() as *const LeafNode<K, V> as *const u8 as *mut u8;
-        let ret = self.ascend().ok();
-        heap::deallocate(ptr, mem::size_of::<LeafNode<K, V>>(), mem::align_of::<LeafNode<K, V>>());
-        ret
-    }
-}
-
-impl<K, V> NodeRef<marker::Owned, K, V, marker::Internal> {
-    /// Similar to `ascend`, gets a reference to a node's parent node, but also
-    /// deallocate the current node in the process. This is unsafe because the
-    /// current node will still be accessible despite being deallocated.
-    pub unsafe fn deallocate_and_ascend(self) -> Option<
-        Handle<
-            NodeRef<
-                marker::Owned,
-                K, V,
-                marker::Internal
-            >,
-            marker::Edge
-        >
-    > {
-        let ptr = self.as_internal() as *const InternalNode<K, V> as *const u8 as *mut u8;
-        let ret = self.ascend().ok();
-        heap::deallocate(
-            ptr,
-            mem::size_of::<InternalNode<K, V>>(),
-            mem::align_of::<InternalNode<K, V>>()
-        );
-        ret
-    }
-}
-
-impl<'a, K, V, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
-    /// Unsafely asserts to the compiler some static information about whether this
-    /// node is a `Leaf`.
-    unsafe fn cast_unchecked<NewType>(&mut self)
-            -> NodeRef<marker::Mut, K, V, NewType> {
-
-        NodeRef {
-            height: self.height,
-            node: self.node,
-            root: self.root,
-            _marker: PhantomData
-        }
-    }
-
-    /// Temporarily takes out another, mutable reference to the same node. Beware, as
-    /// this method is very dangerous, doubly so since it may not immediately appear
-    /// dangerous.
-    ///
-    /// Because mutable pointers can roam anywhere around the tree and can even (through
-    /// `into_root_mut`) mess with the root of the tree, the result of `reborrow_mut`
-    /// can easily be used to make the original mutable pointer dangling, or, in the case
-    /// of a reborrowed handle, out of bounds.
-    // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts
-    // the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.
-    unsafe fn reborrow_mut(&mut self) -> NodeRef<marker::Mut, K, V, Type> {
-        NodeRef {
-            height: self.height,
-            node: self.node,
-            root: self.root,
-            _marker: PhantomData
-        }
-    }
-
-    fn as_leaf_mut(&mut self) -> &mut LeafNode<K, V> {
-        unsafe {
-            &mut *(self.node.get() as *mut LeafNode<K, V>)
-        }
-    }
-
-    pub fn keys_mut(&mut self) -> &mut [K] {
-        unsafe { self.reborrow_mut().into_slices_mut().0 }
-    }
-
-    pub fn vals_mut(&mut self) -> &mut [V] {
-        unsafe { self.reborrow_mut().into_slices_mut().1 }
-    }
-}
-
-impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Immut<'a>, K, V, Type> {
-    pub fn into_slices(self) -> (&'a [K], &'a [V]) {
-        unsafe {
-            (
-                slice::from_raw_parts(
-                    self.as_leaf().keys.as_ptr(),
-                    self.len()
-                ),
-                slice::from_raw_parts(
-                    self.as_leaf().vals.as_ptr(),
-                    self.len()
-                )
-            )
-        }
-    }
-}
-
-impl<'a, K: 'a, V: 'a, Type> NodeRef<marker::Mut<'a>, K, V, Type> {
-    /// Gets a mutable reference to the root itself. This is useful primarily when the
-    /// height of the tree needs to be adjusted. Never call this on a reborrowed pointer.
-    pub fn into_root_mut(self) -> &'a mut Root<K, V> {
-        unsafe {
-            &mut *(self.root as *mut Root<K, V>)
-        }
-    }
-
-    pub fn into_slices_mut(mut self) -> (&'a mut [K], &'a mut [V]) {
-        unsafe {
-            (
-                slice::from_raw_parts_mut(
-                    &mut self.as_leaf_mut().keys as *mut [K] as *mut K,
-                    self.len()
-                ),
-                slice::from_raw_parts_mut(
-                    &mut self.as_leaf_mut().vals as *mut [V] as *mut V,
-                    self.len()
-                )
-            )
-        }
-    }
-}
-
-impl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Leaf> {
-    /// Adds a key/value pair the end of the node.
-    pub fn push(&mut self, key: K, val: V) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(self.len() < CAPACITY);
-
-        let idx = self.len();
-
-        unsafe {
-            ptr::write(self.keys_mut().get_unchecked_mut(idx), key);
-            ptr::write(self.vals_mut().get_unchecked_mut(idx), val);
-        }
-
-        self.as_leaf_mut().len += 1;
-    }
-
-    /// Adds a key/value pair to the beginning of the node.
-    pub fn push_front(&mut self, key: K, val: V) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(self.len() < CAPACITY);
-
-        unsafe {
-            slice_insert(self.keys_mut(), 0, key);
-            slice_insert(self.vals_mut(), 0, val);
-        }
-
-        self.as_leaf_mut().len += 1;
-    }
-}
-
-impl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::Internal> {
-    /// Adds a key/value pair and an edge to go to the right of that pair to
-    /// the end of the node.
-    pub fn push(&mut self, key: K, val: V, edge: Root<K, V>) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(edge.height == self.height - 1);
-        debug_assert!(self.len() < CAPACITY);
-
-        let idx = self.len();
-
-        unsafe {
-            ptr::write(self.keys_mut().get_unchecked_mut(idx), key);
-            ptr::write(self.vals_mut().get_unchecked_mut(idx), val);
-            ptr::write(self.as_internal_mut().edges.get_unchecked_mut(idx + 1), edge.node);
-
-            self.as_leaf_mut().len += 1;
-
-            Handle::new_edge(self.reborrow_mut(), idx + 1).correct_parent_link();
-        }
-    }
-
-    fn correct_childrens_parent_links(&mut self, first: usize, after_last: usize) {
-        for i in first..after_last {
-            Handle::new_edge(unsafe { self.reborrow_mut() }, i).correct_parent_link();
-        }
-    }
-
-    fn correct_all_childrens_parent_links(&mut self) {
-        let len = self.len();
-        self.correct_childrens_parent_links(0, len + 1);
-    }
-
-    /// Adds a key/value pair and an edge to go to the left of that pair to
-    /// the beginning of the node.
-    pub fn push_front(&mut self, key: K, val: V, edge: Root<K, V>) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(edge.height == self.height - 1);
-        debug_assert!(self.len() < CAPACITY);
-
-        unsafe {
-            slice_insert(self.keys_mut(), 0, key);
-            slice_insert(self.vals_mut(), 0, val);
-            slice_insert(
-                slice::from_raw_parts_mut(
-                    self.as_internal_mut().edges.as_mut_ptr(),
-                    self.len()+1
-                ),
-                0,
-                edge.node
-            );
-
-            self.as_leaf_mut().len += 1;
-
-            self.correct_all_childrens_parent_links();
-        }
-    }
-}
-
-impl<'a, K, V> NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal> {
-    /// Removes a key/value pair from the end of this node. If this is an internal node,
-    /// also removes the edge that was to the right of that pair.
-    pub fn pop(&mut self) -> (K, V, Option<Root<K, V>>) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(self.len() > 0);
-
-        let idx = self.len() - 1;
-
-        unsafe {
-            let key = ptr::read(self.keys().get_unchecked(idx));
-            let val = ptr::read(self.vals().get_unchecked(idx));
-            let edge = match self.reborrow_mut().force() {
-                ForceResult::Leaf(_) => None,
-                ForceResult::Internal(internal) => {
-                    let edge = ptr::read(internal.as_internal().edges.get_unchecked(idx + 1));
-                    let mut new_root = Root { node: edge, height: internal.height - 1 };
-                    new_root.as_mut().as_leaf_mut().parent = ptr::null();
-                    Some(new_root)
-                }
-            };
-
-            self.as_leaf_mut().len -= 1;
-            (key, val, edge)
-        }
-    }
-
-    /// Removes a key/value pair from the beginning of this node. If this is an internal node,
-    /// also removes the edge that was to the left of that pair.
-    pub fn pop_front(&mut self) -> (K, V, Option<Root<K, V>>) {
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(self.len() > 0);
-
-        let old_len = self.len();
-
-        unsafe {
-            let key = slice_remove(self.keys_mut(), 0);
-            let val = slice_remove(self.vals_mut(), 0);
-            let edge = match self.reborrow_mut().force() {
-                ForceResult::Leaf(_) => None,
-                ForceResult::Internal(mut internal) => {
-                    let edge = slice_remove(
-                        slice::from_raw_parts_mut(
-                            internal.as_internal_mut().edges.as_mut_ptr(),
-                            old_len+1
-                        ),
-                        0
-                    );
-
-                    let mut new_root = Root { node: edge, height: internal.height - 1 };
-                    new_root.as_mut().as_leaf_mut().parent = ptr::null();
-
-                    for i in 0..old_len {
-                        Handle::new_edge(internal.reborrow_mut(), i).correct_parent_link();
-                    }
-
-                    Some(new_root)
-                }
-            };
-
-            self.as_leaf_mut().len -= 1;
-
-            (key, val, edge)
-        }
-    }
-
-    fn into_kv_pointers_mut(mut self) -> (*mut K, *mut V) {
-        (
-            self.keys_mut().as_mut_ptr(),
-            self.vals_mut().as_mut_ptr()
-        )
-    }
-}
-
-impl<BorrowType, K, V> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {
-    /// Checks whether a node is an `Internal` node or a `Leaf` node.
-    pub fn force(self) -> ForceResult<
-        NodeRef<BorrowType, K, V, marker::Leaf>,
-        NodeRef<BorrowType, K, V, marker::Internal>
-    > {
-        if self.height == 0 {
-            ForceResult::Leaf(NodeRef {
-                height: self.height,
-                node: self.node,
-                root: self.root,
-                _marker: PhantomData
-            })
-        } else {
-            ForceResult::Internal(NodeRef {
-                height: self.height,
-                node: self.node,
-                root: self.root,
-                _marker: PhantomData
-            })
-        }
-    }
-}
-
-/// A reference to a specific key/value pair or edge within a node. The `Node` parameter
-/// must be a `NodeRef`, while the `Type` can either be `KV` (signifying a handle on a key/value
-/// pair) or `Edge` (signifying a handle on an edge).
-///
-/// Note that even `Leaf` nodes can have `Edge` handles. Instead of representing a pointer to
-/// a child node, these represent the spaces where child pointers would go between the key/value
-/// pairs. For example, in a node with length 2, there would be 3 possible edge locations - one
-/// to the left of the node, one between the two pairs, and one at the right of the node.
-pub struct Handle<Node, Type> {
-    node: Node,
-    idx: usize,
-    _marker: PhantomData<Type>
-}
-
-impl<Node: Copy, Type> Copy for Handle<Node, Type> { }
-// We don't need the full generality of `#[derive(Clone)]`, as the only time `Node` will be
-// `Clone`able is when it is an immutable reference and therefore `Copy`.
-impl<Node: Copy, Type> Clone for Handle<Node, Type> {
-    fn clone(&self) -> Self {
-        *self
-    }
-}
-
-impl<Node, Type> Handle<Node, Type> {
-    /// Retrieves the node that contains the edge of key/value pair this handle pointes to.
-    pub fn into_node(self) -> Node {
-        self.node
-    }
-}
-
-impl<BorrowType, K, V, NodeType> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV> {
-    /// Creates a new handle to a key/value pair in `node`. `idx` must be less than `node.len()`.
-    pub fn new_kv(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {
-        // Necessary for correctness, but in a private module
-        debug_assert!(idx < node.len());
-
-        Handle {
-            node: node,
-            idx: idx,
-            _marker: PhantomData
-        }
-    }
-
-    pub fn left_edge(self) -> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {
-        Handle::new_edge(self.node, self.idx)
-    }
-
-    pub fn right_edge(self) -> Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {
-        Handle::new_edge(self.node, self.idx + 1)
-    }
-}
-
-impl<BorrowType, K, V, NodeType, HandleType> PartialEq
-        for Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
-
-    fn eq(&self, other: &Self) -> bool {
-        self.node.node == other.node.node && self.idx == other.idx
-    }
-}
-
-impl<BorrowType, K, V, NodeType, HandleType>
-        Handle<NodeRef<BorrowType, K, V, NodeType>, HandleType> {
-
-    /// Temporarily takes out another, immutable handle on the same location.
-    pub fn reborrow(&self)
-            -> Handle<NodeRef<marker::Immut, K, V, NodeType>, HandleType> {
-
-        // We can't use Handle::new_kv or Handle::new_edge because we don't know our type
-        Handle {
-            node: self.node.reborrow(),
-            idx: self.idx,
-            _marker: PhantomData
-        }
-    }
-}
-
-impl<'a, K, V, NodeType, HandleType>
-        Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, HandleType> {
-
-    /// Temporarily takes out another, mutable handle on the same location. Beware, as
-    /// this method is very dangerous, doubly so since it may not immediately appear
-    /// dangerous.
-    ///
-    /// Because mutable pointers can roam anywhere around the tree and can even (through
-    /// `into_root_mut`) mess with the root of the tree, the result of `reborrow_mut`
-    /// can easily be used to make the original mutable pointer dangling, or, in the case
-    /// of a reborrowed handle, out of bounds.
-    // FIXME(@gereeter) consider adding yet another type parameter to `NodeRef` that restricts
-    // the use of `ascend` and `into_root_mut` on reborrowed pointers, preventing this unsafety.
-    pub unsafe fn reborrow_mut(&mut self)
-            -> Handle<NodeRef<marker::Mut, K, V, NodeType>, HandleType> {
-
-        // We can't use Handle::new_kv or Handle::new_edge because we don't know our type
-        Handle {
-            node: self.node.reborrow_mut(),
-            idx: self.idx,
-            _marker: PhantomData
-        }
-    }
-}
-
-impl<BorrowType, K, V, NodeType>
-        Handle<NodeRef<BorrowType, K, V, NodeType>, marker::Edge> {
-
-    /// Creates a new handle to an edge in `node`. `idx` must be less than or equal to
-    /// `node.len()`.
-    pub fn new_edge(node: NodeRef<BorrowType, K, V, NodeType>, idx: usize) -> Self {
-        // Necessary for correctness, but in a private module
-        debug_assert!(idx <= node.len());
-
-        Handle {
-            node: node,
-            idx: idx,
-            _marker: PhantomData
-        }
-    }
-
-    pub fn left_kv(self)
-            -> Result<Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV>, Self> {
-
-        if self.idx > 0 {
-            Ok(Handle::new_kv(self.node, self.idx - 1))
-        } else {
-            Err(self)
-        }
-    }
-
-    pub fn right_kv(self)
-            -> Result<Handle<NodeRef<BorrowType, K, V, NodeType>, marker::KV>, Self> {
-
-        if self.idx < self.node.len() {
-            Ok(Handle::new_kv(self.node, self.idx))
-        } else {
-            Err(self)
-        }
-    }
-}
-
-impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge> {
-    /// Inserts a new key/value pair between the key/value pairs to the right and left of
-    /// this edge. This method assumes that there is enough space in the node for the new
-    /// pair to fit.
-    ///
-    /// The returned pointer points to the inserted value.
-    fn insert_fit(&mut self, key: K, val: V) -> *mut V {
-        // Necessary for correctness, but in a private module
-        debug_assert!(self.node.len() < CAPACITY);
-
-        unsafe {
-            slice_insert(self.node.keys_mut(), self.idx, key);
-            slice_insert(self.node.vals_mut(), self.idx, val);
-
-            self.node.as_leaf_mut().len += 1;
-
-            self.node.vals_mut().get_unchecked_mut(self.idx)
-        }
-    }
-
-    /// Inserts a new key/value pair between the key/value pairs to the right and left of
-    /// this edge. This method splits the node if there isn't enough room.
-    ///
-    /// The returned pointer points to the inserted value.
-    pub fn insert(mut self, key: K, val: V)
-            -> (InsertResult<'a, K, V, marker::Leaf>, *mut V) {
-
-        if self.node.len() < CAPACITY {
-            let ptr = self.insert_fit(key, val);
-            (InsertResult::Fit(Handle::new_kv(self.node, self.idx)), ptr)
-        } else {
-            let middle = Handle::new_kv(self.node, B);
-            let (mut left, k, v, mut right) = middle.split();
-            let ptr = if self.idx <= B {
-                unsafe {
-                    Handle::new_edge(left.reborrow_mut(), self.idx).insert_fit(key, val)
-                }
-            } else {
-                unsafe {
-                    Handle::new_edge(
-                        right.as_mut().cast_unchecked::<marker::Leaf>(),
-                        self.idx - (B + 1)
-                    ).insert_fit(key, val)
-                }
-            };
-            (InsertResult::Split(left, k, v, right), ptr)
-        }
-    }
-}
-
-impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> {
-    /// Fixes the parent pointer and index in the child node below this edge. This is useful
-    /// when the ordering of edges has been changed, such as in the various `insert` methods.
-    fn correct_parent_link(mut self) {
-        let idx = self.idx as u16;
-        let ptr = self.node.as_internal_mut() as *mut _;
-        let mut child = self.descend();
-        child.as_leaf_mut().parent = ptr;
-        child.as_leaf_mut().parent_idx = idx;
-    }
-
-    /// Unsafely asserts to the compiler some static information about whether the underlying
-    /// node of this handle is a `Leaf`.
-    unsafe fn cast_unchecked<NewType>(&mut self)
-            -> Handle<NodeRef<marker::Mut, K, V, NewType>, marker::Edge> {
-
-        Handle::new_edge(self.node.cast_unchecked(), self.idx)
-    }
-
-    /// Inserts a new key/value pair and an edge that will go to the right of that new pair
-    /// between this edge and the key/value pair to the right of this edge. This method assumes
-    /// that there is enough space in the node for the new pair to fit.
-    fn insert_fit(&mut self, key: K, val: V, edge: Root<K, V>) {
-        // Necessary for correctness, but in an internal module
-        debug_assert!(self.node.len() < CAPACITY);
-        debug_assert!(edge.height == self.node.height - 1);
-
-        unsafe {
-            // This cast is a lie, but it allows us to reuse the key/value insertion logic.
-            self.cast_unchecked::<marker::Leaf>().insert_fit(key, val);
-
-            slice_insert(
-                slice::from_raw_parts_mut(
-                    self.node.as_internal_mut().edges.as_mut_ptr(),
-                    self.node.len()
-                ),
-                self.idx + 1,
-                edge.node
-            );
-
-            for i in (self.idx+1)..(self.node.len()+1) {
-                Handle::new_edge(self.node.reborrow_mut(), i).correct_parent_link();
-            }
-        }
-    }
-
-    /// Inserts a new key/value pair and an edge that will go to the right of that new pair
-    /// between this edge and the key/value pair to the right of this edge. This method splits
-    /// the node if there isn't enough room.
-    pub fn insert(mut self, key: K, val: V, edge: Root<K, V>)
-            -> InsertResult<'a, K, V, marker::Internal> {
-
-        // Necessary for correctness, but this is an internal module
-        debug_assert!(edge.height == self.node.height - 1);
-
-        if self.node.len() < CAPACITY {
-            self.insert_fit(key, val, edge);
-            InsertResult::Fit(Handle::new_kv(self.node, self.idx))
-        } else {
-            let middle = Handle::new_kv(self.node, B);
-            let (mut left, k, v, mut right) = middle.split();
-            if self.idx <= B {
-                unsafe {
-                    Handle::new_edge(left.reborrow_mut(), self.idx).insert_fit(key, val, edge);
-                }
-            } else {
-                unsafe {
-                    Handle::new_edge(
-                        right.as_mut().cast_unchecked::<marker::Internal>(),
-                        self.idx - (B + 1)
-                    ).insert_fit(key, val, edge);
-                }
-            }
-            InsertResult::Split(left, k, v, right)
-        }
-    }
-}
-
-impl<BorrowType, K, V>
-        Handle<NodeRef<BorrowType, K, V, marker::Internal>, marker::Edge> {
-
-    /// Finds the node pointed to by this edge.
-    ///
-    /// `edge.descend().ascend().unwrap()` and `node.ascend().unwrap().descend()` should
-    /// both, upon success, do nothing.
-    pub fn descend(self) -> NodeRef<BorrowType, K, V, marker::LeafOrInternal> {
-        NodeRef {
-            height: self.node.height - 1,
-            node: unsafe { self.node.as_internal().edges.get_unchecked(self.idx).as_ptr() },
-            root: self.node.root,
-            _marker: PhantomData
-        }
-    }
-}
-
-impl<'a, K: 'a, V: 'a, NodeType>
-        Handle<NodeRef<marker::Immut<'a>, K, V, NodeType>, marker::KV> {
-
-    pub fn into_kv(self) -> (&'a K, &'a V) {
-        let (keys, vals) = self.node.into_slices();
-        unsafe {
-            (keys.get_unchecked(self.idx), vals.get_unchecked(self.idx))
-        }
-    }
-}
-
-impl<'a, K: 'a, V: 'a, NodeType>
-        Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, marker::KV> {
-
-    pub fn into_kv_mut(self) -> (&'a mut K, &'a mut V) {
-        let (mut keys, mut vals) = self.node.into_slices_mut();
-        unsafe {
-            (keys.get_unchecked_mut(self.idx), vals.get_unchecked_mut(self.idx))
-        }
-    }
-}
-
-impl<'a, K, V, NodeType> Handle<NodeRef<marker::Mut<'a>, K, V, NodeType>, marker::KV> {
-    pub fn kv_mut(&mut self) -> (&mut K, &mut V) {
-        unsafe {
-            let (mut keys, mut vals) = self.node.reborrow_mut().into_slices_mut();
-            (keys.get_unchecked_mut(self.idx), vals.get_unchecked_mut(self.idx))
-        }
-    }
-}
-
-impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::KV> {
-    /// Splits the underlying node into three parts:
-    ///
-    /// - The node is truncated to only contain the key/value pairs to the right of
-    ///   this handle.
-    /// - The key and value pointed to by this handle and extracted.
-    /// - All the key/value pairs to the right of this handle are put into a newly
-    ///   allocated node.
-    pub fn split(mut self)
-            -> (NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, K, V, Root<K, V>) {
-        unsafe {
-            let mut new_node = Box::new(LeafNode::new());
-
-            let k = ptr::read(self.node.keys().get_unchecked(self.idx));
-            let v = ptr::read(self.node.vals().get_unchecked(self.idx));
-
-            let new_len = self.node.len() - self.idx - 1;
-
-            ptr::copy_nonoverlapping(
-                self.node.keys().as_ptr().offset(self.idx as isize + 1),
-                new_node.keys.as_mut_ptr(),
-                new_len
-            );
-            ptr::copy_nonoverlapping(
-                self.node.vals().as_ptr().offset(self.idx as isize + 1),
-                new_node.vals.as_mut_ptr(),
-                new_len
-            );
-
-            self.node.as_leaf_mut().len = self.idx as u16;
-            new_node.len = new_len as u16;
-
-            (
-                self.node,
-                k, v,
-                Root {
-                    node: BoxedNode::from_leaf(new_node),
-                    height: 0
-                }
-            )
-        }
-    }
-
-    /// Removes the key/value pair pointed to by this handle, returning the edge between the
-    /// now adjacent key/value pairs to the left and right of this handle.
-    pub fn remove(mut self)
-            -> (Handle<NodeRef<marker::Mut<'a>, K, V, marker::Leaf>, marker::Edge>, K, V) {
-        unsafe {
-            let k = slice_remove(self.node.keys_mut(), self.idx);
-            let v = slice_remove(self.node.vals_mut(), self.idx);
-            self.node.as_leaf_mut().len -= 1;
-            (self.left_edge(), k, v)
-        }
-    }
-}
-
-impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::KV> {
-    /// Splits the underlying node into three parts:
-    ///
-    /// - The node is truncated to only contain the edges and key/value pairs to the
-    ///   right of this handle.
-    /// - The key and value pointed to by this handle and extracted.
-    /// - All the edges and key/value pairs to the right of this handle are put into
-    ///   a newly allocated node.
-    pub fn split(mut self)
-            -> (NodeRef<marker::Mut<'a>, K, V, marker::Internal>, K, V, Root<K, V>) {
-        unsafe {
-            let mut new_node = Box::new(InternalNode::new());
-
-            let k = ptr::read(self.node.keys().get_unchecked(self.idx));
-            let v = ptr::read(self.node.vals().get_unchecked(self.idx));
-
-            let height = self.node.height;
-            let new_len = self.node.len() - self.idx - 1;
-
-            ptr::copy_nonoverlapping(
-                self.node.keys().as_ptr().offset(self.idx as isize + 1),
-                new_node.data.keys.as_mut_ptr(),
-                new_len
-            );
-            ptr::copy_nonoverlapping(
-                self.node.vals().as_ptr().offset(self.idx as isize + 1),
-                new_node.data.vals.as_mut_ptr(),
-                new_len
-            );
-            ptr::copy_nonoverlapping(
-                self.node.as_internal().edges.as_ptr().offset(self.idx as isize + 1),
-                new_node.edges.as_mut_ptr(),
-                new_len + 1
-            );
-
-            self.node.as_leaf_mut().len = self.idx as u16;
-            new_node.data.len = new_len as u16;
-
-            let mut new_root = Root {
-                node: BoxedNode::from_internal(new_node),
-                height: height
-            };
-
-            for i in 0..(new_len+1) {
-                Handle::new_edge(new_root.as_mut().cast_unchecked(), i).correct_parent_link();
-            }
-
-            (
-                self.node,
-                k, v,
-                new_root
-            )
-        }
-    }
-
-    /// Returns whether it is valid to call `.merge()`, i.e., whether there is enough room in
-    /// a node to hold the combination of the nodes to the left and right of this handle along
-    /// with the key/value pair at this handle.
-    pub fn can_merge(&self) -> bool {
-        (
-            self.reborrow()
-                .left_edge()
-                .descend()
-                .len()
-          + self.reborrow()
-                .right_edge()
-                .descend()
-                .len()
-          + 1
-        ) <= CAPACITY
-    }
-
-    /// Combines the node immediately to the left of this handle, the key/value pair pointed
-    /// to by this handle, and the node immediately to the right of this handle into one new
-    /// child of the underlying node, returning an edge referencing that new child.
-    ///
-    /// Assumes that this edge `.can_merge()`.
-    pub fn merge(mut self)
-            -> Handle<NodeRef<marker::Mut<'a>, K, V, marker::Internal>, marker::Edge> {
-        let self1 = unsafe { ptr::read(&self) };
-        let self2 = unsafe { ptr::read(&self) };
-        let mut left_node = self1.left_edge().descend();
-        let left_len = left_node.len();
-        let mut right_node = self2.right_edge().descend();
-        let right_len = right_node.len();
-
-        // necessary for correctness, but in a private module
-        debug_assert!(left_len + right_len + 1 <= CAPACITY);
-
-        unsafe {
-            ptr::write(left_node.keys_mut().get_unchecked_mut(left_len),
-                       slice_remove(self.node.keys_mut(), self.idx));
-            ptr::copy_nonoverlapping(
-                right_node.keys().as_ptr(),
-                left_node.keys_mut().as_mut_ptr().offset(left_len as isize + 1),
-                right_len
-            );
-            ptr::write(left_node.vals_mut().get_unchecked_mut(left_len),
-                       slice_remove(self.node.vals_mut(), self.idx));
-            ptr::copy_nonoverlapping(
-                right_node.vals().as_ptr(),
-                left_node.vals_mut().as_mut_ptr().offset(left_len as isize + 1),
-                right_len
-            );
-
-            slice_remove(&mut self.node.as_internal_mut().edges, self.idx + 1);
-            for i in self.idx+1..self.node.len() {
-                Handle::new_edge(self.node.reborrow_mut(), i).correct_parent_link();
-            }
-            self.node.as_leaf_mut().len -= 1;
-
-            left_node.as_leaf_mut().len += right_len as u16 + 1;
-
-            if self.node.height > 1 {
-                ptr::copy_nonoverlapping(
-                    right_node.cast_unchecked().as_internal().edges.as_ptr(),
-                    left_node.cast_unchecked()
-                             .as_internal_mut()
-                             .edges
-                             .as_mut_ptr()
-                             .offset(left_len as isize + 1),
-                    right_len + 1
-                );
-
-                for i in left_len+1..left_len+right_len+2 {
-                    Handle::new_edge(
-                        left_node.cast_unchecked().reborrow_mut(),
-                        i
-                    ).correct_parent_link();
-                }
-
-                heap::deallocate(
-                    right_node.node.get() as *mut u8,
-                    mem::size_of::<InternalNode<K, V>>(),
-                    mem::align_of::<InternalNode<K, V>>()
-                );
-            } else {
-                heap::deallocate(
-                    right_node.node.get() as *mut u8,
-                    mem::size_of::<LeafNode<K, V>>(),
-                    mem::align_of::<LeafNode<K, V>>()
-                );
-            }
-
-            Handle::new_edge(self.node, self.idx)
-        }
-    }
-
-    /// This removes a key/value pair from the left child and replaces it with the key/value pair
-    /// pointed to by this handle while pushing the old key/value pair of this handle into the right
-    /// child.
-    pub fn steal_left(&mut self) {
-        unsafe {
-            let (k, v, edge) = self.reborrow_mut().left_edge().descend().pop();
-
-            let k = mem::replace(self.reborrow_mut().into_kv_mut().0, k);
-            let v = mem::replace(self.reborrow_mut().into_kv_mut().1, v);
-
-            match self.reborrow_mut().right_edge().descend().force() {
-                ForceResult::Leaf(mut leaf) => leaf.push_front(k, v),
-                ForceResult::Internal(mut internal) => internal.push_front(k, v, edge.unwrap())
-            }
-        }
-    }
-
-    /// This removes a key/value pair from the right child and replaces it with the key/value pair
-    /// pointed to by this handle while pushing the old key/value pair of this handle into the left
-    /// child.
-    pub fn steal_right(&mut self) {
-        unsafe {
-            let (k, v, edge) = self.reborrow_mut().right_edge().descend().pop_front();
-
-            let k = mem::replace(self.reborrow_mut().into_kv_mut().0, k);
-            let v = mem::replace(self.reborrow_mut().into_kv_mut().1, v);
-
-            match self.reborrow_mut().left_edge().descend().force() {
-                ForceResult::Leaf(mut leaf) => leaf.push(k, v),
-                ForceResult::Internal(mut internal) => internal.push(k, v, edge.unwrap())
-            }
-        }
-    }
-
-    /// This does stealing similar to `steal_left` but steals multiple elements at once.
-    pub fn bulk_steal_left(&mut self, count: usize) {
-        unsafe {
-            let mut left_node = ptr::read(self).left_edge().descend();
-            let left_len = left_node.len();
-            let mut right_node = ptr::read(self).right_edge().descend();
-            let right_len = right_node.len();
-
-            // Make sure that we may steal safely.
-            debug_assert!(right_len + count <= CAPACITY);
-            debug_assert!(left_len >= count);
-
-            let new_left_len = left_len - count;
-
-            // Move data.
-            {
-                let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();
-                let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();
-                let parent_kv = {
-                    let kv = self.reborrow_mut().into_kv_mut();
-                    (kv.0 as *mut K, kv.1 as *mut V)
-                };
-
-                // Make room for stolen elements in the right child.
-                ptr::copy(right_kv.0,
-                          right_kv.0.offset(count as isize),
-                          right_len);
-                ptr::copy(right_kv.1,
-                          right_kv.1.offset(count as isize),
-                          right_len);
-
-                // Move elements from the left child to the right one.
-                move_kv(left_kv, new_left_len + 1, right_kv, 0, count - 1);
-
-                // Move parent's key/value pair to the right child.
-                move_kv(parent_kv, 0, right_kv, count - 1, 1);
-
-                // Move the left-most stolen pair to the parent.
-                move_kv(left_kv, new_left_len, parent_kv, 0, 1);
-            }
-
-            left_node.reborrow_mut().as_leaf_mut().len -= count as u16;
-            right_node.reborrow_mut().as_leaf_mut().len += count as u16;
-
-            match (left_node.force(), right_node.force()) {
-                (ForceResult::Internal(left), ForceResult::Internal(mut right)) => {
-                    // Make room for stolen edges.
-                    let right_edges = right.reborrow_mut().as_internal_mut().edges.as_mut_ptr();
-                    ptr::copy(right_edges,
-                              right_edges.offset(count as isize),
-                              right_len + 1);
-                    right.correct_childrens_parent_links(count, count + right_len + 1);
-
-                    move_edges(left, new_left_len + 1, right, 0, count);
-                },
-                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
-            }
-        }
-    }
-
-    /// The symmetric clone of `bulk_steal_left`.
-    pub fn bulk_steal_right(&mut self, count: usize) {
-        unsafe {
-            let mut left_node = ptr::read(self).left_edge().descend();
-            let left_len = left_node.len();
-            let mut right_node = ptr::read(self).right_edge().descend();
-            let right_len = right_node.len();
-
-            // Make sure that we may steal safely.
-            debug_assert!(left_len + count <= CAPACITY);
-            debug_assert!(right_len >= count);
-
-            let new_right_len = right_len - count;
-
-            // Move data.
-            {
-                let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();
-                let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();
-                let parent_kv = {
-                    let kv = self.reborrow_mut().into_kv_mut();
-                    (kv.0 as *mut K, kv.1 as *mut V)
-                };
-
-                // Move parent's key/value pair to the left child.
-                move_kv(parent_kv, 0, left_kv, left_len, 1);
-
-                // Move elements from the right child to the left one.
-                move_kv(right_kv, 0, left_kv, left_len + 1, count - 1);
-
-                // Move the right-most stolen pair to the parent.
-                move_kv(right_kv, count - 1, parent_kv, 0, 1);
-
-                // Fix right indexing
-                ptr::copy(right_kv.0.offset(count as isize),
-                          right_kv.0,
-                          new_right_len);
-                ptr::copy(right_kv.1.offset(count as isize),
-                          right_kv.1,
-                          new_right_len);
-            }
-
-            left_node.reborrow_mut().as_leaf_mut().len += count as u16;
-            right_node.reborrow_mut().as_leaf_mut().len -= count as u16;
-
-            match (left_node.force(), right_node.force()) {
-                (ForceResult::Internal(left), ForceResult::Internal(mut right)) => {
-                    move_edges(right.reborrow_mut(), 0, left, left_len + 1, count);
-
-                    // Fix right indexing.
-                    let right_edges = right.reborrow_mut().as_internal_mut().edges.as_mut_ptr();
-                    ptr::copy(right_edges.offset(count as isize),
-                              right_edges,
-                              new_right_len + 1);
-                    right.correct_childrens_parent_links(0, new_right_len + 1);
-                },
-                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
-            }
-        }
-    }
-}
-
-unsafe fn move_kv<K, V>(
-    source: (*mut K, *mut V), source_offset: usize,
-    dest: (*mut K, *mut V), dest_offset: usize,
-    count: usize)
-{
-    ptr::copy_nonoverlapping(source.0.offset(source_offset as isize),
-                             dest.0.offset(dest_offset as isize),
-                             count);
-    ptr::copy_nonoverlapping(source.1.offset(source_offset as isize),
-                             dest.1.offset(dest_offset as isize),
-                             count);
-}
-
-// Source and destination must have the same height.
-unsafe fn move_edges<K, V>(
-    mut source: NodeRef<marker::Mut, K, V, marker::Internal>, source_offset: usize,
-    mut dest: NodeRef<marker::Mut, K, V, marker::Internal>, dest_offset: usize,
-    count: usize)
-{
-    let source_ptr = source.as_internal_mut().edges.as_mut_ptr();
-    let dest_ptr = dest.as_internal_mut().edges.as_mut_ptr();
-    ptr::copy_nonoverlapping(source_ptr.offset(source_offset as isize),
-                             dest_ptr.offset(dest_offset as isize),
-                             count);
-    dest.correct_childrens_parent_links(dest_offset, dest_offset + count);
-}
-
-impl<BorrowType, K, V, HandleType>
-        Handle<NodeRef<BorrowType, K, V, marker::LeafOrInternal>, HandleType> {
-
-    /// Check whether the underlying node is an `Internal` node or a `Leaf` node.
-    pub fn force(self) -> ForceResult<
-        Handle<NodeRef<BorrowType, K, V, marker::Leaf>, HandleType>,
-        Handle<NodeRef<BorrowType, K, V, marker::Internal>, HandleType>
-    > {
-        match self.node.force() {
-            ForceResult::Leaf(node) => ForceResult::Leaf(Handle {
-                node: node,
-                idx: self.idx,
-                _marker: PhantomData
-            }),
-            ForceResult::Internal(node) => ForceResult::Internal(Handle {
-                node: node,
-                idx: self.idx,
-                _marker: PhantomData
-            })
-        }
-    }
-}
-
-impl<'a, K, V> Handle<NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>, marker::Edge> {
-    /// Move the suffix after `self` from one node to another one. `right` must be empty.
-    /// The first edge of `right` remains unchanged.
-    pub fn move_suffix(&mut self,
-            right: &mut NodeRef<marker::Mut<'a>, K, V, marker::LeafOrInternal>) {
-        unsafe {
-            let left_new_len = self.idx;
-            let mut left_node = self.reborrow_mut().into_node();
-
-            let right_new_len = left_node.len() - left_new_len;
-            let mut right_node = right.reborrow_mut();
-
-            debug_assert!(right_node.len() == 0);
-            debug_assert!(left_node.height == right_node.height);
-
-            let left_kv = left_node.reborrow_mut().into_kv_pointers_mut();
-            let right_kv = right_node.reborrow_mut().into_kv_pointers_mut();
-
-
-            move_kv(left_kv, left_new_len, right_kv, 0, right_new_len);
-
-            left_node.reborrow_mut().as_leaf_mut().len = left_new_len as u16;
-            right_node.reborrow_mut().as_leaf_mut().len = right_new_len as u16;
-
-            match (left_node.force(), right_node.force()) {
-                (ForceResult::Internal(left), ForceResult::Internal(right)) => {
-                    move_edges(left, left_new_len + 1, right, 1, right_new_len);
-                },
-                (ForceResult::Leaf(_), ForceResult::Leaf(_)) => { }
-                _ => { unreachable!(); }
-            }
-        }
-    }
-}
-
-pub enum ForceResult<Leaf, Internal> {
-    Leaf(Leaf),
-    Internal(Internal)
-}
-
-pub enum InsertResult<'a, K, V, Type> {
-    Fit(Handle<NodeRef<marker::Mut<'a>, K, V, Type>, marker::KV>),
-    Split(NodeRef<marker::Mut<'a>, K, V, Type>, K, V, Root<K, V>)
-}
-
-pub mod marker {
-    use core::marker::PhantomData;
-
-    pub enum Leaf { }
-    pub enum Internal { }
-    pub enum LeafOrInternal { }
-
-    pub enum Owned { }
-    pub struct Immut<'a>(PhantomData<&'a ()>);
-    pub struct Mut<'a>(PhantomData<&'a mut ()>);
-
-    pub enum KV { }
-    pub enum Edge { }
-}
-
-unsafe fn slice_insert<T>(slice: &mut [T], idx: usize, val: T) {
-    ptr::copy(
-        slice.as_ptr().offset(idx as isize),
-        slice.as_mut_ptr().offset(idx as isize + 1),
-        slice.len() - idx
-    );
-    ptr::write(slice.get_unchecked_mut(idx), val);
-}
-
-unsafe fn slice_remove<T>(slice: &mut [T], idx: usize) -> T {
-    let ret = ptr::read(slice.get_unchecked(idx));
-    ptr::copy(
-        slice.as_ptr().offset(idx as isize + 1),
-        slice.as_mut_ptr().offset(idx as isize),
-        slice.len() - idx - 1
-    );
-    ret
-}
diff --git a/src/libcollections/btree/search.rs b/src/libcollections/btree/search.rs
deleted file mode 100644
index bc1272fbc78..00000000000
--- a/src/libcollections/btree/search.rs
+++ /dev/null
@@ -1,75 +0,0 @@
-// Copyright 2015 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.
-
-use core::cmp::Ordering;
-
-use borrow::Borrow;
-
-use super::node::{Handle, NodeRef, marker};
-
-use super::node::ForceResult::*;
-use self::SearchResult::*;
-
-pub enum SearchResult<BorrowType, K, V, FoundType, GoDownType> {
-    Found(Handle<NodeRef<BorrowType, K, V, FoundType>, marker::KV>),
-    GoDown(Handle<NodeRef<BorrowType, K, V, GoDownType>, marker::Edge>)
-}
-
-pub fn search_tree<BorrowType, K, V, Q: ?Sized>(
-    mut node: NodeRef<BorrowType, K, V, marker::LeafOrInternal>,
-    key: &Q
-) -> SearchResult<BorrowType, K, V, marker::LeafOrInternal, marker::Leaf>
-        where Q: Ord, K: Borrow<Q> {
-
-    loop {
-        match search_node(node, key) {
-            Found(handle) => return Found(handle),
-            GoDown(handle) => match handle.force() {
-                Leaf(leaf) => return GoDown(leaf),
-                Internal(internal) => {
-                    node = internal.descend();
-                    continue;
-                }
-            }
-        }
-    }
-}
-
-pub fn search_node<BorrowType, K, V, Type, Q: ?Sized>(
-    node: NodeRef<BorrowType, K, V, Type>,
-    key: &Q
-) -> SearchResult<BorrowType, K, V, Type, Type>
-        where Q: Ord, K: Borrow<Q> {
-
-    match search_linear(&node, key) {
-        (idx, true) => Found(
-            Handle::new_kv(node, idx)
-        ),
-        (idx, false) => SearchResult::GoDown(
-            Handle::new_edge(node, idx)
-        )
-    }
-}
-
-pub fn search_linear<BorrowType, K, V, Type, Q: ?Sized>(
-    node: &NodeRef<BorrowType, K, V, Type>,
-    key: &Q
-) -> (usize, bool)
-        where Q: Ord, K: Borrow<Q> {
-
-    for (i, k) in node.keys().iter().enumerate() {
-        match key.cmp(k.borrow()) {
-            Ordering::Greater => {},
-            Ordering::Equal => return (i, true),
-            Ordering::Less => return (i, false)
-        }
-    }
-    (node.keys().len(), false)
-}
diff --git a/src/libcollections/btree/set.rs b/src/libcollections/btree/set.rs
deleted file mode 100644
index d32460da939..00000000000
--- a/src/libcollections/btree/set.rs
+++ /dev/null
@@ -1,1133 +0,0 @@
-// Copyright 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.
-
-// This is pretty much entirely stolen from TreeSet, since BTreeMap has an identical interface
-// to TreeMap
-
-use core::cmp::Ordering::{self, Less, Greater, Equal};
-use core::cmp::{min, max};
-use core::fmt::Debug;
-use core::fmt;
-use core::iter::{Peekable, FromIterator, FusedIterator};
-use core::ops::{BitOr, BitAnd, BitXor, Sub};
-
-use borrow::Borrow;
-use btree_map::{BTreeMap, Keys};
-use super::Recover;
-use range::RangeArgument;
-
-// FIXME(conventions): implement bounded iterators
-
-/// A set based on a B-Tree.
-///
-/// See [`BTreeMap`]'s documentation for a detailed discussion of this collection's performance
-/// benefits and drawbacks.
-///
-/// It is a logic error for an item to be modified in such a way that the item's ordering relative
-/// to any other item, as determined by the [`Ord`] trait, changes while it is in the set. This is
-/// normally only possible through [`Cell`], [`RefCell`], global state, I/O, or unsafe code.
-///
-/// [`BTreeMap`]: struct.BTreeMap.html
-/// [`Ord`]: ../../std/cmp/trait.Ord.html
-/// [`Cell`]: ../../std/cell/struct.Cell.html
-/// [`RefCell`]: ../../std/cell/struct.RefCell.html
-///
-/// # Examples
-///
-/// ```
-/// use std::collections::BTreeSet;
-///
-/// // Type inference lets us omit an explicit type signature (which
-/// // would be `BTreeSet<&str>` in this example).
-/// let mut books = BTreeSet::new();
-///
-/// // Add some books.
-/// books.insert("A Dance With Dragons");
-/// books.insert("To Kill a Mockingbird");
-/// books.insert("The Odyssey");
-/// books.insert("The Great Gatsby");
-///
-/// // Check for a specific one.
-/// if !books.contains("The Winds of Winter") {
-///     println!("We have {} books, but The Winds of Winter ain't one.",
-///              books.len());
-/// }
-///
-/// // Remove a book.
-/// books.remove("The Odyssey");
-///
-/// // Iterate over everything.
-/// for book in &books {
-///     println!("{}", book);
-/// }
-/// ```
-#[derive(Clone, Hash, PartialEq, Eq, Ord, PartialOrd)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct BTreeSet<T> {
-    map: BTreeMap<T, ()>,
-}
-
-/// An iterator over the items of a `BTreeSet`.
-///
-/// This `struct` is created by the [`iter`] method on [`BTreeSet`].
-/// See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`iter`]: struct.BTreeSet.html#method.iter
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
-    iter: Keys<'a, T, ()>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Iter")
-         .field(&self.iter.clone())
-         .finish()
-    }
-}
-
-/// An owning iterator over the items of a `BTreeSet`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`BTreeSet`][`BTreeSet`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`into_iter`]: struct.BTreeSet.html#method.into_iter
-#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Debug)]
-pub struct IntoIter<T> {
-    iter: ::btree_map::IntoIter<T, ()>,
-}
-
-/// An iterator over a sub-range of items in a `BTreeSet`.
-///
-/// This `struct` is created by the [`range`] method on [`BTreeSet`].
-/// See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`range`]: struct.BTreeSet.html#method.range
-#[derive(Debug)]
-#[stable(feature = "btree_range", since = "1.17.0")]
-pub struct Range<'a, T: 'a> {
-    iter: ::btree_map::Range<'a, T, ()>,
-}
-
-/// A lazy iterator producing elements in the difference of `BTreeSet`s.
-///
-/// This `struct` is created by the [`difference`] method on [`BTreeSet`].
-/// See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`difference`]: struct.BTreeSet.html#method.difference
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Difference<'a, T: 'a> {
-    a: Peekable<Iter<'a, T>>,
-    b: Peekable<Iter<'a, T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Difference<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Difference")
-         .field(&self.a)
-         .field(&self.b)
-         .finish()
-    }
-}
-
-/// A lazy iterator producing elements in the symmetric difference of `BTreeSet`s.
-///
-/// This `struct` is created by the [`symmetric_difference`] method on
-/// [`BTreeSet`]. See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`symmetric_difference`]: struct.BTreeSet.html#method.symmetric_difference
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct SymmetricDifference<'a, T: 'a> {
-    a: Peekable<Iter<'a, T>>,
-    b: Peekable<Iter<'a, T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for SymmetricDifference<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("SymmetricDifference")
-         .field(&self.a)
-         .field(&self.b)
-         .finish()
-    }
-}
-
-/// A lazy iterator producing elements in the intersection of `BTreeSet`s.
-///
-/// This `struct` is created by the [`intersection`] method on [`BTreeSet`].
-/// See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`intersection`]: struct.BTreeSet.html#method.intersection
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Intersection<'a, T: 'a> {
-    a: Peekable<Iter<'a, T>>,
-    b: Peekable<Iter<'a, T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Intersection<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Intersection")
-         .field(&self.a)
-         .field(&self.b)
-         .finish()
-    }
-}
-
-/// A lazy iterator producing elements in the union of `BTreeSet`s.
-///
-/// This `struct` is created by the [`union`] method on [`BTreeSet`].
-/// See its documentation for more.
-///
-/// [`BTreeSet`]: struct.BTreeSet.html
-/// [`union`]: struct.BTreeSet.html#method.union
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Union<'a, T: 'a> {
-    a: Peekable<Iter<'a, T>>,
-    b: Peekable<Iter<'a, T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Union<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Union")
-         .field(&self.a)
-         .field(&self.b)
-         .finish()
-    }
-}
-
-impl<T: Ord> BTreeSet<T> {
-    /// Makes a new `BTreeSet` with a reasonable choice of B.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![allow(unused_mut)]
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut set: BTreeSet<i32> = BTreeSet::new();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> BTreeSet<T> {
-        BTreeSet { map: BTreeMap::new() }
-    }
-}
-
-impl<T> BTreeSet<T> {
-    /// Gets an iterator that visits the values in the `BTreeSet` in ascending order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let set: BTreeSet<usize> = [1, 2, 3].iter().cloned().collect();
-    /// let mut set_iter = set.iter();
-    /// assert_eq!(set_iter.next(), Some(&1));
-    /// assert_eq!(set_iter.next(), Some(&2));
-    /// assert_eq!(set_iter.next(), Some(&3));
-    /// assert_eq!(set_iter.next(), None);
-    /// ```
-    ///
-    /// Values returned by the iterator are returned in ascending order:
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let set: BTreeSet<usize> = [3, 1, 2].iter().cloned().collect();
-    /// let mut set_iter = set.iter();
-    /// assert_eq!(set_iter.next(), Some(&1));
-    /// assert_eq!(set_iter.next(), Some(&2));
-    /// assert_eq!(set_iter.next(), Some(&3));
-    /// assert_eq!(set_iter.next(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter(&self) -> Iter<T> {
-        Iter { iter: self.map.keys() }
-    }
-}
-
-impl<T: Ord> BTreeSet<T> {
-    /// Constructs a double-ended iterator over a sub-range of elements in the set.
-    /// The simplest way is to use the range syntax `min..max`, thus `range(min..max)` will
-    /// yield elements from min (inclusive) to max (exclusive).
-    /// The range may also be entered as `(Bound<T>, Bound<T>)`, so for example
-    /// `range((Excluded(4), Included(10)))` will yield a left-exclusive, right-inclusive
-    /// range from 4 to 10.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    /// use std::collections::Bound::Included;
-    ///
-    /// let mut set = BTreeSet::new();
-    /// set.insert(3);
-    /// set.insert(5);
-    /// set.insert(8);
-    /// for &elem in set.range((Included(&4), Included(&8))) {
-    ///     println!("{}", elem);
-    /// }
-    /// assert_eq!(Some(&5), set.range(4..).next());
-    /// ```
-    #[stable(feature = "btree_range", since = "1.17.0")]
-    pub fn range<K: ?Sized, R>(&self, range: R) -> Range<T>
-        where K: Ord, T: Borrow<K>, R: RangeArgument<K>
-    {
-        Range { iter: self.map.range(range) }
-    }
-}
-
-impl<T: Ord> BTreeSet<T> {
-    /// Visits the values representing the difference,
-    /// i.e. the values that are in `self` but not in `other`,
-    /// in ascending order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut a = BTreeSet::new();
-    /// a.insert(1);
-    /// a.insert(2);
-    ///
-    /// let mut b = BTreeSet::new();
-    /// b.insert(2);
-    /// b.insert(3);
-    ///
-    /// let diff: Vec<_> = a.difference(&b).cloned().collect();
-    /// assert_eq!(diff, [1]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn difference<'a>(&'a self, other: &'a BTreeSet<T>) -> Difference<'a, T> {
-        Difference {
-            a: self.iter().peekable(),
-            b: other.iter().peekable(),
-        }
-    }
-
-    /// Visits the values representing the symmetric difference,
-    /// i.e. the values that are in `self` or in `other` but not in both,
-    /// in ascending order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut a = BTreeSet::new();
-    /// a.insert(1);
-    /// a.insert(2);
-    ///
-    /// let mut b = BTreeSet::new();
-    /// b.insert(2);
-    /// b.insert(3);
-    ///
-    /// let sym_diff: Vec<_> = a.symmetric_difference(&b).cloned().collect();
-    /// assert_eq!(sym_diff, [1, 3]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn symmetric_difference<'a>(&'a self,
-                                    other: &'a BTreeSet<T>)
-                                    -> SymmetricDifference<'a, T> {
-        SymmetricDifference {
-            a: self.iter().peekable(),
-            b: other.iter().peekable(),
-        }
-    }
-
-    /// Visits the values representing the intersection,
-    /// i.e. the values that are both in `self` and `other`,
-    /// in ascending order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut a = BTreeSet::new();
-    /// a.insert(1);
-    /// a.insert(2);
-    ///
-    /// let mut b = BTreeSet::new();
-    /// b.insert(2);
-    /// b.insert(3);
-    ///
-    /// let intersection: Vec<_> = a.intersection(&b).cloned().collect();
-    /// assert_eq!(intersection, [2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn intersection<'a>(&'a self, other: &'a BTreeSet<T>) -> Intersection<'a, T> {
-        Intersection {
-            a: self.iter().peekable(),
-            b: other.iter().peekable(),
-        }
-    }
-
-    /// Visits the values representing the union,
-    /// i.e. all the values in `self` or `other`, without duplicates,
-    /// in ascending order.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut a = BTreeSet::new();
-    /// a.insert(1);
-    ///
-    /// let mut b = BTreeSet::new();
-    /// b.insert(2);
-    ///
-    /// let union: Vec<_> = a.union(&b).cloned().collect();
-    /// assert_eq!(union, [1, 2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn union<'a>(&'a self, other: &'a BTreeSet<T>) -> Union<'a, T> {
-        Union {
-            a: self.iter().peekable(),
-            b: other.iter().peekable(),
-        }
-    }
-
-    /// Returns the number of elements in the set.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut v = BTreeSet::new();
-    /// assert_eq!(v.len(), 0);
-    /// v.insert(1);
-    /// assert_eq!(v.len(), 1);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.map.len()
-    }
-
-    /// Returns `true` if the set contains no elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut v = BTreeSet::new();
-    /// assert!(v.is_empty());
-    /// v.insert(1);
-    /// assert!(!v.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Clears the set, removing all values.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut v = BTreeSet::new();
-    /// v.insert(1);
-    /// v.clear();
-    /// assert!(v.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        self.map.clear()
-    }
-
-    /// Returns `true` if the set contains a value.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let set: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
-    /// assert_eq!(set.contains(&1), true);
-    /// assert_eq!(set.contains(&4), false);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains<Q: ?Sized>(&self, value: &Q) -> bool
-        where T: Borrow<Q>,
-              Q: Ord
-    {
-        self.map.contains_key(value)
-    }
-
-    /// Returns a reference to the value in the set, if any, that is equal to the given value.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
-    pub fn get<Q: ?Sized>(&self, value: &Q) -> Option<&T>
-        where T: Borrow<Q>,
-              Q: Ord
-    {
-        Recover::get(&self.map, value)
-    }
-
-    /// Returns `true` if `self` has no elements in common with `other`.
-    /// This is equivalent to checking for an empty intersection.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let a: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
-    /// let mut b = BTreeSet::new();
-    ///
-    /// assert_eq!(a.is_disjoint(&b), true);
-    /// b.insert(4);
-    /// assert_eq!(a.is_disjoint(&b), true);
-    /// b.insert(1);
-    /// assert_eq!(a.is_disjoint(&b), false);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_disjoint(&self, other: &BTreeSet<T>) -> bool {
-        self.intersection(other).next().is_none()
-    }
-
-    /// Returns `true` if the set is a subset of another,
-    /// i.e. `other` contains at least all the values in `self`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let sup: BTreeSet<_> = [1, 2, 3].iter().cloned().collect();
-    /// let mut set = BTreeSet::new();
-    ///
-    /// assert_eq!(set.is_subset(&sup), true);
-    /// set.insert(2);
-    /// assert_eq!(set.is_subset(&sup), true);
-    /// set.insert(4);
-    /// assert_eq!(set.is_subset(&sup), false);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_subset(&self, other: &BTreeSet<T>) -> bool {
-        // Stolen from TreeMap
-        let mut x = self.iter();
-        let mut y = other.iter();
-        let mut a = x.next();
-        let mut b = y.next();
-        while a.is_some() {
-            if b.is_none() {
-                return false;
-            }
-
-            let a1 = a.unwrap();
-            let b1 = b.unwrap();
-
-            match b1.cmp(a1) {
-                Less => (),
-                Greater => return false,
-                Equal => a = x.next(),
-            }
-
-            b = y.next();
-        }
-        true
-    }
-
-    /// Returns `true` if the set is a superset of another,
-    /// i.e. `self` contains at least all the values in `other`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let sub: BTreeSet<_> = [1, 2].iter().cloned().collect();
-    /// let mut set = BTreeSet::new();
-    ///
-    /// assert_eq!(set.is_superset(&sub), false);
-    ///
-    /// set.insert(0);
-    /// set.insert(1);
-    /// assert_eq!(set.is_superset(&sub), false);
-    ///
-    /// set.insert(2);
-    /// assert_eq!(set.is_superset(&sub), true);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_superset(&self, other: &BTreeSet<T>) -> bool {
-        other.is_subset(self)
-    }
-
-    /// Adds a value to the set.
-    ///
-    /// If the set did not have this value present, `true` is returned.
-    ///
-    /// If the set did have this value present, `false` is returned, and the
-    /// entry is not updated. See the [module-level documentation] for more.
-    ///
-    /// [module-level documentation]: index.html#insert-and-complex-keys
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut set = BTreeSet::new();
-    ///
-    /// assert_eq!(set.insert(2), true);
-    /// assert_eq!(set.insert(2), false);
-    /// assert_eq!(set.len(), 1);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, value: T) -> bool {
-        self.map.insert(value, ()).is_none()
-    }
-
-    /// Adds a value to the set, replacing the existing value, if any, that is equal to the given
-    /// one. Returns the replaced value.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
-    pub fn replace(&mut self, value: T) -> Option<T> {
-        Recover::replace(&mut self.map, value)
-    }
-
-    /// Removes a value from the set. Returns `true` if the value was
-    /// present in the set.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut set = BTreeSet::new();
-    ///
-    /// set.insert(2);
-    /// assert_eq!(set.remove(&2), true);
-    /// assert_eq!(set.remove(&2), false);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove<Q: ?Sized>(&mut self, value: &Q) -> bool
-        where T: Borrow<Q>,
-              Q: Ord
-    {
-        self.map.remove(value).is_some()
-    }
-
-    /// Removes and returns the value in the set, if any, that is equal to the given one.
-    ///
-    /// The value may be any borrowed form of the set's value type,
-    /// but the ordering on the borrowed form *must* match the
-    /// ordering on the value type.
-    #[stable(feature = "set_recovery", since = "1.9.0")]
-    pub fn take<Q: ?Sized>(&mut self, value: &Q) -> Option<T>
-        where T: Borrow<Q>,
-              Q: Ord
-    {
-        Recover::take(&mut self.map, value)
-    }
-
-    /// Moves all elements from `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let mut a = BTreeSet::new();
-    /// a.insert(1);
-    /// a.insert(2);
-    /// a.insert(3);
-    ///
-    /// let mut b = BTreeSet::new();
-    /// b.insert(3);
-    /// b.insert(4);
-    /// b.insert(5);
-    ///
-    /// a.append(&mut b);
-    ///
-    /// assert_eq!(a.len(), 5);
-    /// assert_eq!(b.len(), 0);
-    ///
-    /// assert!(a.contains(&1));
-    /// assert!(a.contains(&2));
-    /// assert!(a.contains(&3));
-    /// assert!(a.contains(&4));
-    /// assert!(a.contains(&5));
-    /// ```
-    #[stable(feature = "btree_append", since = "1.11.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        self.map.append(&mut other.map);
-    }
-
-    /// Splits the collection into two at the given key. Returns everything after the given key,
-    /// including the key.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::collections::BTreeMap;
-    ///
-    /// let mut a = BTreeMap::new();
-    /// a.insert(1, "a");
-    /// a.insert(2, "b");
-    /// a.insert(3, "c");
-    /// a.insert(17, "d");
-    /// a.insert(41, "e");
-    ///
-    /// let b = a.split_off(&3);
-    ///
-    /// assert_eq!(a.len(), 2);
-    /// assert_eq!(b.len(), 3);
-    ///
-    /// assert_eq!(a[&1], "a");
-    /// assert_eq!(a[&2], "b");
-    ///
-    /// assert_eq!(b[&3], "c");
-    /// assert_eq!(b[&17], "d");
-    /// assert_eq!(b[&41], "e");
-    /// ```
-    #[stable(feature = "btree_split_off", since = "1.11.0")]
-    pub fn split_off<Q: ?Sized + Ord>(&mut self, key: &Q) -> Self where T: Borrow<Q> {
-        BTreeSet { map: self.map.split_off(key) }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> FromIterator<T> for BTreeSet<T> {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> BTreeSet<T> {
-        let mut set = BTreeSet::new();
-        set.extend(iter);
-        set
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IntoIterator for BTreeSet<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    /// Gets an iterator for moving out the `BTreeSet`'s contents.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let set: BTreeSet<usize> = [1, 2, 3, 4].iter().cloned().collect();
-    ///
-    /// let v: Vec<_> = set.into_iter().collect();
-    /// assert_eq!(v, [1, 2, 3, 4]);
-    /// ```
-    fn into_iter(self) -> IntoIter<T> {
-        IntoIter { iter: self.map.into_iter() }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a BTreeSet<T> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Extend<T> for BTreeSet<T> {
-    #[inline]
-    fn extend<Iter: IntoIterator<Item = T>>(&mut self, iter: Iter) {
-        for elem in iter {
-            self.insert(elem);
-        }
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Ord + Copy> Extend<&'a T> for BTreeSet<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Default for BTreeSet<T> {
-    /// Makes an empty `BTreeSet<T>` with a reasonable choice of B.
-    fn default() -> BTreeSet<T> {
-        BTreeSet::new()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, T: Ord + Clone> Sub<&'b BTreeSet<T>> for &'a BTreeSet<T> {
-    type Output = BTreeSet<T>;
-
-    /// Returns the difference of `self` and `rhs` as a new `BTreeSet<T>`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
-    ///
-    /// let result = &a - &b;
-    /// let result_vec: Vec<_> = result.into_iter().collect();
-    /// assert_eq!(result_vec, [1, 2]);
-    /// ```
-    fn sub(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
-        self.difference(rhs).cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, T: Ord + Clone> BitXor<&'b BTreeSet<T>> for &'a BTreeSet<T> {
-    type Output = BTreeSet<T>;
-
-    /// Returns the symmetric difference of `self` and `rhs` as a new `BTreeSet<T>`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
-    ///
-    /// let result = &a ^ &b;
-    /// let result_vec: Vec<_> = result.into_iter().collect();
-    /// assert_eq!(result_vec, [1, 4]);
-    /// ```
-    fn bitxor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
-        self.symmetric_difference(rhs).cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, T: Ord + Clone> BitAnd<&'b BTreeSet<T>> for &'a BTreeSet<T> {
-    type Output = BTreeSet<T>;
-
-    /// Returns the intersection of `self` and `rhs` as a new `BTreeSet<T>`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<_> = vec![2, 3, 4].into_iter().collect();
-    ///
-    /// let result = &a & &b;
-    /// let result_vec: Vec<_> = result.into_iter().collect();
-    /// assert_eq!(result_vec, [2, 3]);
-    /// ```
-    fn bitand(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
-        self.intersection(rhs).cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, 'b, T: Ord + Clone> BitOr<&'b BTreeSet<T>> for &'a BTreeSet<T> {
-    type Output = BTreeSet<T>;
-
-    /// Returns the union of `self` and `rhs` as a new `BTreeSet<T>`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::BTreeSet;
-    ///
-    /// let a: BTreeSet<_> = vec![1, 2, 3].into_iter().collect();
-    /// let b: BTreeSet<_> = vec![3, 4, 5].into_iter().collect();
-    ///
-    /// let result = &a | &b;
-    /// let result_vec: Vec<_> = result.into_iter().collect();
-    /// assert_eq!(result_vec, [1, 2, 3, 4, 5]);
-    /// ```
-    fn bitor(self, rhs: &BTreeSet<T>) -> BTreeSet<T> {
-        self.union(rhs).cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Debug> Debug for BTreeSet<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_set().entries(self.iter()).finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Iter<'a, T> {
-    fn clone(&self) -> Iter<'a, T> {
-        Iter { iter: self.iter.clone() }
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        self.iter.next()
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
-    fn next_back(&mut self) -> Option<&'a T> {
-        self.iter.next_back()
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-    fn len(&self) -> usize { self.iter.len() }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Iter<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    fn next(&mut self) -> Option<T> {
-        self.iter.next().map(|(k, _)| k)
-    }
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    fn next_back(&mut self) -> Option<T> {
-        self.iter.next_back().map(|(k, _)| k)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn len(&self) -> usize { self.iter.len() }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<T> FusedIterator for IntoIter<T> {}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, T> Clone for Range<'a, T> {
-    fn clone(&self) -> Range<'a, T> {
-        Range { iter: self.iter.clone() }
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, T> Iterator for Range<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        self.iter.next().map(|(k, _)| k)
-    }
-}
-
-#[stable(feature = "btree_range", since = "1.17.0")]
-impl<'a, T> DoubleEndedIterator for Range<'a, T> {
-    fn next_back(&mut self) -> Option<&'a T> {
-        self.iter.next_back().map(|(k, _)| k)
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Range<'a, T> {}
-
-/// Compare `x` and `y`, but return `short` if x is None and `long` if y is None
-fn cmp_opt<T: Ord>(x: Option<&T>, y: Option<&T>, short: Ordering, long: Ordering) -> Ordering {
-    match (x, y) {
-        (None, _) => short,
-        (_, None) => long,
-        (Some(x1), Some(y1)) => x1.cmp(y1),
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Difference<'a, T> {
-    fn clone(&self) -> Difference<'a, T> {
-        Difference {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: Ord> Iterator for Difference<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Less, Less) {
-                Less => return self.a.next(),
-                Equal => {
-                    self.a.next();
-                    self.b.next();
-                }
-                Greater => {
-                    self.b.next();
-                }
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let a_len = self.a.len();
-        let b_len = self.b.len();
-        (a_len.saturating_sub(b_len), Some(a_len))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: Ord> FusedIterator for Difference<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for SymmetricDifference<'a, T> {
-    fn clone(&self) -> SymmetricDifference<'a, T> {
-        SymmetricDifference {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: Ord> Iterator for SymmetricDifference<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
-                Less => return self.a.next(),
-                Equal => {
-                    self.a.next();
-                    self.b.next();
-                }
-                Greater => return self.b.next(),
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(self.a.len() + self.b.len()))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: Ord> FusedIterator for SymmetricDifference<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Intersection<'a, T> {
-    fn clone(&self) -> Intersection<'a, T> {
-        Intersection {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: Ord> Iterator for Intersection<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        loop {
-            let o_cmp = match (self.a.peek(), self.b.peek()) {
-                (None, _) => None,
-                (_, None) => None,
-                (Some(a1), Some(b1)) => Some(a1.cmp(b1)),
-            };
-            match o_cmp {
-                None => return None,
-                Some(Less) => {
-                    self.a.next();
-                }
-                Some(Equal) => {
-                    self.b.next();
-                    return self.a.next();
-                }
-                Some(Greater) => {
-                    self.b.next();
-                }
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (0, Some(min(self.a.len(), self.b.len())))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: Ord> FusedIterator for Intersection<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Union<'a, T> {
-    fn clone(&self) -> Union<'a, T> {
-        Union {
-            a: self.a.clone(),
-            b: self.b.clone(),
-        }
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: Ord> Iterator for Union<'a, T> {
-    type Item = &'a T;
-
-    fn next(&mut self) -> Option<&'a T> {
-        loop {
-            match cmp_opt(self.a.peek(), self.b.peek(), Greater, Less) {
-                Less => return self.a.next(),
-                Equal => {
-                    self.b.next();
-                    return self.a.next();
-                }
-                Greater => return self.b.next(),
-            }
-        }
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let a_len = self.a.len();
-        let b_len = self.b.len();
-        (max(a_len, b_len), Some(a_len + b_len))
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: Ord> FusedIterator for Union<'a, T> {}
diff --git a/src/libcollections/fmt.rs b/src/libcollections/fmt.rs
deleted file mode 100644
index 62a88164621..00000000000
--- a/src/libcollections/fmt.rs
+++ /dev/null
@@ -1,535 +0,0 @@
-// Copyright 2013-2015 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.
-
-//! Utilities for formatting and printing `String`s
-//!
-//! This module contains the runtime support for the `format!` syntax extension.
-//! This macro is implemented in the compiler to emit calls to this module in
-//! order to format arguments at runtime into strings.
-//!
-//! # Usage
-//!
-//! The `format!` macro is intended to be familiar to those coming from C's
-//! printf/fprintf functions or Python's `str.format` function.
-//!
-//! Some examples of the `format!` extension are:
-//!
-//! ```
-//! format!("Hello");                 // => "Hello"
-//! format!("Hello, {}!", "world");   // => "Hello, world!"
-//! format!("The number is {}", 1);   // => "The number is 1"
-//! format!("{:?}", (3, 4));          // => "(3, 4)"
-//! format!("{value}", value=4);      // => "4"
-//! format!("{} {}", 1, 2);           // => "1 2"
-//! format!("{:04}", 42);             // => "0042" with leading zeros
-//! ```
-//!
-//! From these, you can see that the first argument is a format string. It is
-//! required by the compiler for this to be a string literal; it cannot be a
-//! variable passed in (in order to perform validity checking). The compiler
-//! will then parse the format string and determine if the list of arguments
-//! provided is suitable to pass to this format string.
-//!
-//! ## Positional parameters
-//!
-//! Each formatting argument is allowed to specify which value argument it's
-//! referencing, and if omitted it is assumed to be "the next argument". For
-//! example, the format string `{} {} {}` would take three parameters, and they
-//! would be formatted in the same order as they're given. The format string
-//! `{2} {1} {0}`, however, would format arguments in reverse order.
-//!
-//! Things can get a little tricky once you start intermingling the two types of
-//! positional specifiers. The "next argument" specifier can be thought of as an
-//! iterator over the argument. Each time a "next argument" specifier is seen,
-//! the iterator advances. This leads to behavior like this:
-//!
-//! ```
-//! format!("{1} {} {0} {}", 1, 2); // => "2 1 1 2"
-//! ```
-//!
-//! The internal iterator over the argument has not been advanced by the time
-//! the first `{}` is seen, so it prints the first argument. Then upon reaching
-//! the second `{}`, the iterator has advanced forward to the second argument.
-//! Essentially, parameters which explicitly name their argument do not affect
-//! parameters which do not name an argument in terms of positional specifiers.
-//!
-//! A format string is required to use all of its arguments, otherwise it is a
-//! compile-time error. You may refer to the same argument more than once in the
-//! format string.
-//!
-//! ## Named parameters
-//!
-//! Rust itself does not have a Python-like equivalent of named parameters to a
-//! function, but the `format!` macro is a syntax extension which allows it to
-//! leverage named parameters. Named parameters are listed at the end of the
-//! argument list and have the syntax:
-//!
-//! ```text
-//! identifier '=' expression
-//! ```
-//!
-//! For example, the following `format!` expressions all use named argument:
-//!
-//! ```
-//! format!("{argument}", argument = "test");   // => "test"
-//! format!("{name} {}", 1, name = 2);          // => "2 1"
-//! format!("{a} {c} {b}", a="a", b='b', c=3);  // => "a 3 b"
-//! ```
-//!
-//! It is not valid to put positional parameters (those without names) after
-//! arguments which have names. Like with positional parameters, it is not
-//! valid to provide named parameters that are unused by the format string.
-//!
-//! ## Argument types
-//!
-//! Each argument's type is dictated by the format string.
-//! There are various parameters which require a particular type, however.
-//! An example is the `{:.*}` syntax, which sets the number of decimal places
-//! in floating-point types:
-//!
-//! ```
-//! let formatted_number = format!("{:.*}", 2, 1.234567);
-//!
-//! assert_eq!("1.23", formatted_number)
-//! ```
-//!
-//! If this syntax is used, then the number of characters to print precedes the
-//! actual object being formatted, and the number of characters must have the
-//! type `usize`.
-//!
-//! ## Formatting traits
-//!
-//! When requesting that an argument be formatted with a particular type, you
-//! are actually requesting that an argument ascribes to a particular trait.
-//! This allows multiple actual types to be formatted via `{:x}` (like `i8` as
-//! well as `isize`).  The current mapping of types to traits is:
-//!
-//! * *nothing* ⇒ [`Display`](trait.Display.html)
-//! * `?` ⇒ [`Debug`](trait.Debug.html)
-//! * `o` ⇒ [`Octal`](trait.Octal.html)
-//! * `x` ⇒ [`LowerHex`](trait.LowerHex.html)
-//! * `X` ⇒ [`UpperHex`](trait.UpperHex.html)
-//! * `p` ⇒ [`Pointer`](trait.Pointer.html)
-//! * `b` ⇒ [`Binary`](trait.Binary.html)
-//! * `e` ⇒ [`LowerExp`](trait.LowerExp.html)
-//! * `E` ⇒ [`UpperExp`](trait.UpperExp.html)
-//!
-//! What this means is that any type of argument which implements the
-//! `fmt::Binary` trait can then be formatted with `{:b}`. Implementations
-//! are provided for these traits for a number of primitive types by the
-//! standard library as well. If no format is specified (as in `{}` or `{:6}`),
-//! then the format trait used is the `Display` trait.
-//!
-//! When implementing a format trait for your own type, you will have to
-//! implement a method of the signature:
-//!
-//! ```
-//! # #![allow(dead_code)]
-//! # use std::fmt;
-//! # struct Foo; // our custom type
-//! # impl fmt::Display for Foo {
-//! fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//! # write!(f, "testing, testing")
-//! # } }
-//! ```
-//!
-//! Your type will be passed as `self` by-reference, and then the function
-//! should emit output into the `f.buf` stream. It is up to each format trait
-//! implementation to correctly adhere to the requested formatting parameters.
-//! The values of these parameters will be listed in the fields of the
-//! `Formatter` struct. In order to help with this, the `Formatter` struct also
-//! provides some helper methods.
-//!
-//! Additionally, the return value of this function is `fmt::Result` which is a
-//! type alias of `Result<(), std::fmt::Error>`. Formatting implementations
-//! should ensure that they propagate errors from the `Formatter` (e.g., when
-//! calling `write!`) however, they should never return errors spuriously. That
-//! is, a formatting implementation must and may only return an error if the
-//! passed-in `Formatter` returns an error. This is because, contrary to what
-//! the function signature might suggest, string formatting is an infallible
-//! operation. This function only returns a result because writing to the
-//! underlying stream might fail and it must provide a way to propagate the fact
-//! that an error has occurred back up the stack.
-//!
-//! An example of implementing the formatting traits would look
-//! like:
-//!
-//! ```
-//! use std::fmt;
-//!
-//! #[derive(Debug)]
-//! struct Vector2D {
-//!     x: isize,
-//!     y: isize,
-//! }
-//!
-//! impl fmt::Display for Vector2D {
-//!     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//!         // The `f` value implements the `Write` trait, which is what the
-//!         // write! macro is expecting. Note that this formatting ignores the
-//!         // various flags provided to format strings.
-//!         write!(f, "({}, {})", self.x, self.y)
-//!     }
-//! }
-//!
-//! // Different traits allow different forms of output of a type. The meaning
-//! // of this format is to print the magnitude of a vector.
-//! impl fmt::Binary for Vector2D {
-//!     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-//!         let magnitude = (self.x * self.x + self.y * self.y) as f64;
-//!         let magnitude = magnitude.sqrt();
-//!
-//!         // Respect the formatting flags by using the helper method
-//!         // `pad_integral` on the Formatter object. See the method
-//!         // documentation for details, and the function `pad` can be used
-//!         // to pad strings.
-//!         let decimals = f.precision().unwrap_or(3);
-//!         let string = format!("{:.*}", decimals, magnitude);
-//!         f.pad_integral(true, "", &string)
-//!     }
-//! }
-//!
-//! fn main() {
-//!     let myvector = Vector2D { x: 3, y: 4 };
-//!
-//!     println!("{}", myvector);       // => "(3, 4)"
-//!     println!("{:?}", myvector);     // => "Vector2D {x: 3, y:4}"
-//!     println!("{:10.3b}", myvector); // => "     5.000"
-//! }
-//! ```
-//!
-//! ### `fmt::Display` vs `fmt::Debug`
-//!
-//! These two formatting traits have distinct purposes:
-//!
-//! - `fmt::Display` implementations assert that the type can be faithfully
-//!   represented as a UTF-8 string at all times. It is **not** expected that
-//!   all types implement the `Display` trait.
-//! - `fmt::Debug` implementations should be implemented for **all** public types.
-//!   Output will typically represent the internal state as faithfully as possible.
-//!   The purpose of the `Debug` trait is to facilitate debugging Rust code. In
-//!   most cases, using `#[derive(Debug)]` is sufficient and recommended.
-//!
-//! Some examples of the output from both traits:
-//!
-//! ```
-//! assert_eq!(format!("{} {:?}", 3, 4), "3 4");
-//! assert_eq!(format!("{} {:?}", 'a', 'b'), "a 'b'");
-//! assert_eq!(format!("{} {:?}", "foo\n", "bar\n"), "foo\n \"bar\\n\"");
-//! ```
-//!
-//! ## Related macros
-//!
-//! There are a number of related macros in the `format!` family. The ones that
-//! are currently implemented are:
-//!
-//! ```ignore
-//! format!      // described above
-//! write!       // first argument is a &mut io::Write, the destination
-//! writeln!     // same as write but appends a newline
-//! print!       // the format string is printed to the standard output
-//! println!     // same as print but appends a newline
-//! format_args! // described below.
-//! ```
-//!
-//! ### `write!`
-//!
-//! This and `writeln` are two macros which are used to emit the format string
-//! to a specified stream. This is used to prevent intermediate allocations of
-//! format strings and instead directly write the output. Under the hood, this
-//! function is actually invoking the `write_fmt` function defined on the
-//! `std::io::Write` trait. Example usage is:
-//!
-//! ```
-//! # #![allow(unused_must_use)]
-//! use std::io::Write;
-//! let mut w = Vec::new();
-//! write!(&mut w, "Hello {}!", "world");
-//! ```
-//!
-//! ### `print!`
-//!
-//! This and `println` emit their output to stdout. Similarly to the `write!`
-//! macro, the goal of these macros is to avoid intermediate allocations when
-//! printing output. Example usage is:
-//!
-//! ```
-//! print!("Hello {}!", "world");
-//! println!("I have a newline {}", "character at the end");
-//! ```
-//!
-//! ### `format_args!`
-//!
-//! This is a curious macro which is used to safely pass around
-//! an opaque object describing the format string. This object
-//! does not require any heap allocations to create, and it only
-//! references information on the stack. Under the hood, all of
-//! the related macros are implemented in terms of this. First
-//! off, some example usage is:
-//!
-//! ```
-//! # #![allow(unused_must_use)]
-//! use std::fmt;
-//! use std::io::{self, Write};
-//!
-//! let mut some_writer = io::stdout();
-//! write!(&mut some_writer, "{}", format_args!("print with a {}", "macro"));
-//!
-//! fn my_fmt_fn(args: fmt::Arguments) {
-//!     write!(&mut io::stdout(), "{}", args);
-//! }
-//! my_fmt_fn(format_args!(", or a {} too", "function"));
-//! ```
-//!
-//! The result of the `format_args!` macro is a value of type `fmt::Arguments`.
-//! This structure can then be passed to the `write` and `format` functions
-//! inside this module in order to process the format string.
-//! The goal of this macro is to even further prevent intermediate allocations
-//! when dealing formatting strings.
-//!
-//! For example, a logging library could use the standard formatting syntax, but
-//! it would internally pass around this structure until it has been determined
-//! where output should go to.
-//!
-//! # Syntax
-//!
-//! The syntax for the formatting language used is drawn from other languages,
-//! so it should not be too alien. Arguments are formatted with Python-like
-//! syntax, meaning that arguments are surrounded by `{}` instead of the C-like
-//! `%`. The actual grammar for the formatting syntax is:
-//!
-//! ```text
-//! format_string := <text> [ maybe-format <text> ] *
-//! maybe-format := '{' '{' | '}' '}' | <format>
-//! format := '{' [ argument ] [ ':' format_spec ] '}'
-//! argument := integer | identifier
-//!
-//! format_spec := [[fill]align][sign]['#']['0'][width]['.' precision][type]
-//! fill := character
-//! align := '<' | '^' | '>'
-//! sign := '+' | '-'
-//! width := count
-//! precision := count | '*'
-//! type := identifier | ''
-//! count := parameter | integer
-//! parameter := argument '$'
-//! ```
-//!
-//! # Formatting Parameters
-//!
-//! Each argument being formatted can be transformed by a number of formatting
-//! parameters (corresponding to `format_spec` in the syntax above). These
-//! parameters affect the string representation of what's being formatted. This
-//! syntax draws heavily from Python's, so it may seem a bit familiar.
-//!
-//! ## Fill/Alignment
-//!
-//! The fill character is provided normally in conjunction with the `width`
-//! parameter. This indicates that if the value being formatted is smaller than
-//! `width` some extra characters will be printed around it. The extra
-//! characters are specified by `fill`, and the alignment can be one of the
-//! following options:
-//!
-//! * `<` - the argument is left-aligned in `width` columns
-//! * `^` - the argument is center-aligned in `width` columns
-//! * `>` - the argument is right-aligned in `width` columns
-//!
-//! Note that alignment may not be implemented by some types. A good way
-//! to ensure padding is applied is to format your input, then use this
-//! resulting string to pad your output.
-//!
-//! ## Sign/`#`/`0`
-//!
-//! These can all be interpreted as flags for a particular formatter.
-//!
-//! * `+` - This is intended for numeric types and indicates that the sign
-//!         should always be printed. Positive signs are never printed by
-//!         default, and the negative sign is only printed by default for the
-//!         `Signed` trait. This flag indicates that the correct sign (`+` or `-`)
-//!         should always be printed.
-//! * `-` - Currently not used
-//! * `#` - This flag is indicates that the "alternate" form of printing should
-//!         be used. The alternate forms are:
-//!     * `#?` - pretty-print the `Debug` formatting
-//!     * `#x` - precedes the argument with a `0x`
-//!     * `#X` - precedes the argument with a `0x`
-//!     * `#b` - precedes the argument with a `0b`
-//!     * `#o` - precedes the argument with a `0o`
-//! * `0` - This is used to indicate for integer formats that the padding should
-//!         both be done with a `0` character as well as be sign-aware. A format
-//!         like `{:08}` would yield `00000001` for the integer `1`, while the
-//!         same format would yield `-0000001` for the integer `-1`. Notice that
-//!         the negative version has one fewer zero than the positive version.
-//!         Note that padding zeroes are always placed after the sign (if any)
-//!         and before the digits. When used together with the `#` flag, a similar
-//!         rule applies: padding zeroes are inserted after the prefix but before
-//!         the digits.
-//!
-//! ## Width
-//!
-//! This is a parameter for the "minimum width" that the format should take up.
-//! If the value's string does not fill up this many characters, then the
-//! padding specified by fill/alignment will be used to take up the required
-//! space.
-//!
-//! The default fill/alignment for non-numerics is a space and left-aligned. The
-//! defaults for numeric formatters is also a space but with right-alignment. If
-//! the `0` flag is specified for numerics, then the implicit fill character is
-//! `0`.
-//!
-//! The value for the width can also be provided as a `usize` in the list of
-//! parameters by using the dollar syntax indicating that the second argument is
-//! a `usize` specifying the width, for example:
-//!
-//! ```
-//! // All of these print "Hello x    !"
-//! println!("Hello {:5}!", "x");
-//! println!("Hello {:1$}!", "x", 5);
-//! println!("Hello {1:0$}!", 5, "x");
-//! println!("Hello {:width$}!", "x", width = 5);
-//! ```
-//!
-//! Referring to an argument with the dollar syntax does not affect the "next
-//! argument" counter, so it's usually a good idea to refer to arguments by
-//! position, or use named arguments.
-//!
-//! ## Precision
-//!
-//! For non-numeric types, this can be considered a "maximum width". If the resulting string is
-//! longer than this width, then it is truncated down to this many characters and that truncated
-//! value is emitted with proper `fill`, `alignment` and `width` if those parameters are set.
-//!
-//! For integral types, this is ignored.
-//!
-//! For floating-point types, this indicates how many digits after the decimal point should be
-//! printed.
-//!
-//! There are three possible ways to specify the desired `precision`:
-//!
-//! 1. An integer `.N`:
-//!
-//!    the integer `N` itself is the precision.
-//!
-//! 2. An integer or name followed by dollar sign `.N$`:
-//!
-//!    use format *argument* `N` (which must be a `usize`) as the precision.
-//!
-//! 3. An asterisk `.*`:
-//!
-//!    `.*` means that this `{...}` is associated with *two* format inputs rather than one: the
-//!    first input holds the `usize` precision, and the second holds the value to print.  Note that
-//!    in this case, if one uses the format string `{<arg>:<spec>.*}`, then the `<arg>` part refers
-//!    to the *value* to print, and the `precision` must come in the input preceding `<arg>`.
-//!
-//! For example, the following calls all print the same thing `Hello x is 0.01000`:
-//!
-//! ```
-//! // Hello {arg 0 ("x")} is {arg 1 (0.01) with precision specified inline (5)}
-//! println!("Hello {0} is {1:.5}", "x", 0.01);
-//!
-//! // Hello {arg 1 ("x")} is {arg 2 (0.01) with precision specified in arg 0 (5)}
-//! println!("Hello {1} is {2:.0$}", 5, "x", 0.01);
-//!
-//! // Hello {arg 0 ("x")} is {arg 2 (0.01) with precision specified in arg 1 (5)}
-//! println!("Hello {0} is {2:.1$}", "x", 5, 0.01);
-//!
-//! // Hello {next arg ("x")} is {second of next two args (0.01) with precision
-//! //                          specified in first of next two args (5)}
-//! println!("Hello {} is {:.*}",    "x", 5, 0.01);
-//!
-//! // Hello {next arg ("x")} is {arg 2 (0.01) with precision
-//! //                          specified in its predecessor (5)}
-//! println!("Hello {} is {2:.*}",   "x", 5, 0.01);
-//!
-//! // Hello {next arg ("x")} is {arg "number" (0.01) with precision specified
-//! //                          in arg "prec" (5)}
-//! println!("Hello {} is {number:.prec$}", "x", prec = 5, number = 0.01);
-//! ```
-//!
-//! While these:
-//!
-//! ```
-//! println!("{}, `{name:.*}` has 3 fractional digits", "Hello", 3, name=1234.56);
-//! println!("{}, `{name:.*}` has 3 characters", "Hello", 3, name="1234.56");
-//! println!("{}, `{name:>8.*}` has 3 right-aligned characters", "Hello", 3, name="1234.56");
-//! ```
-//!
-//! print two significantly different things:
-//!
-//! ```text
-//! Hello, `1234.560` has 3 fractional digits
-//! Hello, `123` has 3 characters
-//! Hello, `     123` has 3 right-aligned characters
-//! ```
-//!
-//! # Escaping
-//!
-//! The literal characters `{` and `}` may be included in a string by preceding
-//! them with the same character. For example, the `{` character is escaped with
-//! `{{` and the `}` character is escaped with `}}`.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-#[unstable(feature = "fmt_internals", issue = "0")]
-pub use core::fmt::rt;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{Formatter, Result, Write};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{Octal, Binary};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{Display, Debug};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{LowerHex, UpperHex, Pointer};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{LowerExp, UpperExp};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::Error;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{ArgumentV1, Arguments, write};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::fmt::{DebugList, DebugMap, DebugSet, DebugStruct, DebugTuple};
-
-use string;
-
-/// The format function takes a precompiled format string and a list of
-/// arguments, to return the resulting formatted string.
-///
-/// # Arguments
-///
-///   * args - a structure of arguments generated via the `format_args!` macro.
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// use std::fmt;
-///
-/// let s = fmt::format(format_args!("Hello, {}!", "world"));
-/// assert_eq!(s, "Hello, world!");
-/// ```
-///
-/// Please note that using [`format!`][format!] might be preferrable.
-/// Example:
-///
-/// ```
-/// let s = format!("Hello, {}!", "world");
-/// assert_eq!(s, "Hello, world!");
-/// ```
-///
-/// [format!]: ../macro.format.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub fn format(args: Arguments) -> string::String {
-    let capacity = args.estimated_capacity();
-    let mut output = string::String::with_capacity(capacity);
-    output.write_fmt(args)
-          .expect("a formatting trait implementation returned an error");
-    output
-}
diff --git a/src/libcollections/lib.rs b/src/libcollections/lib.rs
deleted file mode 100644
index 34626326c22..00000000000
--- a/src/libcollections/lib.rs
+++ /dev/null
@@ -1,192 +0,0 @@
-// Copyright 2013-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.
-
-//! Collection types.
-//!
-//! See [`std::collections`](../std/collections/index.html) for a detailed
-//! discussion of collections in Rust.
-
-#![crate_name = "collections"]
-#![crate_type = "rlib"]
-#![unstable(feature = "collections",
-            reason = "library is unlikely to be stabilized with the current \
-                      layout and name, use std::collections instead",
-            issue = "27783")]
-#![doc(html_logo_url = "https://www.rust-lang.org/logos/rust-logo-128x128-blk-v2.png",
-       html_favicon_url = "https://doc.rust-lang.org/favicon.ico",
-       html_root_url = "https://doc.rust-lang.org/nightly/",
-       html_playground_url = "https://play.rust-lang.org/",
-       issue_tracker_base_url = "https://github.com/rust-lang/rust/issues/",
-       test(no_crate_inject, attr(allow(unused_variables), deny(warnings))))]
-
-#![cfg_attr(test, allow(deprecated))] // rand
-#![deny(warnings)]
-#![deny(missing_debug_implementations)]
-
-#![feature(alloc)]
-#![feature(allow_internal_unstable)]
-#![feature(box_patterns)]
-#![feature(box_syntax)]
-#![cfg_attr(not(test), feature(char_escape_debug))]
-#![cfg_attr(not(test), feature(core_float))]
-#![feature(core_intrinsics)]
-#![feature(dropck_eyepatch)]
-#![feature(exact_size_is_empty)]
-#![feature(fmt_internals)]
-#![feature(fused)]
-#![feature(generic_param_attrs)]
-#![feature(heap_api)]
-#![feature(i128_type)]
-#![feature(inclusive_range)]
-#![feature(lang_items)]
-#![feature(manually_drop)]
-#![feature(nonzero)]
-#![feature(pattern)]
-#![feature(placement_in)]
-#![feature(placement_in_syntax)]
-#![feature(placement_new_protocol)]
-#![feature(shared)]
-#![feature(slice_get_slice)]
-#![feature(slice_patterns)]
-#![cfg_attr(not(test), feature(slice_rotate))]
-#![feature(slice_rsplit)]
-#![cfg_attr(not(test), feature(sort_unstable))]
-#![feature(specialization)]
-#![feature(staged_api)]
-#![feature(str_internals)]
-#![feature(str_box_extras)]
-#![feature(str_mut_extras)]
-#![feature(trusted_len)]
-#![feature(unicode)]
-#![feature(unique)]
-#![cfg_attr(not(test), feature(str_checked_slicing))]
-#![cfg_attr(test, feature(rand, test))]
-#![feature(offset_to)]
-
-#![no_std]
-
-extern crate std_unicode;
-extern crate alloc;
-
-#[cfg(test)]
-#[macro_use]
-extern crate std;
-#[cfg(test)]
-extern crate test;
-
-#[doc(no_inline)]
-pub use binary_heap::BinaryHeap;
-#[doc(no_inline)]
-pub use btree_map::BTreeMap;
-#[doc(no_inline)]
-pub use btree_set::BTreeSet;
-#[doc(no_inline)]
-pub use linked_list::LinkedList;
-#[doc(no_inline)]
-pub use vec_deque::VecDeque;
-#[doc(no_inline)]
-pub use string::String;
-#[doc(no_inline)]
-pub use vec::Vec;
-
-// Needed for the vec! macro
-pub use alloc::boxed;
-
-#[macro_use]
-mod macros;
-
-pub mod binary_heap;
-mod btree;
-pub mod borrow;
-pub mod fmt;
-pub mod linked_list;
-pub mod range;
-pub mod slice;
-pub mod str;
-pub mod string;
-pub mod vec;
-pub mod vec_deque;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod btree_map {
-    //! A map based on a B-Tree.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub use btree::map::*;
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub mod btree_set {
-    //! A set based on a B-Tree.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub use btree::set::*;
-}
-
-#[cfg(not(test))]
-mod std {
-    pub use core::ops;      // RangeFull
-}
-
-/// An endpoint of a range of keys.
-///
-/// # Examples
-///
-/// `Bound`s are range endpoints:
-///
-/// ```
-/// #![feature(collections_range)]
-///
-/// use std::collections::range::RangeArgument;
-/// use std::collections::Bound::*;
-///
-/// assert_eq!((..100).start(), Unbounded);
-/// assert_eq!((1..12).start(), Included(&1));
-/// assert_eq!((1..12).end(), Excluded(&12));
-/// ```
-///
-/// Using a tuple of `Bound`s as an argument to [`BTreeMap::range`].
-/// Note that in most cases, it's better to use range syntax (`1..5`) instead.
-///
-/// ```
-/// use std::collections::BTreeMap;
-/// use std::collections::Bound::{Excluded, Included, Unbounded};
-///
-/// let mut map = BTreeMap::new();
-/// map.insert(3, "a");
-/// map.insert(5, "b");
-/// map.insert(8, "c");
-///
-/// for (key, value) in map.range((Excluded(3), Included(8))) {
-///     println!("{}: {}", key, value);
-/// }
-///
-/// assert_eq!(Some((&3, &"a")), map.range((Unbounded, Included(5))).next());
-/// ```
-///
-/// [`BTreeMap::range`]: btree_map/struct.BTreeMap.html#method.range
-#[stable(feature = "collections_bound", since = "1.17.0")]
-#[derive(Clone, Copy, Debug, Hash, PartialEq, Eq)]
-pub enum Bound<T> {
-    /// An inclusive bound.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Included(T),
-    /// An exclusive bound.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Excluded(T),
-    /// An infinite endpoint. Indicates that there is no bound in this direction.
-    #[stable(feature = "collections_bound", since = "1.17.0")]
-    Unbounded,
-}
-
-/// An intermediate trait for specialization of `Extend`.
-#[doc(hidden)]
-trait SpecExtend<I: IntoIterator> {
-    /// Extends `self` with the contents of the given iterator.
-    fn spec_extend(&mut self, iter: I);
-}
diff --git a/src/libcollections/linked_list.rs b/src/libcollections/linked_list.rs
deleted file mode 100644
index ae258083546..00000000000
--- a/src/libcollections/linked_list.rs
+++ /dev/null
@@ -1,1504 +0,0 @@
-// Copyright 2012-2015 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.
-
-//! A doubly-linked list with owned nodes.
-//!
-//! The `LinkedList` allows pushing and popping elements at either end
-//! in constant time.
-//!
-//! Almost always it is better to use `Vec` or [`VecDeque`] instead of
-//! [`LinkedList`]. In general, array-based containers are faster,
-//! more memory efficient and make better use of CPU cache.
-//!
-//! [`LinkedList`]: ../linked_list/struct.LinkedList.html
-//! [`VecDeque`]: ../vec_deque/struct.VecDeque.html
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use alloc::boxed::{Box, IntermediateBox};
-use core::cmp::Ordering;
-use core::fmt;
-use core::hash::{Hasher, Hash};
-use core::iter::{FromIterator, FusedIterator};
-use core::marker::PhantomData;
-use core::mem;
-use core::ops::{BoxPlace, InPlace, Place, Placer};
-use core::ptr::{self, Shared};
-
-use super::SpecExtend;
-
-/// A doubly-linked list with owned nodes.
-///
-/// The `LinkedList` allows pushing and popping elements at either end
-/// in constant time.
-///
-/// Almost always it is better to use `Vec` or `VecDeque` instead of
-/// `LinkedList`. In general, array-based containers are faster,
-/// more memory efficient and make better use of CPU cache.
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct LinkedList<T> {
-    head: Option<Shared<Node<T>>>,
-    tail: Option<Shared<Node<T>>>,
-    len: usize,
-    marker: PhantomData<Box<Node<T>>>,
-}
-
-struct Node<T> {
-    next: Option<Shared<Node<T>>>,
-    prev: Option<Shared<Node<T>>>,
-    element: T,
-}
-
-/// An iterator over the elements of a `LinkedList`.
-///
-/// This `struct` is created by the [`iter`] method on [`LinkedList`]. See its
-/// documentation for more.
-///
-/// [`iter`]: struct.LinkedList.html#method.iter
-/// [`LinkedList`]: struct.LinkedList.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
-    head: Option<Shared<Node<T>>>,
-    tail: Option<Shared<Node<T>>>,
-    len: usize,
-    marker: PhantomData<&'a Node<T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Iter")
-         .field(&self.len)
-         .finish()
-    }
-}
-
-// FIXME #19839: deriving is too aggressive on the bounds (T doesn't need to be Clone).
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Iter<'a, T> {
-    fn clone(&self) -> Self {
-        Iter { ..*self }
-    }
-}
-
-/// A mutable iterator over the elements of a `LinkedList`.
-///
-/// This `struct` is created by the [`iter_mut`] method on [`LinkedList`]. See its
-/// documentation for more.
-///
-/// [`iter_mut`]: struct.LinkedList.html#method.iter_mut
-/// [`LinkedList`]: struct.LinkedList.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IterMut<'a, T: 'a> {
-    list: &'a mut LinkedList<T>,
-    head: Option<Shared<Node<T>>>,
-    tail: Option<Shared<Node<T>>>,
-    len: usize,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IterMut")
-         .field(&self.list)
-         .field(&self.len)
-         .finish()
-    }
-}
-
-/// An owning iterator over the elements of a `LinkedList`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`LinkedList`][`LinkedList`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`into_iter`]: struct.LinkedList.html#method.into_iter
-/// [`LinkedList`]: struct.LinkedList.html
-#[derive(Clone)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<T> {
-    list: LinkedList<T>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IntoIter")
-         .field(&self.list)
-         .finish()
-    }
-}
-
-impl<T> Node<T> {
-    fn new(element: T) -> Self {
-        Node {
-            next: None,
-            prev: None,
-            element: element,
-        }
-    }
-
-    fn into_element(self: Box<Self>) -> T {
-        self.element
-    }
-}
-
-// private methods
-impl<T> LinkedList<T> {
-    /// Adds the given node to the front of the list.
-    #[inline]
-    fn push_front_node(&mut self, mut node: Box<Node<T>>) {
-        unsafe {
-            node.next = self.head;
-            node.prev = None;
-            let node = Some(Shared::new(Box::into_raw(node)));
-
-            match self.head {
-                None => self.tail = node,
-                Some(mut head) => head.as_mut().prev = node,
-            }
-
-            self.head = node;
-            self.len += 1;
-        }
-    }
-
-    /// Removes and returns the node at the front of the list.
-    #[inline]
-    fn pop_front_node(&mut self) -> Option<Box<Node<T>>> {
-        self.head.map(|node| unsafe {
-            let node = Box::from_raw(node.as_ptr());
-            self.head = node.next;
-
-            match self.head {
-                None => self.tail = None,
-                Some(mut head) => head.as_mut().prev = None,
-            }
-
-            self.len -= 1;
-            node
-        })
-    }
-
-    /// Adds the given node to the back of the list.
-    #[inline]
-    fn push_back_node(&mut self, mut node: Box<Node<T>>) {
-        unsafe {
-            node.next = None;
-            node.prev = self.tail;
-            let node = Some(Shared::new(Box::into_raw(node)));
-
-            match self.tail {
-                None => self.head = node,
-                Some(mut tail) => tail.as_mut().next = node,
-            }
-
-            self.tail = node;
-            self.len += 1;
-        }
-    }
-
-    /// Removes and returns the node at the back of the list.
-    #[inline]
-    fn pop_back_node(&mut self) -> Option<Box<Node<T>>> {
-        self.tail.map(|node| unsafe {
-            let node = Box::from_raw(node.as_ptr());
-            self.tail = node.prev;
-
-            match self.tail {
-                None => self.head = None,
-                Some(mut tail) => tail.as_mut().next = None,
-            }
-
-            self.len -= 1;
-            node
-        })
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for LinkedList<T> {
-    /// Creates an empty `LinkedList<T>`.
-    #[inline]
-    fn default() -> Self {
-        Self::new()
-    }
-}
-
-impl<T> LinkedList<T> {
-    /// Creates an empty `LinkedList`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let list: LinkedList<u32> = LinkedList::new();
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> Self {
-        LinkedList {
-            head: None,
-            tail: None,
-            len: 0,
-            marker: PhantomData,
-        }
-    }
-
-    /// Moves all elements from `other` to the end of the list.
-    ///
-    /// This reuses all the nodes from `other` and moves them into `self`. After
-    /// this operation, `other` becomes empty.
-    ///
-    /// This operation should compute in O(1) time and O(1) memory.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list1 = LinkedList::new();
-    /// list1.push_back('a');
-    ///
-    /// let mut list2 = LinkedList::new();
-    /// list2.push_back('b');
-    /// list2.push_back('c');
-    ///
-    /// list1.append(&mut list2);
-    ///
-    /// let mut iter = list1.iter();
-    /// assert_eq!(iter.next(), Some(&'a'));
-    /// assert_eq!(iter.next(), Some(&'b'));
-    /// assert_eq!(iter.next(), Some(&'c'));
-    /// assert!(iter.next().is_none());
-    ///
-    /// assert!(list2.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        match self.tail {
-            None => mem::swap(self, other),
-            Some(mut tail) => {
-                if let Some(mut other_head) = other.head.take() {
-                    unsafe {
-                        tail.as_mut().next = Some(other_head);
-                        other_head.as_mut().prev = Some(tail);
-                    }
-
-                    self.tail = other.tail.take();
-                    self.len += mem::replace(&mut other.len, 0);
-                }
-            }
-        }
-    }
-
-    /// Provides a forward iterator.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list: LinkedList<u32> = LinkedList::new();
-    ///
-    /// list.push_back(0);
-    /// list.push_back(1);
-    /// list.push_back(2);
-    ///
-    /// let mut iter = list.iter();
-    /// assert_eq!(iter.next(), Some(&0));
-    /// assert_eq!(iter.next(), Some(&1));
-    /// assert_eq!(iter.next(), Some(&2));
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter(&self) -> Iter<T> {
-        Iter {
-            head: self.head,
-            tail: self.tail,
-            len: self.len,
-            marker: PhantomData,
-        }
-    }
-
-    /// Provides a forward iterator with mutable references.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list: LinkedList<u32> = LinkedList::new();
-    ///
-    /// list.push_back(0);
-    /// list.push_back(1);
-    /// list.push_back(2);
-    ///
-    /// for element in list.iter_mut() {
-    ///     *element += 10;
-    /// }
-    ///
-    /// let mut iter = list.iter();
-    /// assert_eq!(iter.next(), Some(&10));
-    /// assert_eq!(iter.next(), Some(&11));
-    /// assert_eq!(iter.next(), Some(&12));
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter_mut(&mut self) -> IterMut<T> {
-        IterMut {
-            head: self.head,
-            tail: self.tail,
-            len: self.len,
-            list: self,
-        }
-    }
-
-    /// Returns `true` if the `LinkedList` is empty.
-    ///
-    /// This operation should compute in O(1) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    /// assert!(dl.is_empty());
-    ///
-    /// dl.push_front("foo");
-    /// assert!(!dl.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.head.is_none()
-    }
-
-    /// Returns the length of the `LinkedList`.
-    ///
-    /// This operation should compute in O(1) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    ///
-    /// dl.push_front(2);
-    /// assert_eq!(dl.len(), 1);
-    ///
-    /// dl.push_front(1);
-    /// assert_eq!(dl.len(), 2);
-    ///
-    /// dl.push_back(3);
-    /// assert_eq!(dl.len(), 3);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Removes all elements from the `LinkedList`.
-    ///
-    /// This operation should compute in O(n) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    ///
-    /// dl.push_front(2);
-    /// dl.push_front(1);
-    /// assert_eq!(dl.len(), 2);
-    /// assert_eq!(dl.front(), Some(&1));
-    ///
-    /// dl.clear();
-    /// assert_eq!(dl.len(), 0);
-    /// assert_eq!(dl.front(), None);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        *self = Self::new();
-    }
-
-    /// Returns `true` if the `LinkedList` contains an element equal to the
-    /// given value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list: LinkedList<u32> = LinkedList::new();
-    ///
-    /// list.push_back(0);
-    /// list.push_back(1);
-    /// list.push_back(2);
-    ///
-    /// assert_eq!(list.contains(&0), true);
-    /// assert_eq!(list.contains(&10), false);
-    /// ```
-    #[stable(feature = "linked_list_contains", since = "1.12.0")]
-    pub fn contains(&self, x: &T) -> bool
-        where T: PartialEq<T>
-    {
-        self.iter().any(|e| e == x)
-    }
-
-    /// Provides a reference to the front element, or `None` if the list is
-    /// empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    /// assert_eq!(dl.front(), None);
-    ///
-    /// dl.push_front(1);
-    /// assert_eq!(dl.front(), Some(&1));
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn front(&self) -> Option<&T> {
-        unsafe {
-            self.head.as_ref().map(|node| &node.as_ref().element)
-        }
-    }
-
-    /// Provides a mutable reference to the front element, or `None` if the list
-    /// is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    /// assert_eq!(dl.front(), None);
-    ///
-    /// dl.push_front(1);
-    /// assert_eq!(dl.front(), Some(&1));
-    ///
-    /// match dl.front_mut() {
-    ///     None => {},
-    ///     Some(x) => *x = 5,
-    /// }
-    /// assert_eq!(dl.front(), Some(&5));
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn front_mut(&mut self) -> Option<&mut T> {
-        unsafe {
-            self.head.as_mut().map(|node| &mut node.as_mut().element)
-        }
-    }
-
-    /// Provides a reference to the back element, or `None` if the list is
-    /// empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    /// assert_eq!(dl.back(), None);
-    ///
-    /// dl.push_back(1);
-    /// assert_eq!(dl.back(), Some(&1));
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn back(&self) -> Option<&T> {
-        unsafe {
-            self.tail.as_ref().map(|node| &node.as_ref().element)
-        }
-    }
-
-    /// Provides a mutable reference to the back element, or `None` if the list
-    /// is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    /// assert_eq!(dl.back(), None);
-    ///
-    /// dl.push_back(1);
-    /// assert_eq!(dl.back(), Some(&1));
-    ///
-    /// match dl.back_mut() {
-    ///     None => {},
-    ///     Some(x) => *x = 5,
-    /// }
-    /// assert_eq!(dl.back(), Some(&5));
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn back_mut(&mut self) -> Option<&mut T> {
-        unsafe {
-            self.tail.as_mut().map(|node| &mut node.as_mut().element)
-        }
-    }
-
-    /// Adds an element first in the list.
-    ///
-    /// This operation should compute in O(1) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut dl = LinkedList::new();
-    ///
-    /// dl.push_front(2);
-    /// assert_eq!(dl.front().unwrap(), &2);
-    ///
-    /// dl.push_front(1);
-    /// assert_eq!(dl.front().unwrap(), &1);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_front(&mut self, elt: T) {
-        self.push_front_node(box Node::new(elt));
-    }
-
-    /// Removes the first element and returns it, or `None` if the list is
-    /// empty.
-    ///
-    /// This operation should compute in O(1) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut d = LinkedList::new();
-    /// assert_eq!(d.pop_front(), None);
-    ///
-    /// d.push_front(1);
-    /// d.push_front(3);
-    /// assert_eq!(d.pop_front(), Some(3));
-    /// assert_eq!(d.pop_front(), Some(1));
-    /// assert_eq!(d.pop_front(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop_front(&mut self) -> Option<T> {
-        self.pop_front_node().map(Node::into_element)
-    }
-
-    /// Appends an element to the back of a list
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut d = LinkedList::new();
-    /// d.push_back(1);
-    /// d.push_back(3);
-    /// assert_eq!(3, *d.back().unwrap());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_back(&mut self, elt: T) {
-        self.push_back_node(box Node::new(elt));
-    }
-
-    /// Removes the last element from a list and returns it, or `None` if
-    /// it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut d = LinkedList::new();
-    /// assert_eq!(d.pop_back(), None);
-    /// d.push_back(1);
-    /// d.push_back(3);
-    /// assert_eq!(d.pop_back(), Some(3));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop_back(&mut self) -> Option<T> {
-        self.pop_back_node().map(Node::into_element)
-    }
-
-    /// Splits the list into two at the given index. Returns everything after the given index,
-    /// including the index.
-    ///
-    /// This operation should compute in O(n) time.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut d = LinkedList::new();
-    ///
-    /// d.push_front(1);
-    /// d.push_front(2);
-    /// d.push_front(3);
-    ///
-    /// let mut splitted = d.split_off(2);
-    ///
-    /// assert_eq!(splitted.pop_front(), Some(1));
-    /// assert_eq!(splitted.pop_front(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn split_off(&mut self, at: usize) -> LinkedList<T> {
-        let len = self.len();
-        assert!(at <= len, "Cannot split off at a nonexistent index");
-        if at == 0 {
-            return mem::replace(self, Self::new());
-        } else if at == len {
-            return Self::new();
-        }
-
-        // Below, we iterate towards the `i-1`th node, either from the start or the end,
-        // depending on which would be faster.
-        let split_node = if at - 1 <= len - 1 - (at - 1) {
-            let mut iter = self.iter_mut();
-            // instead of skipping using .skip() (which creates a new struct),
-            // we skip manually so we can access the head field without
-            // depending on implementation details of Skip
-            for _ in 0..at - 1 {
-                iter.next();
-            }
-            iter.head
-        } else {
-            // better off starting from the end
-            let mut iter = self.iter_mut();
-            for _ in 0..len - 1 - (at - 1) {
-                iter.next_back();
-            }
-            iter.tail
-        };
-
-        // The split node is the new tail node of the first part and owns
-        // the head of the second part.
-        let second_part_head;
-
-        unsafe {
-            second_part_head = split_node.unwrap().as_mut().next.take();
-            if let Some(mut head) = second_part_head {
-                head.as_mut().prev = None;
-            }
-        }
-
-        let second_part = LinkedList {
-            head: second_part_head,
-            tail: self.tail,
-            len: len - at,
-            marker: PhantomData,
-        };
-
-        // Fix the tail ptr of the first part
-        self.tail = split_node;
-        self.len = at;
-
-        second_part
-    }
-
-    /// Returns a place for insertion at the front of the list.
-    ///
-    /// Using this method with placement syntax is equivalent to
-    /// [`push_front`](#method.push_front), but may be more efficient.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collection_placement)]
-    /// #![feature(placement_in_syntax)]
-    ///
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list = LinkedList::new();
-    /// list.front_place() <- 2;
-    /// list.front_place() <- 4;
-    /// assert!(list.iter().eq(&[4, 2]));
-    /// ```
-    #[unstable(feature = "collection_placement",
-               reason = "method name and placement protocol are subject to change",
-               issue = "30172")]
-    pub fn front_place(&mut self) -> FrontPlace<T> {
-        FrontPlace {
-            list: self,
-            node: IntermediateBox::make_place(),
-        }
-    }
-
-    /// Returns a place for insertion at the back of the list.
-    ///
-    /// Using this method with placement syntax is equivalent to [`push_back`](#method.push_back),
-    /// but may be more efficient.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collection_placement)]
-    /// #![feature(placement_in_syntax)]
-    ///
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list = LinkedList::new();
-    /// list.back_place() <- 2;
-    /// list.back_place() <- 4;
-    /// assert!(list.iter().eq(&[2, 4]));
-    /// ```
-    #[unstable(feature = "collection_placement",
-               reason = "method name and placement protocol are subject to change",
-               issue = "30172")]
-    pub fn back_place(&mut self) -> BackPlace<T> {
-        BackPlace {
-            list: self,
-            node: IntermediateBox::make_place(),
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for LinkedList<T> {
-    fn drop(&mut self) {
-        while let Some(_) = self.pop_front_node() {}
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a T> {
-        if self.len == 0 {
-            None
-        } else {
-            self.head.map(|node| unsafe {
-                // Need an unbound lifetime to get 'a
-                let node = &*node.as_ptr();
-                self.len -= 1;
-                self.head = node.next;
-                &node.element
-            })
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a T> {
-        if self.len == 0 {
-            None
-        } else {
-            self.tail.map(|node| unsafe {
-                // Need an unbound lifetime to get 'a
-                let node = &*node.as_ptr();
-                self.len -= 1;
-                self.tail = node.prev;
-                &node.element
-            })
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Iter<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for IterMut<'a, T> {
-    type Item = &'a mut T;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a mut T> {
-        if self.len == 0 {
-            None
-        } else {
-            self.head.map(|node| unsafe {
-                // Need an unbound lifetime to get 'a
-                let node = &mut *node.as_ptr();
-                self.len -= 1;
-                self.head = node.next;
-                &mut node.element
-            })
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a mut T> {
-        if self.len == 0 {
-            None
-        } else {
-            self.tail.map(|node| unsafe {
-                // Need an unbound lifetime to get 'a
-                let node = &mut *node.as_ptr();
-                self.len -= 1;
-                self.tail = node.prev;
-                &mut node.element
-            })
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for IterMut<'a, T> {}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for IterMut<'a, T> {}
-
-impl<'a, T> IterMut<'a, T> {
-    /// Inserts the given element just after the element most recently returned by `.next()`.
-    /// The inserted element does not appear in the iteration.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(linked_list_extras)]
-    ///
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list: LinkedList<_> = vec![1, 3, 4].into_iter().collect();
-    ///
-    /// {
-    ///     let mut it = list.iter_mut();
-    ///     assert_eq!(it.next().unwrap(), &1);
-    ///     // insert `2` after `1`
-    ///     it.insert_next(2);
-    /// }
-    /// {
-    ///     let vec: Vec<_> = list.into_iter().collect();
-    ///     assert_eq!(vec, [1, 2, 3, 4]);
-    /// }
-    /// ```
-    #[inline]
-    #[unstable(feature = "linked_list_extras",
-               reason = "this is probably better handled by a cursor type -- we'll see",
-               issue = "27794")]
-    pub fn insert_next(&mut self, element: T) {
-        match self.head {
-            None => self.list.push_back(element),
-            Some(mut head) => unsafe {
-                let mut prev = match head.as_ref().prev {
-                    None => return self.list.push_front(element),
-                    Some(prev) => prev,
-                };
-
-                let node = Some(Shared::new(Box::into_raw(box Node {
-                    next: Some(head),
-                    prev: Some(prev),
-                    element: element,
-                })));
-
-                prev.as_mut().next = node;
-                head.as_mut().prev = node;
-
-                self.list.len += 1;
-            },
-        }
-    }
-
-    /// Provides a reference to the next element, without changing the iterator.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(linked_list_extras)]
-    ///
-    /// use std::collections::LinkedList;
-    ///
-    /// let mut list: LinkedList<_> = vec![1, 2, 3].into_iter().collect();
-    ///
-    /// let mut it = list.iter_mut();
-    /// assert_eq!(it.next().unwrap(), &1);
-    /// assert_eq!(it.peek_next().unwrap(), &2);
-    /// // We just peeked at 2, so it was not consumed from the iterator.
-    /// assert_eq!(it.next().unwrap(), &2);
-    /// ```
-    #[inline]
-    #[unstable(feature = "linked_list_extras",
-               reason = "this is probably better handled by a cursor type -- we'll see",
-               issue = "27794")]
-    pub fn peek_next(&mut self) -> Option<&mut T> {
-        if self.len == 0 {
-            None
-        } else {
-            unsafe {
-                self.head.as_mut().map(|node| &mut node.as_mut().element)
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.list.pop_front()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.list.len, Some(self.list.len))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.list.pop_back()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<T> FusedIterator for IntoIter<T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> FromIterator<T> for LinkedList<T> {
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Self {
-        let mut list = Self::new();
-        list.extend(iter);
-        list
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IntoIterator for LinkedList<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    /// Consumes the list into an iterator yielding elements by value.
-    #[inline]
-    fn into_iter(self) -> IntoIter<T> {
-        IntoIter { list: self }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a LinkedList<T> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut LinkedList<T> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Extend<T> for LinkedList<T> {
-    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        <Self as SpecExtend<I>>::spec_extend(self, iter);
-    }
-}
-
-impl<I: IntoIterator> SpecExtend<I> for LinkedList<I::Item> {
-    default fn spec_extend(&mut self, iter: I) {
-        for elt in iter {
-            self.push_back(elt);
-        }
-    }
-}
-
-impl<T> SpecExtend<LinkedList<T>> for LinkedList<T> {
-    fn spec_extend(&mut self, ref mut other: LinkedList<T>) {
-        self.append(other);
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for LinkedList<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialEq> PartialEq for LinkedList<T> {
-    fn eq(&self, other: &Self) -> bool {
-        self.len() == other.len() && self.iter().eq(other)
-    }
-
-    fn ne(&self, other: &Self) -> bool {
-        self.len() != other.len() || self.iter().ne(other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq> Eq for LinkedList<T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd> PartialOrd for LinkedList<T> {
-    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-        self.iter().partial_cmp(other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Ord for LinkedList<T> {
-    #[inline]
-    fn cmp(&self, other: &Self) -> Ordering {
-        self.iter().cmp(other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> Clone for LinkedList<T> {
-    fn clone(&self) -> Self {
-        self.iter().cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Debug> fmt::Debug for LinkedList<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self).finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Hash> Hash for LinkedList<T> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.len().hash(state);
-        for elt in self {
-            elt.hash(state);
-        }
-    }
-}
-
-unsafe fn finalize<T>(node: IntermediateBox<Node<T>>) -> Box<Node<T>> {
-    let mut node = node.finalize();
-    ptr::write(&mut node.next, None);
-    ptr::write(&mut node.prev, None);
-    node
-}
-
-/// A place for insertion at the front of a `LinkedList`.
-///
-/// See [`LinkedList::front_place`](struct.LinkedList.html#method.front_place) for details.
-#[must_use = "places do nothing unless written to with `<-` syntax"]
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-pub struct FrontPlace<'a, T: 'a> {
-    list: &'a mut LinkedList<T>,
-    node: IntermediateBox<Node<T>>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for FrontPlace<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("FrontPlace")
-         .field(&self.list)
-         .finish()
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Placer<T> for FrontPlace<'a, T> {
-    type Place = Self;
-
-    fn make_place(self) -> Self {
-        self
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for FrontPlace<'a, T> {
-    fn pointer(&mut self) -> *mut T {
-        unsafe { &mut (*self.node.pointer()).element }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for FrontPlace<'a, T> {
-    type Owner = ();
-
-    unsafe fn finalize(self) {
-        let FrontPlace { list, node } = self;
-        list.push_front_node(finalize(node));
-    }
-}
-
-/// A place for insertion at the back of a `LinkedList`.
-///
-/// See [`LinkedList::back_place`](struct.LinkedList.html#method.back_place) for details.
-#[must_use = "places do nothing unless written to with `<-` syntax"]
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-pub struct BackPlace<'a, T: 'a> {
-    list: &'a mut LinkedList<T>,
-    node: IntermediateBox<Node<T>>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for BackPlace<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("BackPlace")
-         .field(&self.list)
-         .finish()
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Placer<T> for BackPlace<'a, T> {
-    type Place = Self;
-
-    fn make_place(self) -> Self {
-        self
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for BackPlace<'a, T> {
-    fn pointer(&mut self) -> *mut T {
-        unsafe { &mut (*self.node.pointer()).element }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for BackPlace<'a, T> {
-    type Owner = ();
-
-    unsafe fn finalize(self) {
-        let BackPlace { list, node } = self;
-        list.push_back_node(finalize(node));
-    }
-}
-
-// Ensure that `LinkedList` and its read-only iterators are covariant in their type parameters.
-#[allow(dead_code)]
-fn assert_covariance() {
-    fn a<'a>(x: LinkedList<&'static str>) -> LinkedList<&'a str> {
-        x
-    }
-    fn b<'i, 'a>(x: Iter<'i, &'static str>) -> Iter<'i, &'a str> {
-        x
-    }
-    fn c<'a>(x: IntoIter<&'static str>) -> IntoIter<&'a str> {
-        x
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Send> Send for LinkedList<T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Sync> Sync for LinkedList<T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<'a, T: Sync> Send for Iter<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<'a, T: Sync> Sync for Iter<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<'a, T: Send> Send for IterMut<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<'a, T: Sync> Sync for IterMut<'a, T> {}
-
-#[cfg(test)]
-mod tests {
-    use std::__rand::{thread_rng, Rng};
-    use std::thread;
-    use std::vec::Vec;
-
-    use super::{LinkedList, Node};
-
-    #[cfg(test)]
-    fn list_from<T: Clone>(v: &[T]) -> LinkedList<T> {
-        v.iter().cloned().collect()
-    }
-
-    pub fn check_links<T>(list: &LinkedList<T>) {
-        unsafe {
-            let mut len = 0;
-            let mut last_ptr: Option<&Node<T>> = None;
-            let mut node_ptr: &Node<T>;
-            match list.head {
-                None => {
-                    assert_eq!(0, list.len);
-                    return;
-                }
-                Some(node) => node_ptr = &*node.as_ptr(),
-            }
-            loop {
-                match (last_ptr, node_ptr.prev) {
-                    (None, None) => {}
-                    (None, _) => panic!("prev link for head"),
-                    (Some(p), Some(pptr)) => {
-                        assert_eq!(p as *const Node<T>, pptr.as_ptr() as *const Node<T>);
-                    }
-                    _ => panic!("prev link is none, not good"),
-                }
-                match node_ptr.next {
-                    Some(next) => {
-                        last_ptr = Some(node_ptr);
-                        node_ptr = &*next.as_ptr();
-                        len += 1;
-                    }
-                    None => {
-                        len += 1;
-                        break;
-                    }
-                }
-            }
-            assert_eq!(len, list.len);
-        }
-    }
-
-    #[test]
-    fn test_append() {
-        // Empty to empty
-        {
-            let mut m = LinkedList::<i32>::new();
-            let mut n = LinkedList::new();
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 0);
-            assert_eq!(n.len(), 0);
-        }
-        // Non-empty to empty
-        {
-            let mut m = LinkedList::new();
-            let mut n = LinkedList::new();
-            n.push_back(2);
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 1);
-            assert_eq!(m.pop_back(), Some(2));
-            assert_eq!(n.len(), 0);
-            check_links(&m);
-        }
-        // Empty to non-empty
-        {
-            let mut m = LinkedList::new();
-            let mut n = LinkedList::new();
-            m.push_back(2);
-            m.append(&mut n);
-            check_links(&m);
-            assert_eq!(m.len(), 1);
-            assert_eq!(m.pop_back(), Some(2));
-            check_links(&m);
-        }
-
-        // Non-empty to non-empty
-        let v = vec![1, 2, 3, 4, 5];
-        let u = vec![9, 8, 1, 2, 3, 4, 5];
-        let mut m = list_from(&v);
-        let mut n = list_from(&u);
-        m.append(&mut n);
-        check_links(&m);
-        let mut sum = v;
-        sum.extend_from_slice(&u);
-        assert_eq!(sum.len(), m.len());
-        for elt in sum {
-            assert_eq!(m.pop_front(), Some(elt))
-        }
-        assert_eq!(n.len(), 0);
-        // let's make sure it's working properly, since we
-        // did some direct changes to private members
-        n.push_back(3);
-        assert_eq!(n.len(), 1);
-        assert_eq!(n.pop_front(), Some(3));
-        check_links(&n);
-    }
-
-    #[test]
-    fn test_insert_prev() {
-        let mut m = list_from(&[0, 2, 4, 6, 8]);
-        let len = m.len();
-        {
-            let mut it = m.iter_mut();
-            it.insert_next(-2);
-            loop {
-                match it.next() {
-                    None => break,
-                    Some(elt) => {
-                        it.insert_next(*elt + 1);
-                        match it.peek_next() {
-                            Some(x) => assert_eq!(*x, *elt + 2),
-                            None => assert_eq!(8, *elt),
-                        }
-                    }
-                }
-            }
-            it.insert_next(0);
-            it.insert_next(1);
-        }
-        check_links(&m);
-        assert_eq!(m.len(), 3 + len * 2);
-        assert_eq!(m.into_iter().collect::<Vec<_>>(),
-                   [-2, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 1]);
-    }
-
-    #[test]
-    #[cfg_attr(target_os = "emscripten", ignore)]
-    fn test_send() {
-        let n = list_from(&[1, 2, 3]);
-        thread::spawn(move || {
-                check_links(&n);
-                let a: &[_] = &[&1, &2, &3];
-                assert_eq!(a, &*n.iter().collect::<Vec<_>>());
-            })
-            .join()
-            .ok()
-            .unwrap();
-    }
-
-    #[test]
-    fn test_fuzz() {
-        for _ in 0..25 {
-            fuzz_test(3);
-            fuzz_test(16);
-            fuzz_test(189);
-        }
-    }
-
-    #[test]
-    fn test_26021() {
-        // There was a bug in split_off that failed to null out the RHS's head's prev ptr.
-        // This caused the RHS's dtor to walk up into the LHS at drop and delete all of
-        // its nodes.
-        //
-        // https://github.com/rust-lang/rust/issues/26021
-        let mut v1 = LinkedList::new();
-        v1.push_front(1);
-        v1.push_front(1);
-        v1.push_front(1);
-        v1.push_front(1);
-        let _ = v1.split_off(3); // Dropping this now should not cause laundry consumption
-        assert_eq!(v1.len(), 3);
-
-        assert_eq!(v1.iter().len(), 3);
-        assert_eq!(v1.iter().collect::<Vec<_>>().len(), 3);
-    }
-
-    #[test]
-    fn test_split_off() {
-        let mut v1 = LinkedList::new();
-        v1.push_front(1);
-        v1.push_front(1);
-        v1.push_front(1);
-        v1.push_front(1);
-
-        // test all splits
-        for ix in 0..1 + v1.len() {
-            let mut a = v1.clone();
-            let b = a.split_off(ix);
-            check_links(&a);
-            check_links(&b);
-            a.extend(b);
-            assert_eq!(v1, a);
-        }
-    }
-
-    #[cfg(test)]
-    fn fuzz_test(sz: i32) {
-        let mut m: LinkedList<_> = LinkedList::new();
-        let mut v = vec![];
-        for i in 0..sz {
-            check_links(&m);
-            let r: u8 = thread_rng().next_u32() as u8;
-            match r % 6 {
-                0 => {
-                    m.pop_back();
-                    v.pop();
-                }
-                1 => {
-                    if !v.is_empty() {
-                        m.pop_front();
-                        v.remove(0);
-                    }
-                }
-                2 | 4 => {
-                    m.push_front(-i);
-                    v.insert(0, -i);
-                }
-                3 | 5 | _ => {
-                    m.push_back(i);
-                    v.push(i);
-                }
-            }
-        }
-
-        check_links(&m);
-
-        let mut i = 0;
-        for (a, &b) in m.into_iter().zip(&v) {
-            i += 1;
-            assert_eq!(a, b);
-        }
-        assert_eq!(i, v.len());
-    }
-}
diff --git a/src/libcollections/macros.rs b/src/libcollections/macros.rs
deleted file mode 100644
index 396a917dfde..00000000000
--- a/src/libcollections/macros.rs
+++ /dev/null
@@ -1,92 +0,0 @@
-// Copyright 2014-2015 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.
-
-/// Creates a `Vec` containing the arguments.
-///
-/// `vec!` allows `Vec`s to be defined with the same syntax as array expressions.
-/// There are two forms of this macro:
-///
-/// - Create a `Vec` containing a given list of elements:
-///
-/// ```
-/// let v = vec![1, 2, 3];
-/// assert_eq!(v[0], 1);
-/// assert_eq!(v[1], 2);
-/// assert_eq!(v[2], 3);
-/// ```
-///
-/// - Create a `Vec` from a given element and size:
-///
-/// ```
-/// let v = vec![1; 3];
-/// assert_eq!(v, [1, 1, 1]);
-/// ```
-///
-/// Note that unlike array expressions this syntax supports all elements
-/// which implement `Clone` and the number of elements doesn't have to be
-/// a constant.
-///
-/// This will use `clone()` to duplicate an expression, so one should be careful
-/// using this with types having a nonstandard `Clone` implementation. For
-/// example, `vec![Rc::new(1); 5]` will create a vector of five references
-/// to the same boxed integer value, not five references pointing to independently
-/// boxed integers.
-#[cfg(not(test))]
-#[macro_export]
-#[stable(feature = "rust1", since = "1.0.0")]
-#[allow_internal_unstable]
-macro_rules! vec {
-    ($elem:expr; $n:expr) => (
-        $crate::vec::from_elem($elem, $n)
-    );
-    ($($x:expr),*) => (
-        <[_]>::into_vec(box [$($x),*])
-    );
-    ($($x:expr,)*) => (vec![$($x),*])
-}
-
-// HACK(japaric): with cfg(test) the inherent `[T]::into_vec` method, which is
-// required for this macro definition, is not available. Instead use the
-// `slice::into_vec`  function which is only available with cfg(test)
-// NB see the slice::hack module in slice.rs for more information
-#[cfg(test)]
-macro_rules! vec {
-    ($elem:expr; $n:expr) => (
-        $crate::vec::from_elem($elem, $n)
-    );
-    ($($x:expr),*) => (
-        $crate::slice::into_vec(box [$($x),*])
-    );
-    ($($x:expr,)*) => (vec![$($x),*])
-}
-
-/// Use the syntax described in `std::fmt` to create a value of type `String`.
-/// See [`std::fmt`][fmt] for more information.
-///
-/// [fmt]: ../std/fmt/index.html
-///
-/// # Panics
-///
-/// `format!` panics if a formatting trait implementation returns an error.
-/// This indicates an incorrect implementation
-/// since `fmt::Write for String` never returns an error itself.
-///
-/// # Examples
-///
-/// ```
-/// format!("test");
-/// format!("hello {}", "world!");
-/// format!("x = {}, y = {y}", 10, y = 30);
-/// ```
-#[macro_export]
-#[stable(feature = "rust1", since = "1.0.0")]
-macro_rules! format {
-    ($($arg:tt)*) => ($crate::fmt::format(format_args!($($arg)*)))
-}
diff --git a/src/libcollections/range.rs b/src/libcollections/range.rs
deleted file mode 100644
index bc8566e8cbe..00000000000
--- a/src/libcollections/range.rs
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright 2015 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.
-
-#![unstable(feature = "collections_range",
-            reason = "waiting for dust to settle on inclusive ranges",
-            issue = "30877")]
-
-//! Range syntax.
-
-use core::ops::{RangeFull, Range, RangeTo, RangeFrom, RangeInclusive, RangeToInclusive};
-use Bound::{self, Excluded, Included, Unbounded};
-
-/// `RangeArgument` is implemented by Rust's built-in range types, produced
-/// by range syntax like `..`, `a..`, `..b` or `c..d`.
-pub trait RangeArgument<T: ?Sized> {
-    /// Start index bound.
-    ///
-    /// Returns the start value as a `Bound`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collections)]
-    /// #![feature(collections_range)]
-    ///
-    /// extern crate collections;
-    ///
-    /// # fn main() {
-    /// use collections::range::RangeArgument;
-    /// use collections::Bound::*;
-    ///
-    /// assert_eq!((..10).start(), Unbounded);
-    /// assert_eq!((3..10).start(), Included(&3));
-    /// # }
-    /// ```
-    fn start(&self) -> Bound<&T>;
-
-    /// End index bound.
-    ///
-    /// Returns the end value as a `Bound`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collections)]
-    /// #![feature(collections_range)]
-    ///
-    /// extern crate collections;
-    ///
-    /// # fn main() {
-    /// use collections::range::RangeArgument;
-    /// use collections::Bound::*;
-    ///
-    /// assert_eq!((3..).end(), Unbounded);
-    /// assert_eq!((3..10).end(), Excluded(&10));
-    /// # }
-    /// ```
-    fn end(&self) -> Bound<&T>;
-}
-
-// FIXME add inclusive ranges to RangeArgument
-
-impl<T: ?Sized> RangeArgument<T> for RangeFull {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Unbounded
-    }
-}
-
-impl<T> RangeArgument<T> for RangeFrom<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Unbounded
-    }
-}
-
-impl<T> RangeArgument<T> for RangeTo<T> {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Excluded(&self.end)
-    }
-}
-
-impl<T> RangeArgument<T> for Range<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Excluded(&self.end)
-    }
-}
-
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> RangeArgument<T> for RangeInclusive<T> {
-    fn start(&self) -> Bound<&T> {
-        Included(&self.start)
-    }
-    fn end(&self) -> Bound<&T> {
-        Included(&self.end)
-    }
-}
-
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> RangeArgument<T> for RangeToInclusive<T> {
-    fn start(&self) -> Bound<&T> {
-        Unbounded
-    }
-    fn end(&self) -> Bound<&T> {
-        Included(&self.end)
-    }
-}
-
-impl<T> RangeArgument<T> for (Bound<T>, Bound<T>) {
-    fn start(&self) -> Bound<&T> {
-        match *self {
-            (Included(ref start), _) => Included(start),
-            (Excluded(ref start), _) => Excluded(start),
-            (Unbounded, _)           => Unbounded,
-        }
-    }
-
-    fn end(&self) -> Bound<&T> {
-        match *self {
-            (_, Included(ref end)) => Included(end),
-            (_, Excluded(ref end)) => Excluded(end),
-            (_, Unbounded)         => Unbounded,
-        }
-    }
-}
-
-impl<'a, T: ?Sized + 'a> RangeArgument<T> for (Bound<&'a T>, Bound<&'a T>) {
-    fn start(&self) -> Bound<&T> {
-        self.0
-    }
-
-    fn end(&self) -> Bound<&T> {
-        self.1
-    }
-}
diff --git a/src/libcollections/slice.rs b/src/libcollections/slice.rs
deleted file mode 100644
index 97d6687c79b..00000000000
--- a/src/libcollections/slice.rs
+++ /dev/null
@@ -1,1943 +0,0 @@
-// Copyright 2012-2015 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.
-
-//! A dynamically-sized view into a contiguous sequence, `[T]`.
-//!
-//! Slices are a view into a block of memory represented as a pointer and a
-//! length.
-//!
-//! ```
-//! // slicing a Vec
-//! let vec = vec![1, 2, 3];
-//! let int_slice = &vec[..];
-//! // coercing an array to a slice
-//! let str_slice: &[&str] = &["one", "two", "three"];
-//! ```
-//!
-//! Slices are either mutable or shared. The shared slice type is `&[T]`,
-//! while the mutable slice type is `&mut [T]`, where `T` represents the element
-//! type. For example, you can mutate the block of memory that a mutable slice
-//! points to:
-//!
-//! ```
-//! let x = &mut [1, 2, 3];
-//! x[1] = 7;
-//! assert_eq!(x, &[1, 7, 3]);
-//! ```
-//!
-//! Here are some of the things this module contains:
-//!
-//! ## Structs
-//!
-//! There are several structs that are useful for slices, such as [`Iter`], which
-//! represents iteration over a slice.
-//!
-//! ## Trait Implementations
-//!
-//! There are several implementations of common traits for slices. Some examples
-//! include:
-//!
-//! * [`Clone`]
-//! * [`Eq`], [`Ord`] - for slices whose element type are [`Eq`] or [`Ord`].
-//! * [`Hash`] - for slices whose element type is [`Hash`].
-//!
-//! ## Iteration
-//!
-//! The slices implement `IntoIterator`. The iterator yields references to the
-//! slice elements.
-//!
-//! ```
-//! let numbers = &[0, 1, 2];
-//! for n in numbers {
-//!     println!("{} is a number!", n);
-//! }
-//! ```
-//!
-//! The mutable slice yields mutable references to the elements:
-//!
-//! ```
-//! let mut scores = [7, 8, 9];
-//! for score in &mut scores[..] {
-//!     *score += 1;
-//! }
-//! ```
-//!
-//! This iterator yields mutable references to the slice's elements, so while
-//! the element type of the slice is `i32`, the element type of the iterator is
-//! `&mut i32`.
-//!
-//! * [`.iter`] and [`.iter_mut`] are the explicit methods to return the default
-//!   iterators.
-//! * Further methods that return iterators are [`.split`], [`.splitn`],
-//!   [`.chunks`], [`.windows`] and more.
-//!
-//! *[See also the slice primitive type](../../std/primitive.slice.html).*
-//!
-//! [`Clone`]: ../../std/clone/trait.Clone.html
-//! [`Eq`]: ../../std/cmp/trait.Eq.html
-//! [`Ord`]: ../../std/cmp/trait.Ord.html
-//! [`Iter`]: struct.Iter.html
-//! [`Hash`]: ../../std/hash/trait.Hash.html
-//! [`.iter`]: ../../std/primitive.slice.html#method.iter
-//! [`.iter_mut`]: ../../std/primitive.slice.html#method.iter_mut
-//! [`.split`]: ../../std/primitive.slice.html#method.split
-//! [`.splitn`]: ../../std/primitive.slice.html#method.splitn
-//! [`.chunks`]: ../../std/primitive.slice.html#method.chunks
-//! [`.windows`]: ../../std/primitive.slice.html#method.windows
-#![stable(feature = "rust1", since = "1.0.0")]
-
-// Many of the usings in this module are only used in the test configuration.
-// It's cleaner to just turn off the unused_imports warning than to fix them.
-#![cfg_attr(test, allow(unused_imports, dead_code))]
-
-use alloc::boxed::Box;
-use core::cmp::Ordering::{self, Less};
-use core::mem::size_of;
-use core::mem;
-use core::ptr;
-use core::slice as core_slice;
-
-use borrow::{Borrow, BorrowMut, ToOwned};
-use vec::Vec;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::slice::{Chunks, Windows};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::slice::{Iter, IterMut};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::slice::{SplitMut, ChunksMut, Split};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::slice::{SplitN, RSplitN, SplitNMut, RSplitNMut};
-#[unstable(feature = "slice_rsplit", issue = "41020")]
-pub use core::slice::{RSplit, RSplitMut};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::slice::{from_raw_parts, from_raw_parts_mut};
-#[unstable(feature = "slice_get_slice", issue = "35729")]
-pub use core::slice::SliceIndex;
-
-////////////////////////////////////////////////////////////////////////////////
-// Basic slice extension methods
-////////////////////////////////////////////////////////////////////////////////
-
-// HACK(japaric) needed for the implementation of `vec!` macro during testing
-// NB see the hack module in this file for more details
-#[cfg(test)]
-pub use self::hack::into_vec;
-
-// HACK(japaric) needed for the implementation of `Vec::clone` during testing
-// NB see the hack module in this file for more details
-#[cfg(test)]
-pub use self::hack::to_vec;
-
-// HACK(japaric): With cfg(test) `impl [T]` is not available, these three
-// functions are actually methods that are in `impl [T]` but not in
-// `core::slice::SliceExt` - we need to supply these functions for the
-// `test_permutations` test
-mod hack {
-    use alloc::boxed::Box;
-    use core::mem;
-
-    #[cfg(test)]
-    use string::ToString;
-    use vec::Vec;
-
-    pub fn into_vec<T>(mut b: Box<[T]>) -> Vec<T> {
-        unsafe {
-            let xs = Vec::from_raw_parts(b.as_mut_ptr(), b.len(), b.len());
-            mem::forget(b);
-            xs
-        }
-    }
-
-    #[inline]
-    pub fn to_vec<T>(s: &[T]) -> Vec<T>
-        where T: Clone
-    {
-        let mut vector = Vec::with_capacity(s.len());
-        vector.extend_from_slice(s);
-        vector
-    }
-}
-
-#[lang = "slice"]
-#[cfg(not(test))]
-impl<T> [T] {
-    /// Returns the number of elements in the slice.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let a = [1, 2, 3];
-    /// assert_eq!(a.len(), 3);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn len(&self) -> usize {
-        core_slice::SliceExt::len(self)
-    }
-
-    /// Returns `true` if the slice has a length of 0.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let a = [1, 2, 3];
-    /// assert!(!a.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn is_empty(&self) -> bool {
-        core_slice::SliceExt::is_empty(self)
-    }
-
-    /// Returns the first element of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert_eq!(Some(&10), v.first());
-    ///
-    /// let w: &[i32] = &[];
-    /// assert_eq!(None, w.first());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn first(&self) -> Option<&T> {
-        core_slice::SliceExt::first(self)
-    }
-
-    /// Returns a mutable pointer to the first element of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [0, 1, 2];
-    ///
-    /// if let Some(first) = x.first_mut() {
-    ///     *first = 5;
-    /// }
-    /// assert_eq!(x, &[5, 1, 2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn first_mut(&mut self) -> Option<&mut T> {
-        core_slice::SliceExt::first_mut(self)
-    }
-
-    /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &[0, 1, 2];
-    ///
-    /// if let Some((first, elements)) = x.split_first() {
-    ///     assert_eq!(first, &0);
-    ///     assert_eq!(elements, &[1, 2]);
-    /// }
-    /// ```
-    #[stable(feature = "slice_splits", since = "1.5.0")]
-    #[inline]
-    pub fn split_first(&self) -> Option<(&T, &[T])> {
-        core_slice::SliceExt::split_first(self)
-    }
-
-    /// Returns the first and all the rest of the elements of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [0, 1, 2];
-    ///
-    /// if let Some((first, elements)) = x.split_first_mut() {
-    ///     *first = 3;
-    ///     elements[0] = 4;
-    ///     elements[1] = 5;
-    /// }
-    /// assert_eq!(x, &[3, 4, 5]);
-    /// ```
-    #[stable(feature = "slice_splits", since = "1.5.0")]
-    #[inline]
-    pub fn split_first_mut(&mut self) -> Option<(&mut T, &mut [T])> {
-        core_slice::SliceExt::split_first_mut(self)
-    }
-
-    /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &[0, 1, 2];
-    ///
-    /// if let Some((last, elements)) = x.split_last() {
-    ///     assert_eq!(last, &2);
-    ///     assert_eq!(elements, &[0, 1]);
-    /// }
-    /// ```
-    #[stable(feature = "slice_splits", since = "1.5.0")]
-    #[inline]
-    pub fn split_last(&self) -> Option<(&T, &[T])> {
-        core_slice::SliceExt::split_last(self)
-
-    }
-
-    /// Returns the last and all the rest of the elements of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [0, 1, 2];
-    ///
-    /// if let Some((last, elements)) = x.split_last_mut() {
-    ///     *last = 3;
-    ///     elements[0] = 4;
-    ///     elements[1] = 5;
-    /// }
-    /// assert_eq!(x, &[4, 5, 3]);
-    /// ```
-    #[stable(feature = "slice_splits", since = "1.5.0")]
-    #[inline]
-    pub fn split_last_mut(&mut self) -> Option<(&mut T, &mut [T])> {
-        core_slice::SliceExt::split_last_mut(self)
-    }
-
-    /// Returns the last element of the slice, or `None` if it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert_eq!(Some(&30), v.last());
-    ///
-    /// let w: &[i32] = &[];
-    /// assert_eq!(None, w.last());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn last(&self) -> Option<&T> {
-        core_slice::SliceExt::last(self)
-    }
-
-    /// Returns a mutable pointer to the last item in the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [0, 1, 2];
-    ///
-    /// if let Some(last) = x.last_mut() {
-    ///     *last = 10;
-    /// }
-    /// assert_eq!(x, &[0, 1, 10]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn last_mut(&mut self) -> Option<&mut T> {
-        core_slice::SliceExt::last_mut(self)
-    }
-
-    /// Returns a reference to an element or subslice depending on the type of
-    /// index.
-    ///
-    /// - If given a position, returns a reference to the element at that
-    ///   position or `None` if out of bounds.
-    /// - If given a range, returns the subslice corresponding to that range,
-    ///   or `None` if out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert_eq!(Some(&40), v.get(1));
-    /// assert_eq!(Some(&[10, 40][..]), v.get(0..2));
-    /// assert_eq!(None, v.get(3));
-    /// assert_eq!(None, v.get(0..4));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn get<I>(&self, index: I) -> Option<&I::Output>
-        where I: SliceIndex<Self>
-    {
-        core_slice::SliceExt::get(self, index)
-    }
-
-    /// Returns a mutable reference to an element or subslice depending on the
-    /// type of index (see [`get`]) or `None` if the index is out of bounds.
-    ///
-    /// [`get`]: #method.get
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [0, 1, 2];
-    ///
-    /// if let Some(elem) = x.get_mut(1) {
-    ///     *elem = 42;
-    /// }
-    /// assert_eq!(x, &[0, 42, 2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn get_mut<I>(&mut self, index: I) -> Option<&mut I::Output>
-        where I: SliceIndex<Self>
-    {
-        core_slice::SliceExt::get_mut(self, index)
-    }
-
-    /// Returns a reference to an element or subslice, without doing bounds
-    /// checking.
-    ///
-    /// This is generally not recommended, use with caution! For a safe
-    /// alternative see [`get`].
-    ///
-    /// [`get`]: #method.get
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &[1, 2, 4];
-    ///
-    /// unsafe {
-    ///     assert_eq!(x.get_unchecked(1), &2);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub unsafe fn get_unchecked<I>(&self, index: I) -> &I::Output
-        where I: SliceIndex<Self>
-    {
-        core_slice::SliceExt::get_unchecked(self, index)
-    }
-
-    /// Returns a mutable reference to an element or subslice, without doing
-    /// bounds checking.
-    ///
-    /// This is generally not recommended, use with caution! For a safe
-    /// alternative see [`get_mut`].
-    ///
-    /// [`get_mut`]: #method.get_mut
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [1, 2, 4];
-    ///
-    /// unsafe {
-    ///     let elem = x.get_unchecked_mut(1);
-    ///     *elem = 13;
-    /// }
-    /// assert_eq!(x, &[1, 13, 4]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub unsafe fn get_unchecked_mut<I>(&mut self, index: I) -> &mut I::Output
-        where I: SliceIndex<Self>
-    {
-        core_slice::SliceExt::get_unchecked_mut(self, index)
-    }
-
-    /// Returns a raw pointer to the slice's buffer.
-    ///
-    /// The caller must ensure that the slice outlives the pointer this
-    /// function returns, or else it will end up pointing to garbage.
-    ///
-    /// Modifying the container referenced by this slice may cause its buffer
-    /// to be reallocated, which would also make any pointers to it invalid.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &[1, 2, 4];
-    /// let x_ptr = x.as_ptr();
-    ///
-    /// unsafe {
-    ///     for i in 0..x.len() {
-    ///         assert_eq!(x.get_unchecked(i), &*x_ptr.offset(i as isize));
-    ///     }
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn as_ptr(&self) -> *const T {
-        core_slice::SliceExt::as_ptr(self)
-    }
-
-    /// Returns an unsafe mutable pointer to the slice's buffer.
-    ///
-    /// The caller must ensure that the slice outlives the pointer this
-    /// function returns, or else it will end up pointing to garbage.
-    ///
-    /// Modifying the container referenced by this slice may cause its buffer
-    /// to be reallocated, which would also make any pointers to it invalid.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [1, 2, 4];
-    /// let x_ptr = x.as_mut_ptr();
-    ///
-    /// unsafe {
-    ///     for i in 0..x.len() {
-    ///         *x_ptr.offset(i as isize) += 2;
-    ///     }
-    /// }
-    /// assert_eq!(x, &[3, 4, 6]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn as_mut_ptr(&mut self) -> *mut T {
-        core_slice::SliceExt::as_mut_ptr(self)
-    }
-
-    /// Swaps two elements in the slice.
-    ///
-    /// # Arguments
-    ///
-    /// * a - The index of the first element
-    /// * b - The index of the second element
-    ///
-    /// # Panics
-    ///
-    /// Panics if `a` or `b` are out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = ["a", "b", "c", "d"];
-    /// v.swap(1, 3);
-    /// assert!(v == ["a", "d", "c", "b"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn swap(&mut self, a: usize, b: usize) {
-        core_slice::SliceExt::swap(self, a, b)
-    }
-
-    /// Reverses the order of elements in the slice, in place.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let mut v = [1, 2, 3];
-    /// v.reverse();
-    /// assert!(v == [3, 2, 1]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn reverse(&mut self) {
-        core_slice::SliceExt::reverse(self)
-    }
-
-    /// Returns an iterator over the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &[1, 2, 4];
-    /// let mut iterator = x.iter();
-    ///
-    /// assert_eq!(iterator.next(), Some(&1));
-    /// assert_eq!(iterator.next(), Some(&2));
-    /// assert_eq!(iterator.next(), Some(&4));
-    /// assert_eq!(iterator.next(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn iter(&self) -> Iter<T> {
-        core_slice::SliceExt::iter(self)
-    }
-
-    /// Returns an iterator that allows modifying each value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let x = &mut [1, 2, 4];
-    /// for elem in x.iter_mut() {
-    ///     *elem += 2;
-    /// }
-    /// assert_eq!(x, &[3, 4, 6]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn iter_mut(&mut self) -> IterMut<T> {
-        core_slice::SliceExt::iter_mut(self)
-    }
-
-    /// Returns an iterator over all contiguous windows of length
-    /// `size`. The windows overlap. If the slice is shorter than
-    /// `size`, the iterator returns no values.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `size` is 0.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let slice = ['r', 'u', 's', 't'];
-    /// let mut iter = slice.windows(2);
-    /// assert_eq!(iter.next().unwrap(), &['r', 'u']);
-    /// assert_eq!(iter.next().unwrap(), &['u', 's']);
-    /// assert_eq!(iter.next().unwrap(), &['s', 't']);
-    /// assert!(iter.next().is_none());
-    /// ```
-    ///
-    /// If the slice is shorter than `size`:
-    ///
-    /// ```
-    /// let slice = ['f', 'o', 'o'];
-    /// let mut iter = slice.windows(4);
-    /// assert!(iter.next().is_none());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn windows(&self, size: usize) -> Windows<T> {
-        core_slice::SliceExt::windows(self, size)
-    }
-
-    /// Returns an iterator over `size` elements of the slice at a
-    /// time. The chunks are slices and do not overlap. If `size` does
-    /// not divide the length of the slice, then the last chunk will
-    /// not have length `size`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `size` is 0.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let slice = ['l', 'o', 'r', 'e', 'm'];
-    /// let mut iter = slice.chunks(2);
-    /// assert_eq!(iter.next().unwrap(), &['l', 'o']);
-    /// assert_eq!(iter.next().unwrap(), &['r', 'e']);
-    /// assert_eq!(iter.next().unwrap(), &['m']);
-    /// assert!(iter.next().is_none());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn chunks(&self, size: usize) -> Chunks<T> {
-        core_slice::SliceExt::chunks(self, size)
-    }
-
-    /// Returns an iterator over `chunk_size` elements of the slice at a time.
-    /// The chunks are mutable slices, and do not overlap. If `chunk_size` does
-    /// not divide the length of the slice, then the last chunk will not
-    /// have length `chunk_size`.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `chunk_size` is 0.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = &mut [0, 0, 0, 0, 0];
-    /// let mut count = 1;
-    ///
-    /// for chunk in v.chunks_mut(2) {
-    ///     for elem in chunk.iter_mut() {
-    ///         *elem += count;
-    ///     }
-    ///     count += 1;
-    /// }
-    /// assert_eq!(v, &[1, 1, 2, 2, 3]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn chunks_mut(&mut self, chunk_size: usize) -> ChunksMut<T> {
-        core_slice::SliceExt::chunks_mut(self, chunk_size)
-    }
-
-    /// Divides one slice into two at an index.
-    ///
-    /// The first will contain all indices from `[0, mid)` (excluding
-    /// the index `mid` itself) and the second will contain all
-    /// indices from `[mid, len)` (excluding the index `len` itself).
-    ///
-    /// # Panics
-    ///
-    /// Panics if `mid > len`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30, 20, 50];
-    /// let (v1, v2) = v.split_at(2);
-    /// assert_eq!([10, 40], v1);
-    /// assert_eq!([30, 20, 50], v2);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split_at(&self, mid: usize) -> (&[T], &[T]) {
-        core_slice::SliceExt::split_at(self, mid)
-    }
-
-    /// Divides one `&mut` into two at an index.
-    ///
-    /// The first will contain all indices from `[0, mid)` (excluding
-    /// the index `mid` itself) and the second will contain all
-    /// indices from `[mid, len)` (excluding the index `len` itself).
-    ///
-    /// # Panics
-    ///
-    /// Panics if `mid > len`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [1, 2, 3, 4, 5, 6];
-    ///
-    /// // scoped to restrict the lifetime of the borrows
-    /// {
-    ///    let (left, right) = v.split_at_mut(0);
-    ///    assert!(left == []);
-    ///    assert!(right == [1, 2, 3, 4, 5, 6]);
-    /// }
-    ///
-    /// {
-    ///     let (left, right) = v.split_at_mut(2);
-    ///     assert!(left == [1, 2]);
-    ///     assert!(right == [3, 4, 5, 6]);
-    /// }
-    ///
-    /// {
-    ///     let (left, right) = v.split_at_mut(6);
-    ///     assert!(left == [1, 2, 3, 4, 5, 6]);
-    ///     assert!(right == []);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split_at_mut(&mut self, mid: usize) -> (&mut [T], &mut [T]) {
-        core_slice::SliceExt::split_at_mut(self, mid)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred`. The matched element is not contained in the subslices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let slice = [10, 40, 33, 20];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
-    ///
-    /// assert_eq!(iter.next().unwrap(), &[10, 40]);
-    /// assert_eq!(iter.next().unwrap(), &[20]);
-    /// assert!(iter.next().is_none());
-    /// ```
-    ///
-    /// If the first element is matched, an empty slice will be the first item
-    /// returned by the iterator. Similarly, if the last element in the slice
-    /// is matched, an empty slice will be the last item returned by the
-    /// iterator:
-    ///
-    /// ```
-    /// let slice = [10, 40, 33];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
-    ///
-    /// assert_eq!(iter.next().unwrap(), &[10, 40]);
-    /// assert_eq!(iter.next().unwrap(), &[]);
-    /// assert!(iter.next().is_none());
-    /// ```
-    ///
-    /// If two matched elements are directly adjacent, an empty slice will be
-    /// present between them:
-    ///
-    /// ```
-    /// let slice = [10, 6, 33, 20];
-    /// let mut iter = slice.split(|num| num % 3 == 0);
-    ///
-    /// assert_eq!(iter.next().unwrap(), &[10]);
-    /// assert_eq!(iter.next().unwrap(), &[]);
-    /// assert_eq!(iter.next().unwrap(), &[20]);
-    /// assert!(iter.next().is_none());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split<F>(&self, pred: F) -> Split<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::split(self, pred)
-    }
-
-    /// Returns an iterator over mutable subslices separated by elements that
-    /// match `pred`. The matched element is not contained in the subslices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [10, 40, 30, 20, 60, 50];
-    ///
-    /// for group in v.split_mut(|num| *num % 3 == 0) {
-    ///     group[0] = 1;
-    /// }
-    /// assert_eq!(v, [1, 40, 30, 1, 60, 1]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split_mut<F>(&mut self, pred: F) -> SplitMut<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::split_mut(self, pred)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred`, starting at the end of the slice and working backwards.
-    /// The matched element is not contained in the subslices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(slice_rsplit)]
-    ///
-    /// let slice = [11, 22, 33, 0, 44, 55];
-    /// let mut iter = slice.rsplit(|num| *num == 0);
-    ///
-    /// assert_eq!(iter.next().unwrap(), &[44, 55]);
-    /// assert_eq!(iter.next().unwrap(), &[11, 22, 33]);
-    /// assert_eq!(iter.next(), None);
-    /// ```
-    ///
-    /// As with `split()`, if the first or last element is matched, an empty
-    /// slice will be the first (or last) item returned by the iterator.
-    ///
-    /// ```
-    /// #![feature(slice_rsplit)]
-    ///
-    /// let v = &[0, 1, 1, 2, 3, 5, 8];
-    /// let mut it = v.rsplit(|n| *n % 2 == 0);
-    /// assert_eq!(it.next().unwrap(), &[]);
-    /// assert_eq!(it.next().unwrap(), &[3, 5]);
-    /// assert_eq!(it.next().unwrap(), &[1, 1]);
-    /// assert_eq!(it.next().unwrap(), &[]);
-    /// assert_eq!(it.next(), None);
-    /// ```
-    #[unstable(feature = "slice_rsplit", issue = "41020")]
-    #[inline]
-    pub fn rsplit<F>(&self, pred: F) -> RSplit<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::rsplit(self, pred)
-    }
-
-    /// Returns an iterator over mutable subslices separated by elements that
-    /// match `pred`, starting at the end of the slice and working
-    /// backwards. The matched element is not contained in the subslices.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(slice_rsplit)]
-    ///
-    /// let mut v = [100, 400, 300, 200, 600, 500];
-    ///
-    /// let mut count = 0;
-    /// for group in v.rsplit_mut(|num| *num % 3 == 0) {
-    ///     count += 1;
-    ///     group[0] = count;
-    /// }
-    /// assert_eq!(v, [3, 400, 300, 2, 600, 1]);
-    /// ```
-    ///
-    #[unstable(feature = "slice_rsplit", issue = "41020")]
-    #[inline]
-    pub fn rsplit_mut<F>(&mut self, pred: F) -> RSplitMut<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::rsplit_mut(self, pred)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred`, limited to returning at most `n` items. The matched element is
-    /// not contained in the subslices.
-    ///
-    /// The last element returned, if any, will contain the remainder of the
-    /// slice.
-    ///
-    /// # Examples
-    ///
-    /// Print the slice split once by numbers divisible by 3 (i.e. `[10, 40]`,
-    /// `[20, 60, 50]`):
-    ///
-    /// ```
-    /// let v = [10, 40, 30, 20, 60, 50];
-    ///
-    /// for group in v.splitn(2, |num| *num % 3 == 0) {
-    ///     println!("{:?}", group);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn splitn<F>(&self, n: usize, pred: F) -> SplitN<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::splitn(self, n, pred)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred`, limited to returning at most `n` items. The matched element is
-    /// not contained in the subslices.
-    ///
-    /// The last element returned, if any, will contain the remainder of the
-    /// slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [10, 40, 30, 20, 60, 50];
-    ///
-    /// for group in v.splitn_mut(2, |num| *num % 3 == 0) {
-    ///     group[0] = 1;
-    /// }
-    /// assert_eq!(v, [1, 40, 30, 1, 60, 50]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn splitn_mut<F>(&mut self, n: usize, pred: F) -> SplitNMut<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::splitn_mut(self, n, pred)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred` limited to returning at most `n` items. This starts at the end of
-    /// the slice and works backwards.  The matched element is not contained in
-    /// the subslices.
-    ///
-    /// The last element returned, if any, will contain the remainder of the
-    /// slice.
-    ///
-    /// # Examples
-    ///
-    /// Print the slice split once, starting from the end, by numbers divisible
-    /// by 3 (i.e. `[50]`, `[10, 40, 30, 20]`):
-    ///
-    /// ```
-    /// let v = [10, 40, 30, 20, 60, 50];
-    ///
-    /// for group in v.rsplitn(2, |num| *num % 3 == 0) {
-    ///     println!("{:?}", group);
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rsplitn<F>(&self, n: usize, pred: F) -> RSplitN<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::rsplitn(self, n, pred)
-    }
-
-    /// Returns an iterator over subslices separated by elements that match
-    /// `pred` limited to returning at most `n` items. This starts at the end of
-    /// the slice and works backwards. The matched element is not contained in
-    /// the subslices.
-    ///
-    /// The last element returned, if any, will contain the remainder of the
-    /// slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut s = [10, 40, 30, 20, 60, 50];
-    ///
-    /// for group in s.rsplitn_mut(2, |num| *num % 3 == 0) {
-    ///     group[0] = 1;
-    /// }
-    /// assert_eq!(s, [1, 40, 30, 20, 60, 1]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rsplitn_mut<F>(&mut self, n: usize, pred: F) -> RSplitNMut<T, F>
-        where F: FnMut(&T) -> bool
-    {
-        core_slice::SliceExt::rsplitn_mut(self, n, pred)
-    }
-
-    /// Returns `true` if the slice contains an element with the given value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert!(v.contains(&30));
-    /// assert!(!v.contains(&50));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn contains(&self, x: &T) -> bool
-        where T: PartialEq
-    {
-        core_slice::SliceExt::contains(self, x)
-    }
-
-    /// Returns `true` if `needle` is a prefix of the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert!(v.starts_with(&[10]));
-    /// assert!(v.starts_with(&[10, 40]));
-    /// assert!(!v.starts_with(&[50]));
-    /// assert!(!v.starts_with(&[10, 50]));
-    /// ```
-    ///
-    /// Always returns `true` if `needle` is an empty slice:
-    ///
-    /// ```
-    /// let v = &[10, 40, 30];
-    /// assert!(v.starts_with(&[]));
-    /// let v: &[u8] = &[];
-    /// assert!(v.starts_with(&[]));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn starts_with(&self, needle: &[T]) -> bool
-        where T: PartialEq
-    {
-        core_slice::SliceExt::starts_with(self, needle)
-    }
-
-    /// Returns `true` if `needle` is a suffix of the slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = [10, 40, 30];
-    /// assert!(v.ends_with(&[30]));
-    /// assert!(v.ends_with(&[40, 30]));
-    /// assert!(!v.ends_with(&[50]));
-    /// assert!(!v.ends_with(&[50, 30]));
-    /// ```
-    ///
-    /// Always returns `true` if `needle` is an empty slice:
-    ///
-    /// ```
-    /// let v = &[10, 40, 30];
-    /// assert!(v.ends_with(&[]));
-    /// let v: &[u8] = &[];
-    /// assert!(v.ends_with(&[]));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn ends_with(&self, needle: &[T]) -> bool
-        where T: PartialEq
-    {
-        core_slice::SliceExt::ends_with(self, needle)
-    }
-
-    /// Binary searches this sorted slice for a given element.
-    ///
-    /// If the value is found then `Ok` is returned, containing the
-    /// index of the matching element; if the value is not found then
-    /// `Err` is returned, containing the index where a matching
-    /// element could be inserted while maintaining sorted order.
-    ///
-    /// # Example
-    ///
-    /// Looks up a series of four elements. The first is found, with a
-    /// uniquely determined position; the second and third are not
-    /// found; the fourth could match any position in `[1, 4]`.
-    ///
-    /// ```
-    /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
-    ///
-    /// assert_eq!(s.binary_search(&13),  Ok(9));
-    /// assert_eq!(s.binary_search(&4),   Err(7));
-    /// assert_eq!(s.binary_search(&100), Err(13));
-    /// let r = s.binary_search(&1);
-    /// assert!(match r { Ok(1...4) => true, _ => false, });
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn binary_search(&self, x: &T) -> Result<usize, usize>
-        where T: Ord
-    {
-        core_slice::SliceExt::binary_search(self, x)
-    }
-
-    /// Binary searches this sorted slice with a comparator function.
-    ///
-    /// The comparator function should implement an order consistent
-    /// with the sort order of the underlying slice, returning an
-    /// order code that indicates whether its argument is `Less`,
-    /// `Equal` or `Greater` the desired target.
-    ///
-    /// If a matching value is found then returns `Ok`, containing
-    /// the index for the matched element; if no match is found then
-    /// `Err` is returned, containing the index where a matching
-    /// element could be inserted while maintaining sorted order.
-    ///
-    /// # Example
-    ///
-    /// Looks up a series of four elements. The first is found, with a
-    /// uniquely determined position; the second and third are not
-    /// found; the fourth could match any position in `[1, 4]`.
-    ///
-    /// ```
-    /// let s = [0, 1, 1, 1, 1, 2, 3, 5, 8, 13, 21, 34, 55];
-    ///
-    /// let seek = 13;
-    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Ok(9));
-    /// let seek = 4;
-    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(7));
-    /// let seek = 100;
-    /// assert_eq!(s.binary_search_by(|probe| probe.cmp(&seek)), Err(13));
-    /// let seek = 1;
-    /// let r = s.binary_search_by(|probe| probe.cmp(&seek));
-    /// assert!(match r { Ok(1...4) => true, _ => false, });
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn binary_search_by<'a, F>(&'a self, f: F) -> Result<usize, usize>
-        where F: FnMut(&'a T) -> Ordering
-    {
-        core_slice::SliceExt::binary_search_by(self, f)
-    }
-
-    /// Binary searches this sorted slice with a key extraction function.
-    ///
-    /// Assumes that the slice is sorted by the key, for instance with
-    /// [`sort_by_key`] using the same key extraction function.
-    ///
-    /// If a matching value is found then returns `Ok`, containing the
-    /// index for the matched element; if no match is found then `Err`
-    /// is returned, containing the index where a matching element could
-    /// be inserted while maintaining sorted order.
-    ///
-    /// [`sort_by_key`]: #method.sort_by_key
-    ///
-    /// # Examples
-    ///
-    /// Looks up a series of four elements in a slice of pairs sorted by
-    /// their second elements. The first is found, with a uniquely
-    /// determined position; the second and third are not found; the
-    /// fourth could match any position in `[1, 4]`.
-    ///
-    /// ```
-    /// let s = [(0, 0), (2, 1), (4, 1), (5, 1), (3, 1),
-    ///          (1, 2), (2, 3), (4, 5), (5, 8), (3, 13),
-    ///          (1, 21), (2, 34), (4, 55)];
-    ///
-    /// assert_eq!(s.binary_search_by_key(&13, |&(a,b)| b),  Ok(9));
-    /// assert_eq!(s.binary_search_by_key(&4, |&(a,b)| b),   Err(7));
-    /// assert_eq!(s.binary_search_by_key(&100, |&(a,b)| b), Err(13));
-    /// let r = s.binary_search_by_key(&1, |&(a,b)| b);
-    /// assert!(match r { Ok(1...4) => true, _ => false, });
-    /// ```
-    #[stable(feature = "slice_binary_search_by_key", since = "1.10.0")]
-    #[inline]
-    pub fn binary_search_by_key<'a, B, F>(&'a self, b: &B, f: F) -> Result<usize, usize>
-        where F: FnMut(&'a T) -> B,
-              B: Ord
-    {
-        core_slice::SliceExt::binary_search_by_key(self, b, f)
-    }
-
-    /// Sorts the slice.
-    ///
-    /// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is an adaptive, iterative merge sort inspired by
-    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
-    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
-    /// two or more sorted sequences concatenated one after another.
-    ///
-    /// Also, it allocates temporary storage half the size of `self`, but for short slices a
-    /// non-allocating insertion sort is used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [-5, 4, 1, -3, 2];
-    ///
-    /// v.sort();
-    /// assert!(v == [-5, -3, 1, 2, 4]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn sort(&mut self)
-        where T: Ord
-    {
-        merge_sort(self, |a, b| a.lt(b));
-    }
-
-    /// Sorts the slice with a comparator function.
-    ///
-    /// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is an adaptive, iterative merge sort inspired by
-    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
-    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
-    /// two or more sorted sequences concatenated one after another.
-    ///
-    /// Also, it allocates temporary storage half the size of `self`, but for short slices a
-    /// non-allocating insertion sort is used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [5, 4, 1, 3, 2];
-    /// v.sort_by(|a, b| a.cmp(b));
-    /// assert!(v == [1, 2, 3, 4, 5]);
-    ///
-    /// // reverse sorting
-    /// v.sort_by(|a, b| b.cmp(a));
-    /// assert!(v == [5, 4, 3, 2, 1]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn sort_by<F>(&mut self, mut compare: F)
-        where F: FnMut(&T, &T) -> Ordering
-    {
-        merge_sort(self, |a, b| compare(a, b) == Less);
-    }
-
-    /// Sorts the slice with a key extraction function.
-    ///
-    /// This sort is stable (i.e. does not reorder equal elements) and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is an adaptive, iterative merge sort inspired by
-    /// [timsort](https://en.wikipedia.org/wiki/Timsort).
-    /// It is designed to be very fast in cases where the slice is nearly sorted, or consists of
-    /// two or more sorted sequences concatenated one after another.
-    ///
-    /// Also, it allocates temporary storage half the size of `self`, but for short slices a
-    /// non-allocating insertion sort is used instead.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = [-5i32, 4, 1, -3, 2];
-    ///
-    /// v.sort_by_key(|k| k.abs());
-    /// assert!(v == [1, 2, -3, 4, -5]);
-    /// ```
-    #[stable(feature = "slice_sort_by_key", since = "1.7.0")]
-    #[inline]
-    pub fn sort_by_key<B, F>(&mut self, mut f: F)
-        where F: FnMut(&T) -> B, B: Ord
-    {
-        merge_sort(self, |a, b| f(a).lt(&f(b)));
-    }
-
-    /// Sorts the slice, but may not preserve the order of equal elements.
-    ///
-    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),
-    /// and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is based on Orson Peters' [pattern-defeating quicksort][pdqsort],
-    /// which is a quicksort variant designed to be very fast on certain kinds of patterns,
-    /// sometimes achieving linear time. It is randomized but deterministic, and falls back to
-    /// heapsort on degenerate inputs.
-    ///
-    /// It is generally faster than stable sorting, except in a few special cases, e.g. when the
-    /// slice consists of several concatenated sorted sequences.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(sort_unstable)]
-    ///
-    /// let mut v = [-5, 4, 1, -3, 2];
-    ///
-    /// v.sort_unstable();
-    /// assert!(v == [-5, -3, 1, 2, 4]);
-    /// ```
-    ///
-    /// [pdqsort]: https://github.com/orlp/pdqsort
-    // FIXME #40585: Mention `sort_unstable` in the documentation for `sort`.
-    #[unstable(feature = "sort_unstable", issue = "40585")]
-    #[inline]
-    pub fn sort_unstable(&mut self)
-        where T: Ord
-    {
-        core_slice::SliceExt::sort_unstable(self);
-    }
-
-    /// Sorts the slice with a comparator function, but may not preserve the order of equal
-    /// elements.
-    ///
-    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),
-    /// and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is based on Orson Peters' [pattern-defeating quicksort][pdqsort],
-    /// which is a quicksort variant designed to be very fast on certain kinds of patterns,
-    /// sometimes achieving linear time. It is randomized but deterministic, and falls back to
-    /// heapsort on degenerate inputs.
-    ///
-    /// It is generally faster than stable sorting, except in a few special cases, e.g. when the
-    /// slice consists of several concatenated sorted sequences.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(sort_unstable)]
-    ///
-    /// let mut v = [5, 4, 1, 3, 2];
-    /// v.sort_unstable_by(|a, b| a.cmp(b));
-    /// assert!(v == [1, 2, 3, 4, 5]);
-    ///
-    /// // reverse sorting
-    /// v.sort_unstable_by(|a, b| b.cmp(a));
-    /// assert!(v == [5, 4, 3, 2, 1]);
-    /// ```
-    ///
-    /// [pdqsort]: https://github.com/orlp/pdqsort
-    // FIXME #40585: Mention `sort_unstable_by` in the documentation for `sort_by`.
-    #[unstable(feature = "sort_unstable", issue = "40585")]
-    #[inline]
-    pub fn sort_unstable_by<F>(&mut self, compare: F)
-        where F: FnMut(&T, &T) -> Ordering
-    {
-        core_slice::SliceExt::sort_unstable_by(self, compare);
-    }
-
-    /// Sorts the slice with a key extraction function, but may not preserve the order of equal
-    /// elements.
-    ///
-    /// This sort is unstable (i.e. may reorder equal elements), in-place (i.e. does not allocate),
-    /// and `O(n log n)` worst-case.
-    ///
-    /// # Current implementation
-    ///
-    /// The current algorithm is based on Orson Peters' [pattern-defeating quicksort][pdqsort],
-    /// which is a quicksort variant designed to be very fast on certain kinds of patterns,
-    /// sometimes achieving linear time. It is randomized but deterministic, and falls back to
-    /// heapsort on degenerate inputs.
-    ///
-    /// It is generally faster than stable sorting, except in a few special cases, e.g. when the
-    /// slice consists of several concatenated sorted sequences.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(sort_unstable)]
-    ///
-    /// let mut v = [-5i32, 4, 1, -3, 2];
-    ///
-    /// v.sort_unstable_by_key(|k| k.abs());
-    /// assert!(v == [1, 2, -3, 4, -5]);
-    /// ```
-    ///
-    /// [pdqsort]: https://github.com/orlp/pdqsort
-    // FIXME #40585: Mention `sort_unstable_by_key` in the documentation for `sort_by_key`.
-    #[unstable(feature = "sort_unstable", issue = "40585")]
-    #[inline]
-    pub fn sort_unstable_by_key<B, F>(&mut self, f: F)
-        where F: FnMut(&T) -> B,
-              B: Ord
-    {
-        core_slice::SliceExt::sort_unstable_by_key(self, f);
-    }
-
-    /// Permutes the slice in-place such that `self[mid..]` moves to the
-    /// beginning of the slice while `self[..mid]` moves to the end of the
-    /// slice.  Equivalently, rotates the slice `mid` places to the left
-    /// or `k = self.len() - mid` places to the right.
-    ///
-    /// This is a "k-rotation", a permutation in which item `i` moves to
-    /// position `i + k`, modulo the length of the slice.  See _Elements
-    /// of Programming_ [§10.4][eop].
-    ///
-    /// Rotation by `mid` and rotation by `k` are inverse operations.
-    ///
-    /// [eop]: https://books.google.com/books?id=CO9ULZGINlsC&pg=PA178&q=k-rotation
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if `mid` is greater than the length of the
-    /// slice.  (Note that `mid == self.len()` does _not_ panic; it's a nop
-    /// rotation with `k == 0`, the inverse of a rotation with `mid == 0`.)
-    ///
-    /// # Complexity
-    ///
-    /// Takes linear (in `self.len()`) time.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(slice_rotate)]
-    ///
-    /// let mut a = [1, 2, 3, 4, 5, 6, 7];
-    /// let mid = 2;
-    /// a.rotate(mid);
-    /// assert_eq!(&a, &[3, 4, 5, 6, 7, 1, 2]);
-    /// let k = a.len() - mid;
-    /// a.rotate(k);
-    /// assert_eq!(&a, &[1, 2, 3, 4, 5, 6, 7]);
-    ///
-    /// use std::ops::Range;
-    /// fn slide<T>(slice: &mut [T], range: Range<usize>, to: usize) {
-    ///     if to < range.start {
-    ///         slice[to..range.end].rotate(range.start-to);
-    ///     } else if to > range.end {
-    ///         slice[range.start..to].rotate(range.end-range.start);
-    ///     }
-    /// }
-    /// let mut v: Vec<_> = (0..10).collect();
-    /// slide(&mut v, 1..4, 7);
-    /// assert_eq!(&v, &[0, 4, 5, 6, 1, 2, 3, 7, 8, 9]);
-    /// slide(&mut v, 6..8, 1);
-    /// assert_eq!(&v, &[0, 3, 7, 4, 5, 6, 1, 2, 8, 9]);
-    /// ```
-    #[unstable(feature = "slice_rotate", issue = "41891")]
-    pub fn rotate(&mut self, mid: usize) {
-        core_slice::SliceExt::rotate(self, mid);
-    }
-
-    /// Copies the elements from `src` into `self`.
-    ///
-    /// The length of `src` must be the same as `self`.
-    ///
-    /// If `src` implements `Copy`, it can be more performant to use
-    /// [`copy_from_slice`].
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the two slices have different lengths.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let mut dst = [0, 0, 0];
-    /// let src = [1, 2, 3];
-    ///
-    /// dst.clone_from_slice(&src);
-    /// assert!(dst == [1, 2, 3]);
-    /// ```
-    ///
-    /// [`copy_from_slice`]: #method.copy_from_slice
-    #[stable(feature = "clone_from_slice", since = "1.7.0")]
-    pub fn clone_from_slice(&mut self, src: &[T]) where T: Clone {
-        core_slice::SliceExt::clone_from_slice(self, src)
-    }
-
-    /// Copies all elements from `src` into `self`, using a memcpy.
-    ///
-    /// The length of `src` must be the same as `self`.
-    ///
-    /// If `src` does not implement `Copy`, use [`clone_from_slice`].
-    ///
-    /// # Panics
-    ///
-    /// This function will panic if the two slices have different lengths.
-    ///
-    /// # Example
-    ///
-    /// ```
-    /// let mut dst = [0, 0, 0];
-    /// let src = [1, 2, 3];
-    ///
-    /// dst.copy_from_slice(&src);
-    /// assert_eq!(src, dst);
-    /// ```
-    ///
-    /// [`clone_from_slice`]: #method.clone_from_slice
-    #[stable(feature = "copy_from_slice", since = "1.9.0")]
-    pub fn copy_from_slice(&mut self, src: &[T]) where T: Copy {
-        core_slice::SliceExt::copy_from_slice(self, src)
-    }
-
-    /// Copies `self` into a new `Vec`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let s = [10, 40, 30];
-    /// let x = s.to_vec();
-    /// // Here, `s` and `x` can be modified independently.
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn to_vec(&self) -> Vec<T>
-        where T: Clone
-    {
-        // NB see hack module in this file
-        hack::to_vec(self)
-    }
-
-    /// Converts `self` into a vector without clones or allocation.
-    ///
-    /// The resulting vector can be converted back into a box via
-    /// `Vec<T>`'s `into_boxed_slice` method.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let s: Box<[i32]> = Box::new([10, 40, 30]);
-    /// let x = s.into_vec();
-    /// // `s` cannot be used anymore because it has been converted into `x`.
-    ///
-    /// assert_eq!(x, vec![10, 40, 30]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn into_vec(self: Box<Self>) -> Vec<T> {
-        // NB see hack module in this file
-        hack::into_vec(self)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Extension traits for slices over specific kinds of data
-////////////////////////////////////////////////////////////////////////////////
-#[unstable(feature = "slice_concat_ext",
-           reason = "trait should not have to exist",
-           issue = "27747")]
-/// An extension trait for concatenating slices
-pub trait SliceConcatExt<T: ?Sized> {
-    #[unstable(feature = "slice_concat_ext",
-               reason = "trait should not have to exist",
-               issue = "27747")]
-    /// The resulting type after concatenation
-    type Output;
-
-    /// Flattens a slice of `T` into a single value `Self::Output`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(["hello", "world"].concat(), "helloworld");
-    /// assert_eq!([[1, 2], [3, 4]].concat(), [1, 2, 3, 4]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn concat(&self) -> Self::Output;
-
-    /// Flattens a slice of `T` into a single value `Self::Output`, placing a
-    /// given separator between each.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// assert_eq!(["hello", "world"].join(" "), "hello world");
-    /// assert_eq!([[1, 2], [3, 4]].join(&0), [1, 2, 0, 3, 4]);
-    /// ```
-    #[stable(feature = "rename_connect_to_join", since = "1.3.0")]
-    fn join(&self, sep: &T) -> Self::Output;
-
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_deprecated(since = "1.3.0", reason = "renamed to join")]
-    fn connect(&self, sep: &T) -> Self::Output;
-}
-
-#[unstable(feature = "slice_concat_ext",
-           reason = "trait should not have to exist",
-           issue = "27747")]
-impl<T: Clone, V: Borrow<[T]>> SliceConcatExt<T> for [V] {
-    type Output = Vec<T>;
-
-    fn concat(&self) -> Vec<T> {
-        let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());
-        let mut result = Vec::with_capacity(size);
-        for v in self {
-            result.extend_from_slice(v.borrow())
-        }
-        result
-    }
-
-    fn join(&self, sep: &T) -> Vec<T> {
-        let size = self.iter().fold(0, |acc, v| acc + v.borrow().len());
-        let mut result = Vec::with_capacity(size + self.len());
-        let mut first = true;
-        for v in self {
-            if first {
-                first = false
-            } else {
-                result.push(sep.clone())
-            }
-            result.extend_from_slice(v.borrow())
-        }
-        result
-    }
-
-    fn connect(&self, sep: &T) -> Vec<T> {
-        self.join(sep)
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Standard trait implementations for slices
-////////////////////////////////////////////////////////////////////////////////
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Borrow<[T]> for Vec<T> {
-    fn borrow(&self) -> &[T] {
-        &self[..]
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> BorrowMut<[T]> for Vec<T> {
-    fn borrow_mut(&mut self) -> &mut [T] {
-        &mut self[..]
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> ToOwned for [T] {
-    type Owned = Vec<T>;
-    #[cfg(not(test))]
-    fn to_owned(&self) -> Vec<T> {
-        self.to_vec()
-    }
-
-    #[cfg(test)]
-    fn to_owned(&self) -> Vec<T> {
-        hack::to_vec(self)
-    }
-
-    fn clone_into(&self, target: &mut Vec<T>) {
-        // drop anything in target that will not be overwritten
-        target.truncate(self.len());
-        let len = target.len();
-
-        // reuse the contained values' allocations/resources.
-        target.clone_from_slice(&self[..len]);
-
-        // target.len <= self.len due to the truncate above, so the
-        // slice here is always in-bounds.
-        target.extend_from_slice(&self[len..]);
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Sorting
-////////////////////////////////////////////////////////////////////////////////
-
-/// Inserts `v[0]` into pre-sorted sequence `v[1..]` so that whole `v[..]` becomes sorted.
-///
-/// This is the integral subroutine of insertion sort.
-fn insert_head<T, F>(v: &mut [T], is_less: &mut F)
-    where F: FnMut(&T, &T) -> bool
-{
-    if v.len() >= 2 && is_less(&v[1], &v[0]) {
-        unsafe {
-            // There are three ways to implement insertion here:
-            //
-            // 1. Swap adjacent elements until the first one gets to its final destination.
-            //    However, this way we copy data around more than is necessary. If elements are big
-            //    structures (costly to copy), this method will be slow.
-            //
-            // 2. Iterate until the right place for the first element is found. Then shift the
-            //    elements succeeding it to make room for it and finally place it into the
-            //    remaining hole. This is a good method.
-            //
-            // 3. Copy the first element into a temporary variable. Iterate until the right place
-            //    for it is found. As we go along, copy every traversed element into the slot
-            //    preceding it. Finally, copy data from the temporary variable into the remaining
-            //    hole. This method is very good. Benchmarks demonstrated slightly better
-            //    performance than with the 2nd method.
-            //
-            // All methods were benchmarked, and the 3rd showed best results. So we chose that one.
-            let mut tmp = mem::ManuallyDrop::new(ptr::read(&v[0]));
-
-            // Intermediate state of the insertion process is always tracked by `hole`, which
-            // serves two purposes:
-            // 1. Protects integrity of `v` from panics in `is_less`.
-            // 2. Fills the remaining hole in `v` in the end.
-            //
-            // Panic safety:
-            //
-            // If `is_less` panics at any point during the process, `hole` will get dropped and
-            // fill the hole in `v` with `tmp`, thus ensuring that `v` still holds every object it
-            // initially held exactly once.
-            let mut hole = InsertionHole {
-                src: &mut *tmp,
-                dest: &mut v[1],
-            };
-            ptr::copy_nonoverlapping(&v[1], &mut v[0], 1);
-
-            for i in 2..v.len() {
-                if !is_less(&v[i], &*tmp) {
-                    break;
-                }
-                ptr::copy_nonoverlapping(&v[i], &mut v[i - 1], 1);
-                hole.dest = &mut v[i];
-            }
-            // `hole` gets dropped and thus copies `tmp` into the remaining hole in `v`.
-        }
-    }
-
-    // When dropped, copies from `src` into `dest`.
-    struct InsertionHole<T> {
-        src: *mut T,
-        dest: *mut T,
-    }
-
-    impl<T> Drop for InsertionHole<T> {
-        fn drop(&mut self) {
-            unsafe { ptr::copy_nonoverlapping(self.src, self.dest, 1); }
-        }
-    }
-}
-
-/// Merges non-decreasing runs `v[..mid]` and `v[mid..]` using `buf` as temporary storage, and
-/// stores the result into `v[..]`.
-///
-/// # Safety
-///
-/// The two slices must be non-empty and `mid` must be in bounds. Buffer `buf` must be long enough
-/// to hold a copy of the shorter slice. Also, `T` must not be a zero-sized type.
-unsafe fn merge<T, F>(v: &mut [T], mid: usize, buf: *mut T, is_less: &mut F)
-    where F: FnMut(&T, &T) -> bool
-{
-    let len = v.len();
-    let v = v.as_mut_ptr();
-    let v_mid = v.offset(mid as isize);
-    let v_end = v.offset(len as isize);
-
-    // The merge process first copies the shorter run into `buf`. Then it traces the newly copied
-    // run and the longer run forwards (or backwards), comparing their next unconsumed elements and
-    // copying the lesser (or greater) one into `v`.
-    //
-    // As soon as the shorter run is fully consumed, the process is done. If the longer run gets
-    // consumed first, then we must copy whatever is left of the shorter run into the remaining
-    // hole in `v`.
-    //
-    // Intermediate state of the process is always tracked by `hole`, which serves two purposes:
-    // 1. Protects integrity of `v` from panics in `is_less`.
-    // 2. Fills the remaining hole in `v` if the longer run gets consumed first.
-    //
-    // Panic safety:
-    //
-    // If `is_less` panics at any point during the process, `hole` will get dropped and fill the
-    // hole in `v` with the unconsumed range in `buf`, thus ensuring that `v` still holds every
-    // object it initially held exactly once.
-    let mut hole;
-
-    if mid <= len - mid {
-        // The left run is shorter.
-        ptr::copy_nonoverlapping(v, buf, mid);
-        hole = MergeHole {
-            start: buf,
-            end: buf.offset(mid as isize),
-            dest: v,
-        };
-
-        // Initially, these pointers point to the beginnings of their arrays.
-        let left = &mut hole.start;
-        let mut right = v_mid;
-        let out = &mut hole.dest;
-
-        while *left < hole.end && right < v_end {
-            // Consume the lesser side.
-            // If equal, prefer the left run to maintain stability.
-            let to_copy = if is_less(&*right, &**left) {
-                get_and_increment(&mut right)
-            } else {
-                get_and_increment(left)
-            };
-            ptr::copy_nonoverlapping(to_copy, get_and_increment(out), 1);
-        }
-    } else {
-        // The right run is shorter.
-        ptr::copy_nonoverlapping(v_mid, buf, len - mid);
-        hole = MergeHole {
-            start: buf,
-            end: buf.offset((len - mid) as isize),
-            dest: v_mid,
-        };
-
-        // Initially, these pointers point past the ends of their arrays.
-        let left = &mut hole.dest;
-        let right = &mut hole.end;
-        let mut out = v_end;
-
-        while v < *left && buf < *right {
-            // Consume the greater side.
-            // If equal, prefer the right run to maintain stability.
-            let to_copy = if is_less(&*right.offset(-1), &*left.offset(-1)) {
-                decrement_and_get(left)
-            } else {
-                decrement_and_get(right)
-            };
-            ptr::copy_nonoverlapping(to_copy, decrement_and_get(&mut out), 1);
-        }
-    }
-    // Finally, `hole` gets dropped. If the shorter run was not fully consumed, whatever remains of
-    // it will now be copied into the hole in `v`.
-
-    unsafe fn get_and_increment<T>(ptr: &mut *mut T) -> *mut T {
-        let old = *ptr;
-        *ptr = ptr.offset(1);
-        old
-    }
-
-    unsafe fn decrement_and_get<T>(ptr: &mut *mut T) -> *mut T {
-        *ptr = ptr.offset(-1);
-        *ptr
-    }
-
-    // When dropped, copies the range `start..end` into `dest..`.
-    struct MergeHole<T> {
-        start: *mut T,
-        end: *mut T,
-        dest: *mut T,
-    }
-
-    impl<T> Drop for MergeHole<T> {
-        fn drop(&mut self) {
-            // `T` is not a zero-sized type, so it's okay to divide by it's size.
-            let len = (self.end as usize - self.start as usize) / mem::size_of::<T>();
-            unsafe { ptr::copy_nonoverlapping(self.start, self.dest, len); }
-        }
-    }
-}
-
-/// This merge sort borrows some (but not all) ideas from TimSort, which is described in detail
-/// [here](http://svn.python.org/projects/python/trunk/Objects/listsort.txt).
-///
-/// The algorithm identifies strictly descending and non-descending subsequences, which are called
-/// natural runs. There is a stack of pending runs yet to be merged. Each newly found run is pushed
-/// onto the stack, and then some pairs of adjacent runs are merged until these two invariants are
-/// satisfied:
-///
-/// 1. for every `i` in `1..runs.len()`: `runs[i - 1].len > runs[i].len`
-/// 2. for every `i` in `2..runs.len()`: `runs[i - 2].len > runs[i - 1].len + runs[i].len`
-///
-/// The invariants ensure that the total running time is `O(n log n)` worst-case.
-fn merge_sort<T, F>(v: &mut [T], mut is_less: F)
-    where F: FnMut(&T, &T) -> bool
-{
-    // Slices of up to this length get sorted using insertion sort.
-    const MAX_INSERTION: usize = 20;
-    // Very short runs are extended using insertion sort to span at least this many elements.
-    const MIN_RUN: usize = 10;
-
-    // Sorting has no meaningful behavior on zero-sized types.
-    if size_of::<T>() == 0 {
-        return;
-    }
-
-    let len = v.len();
-
-    // Short arrays get sorted in-place via insertion sort to avoid allocations.
-    if len <= MAX_INSERTION {
-        if len >= 2 {
-            for i in (0..len-1).rev() {
-                insert_head(&mut v[i..], &mut is_less);
-            }
-        }
-        return;
-    }
-
-    // Allocate a buffer to use as scratch memory. We keep the length 0 so we can keep in it
-    // shallow copies of the contents of `v` without risking the dtors running on copies if
-    // `is_less` panics. When merging two sorted runs, this buffer holds a copy of the shorter run,
-    // which will always have length at most `len / 2`.
-    let mut buf = Vec::with_capacity(len / 2);
-
-    // In order to identify natural runs in `v`, we traverse it backwards. That might seem like a
-    // strange decision, but consider the fact that merges more often go in the opposite direction
-    // (forwards). According to benchmarks, merging forwards is slightly faster than merging
-    // backwards. To conclude, identifying runs by traversing backwards improves performance.
-    let mut runs = vec![];
-    let mut end = len;
-    while end > 0 {
-        // Find the next natural run, and reverse it if it's strictly descending.
-        let mut start = end - 1;
-        if start > 0 {
-            start -= 1;
-            unsafe {
-                if is_less(v.get_unchecked(start + 1), v.get_unchecked(start)) {
-                    while start > 0 && is_less(v.get_unchecked(start),
-                                               v.get_unchecked(start - 1)) {
-                        start -= 1;
-                    }
-                    v[start..end].reverse();
-                } else {
-                    while start > 0 && !is_less(v.get_unchecked(start),
-                                                v.get_unchecked(start - 1)) {
-                        start -= 1;
-                    }
-                }
-            }
-        }
-
-        // Insert some more elements into the run if it's too short. Insertion sort is faster than
-        // merge sort on short sequences, so this significantly improves performance.
-        while start > 0 && end - start < MIN_RUN {
-            start -= 1;
-            insert_head(&mut v[start..end], &mut is_less);
-        }
-
-        // Push this run onto the stack.
-        runs.push(Run {
-            start: start,
-            len: end - start,
-        });
-        end = start;
-
-        // Merge some pairs of adjacent runs to satisfy the invariants.
-        while let Some(r) = collapse(&runs) {
-            let left = runs[r + 1];
-            let right = runs[r];
-            unsafe {
-                merge(&mut v[left.start .. right.start + right.len], left.len, buf.as_mut_ptr(),
-                      &mut is_less);
-            }
-            runs[r] = Run {
-                start: left.start,
-                len: left.len + right.len,
-            };
-            runs.remove(r + 1);
-        }
-    }
-
-    // Finally, exactly one run must remain in the stack.
-    debug_assert!(runs.len() == 1 && runs[0].start == 0 && runs[0].len == len);
-
-    // Examines the stack of runs and identifies the next pair of runs to merge. More specifically,
-    // if `Some(r)` is returned, that means `runs[r]` and `runs[r + 1]` must be merged next. If the
-    // algorithm should continue building a new run instead, `None` is returned.
-    //
-    // TimSort is infamous for it's buggy implementations, as described here:
-    // http://envisage-project.eu/timsort-specification-and-verification/
-    //
-    // The gist of the story is: we must enforce the invariants on the top four runs on the stack.
-    // Enforcing them on just top three is not sufficient to ensure that the invariants will still
-    // hold for *all* runs in the stack.
-    //
-    // This function correctly checks invariants for the top four runs. Additionally, if the top
-    // run starts at index 0, it will always demand a merge operation until the stack is fully
-    // collapsed, in order to complete the sort.
-    #[inline]
-    fn collapse(runs: &[Run]) -> Option<usize> {
-        let n = runs.len();
-        if n >= 2 && (runs[n - 1].start == 0 ||
-                      runs[n - 2].len <= runs[n - 1].len ||
-                      (n >= 3 && runs[n - 3].len <= runs[n - 2].len + runs[n - 1].len) ||
-                      (n >= 4 && runs[n - 4].len <= runs[n - 3].len + runs[n - 2].len)) {
-            if n >= 3 && runs[n - 3].len < runs[n - 1].len {
-                Some(n - 3)
-            } else {
-                Some(n - 2)
-            }
-        } else {
-            None
-        }
-    }
-
-    #[derive(Clone, Copy)]
-    struct Run {
-        start: usize,
-        len: usize,
-    }
-}
diff --git a/src/libcollections/str.rs b/src/libcollections/str.rs
deleted file mode 100644
index fdb6ee42127..00000000000
--- a/src/libcollections/str.rs
+++ /dev/null
@@ -1,1997 +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.
-
-//! Unicode string slices.
-//!
-//! The `&str` type is one of the two main string types, the other being `String`.
-//! Unlike its `String` counterpart, its contents are borrowed.
-//!
-//! # Basic Usage
-//!
-//! A basic string declaration of `&str` type:
-//!
-//! ```
-//! let hello_world = "Hello, World!";
-//! ```
-//!
-//! Here we have declared a string literal, also known as a string slice.
-//! String literals have a static lifetime, which means the string `hello_world`
-//! is guaranteed to be valid for the duration of the entire program.
-//! We can explicitly specify `hello_world`'s lifetime as well:
-//!
-//! ```
-//! let hello_world: &'static str = "Hello, world!";
-//! ```
-//!
-//! *[See also the `str` primitive type](../../std/primitive.str.html).*
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-// Many of the usings in this module are only used in the test configuration.
-// It's cleaner to just turn off the unused_imports warning than to fix them.
-#![allow(unused_imports)]
-
-use core::fmt;
-use core::str as core_str;
-use core::str::pattern::Pattern;
-use core::str::pattern::{Searcher, ReverseSearcher, DoubleEndedSearcher};
-use core::mem;
-use core::iter::FusedIterator;
-use std_unicode::str::{UnicodeStr, Utf16Encoder};
-
-use vec_deque::VecDeque;
-use borrow::{Borrow, ToOwned};
-use string::String;
-use std_unicode;
-use vec::Vec;
-use slice::{SliceConcatExt, SliceIndex};
-use boxed::Box;
-
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{FromStr, Utf8Error};
-#[allow(deprecated)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{Lines, LinesAny};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{Split, RSplit};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{SplitN, RSplitN};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{SplitTerminator, RSplitTerminator};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{Matches, RMatches};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{MatchIndices, RMatchIndices};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{from_utf8, from_utf8_mut, Chars, CharIndices, Bytes};
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::{from_utf8_unchecked, from_utf8_unchecked_mut, ParseBoolError};
-#[unstable(feature = "str_box_extras", issue = "41119")]
-pub use alloc::str::from_boxed_utf8_unchecked;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use std_unicode::str::SplitWhitespace;
-#[stable(feature = "rust1", since = "1.0.0")]
-pub use core::str::pattern;
-
-
-#[unstable(feature = "slice_concat_ext",
-           reason = "trait should not have to exist",
-           issue = "27747")]
-impl<S: Borrow<str>> SliceConcatExt<str> for [S] {
-    type Output = String;
-
-    fn concat(&self) -> String {
-        if self.is_empty() {
-            return String::new();
-        }
-
-        // `len` calculation may overflow but push_str will check boundaries
-        let len = self.iter().map(|s| s.borrow().len()).sum();
-        let mut result = String::with_capacity(len);
-
-        for s in self {
-            result.push_str(s.borrow())
-        }
-
-        result
-    }
-
-    fn join(&self, sep: &str) -> String {
-        if self.is_empty() {
-            return String::new();
-        }
-
-        // concat is faster
-        if sep.is_empty() {
-            return self.concat();
-        }
-
-        // this is wrong without the guarantee that `self` is non-empty
-        // `len` calculation may overflow but push_str but will check boundaries
-        let len = sep.len() * (self.len() - 1) +
-                  self.iter().map(|s| s.borrow().len()).sum::<usize>();
-        let mut result = String::with_capacity(len);
-        let mut first = true;
-
-        for s in self {
-            if first {
-                first = false;
-            } else {
-                result.push_str(sep);
-            }
-            result.push_str(s.borrow());
-        }
-        result
-    }
-
-    fn connect(&self, sep: &str) -> String {
-        self.join(sep)
-    }
-}
-
-/// An iterator of [`u16`] over the string encoded as UTF-16.
-///
-/// [`u16`]: ../../std/primitive.u16.html
-///
-/// This struct is created by the [`encode_utf16`] method on [`str`].
-/// See its documentation for more.
-///
-/// [`encode_utf16`]: ../../std/primitive.str.html#method.encode_utf16
-/// [`str`]: ../../std/primitive.str.html
-#[derive(Clone)]
-#[stable(feature = "encode_utf16", since = "1.8.0")]
-pub struct EncodeUtf16<'a> {
-    encoder: Utf16Encoder<Chars<'a>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a> fmt::Debug for EncodeUtf16<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("EncodeUtf16 { .. }")
-    }
-}
-
-#[stable(feature = "encode_utf16", since = "1.8.0")]
-impl<'a> Iterator for EncodeUtf16<'a> {
-    type Item = u16;
-
-    #[inline]
-    fn next(&mut self) -> Option<u16> {
-        self.encoder.next()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.encoder.size_hint()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a> FusedIterator for EncodeUtf16<'a> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Borrow<str> for String {
-    #[inline]
-    fn borrow(&self) -> &str {
-        &self[..]
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ToOwned for str {
-    type Owned = String;
-    fn to_owned(&self) -> String {
-        unsafe { String::from_utf8_unchecked(self.as_bytes().to_owned()) }
-    }
-
-    fn clone_into(&self, target: &mut String) {
-        let mut b = mem::replace(target, String::new()).into_bytes();
-        self.as_bytes().clone_into(&mut b);
-        *target = unsafe { String::from_utf8_unchecked(b) }
-    }
-}
-
-/// Methods for string slices.
-#[lang = "str"]
-#[cfg(not(test))]
-impl str {
-    /// Returns the length of `self`.
-    ///
-    /// This length is in bytes, not [`char`]s or graphemes. In other words,
-    /// it may not be what a human considers the length of the string.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let len = "foo".len();
-    /// assert_eq!(3, len);
-    ///
-    /// let len = "ƒoo".len(); // fancy f!
-    /// assert_eq!(4, len);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn len(&self) -> usize {
-        core_str::StrExt::len(self)
-    }
-
-    /// Returns `true` if `self` has a length of zero bytes.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "";
-    /// assert!(s.is_empty());
-    ///
-    /// let s = "not empty";
-    /// assert!(!s.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        core_str::StrExt::is_empty(self)
-    }
-
-    /// Checks that `index`-th byte lies at the start and/or end of a
-    /// UTF-8 code point sequence.
-    ///
-    /// The start and end of the string (when `index == self.len()`) are
-    /// considered to be
-    /// boundaries.
-    ///
-    /// Returns `false` if `index` is greater than `self.len()`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    /// assert!(s.is_char_boundary(0));
-    /// // start of `老`
-    /// assert!(s.is_char_boundary(6));
-    /// assert!(s.is_char_boundary(s.len()));
-    ///
-    /// // second byte of `ö`
-    /// assert!(!s.is_char_boundary(2));
-    ///
-    /// // third byte of `老`
-    /// assert!(!s.is_char_boundary(8));
-    /// ```
-    #[stable(feature = "is_char_boundary", since = "1.9.0")]
-    #[inline]
-    pub fn is_char_boundary(&self, index: usize) -> bool {
-        core_str::StrExt::is_char_boundary(self, index)
-    }
-
-    /// Converts a string slice to a byte slice.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let bytes = "bors".as_bytes();
-    /// assert_eq!(b"bors", bytes);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline(always)]
-    pub fn as_bytes(&self) -> &[u8] {
-        core_str::StrExt::as_bytes(self)
-    }
-
-    /// Converts a mutable string slice to a mutable byte slice.
-    #[unstable(feature = "str_mut_extras", issue = "41119")]
-    #[inline(always)]
-    pub unsafe fn as_bytes_mut(&mut self) -> &mut [u8] {
-        core_str::StrExt::as_bytes_mut(self)
-    }
-
-    /// Converts a string slice to a raw pointer.
-    ///
-    /// As string slices are a slice of bytes, the raw pointer points to a
-    /// [`u8`]. This pointer will be pointing to the first byte of the string
-    /// slice.
-    ///
-    /// [`u8`]: primitive.u8.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "Hello";
-    /// let ptr = s.as_ptr();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn as_ptr(&self) -> *const u8 {
-        core_str::StrExt::as_ptr(self)
-    }
-
-    /// Returns a subslice of `str`.
-    ///
-    /// This is the non-panicking alternative to indexing the `str`. Returns
-    /// [`None`] whenever equivalent indexing operation would panic.
-    ///
-    /// [`None`]: option/enum.Option.html#variant.None
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(str_checked_slicing)]
-    /// let v = "🗻∈🌏";
-    /// assert_eq!(Some("🗻"), v.get(0..4));
-    /// assert!(v.get(1..).is_none());
-    /// assert!(v.get(..8).is_none());
-    /// assert!(v.get(..42).is_none());
-    /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
-    #[inline]
-    pub fn get<I: SliceIndex<str>>(&self, i: I) -> Option<&I::Output> {
-        core_str::StrExt::get(self, i)
-    }
-
-    /// Returns a mutable subslice of `str`.
-    ///
-    /// This is the non-panicking alternative to indexing the `str`. Returns
-    /// [`None`] whenever equivalent indexing operation would panic.
-    ///
-    /// [`None`]: option/enum.Option.html#variant.None
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(str_checked_slicing)]
-    /// let mut v = String::from("🗻∈🌏");
-    /// assert_eq!(Some("🗻"), v.get_mut(0..4).map(|v| &*v));
-    /// assert!(v.get_mut(1..).is_none());
-    /// assert!(v.get_mut(..8).is_none());
-    /// assert!(v.get_mut(..42).is_none());
-    /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
-    #[inline]
-    pub fn get_mut<I: SliceIndex<str>>(&mut self, i: I) -> Option<&mut I::Output> {
-        core_str::StrExt::get_mut(self, i)
-    }
-
-    /// Returns a unchecked subslice of `str`.
-    ///
-    /// This is the unchecked alternative to indexing the `str`.
-    ///
-    /// # Safety
-    ///
-    /// Callers of this function are responsible that these preconditions are
-    /// satisfied:
-    ///
-    /// * The starting index must come before the ending index;
-    /// * Indexes must be within bounds of the original slice;
-    /// * Indexes must lie on UTF-8 sequence boundaries.
-    ///
-    /// Failing that, the returned string slice may reference invalid memory or
-    /// violate the invariants communicated by the `str` type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(str_checked_slicing)]
-    /// let v = "🗻∈🌏";
-    /// unsafe {
-    ///     assert_eq!("🗻", v.get_unchecked(0..4));
-    ///     assert_eq!("∈", v.get_unchecked(4..7));
-    ///     assert_eq!("🌏", v.get_unchecked(7..11));
-    /// }
-    /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
-    #[inline]
-    pub unsafe fn get_unchecked<I: SliceIndex<str>>(&self, i: I) -> &I::Output {
-        core_str::StrExt::get_unchecked(self, i)
-    }
-
-    /// Returns a mutable, unchecked subslice of `str`.
-    ///
-    /// This is the unchecked alternative to indexing the `str`.
-    ///
-    /// # Safety
-    ///
-    /// Callers of this function are responsible that these preconditions are
-    /// satisfied:
-    ///
-    /// * The starting index must come before the ending index;
-    /// * Indexes must be within bounds of the original slice;
-    /// * Indexes must lie on UTF-8 sequence boundaries.
-    ///
-    /// Failing that, the returned string slice may reference invalid memory or
-    /// violate the invariants communicated by the `str` type.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(str_checked_slicing)]
-    /// let mut v = String::from("🗻∈🌏");
-    /// unsafe {
-    ///     assert_eq!("🗻", v.get_unchecked_mut(0..4));
-    ///     assert_eq!("∈", v.get_unchecked_mut(4..7));
-    ///     assert_eq!("🌏", v.get_unchecked_mut(7..11));
-    /// }
-    /// ```
-    #[unstable(feature = "str_checked_slicing", issue = "39932")]
-    #[inline]
-    pub unsafe fn get_unchecked_mut<I: SliceIndex<str>>(&mut self, i: I) -> &mut I::Output {
-        core_str::StrExt::get_unchecked_mut(self, i)
-    }
-
-    /// Creates a string slice from another string slice, bypassing safety
-    /// checks.
-    ///
-    /// This is generally not recommended, use with caution! For a safe
-    /// alternative see [`str`] and [`Index`].
-    ///
-    /// [`str`]: primitive.str.html
-    /// [`Index`]: ops/trait.Index.html
-    ///
-    /// This new slice goes from `begin` to `end`, including `begin` but
-    /// excluding `end`.
-    ///
-    /// To get a mutable string slice instead, see the
-    /// [`slice_mut_unchecked`] method.
-    ///
-    /// [`slice_mut_unchecked`]: #method.slice_mut_unchecked
-    ///
-    /// # Safety
-    ///
-    /// Callers of this function are responsible that three preconditions are
-    /// satisfied:
-    ///
-    /// * `begin` must come before `end`.
-    /// * `begin` and `end` must be byte positions within the string slice.
-    /// * `begin` and `end` must lie on UTF-8 sequence boundaries.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    ///
-    /// unsafe {
-    ///     assert_eq!("Löwe 老虎 Léopard", s.slice_unchecked(0, 21));
-    /// }
-    ///
-    /// let s = "Hello, world!";
-    ///
-    /// unsafe {
-    ///     assert_eq!("world", s.slice_unchecked(7, 12));
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub unsafe fn slice_unchecked(&self, begin: usize, end: usize) -> &str {
-        core_str::StrExt::slice_unchecked(self, begin, end)
-    }
-
-    /// Creates a string slice from another string slice, bypassing safety
-    /// checks.
-    /// This is generally not recommended, use with caution! For a safe
-    /// alternative see [`str`] and [`IndexMut`].
-    ///
-    /// [`str`]: primitive.str.html
-    /// [`IndexMut`]: ops/trait.IndexMut.html
-    ///
-    /// This new slice goes from `begin` to `end`, including `begin` but
-    /// excluding `end`.
-    ///
-    /// To get an immutable string slice instead, see the
-    /// [`slice_unchecked`] method.
-    ///
-    /// [`slice_unchecked`]: #method.slice_unchecked
-    ///
-    /// # Safety
-    ///
-    /// Callers of this function are responsible that three preconditions are
-    /// satisfied:
-    ///
-    /// * `begin` must come before `end`.
-    /// * `begin` and `end` must be byte positions within the string slice.
-    /// * `begin` and `end` must lie on UTF-8 sequence boundaries.
-    #[stable(feature = "str_slice_mut", since = "1.5.0")]
-    #[inline]
-    pub unsafe fn slice_mut_unchecked(&mut self, begin: usize, end: usize) -> &mut str {
-        core_str::StrExt::slice_mut_unchecked(self, begin, end)
-    }
-
-    /// Divide one string slice into two at an index.
-    ///
-    /// The argument, `mid`, should be a byte offset from the start of the
-    /// string. It must also be on the boundary of a UTF-8 code point.
-    ///
-    /// The two slices returned go from the start of the string slice to `mid`,
-    /// and from `mid` to the end of the string slice.
-    ///
-    /// To get mutable string slices instead, see the [`split_at_mut`]
-    /// method.
-    ///
-    /// [`split_at_mut`]: #method.split_at_mut
-    ///
-    /// # Panics
-    ///
-    /// Panics if `mid` is not on a UTF-8 code point boundary, or if it is
-    /// beyond the last code point of the string slice.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "Per Martin-Löf";
-    ///
-    /// let (first, last) = s.split_at(3);
-    ///
-    /// assert_eq!("Per", first);
-    /// assert_eq!(" Martin-Löf", last);
-    /// ```
-    #[inline]
-    #[stable(feature = "str_split_at", since = "1.4.0")]
-    pub fn split_at(&self, mid: usize) -> (&str, &str) {
-        core_str::StrExt::split_at(self, mid)
-    }
-
-    /// Divide one mutable string slice into two at an index.
-    ///
-    /// The argument, `mid`, should be a byte offset from the start of the
-    /// string. It must also be on the boundary of a UTF-8 code point.
-    ///
-    /// The two slices returned go from the start of the string slice to `mid`,
-    /// and from `mid` to the end of the string slice.
-    ///
-    /// To get immutable string slices instead, see the [`split_at`] method.
-    ///
-    /// [`split_at`]: #method.split_at
-    ///
-    /// # Panics
-    ///
-    /// Panics if `mid` is not on a UTF-8 code point boundary, or if it is
-    /// beyond the last code point of the string slice.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = "Per Martin-Löf".to_string();
-    ///
-    /// let (first, last) = s.split_at_mut(3);
-    ///
-    /// assert_eq!("Per", first);
-    /// assert_eq!(" Martin-Löf", last);
-    /// ```
-    #[inline]
-    #[stable(feature = "str_split_at", since = "1.4.0")]
-    pub fn split_at_mut(&mut self, mid: usize) -> (&mut str, &mut str) {
-        core_str::StrExt::split_at_mut(self, mid)
-    }
-
-    /// Returns an iterator over the [`char`]s of a string slice.
-    ///
-    /// As a string slice consists of valid UTF-8, we can iterate through a
-    /// string slice by [`char`]. This method returns such an iterator.
-    ///
-    /// It's important to remember that [`char`] represents a Unicode Scalar
-    /// Value, and may not match your idea of what a 'character' is. Iteration
-    /// over grapheme clusters may be what you actually want.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let word = "goodbye";
-    ///
-    /// let count = word.chars().count();
-    /// assert_eq!(7, count);
-    ///
-    /// let mut chars = word.chars();
-    ///
-    /// assert_eq!(Some('g'), chars.next());
-    /// assert_eq!(Some('o'), chars.next());
-    /// assert_eq!(Some('o'), chars.next());
-    /// assert_eq!(Some('d'), chars.next());
-    /// assert_eq!(Some('b'), chars.next());
-    /// assert_eq!(Some('y'), chars.next());
-    /// assert_eq!(Some('e'), chars.next());
-    ///
-    /// assert_eq!(None, chars.next());
-    /// ```
-    ///
-    /// Remember, [`char`]s may not match your human intuition about characters:
-    ///
-    /// ```
-    /// let y = "y̆";
-    ///
-    /// let mut chars = y.chars();
-    ///
-    /// assert_eq!(Some('y'), chars.next()); // not 'y̆'
-    /// assert_eq!(Some('\u{0306}'), chars.next());
-    ///
-    /// assert_eq!(None, chars.next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn chars(&self) -> Chars {
-        core_str::StrExt::chars(self)
-    }
-    /// Returns an iterator over the [`char`]s of a string slice, and their
-    /// positions.
-    ///
-    /// As a string slice consists of valid UTF-8, we can iterate through a
-    /// string slice by [`char`]. This method returns an iterator of both
-    /// these [`char`]s, as well as their byte positions.
-    ///
-    /// The iterator yields tuples. The position is first, the [`char`] is
-    /// second.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let word = "goodbye";
-    ///
-    /// let count = word.char_indices().count();
-    /// assert_eq!(7, count);
-    ///
-    /// let mut char_indices = word.char_indices();
-    ///
-    /// assert_eq!(Some((0, 'g')), char_indices.next());
-    /// assert_eq!(Some((1, 'o')), char_indices.next());
-    /// assert_eq!(Some((2, 'o')), char_indices.next());
-    /// assert_eq!(Some((3, 'd')), char_indices.next());
-    /// assert_eq!(Some((4, 'b')), char_indices.next());
-    /// assert_eq!(Some((5, 'y')), char_indices.next());
-    /// assert_eq!(Some((6, 'e')), char_indices.next());
-    ///
-    /// assert_eq!(None, char_indices.next());
-    /// ```
-    ///
-    /// Remember, [`char`]s may not match your human intuition about characters:
-    ///
-    /// ```
-    /// let y = "y̆";
-    ///
-    /// let mut char_indices = y.char_indices();
-    ///
-    /// assert_eq!(Some((0, 'y')), char_indices.next()); // not (0, 'y̆')
-    /// assert_eq!(Some((1, '\u{0306}')), char_indices.next());
-    ///
-    /// assert_eq!(None, char_indices.next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn char_indices(&self) -> CharIndices {
-        core_str::StrExt::char_indices(self)
-    }
-
-    /// An iterator over the bytes of a string slice.
-    ///
-    /// As a string slice consists of a sequence of bytes, we can iterate
-    /// through a string slice by byte. This method returns such an iterator.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut bytes = "bors".bytes();
-    ///
-    /// assert_eq!(Some(b'b'), bytes.next());
-    /// assert_eq!(Some(b'o'), bytes.next());
-    /// assert_eq!(Some(b'r'), bytes.next());
-    /// assert_eq!(Some(b's'), bytes.next());
-    ///
-    /// assert_eq!(None, bytes.next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn bytes(&self) -> Bytes {
-        core_str::StrExt::bytes(self)
-    }
-
-    /// Split a string slice by whitespace.
-    ///
-    /// The iterator returned will return string slices that are sub-slices of
-    /// the original string slice, separated by any amount of whitespace.
-    ///
-    /// 'Whitespace' is defined according to the terms of the Unicode Derived
-    /// Core Property `White_Space`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut iter = "A few words".split_whitespace();
-    ///
-    /// assert_eq!(Some("A"), iter.next());
-    /// assert_eq!(Some("few"), iter.next());
-    /// assert_eq!(Some("words"), iter.next());
-    ///
-    /// assert_eq!(None, iter.next());
-    /// ```
-    ///
-    /// All kinds of whitespace are considered:
-    ///
-    /// ```
-    /// let mut iter = " Mary   had\ta\u{2009}little  \n\t lamb".split_whitespace();
-    /// assert_eq!(Some("Mary"), iter.next());
-    /// assert_eq!(Some("had"), iter.next());
-    /// assert_eq!(Some("a"), iter.next());
-    /// assert_eq!(Some("little"), iter.next());
-    /// assert_eq!(Some("lamb"), iter.next());
-    ///
-    /// assert_eq!(None, iter.next());
-    /// ```
-    #[stable(feature = "split_whitespace", since = "1.1.0")]
-    #[inline]
-    pub fn split_whitespace(&self) -> SplitWhitespace {
-        UnicodeStr::split_whitespace(self)
-    }
-
-    /// An iterator over the lines of a string, as string slices.
-    ///
-    /// Lines are ended with either a newline (`\n`) or a carriage return with
-    /// a line feed (`\r\n`).
-    ///
-    /// The final line ending is optional.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let text = "foo\r\nbar\n\nbaz\n";
-    /// let mut lines = text.lines();
-    ///
-    /// assert_eq!(Some("foo"), lines.next());
-    /// assert_eq!(Some("bar"), lines.next());
-    /// assert_eq!(Some(""), lines.next());
-    /// assert_eq!(Some("baz"), lines.next());
-    ///
-    /// assert_eq!(None, lines.next());
-    /// ```
-    ///
-    /// The final line ending isn't required:
-    ///
-    /// ```
-    /// let text = "foo\nbar\n\r\nbaz";
-    /// let mut lines = text.lines();
-    ///
-    /// assert_eq!(Some("foo"), lines.next());
-    /// assert_eq!(Some("bar"), lines.next());
-    /// assert_eq!(Some(""), lines.next());
-    /// assert_eq!(Some("baz"), lines.next());
-    ///
-    /// assert_eq!(None, lines.next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn lines(&self) -> Lines {
-        core_str::StrExt::lines(self)
-    }
-
-    /// An iterator over the lines of a string.
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[rustc_deprecated(since = "1.4.0", reason = "use lines() instead now")]
-    #[inline]
-    #[allow(deprecated)]
-    pub fn lines_any(&self) -> LinesAny {
-        core_str::StrExt::lines_any(self)
-    }
-
-    /// Returns an iterator of `u16` over the string encoded as UTF-16.
-    #[stable(feature = "encode_utf16", since = "1.8.0")]
-    pub fn encode_utf16(&self) -> EncodeUtf16 {
-        EncodeUtf16 { encoder: Utf16Encoder::new(self[..].chars()) }
-    }
-
-    /// Returns `true` if the given pattern matches a sub-slice of
-    /// this string slice.
-    ///
-    /// Returns `false` if it does not.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let bananas = "bananas";
-    ///
-    /// assert!(bananas.contains("nana"));
-    /// assert!(!bananas.contains("apples"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
-        core_str::StrExt::contains(self, pat)
-    }
-
-    /// Returns `true` if the given pattern matches a prefix of this
-    /// string slice.
-    ///
-    /// Returns `false` if it does not.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let bananas = "bananas";
-    ///
-    /// assert!(bananas.starts_with("bana"));
-    /// assert!(!bananas.starts_with("nana"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn starts_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool {
-        core_str::StrExt::starts_with(self, pat)
-    }
-
-    /// Returns `true` if the given pattern matches a suffix of this
-    /// string slice.
-    ///
-    /// Returns `false` if it does not.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let bananas = "bananas";
-    ///
-    /// assert!(bananas.ends_with("anas"));
-    /// assert!(!bananas.ends_with("nana"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn ends_with<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::ends_with(self, pat)
-    }
-
-    /// Returns the byte index of the first character of this string slice that
-    /// matches the pattern.
-    ///
-    /// Returns [`None`] if the pattern doesn't match.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines if
-    /// a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    /// [`None`]: option/enum.Option.html#variant.None
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    ///
-    /// assert_eq!(s.find('L'), Some(0));
-    /// assert_eq!(s.find('é'), Some(14));
-    /// assert_eq!(s.find("Léopard"), Some(13));
-    /// ```
-    ///
-    /// More complex patterns with closures:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    ///
-    /// assert_eq!(s.find(char::is_whitespace), Some(5));
-    /// assert_eq!(s.find(char::is_lowercase), Some(1));
-    /// ```
-    ///
-    /// Not finding the pattern:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    /// let x: &[_] = &['1', '2'];
-    ///
-    /// assert_eq!(s.find(x), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn find<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize> {
-        core_str::StrExt::find(self, pat)
-    }
-
-    /// Returns the byte index of the last character of this string slice that
-    /// matches the pattern.
-    ///
-    /// Returns [`None`] if the pattern doesn't match.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines if
-    /// a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    /// [`None`]: option/enum.Option.html#variant.None
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    ///
-    /// assert_eq!(s.rfind('L'), Some(13));
-    /// assert_eq!(s.rfind('é'), Some(14));
-    /// ```
-    ///
-    /// More complex patterns with closures:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    ///
-    /// assert_eq!(s.rfind(char::is_whitespace), Some(12));
-    /// assert_eq!(s.rfind(char::is_lowercase), Some(20));
-    /// ```
-    ///
-    /// Not finding the pattern:
-    ///
-    /// ```
-    /// let s = "Löwe 老虎 Léopard";
-    /// let x: &[_] = &['1', '2'];
-    ///
-    /// assert_eq!(s.rfind(x), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rfind<'a, P: Pattern<'a>>(&'a self, pat: P) -> Option<usize>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rfind(self, pat)
-    }
-
-    /// An iterator over substrings of this string slice, separated by
-    /// characters matched by a pattern.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines the
-    /// split.
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern
-    /// allows a reverse search and forward/reverse search yields the same
-    /// elements. This is true for, eg, [`char`] but not for `&str`.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    ///
-    /// If the pattern allows a reverse search but its results might differ
-    /// from a forward search, the [`rsplit`] method can be used.
-    ///
-    /// [`char`]: primitive.char.html
-    /// [`rsplit`]: #method.rsplit
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "Mary had a little lamb".split(' ').collect();
-    /// assert_eq!(v, ["Mary", "had", "a", "little", "lamb"]);
-    ///
-    /// let v: Vec<&str> = "".split('X').collect();
-    /// assert_eq!(v, [""]);
-    ///
-    /// let v: Vec<&str> = "lionXXtigerXleopard".split('X').collect();
-    /// assert_eq!(v, ["lion", "", "tiger", "leopard"]);
-    ///
-    /// let v: Vec<&str> = "lion::tiger::leopard".split("::").collect();
-    /// assert_eq!(v, ["lion", "tiger", "leopard"]);
-    ///
-    /// let v: Vec<&str> = "abc1def2ghi".split(char::is_numeric).collect();
-    /// assert_eq!(v, ["abc", "def", "ghi"]);
-    ///
-    /// let v: Vec<&str> = "lionXtigerXleopard".split(char::is_uppercase).collect();
-    /// assert_eq!(v, ["lion", "tiger", "leopard"]);
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abc1defXghi".split(|c| c == '1' || c == 'X').collect();
-    /// assert_eq!(v, ["abc", "def", "ghi"]);
-    /// ```
-    ///
-    /// If a string contains multiple contiguous separators, you will end up
-    /// with empty strings in the output:
-    ///
-    /// ```
-    /// let x = "||||a||b|c".to_string();
-    /// let d: Vec<_> = x.split('|').collect();
-    ///
-    /// assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
-    /// ```
-    ///
-    /// Contiguous separators are separated by the empty string.
-    ///
-    /// ```
-    /// let x = "(///)".to_string();
-    /// let d: Vec<_> = x.split('/').collect();
-    ///
-    /// assert_eq!(d, &["(", "", "", ")"]);
-    /// ```
-    ///
-    /// Separators at the start or end of a string are neighbored
-    /// by empty strings.
-    ///
-    /// ```
-    /// let d: Vec<_> = "010".split("0").collect();
-    /// assert_eq!(d, &["", "1", ""]);
-    /// ```
-    ///
-    /// When the empty string is used as a separator, it separates
-    /// every character in the string, along with the beginning
-    /// and end of the string.
-    ///
-    /// ```
-    /// let f: Vec<_> = "rust".split("").collect();
-    /// assert_eq!(f, &["", "r", "u", "s", "t", ""]);
-    /// ```
-    ///
-    /// Contiguous separators can lead to possibly surprising behavior
-    /// when whitespace is used as the separator. This code is correct:
-    ///
-    /// ```
-    /// let x = "    a  b c".to_string();
-    /// let d: Vec<_> = x.split(' ').collect();
-    ///
-    /// assert_eq!(d, &["", "", "", "", "a", "", "b", "c"]);
-    /// ```
-    ///
-    /// It does _not_ give you:
-    ///
-    /// ```,ignore
-    /// assert_eq!(d, &["a", "b", "c"]);
-    /// ```
-    ///
-    /// Use [`split_whitespace`] for this behavior.
-    ///
-    /// [`split_whitespace`]: #method.split_whitespace
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split<'a, P: Pattern<'a>>(&'a self, pat: P) -> Split<'a, P> {
-        core_str::StrExt::split(self, pat)
-    }
-
-    /// An iterator over substrings of the given string slice, separated by
-    /// characters matched by a pattern and yielded in reverse order.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines the
-    /// split.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator requires that the pattern supports a reverse
-    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse
-    /// search yields the same elements.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    ///
-    /// For iterating from the front, the [`split`] method can be used.
-    ///
-    /// [`split`]: #method.split
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "Mary had a little lamb".rsplit(' ').collect();
-    /// assert_eq!(v, ["lamb", "little", "a", "had", "Mary"]);
-    ///
-    /// let v: Vec<&str> = "".rsplit('X').collect();
-    /// assert_eq!(v, [""]);
-    ///
-    /// let v: Vec<&str> = "lionXXtigerXleopard".rsplit('X').collect();
-    /// assert_eq!(v, ["leopard", "tiger", "", "lion"]);
-    ///
-    /// let v: Vec<&str> = "lion::tiger::leopard".rsplit("::").collect();
-    /// assert_eq!(v, ["leopard", "tiger", "lion"]);
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abc1defXghi".rsplit(|c| c == '1' || c == 'X').collect();
-    /// assert_eq!(v, ["ghi", "def", "abc"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rsplit<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplit<'a, P>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rsplit(self, pat)
-    }
-
-    /// An iterator over substrings of the given string slice, separated by
-    /// characters matched by a pattern.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines the
-    /// split.
-    ///
-    /// Equivalent to [`split`], except that the trailing substring
-    /// is skipped if empty.
-    ///
-    /// [`split`]: #method.split
-    ///
-    /// This method can be used for string data that is _terminated_,
-    /// rather than _separated_ by a pattern.
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern
-    /// allows a reverse search and forward/reverse search yields the same
-    /// elements. This is true for, eg, [`char`] but not for `&str`.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    /// [`char`]: primitive.char.html
-    ///
-    /// If the pattern allows a reverse search but its results might differ
-    /// from a forward search, the [`rsplit_terminator`] method can be used.
-    ///
-    /// [`rsplit_terminator`]: #method.rsplit_terminator
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "A.B.".split_terminator('.').collect();
-    /// assert_eq!(v, ["A", "B"]);
-    ///
-    /// let v: Vec<&str> = "A..B..".split_terminator(".").collect();
-    /// assert_eq!(v, ["A", "", "B", ""]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn split_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> SplitTerminator<'a, P> {
-        core_str::StrExt::split_terminator(self, pat)
-    }
-
-    /// An iterator over substrings of `self`, separated by characters
-    /// matched by a pattern and yielded in reverse order.
-    ///
-    /// The pattern can be a simple `&str`, [`char`], or a closure that
-    /// determines the split.
-    /// Additional libraries might provide more complex patterns like
-    /// regular expressions.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// Equivalent to [`split`], except that the trailing substring is
-    /// skipped if empty.
-    ///
-    /// [`split`]: #method.split
-    ///
-    /// This method can be used for string data that is _terminated_,
-    /// rather than _separated_ by a pattern.
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator requires that the pattern supports a
-    /// reverse search, and it will be double ended if a forward/reverse
-    /// search yields the same elements.
-    ///
-    /// For iterating from the front, the [`split_terminator`] method can be
-    /// used.
-    ///
-    /// [`split_terminator`]: #method.split_terminator
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v: Vec<&str> = "A.B.".rsplit_terminator('.').collect();
-    /// assert_eq!(v, ["B", "A"]);
-    ///
-    /// let v: Vec<&str> = "A..B..".rsplit_terminator(".").collect();
-    /// assert_eq!(v, ["", "B", "", "A"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rsplit_terminator<'a, P: Pattern<'a>>(&'a self, pat: P) -> RSplitTerminator<'a, P>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rsplit_terminator(self, pat)
-    }
-
-    /// An iterator over substrings of the given string slice, separated by a
-    /// pattern, restricted to returning at most `n` items.
-    ///
-    /// If `n` substrings are returned, the last substring (the `n`th substring)
-    /// will contain the remainder of the string.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines the
-    /// split.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will not be double ended, because it is
-    /// not efficient to support.
-    ///
-    /// If the pattern allows a reverse search, the [`rsplitn`] method can be
-    /// used.
-    ///
-    /// [`rsplitn`]: #method.rsplitn
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "Mary had a little lambda".splitn(3, ' ').collect();
-    /// assert_eq!(v, ["Mary", "had", "a little lambda"]);
-    ///
-    /// let v: Vec<&str> = "lionXXtigerXleopard".splitn(3, "X").collect();
-    /// assert_eq!(v, ["lion", "", "tigerXleopard"]);
-    ///
-    /// let v: Vec<&str> = "abcXdef".splitn(1, 'X').collect();
-    /// assert_eq!(v, ["abcXdef"]);
-    ///
-    /// let v: Vec<&str> = "".splitn(1, 'X').collect();
-    /// assert_eq!(v, [""]);
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abc1defXghi".splitn(2, |c| c == '1' || c == 'X').collect();
-    /// assert_eq!(v, ["abc", "defXghi"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn splitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> SplitN<'a, P> {
-        core_str::StrExt::splitn(self, n, pat)
-    }
-
-    /// An iterator over substrings of this string slice, separated by a
-    /// pattern, starting from the end of the string, restricted to returning
-    /// at most `n` items.
-    ///
-    /// If `n` substrings are returned, the last substring (the `n`th substring)
-    /// will contain the remainder of the string.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that
-    /// determines the split.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will not be double ended, because it is not
-    /// efficient to support.
-    ///
-    /// For splitting from the front, the [`splitn`] method can be used.
-    ///
-    /// [`splitn`]: #method.splitn
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "Mary had a little lamb".rsplitn(3, ' ').collect();
-    /// assert_eq!(v, ["lamb", "little", "Mary had a"]);
-    ///
-    /// let v: Vec<&str> = "lionXXtigerXleopard".rsplitn(3, 'X').collect();
-    /// assert_eq!(v, ["leopard", "tiger", "lionX"]);
-    ///
-    /// let v: Vec<&str> = "lion::tiger::leopard".rsplitn(2, "::").collect();
-    /// assert_eq!(v, ["leopard", "lion::tiger"]);
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abc1defXghi".rsplitn(2, |c| c == '1' || c == 'X').collect();
-    /// assert_eq!(v, ["ghi", "abc1def"]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn rsplitn<'a, P: Pattern<'a>>(&'a self, n: usize, pat: P) -> RSplitN<'a, P>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rsplitn(self, n, pat)
-    }
-
-    /// An iterator over the disjoint matches of a pattern within the given string
-    /// slice.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that
-    /// determines if a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern
-    /// allows a reverse search and forward/reverse search yields the same
-    /// elements. This is true for, eg, [`char`] but not for `&str`.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    /// [`char`]: primitive.char.html
-    ///
-    /// If the pattern allows a reverse search but its results might differ
-    /// from a forward search, the [`rmatches`] method can be used.
-    ///
-    /// [`rmatches`]: #method.rmatches
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abcXXXabcYYYabc".matches("abc").collect();
-    /// assert_eq!(v, ["abc", "abc", "abc"]);
-    ///
-    /// let v: Vec<&str> = "1abc2abc3".matches(char::is_numeric).collect();
-    /// assert_eq!(v, ["1", "2", "3"]);
-    /// ```
-    #[stable(feature = "str_matches", since = "1.2.0")]
-    #[inline]
-    pub fn matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> Matches<'a, P> {
-        core_str::StrExt::matches(self, pat)
-    }
-
-    /// An iterator over the disjoint matches of a pattern within this string slice,
-    /// yielded in reverse order.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines if
-    /// a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator requires that the pattern supports a reverse
-    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse
-    /// search yields the same elements.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    ///
-    /// For iterating from the front, the [`matches`] method can be used.
-    ///
-    /// [`matches`]: #method.matches
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let v: Vec<&str> = "abcXXXabcYYYabc".rmatches("abc").collect();
-    /// assert_eq!(v, ["abc", "abc", "abc"]);
-    ///
-    /// let v: Vec<&str> = "1abc2abc3".rmatches(char::is_numeric).collect();
-    /// assert_eq!(v, ["3", "2", "1"]);
-    /// ```
-    #[stable(feature = "str_matches", since = "1.2.0")]
-    #[inline]
-    pub fn rmatches<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatches<'a, P>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rmatches(self, pat)
-    }
-
-    /// An iterator over the disjoint matches of a pattern within this string
-    /// slice as well as the index that the match starts at.
-    ///
-    /// For matches of `pat` within `self` that overlap, only the indices
-    /// corresponding to the first match are returned.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines
-    /// if a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator will be a [`DoubleEndedIterator`] if the pattern
-    /// allows a reverse search and forward/reverse search yields the same
-    /// elements. This is true for, eg, [`char`] but not for `&str`.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    ///
-    /// If the pattern allows a reverse search but its results might differ
-    /// from a forward search, the [`rmatch_indices`] method can be used.
-    ///
-    /// [`rmatch_indices`]: #method.rmatch_indices
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let v: Vec<_> = "abcXXXabcYYYabc".match_indices("abc").collect();
-    /// assert_eq!(v, [(0, "abc"), (6, "abc"), (12, "abc")]);
-    ///
-    /// let v: Vec<_> = "1abcabc2".match_indices("abc").collect();
-    /// assert_eq!(v, [(1, "abc"), (4, "abc")]);
-    ///
-    /// let v: Vec<_> = "ababa".match_indices("aba").collect();
-    /// assert_eq!(v, [(0, "aba")]); // only the first `aba`
-    /// ```
-    #[stable(feature = "str_match_indices", since = "1.5.0")]
-    #[inline]
-    pub fn match_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> MatchIndices<'a, P> {
-        core_str::StrExt::match_indices(self, pat)
-    }
-
-    /// An iterator over the disjoint matches of a pattern within `self`,
-    /// yielded in reverse order along with the index of the match.
-    ///
-    /// For matches of `pat` within `self` that overlap, only the indices
-    /// corresponding to the last match are returned.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines if a
-    /// character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Iterator behavior
-    ///
-    /// The returned iterator requires that the pattern supports a reverse
-    /// search, and it will be a [`DoubleEndedIterator`] if a forward/reverse
-    /// search yields the same elements.
-    ///
-    /// [`DoubleEndedIterator`]: iter/trait.DoubleEndedIterator.html
-    ///
-    /// For iterating from the front, the [`match_indices`] method can be used.
-    ///
-    /// [`match_indices`]: #method.match_indices
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let v: Vec<_> = "abcXXXabcYYYabc".rmatch_indices("abc").collect();
-    /// assert_eq!(v, [(12, "abc"), (6, "abc"), (0, "abc")]);
-    ///
-    /// let v: Vec<_> = "1abcabc2".rmatch_indices("abc").collect();
-    /// assert_eq!(v, [(4, "abc"), (1, "abc")]);
-    ///
-    /// let v: Vec<_> = "ababa".rmatch_indices("aba").collect();
-    /// assert_eq!(v, [(2, "aba")]); // only the last `aba`
-    /// ```
-    #[stable(feature = "str_match_indices", since = "1.5.0")]
-    #[inline]
-    pub fn rmatch_indices<'a, P: Pattern<'a>>(&'a self, pat: P) -> RMatchIndices<'a, P>
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::rmatch_indices(self, pat)
-    }
-
-    /// Returns a string slice with leading and trailing whitespace removed.
-    ///
-    /// 'Whitespace' is defined according to the terms of the Unicode Derived
-    /// Core Property `White_Space`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = " Hello\tworld\t";
-    ///
-    /// assert_eq!("Hello\tworld", s.trim());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim(&self) -> &str {
-        UnicodeStr::trim(self)
-    }
-
-    /// Returns a string slice with leading whitespace removed.
-    ///
-    /// 'Whitespace' is defined according to the terms of the Unicode Derived
-    /// Core Property `White_Space`.
-    ///
-    /// # Text directionality
-    ///
-    /// A string is a sequence of bytes. 'Left' in this context means the first
-    /// position of that byte string; for a language like Arabic or Hebrew
-    /// which are 'right to left' rather than 'left to right', this will be
-    /// the _right_ side, not the left.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = " Hello\tworld\t";
-    ///
-    /// assert_eq!("Hello\tworld\t", s.trim_left());
-    /// ```
-    ///
-    /// Directionality:
-    ///
-    /// ```
-    /// let s = "  English";
-    /// assert!(Some('E') == s.trim_left().chars().next());
-    ///
-    /// let s = "  עברית";
-    /// assert!(Some('ע') == s.trim_left().chars().next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim_left(&self) -> &str {
-        UnicodeStr::trim_left(self)
-    }
-
-    /// Returns a string slice with trailing whitespace removed.
-    ///
-    /// 'Whitespace' is defined according to the terms of the Unicode Derived
-    /// Core Property `White_Space`.
-    ///
-    /// # Text directionality
-    ///
-    /// A string is a sequence of bytes. 'Right' in this context means the last
-    /// position of that byte string; for a language like Arabic or Hebrew
-    /// which are 'right to left' rather than 'left to right', this will be
-    /// the _left_ side, not the right.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = " Hello\tworld\t";
-    ///
-    /// assert_eq!(" Hello\tworld", s.trim_right());
-    /// ```
-    ///
-    /// Directionality:
-    ///
-    /// ```
-    /// let s = "English  ";
-    /// assert!(Some('h') == s.trim_right().chars().rev().next());
-    ///
-    /// let s = "עברית  ";
-    /// assert!(Some('ת') == s.trim_right().chars().rev().next());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim_right(&self) -> &str {
-        UnicodeStr::trim_right(self)
-    }
-
-    /// Returns a string slice with all prefixes and suffixes that match a
-    /// pattern repeatedly removed.
-    ///
-    /// The pattern can be a [`char`] or a closure that determines if a
-    /// character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
-    /// assert_eq!("123foo1bar123".trim_matches(char::is_numeric), "foo1bar");
-    ///
-    /// let x: &[_] = &['1', '2'];
-    /// assert_eq!("12foo1bar12".trim_matches(x), "foo1bar");
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// assert_eq!("1foo1barXX".trim_matches(|c| c == '1' || c == 'X'), "foo1bar");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
-        where P::Searcher: DoubleEndedSearcher<'a>
-    {
-        core_str::StrExt::trim_matches(self, pat)
-    }
-
-    /// Returns a string slice with all prefixes that match a pattern
-    /// repeatedly removed.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that determines if
-    /// a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Text directionality
-    ///
-    /// A string is a sequence of bytes. 'Left' in this context means the first
-    /// position of that byte string; for a language like Arabic or Hebrew
-    /// which are 'right to left' rather than 'left to right', this will be
-    /// the _right_ side, not the left.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
-    /// assert_eq!("123foo1bar123".trim_left_matches(char::is_numeric), "foo1bar123");
-    ///
-    /// let x: &[_] = &['1', '2'];
-    /// assert_eq!("12foo1bar12".trim_left_matches(x), "foo1bar12");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim_left_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str {
-        core_str::StrExt::trim_left_matches(self, pat)
-    }
-
-    /// Returns a string slice with all suffixes that match a pattern
-    /// repeatedly removed.
-    ///
-    /// The pattern can be a `&str`, [`char`], or a closure that
-    /// determines if a character matches.
-    ///
-    /// [`char`]: primitive.char.html
-    ///
-    /// # Text directionality
-    ///
-    /// A string is a sequence of bytes. 'Right' in this context means the last
-    /// position of that byte string; for a language like Arabic or Hebrew
-    /// which are 'right to left' rather than 'left to right', this will be
-    /// the _left_ side, not the right.
-    ///
-    /// # Examples
-    ///
-    /// Simple patterns:
-    ///
-    /// ```
-    /// assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
-    /// assert_eq!("123foo1bar123".trim_right_matches(char::is_numeric), "123foo1bar");
-    ///
-    /// let x: &[_] = &['1', '2'];
-    /// assert_eq!("12foo1bar12".trim_right_matches(x), "12foo1bar");
-    /// ```
-    ///
-    /// A more complex pattern, using a closure:
-    ///
-    /// ```
-    /// assert_eq!("1fooX".trim_left_matches(|c| c == '1' || c == 'X'), "fooX");
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn trim_right_matches<'a, P: Pattern<'a>>(&'a self, pat: P) -> &'a str
-        where P::Searcher: ReverseSearcher<'a>
-    {
-        core_str::StrExt::trim_right_matches(self, pat)
-    }
-
-    /// Parses this string slice into another type.
-    ///
-    /// Because `parse` is so general, it can cause problems with type
-    /// inference. As such, `parse` is one of the few times you'll see
-    /// the syntax affectionately known as the 'turbofish': `::<>`. This
-    /// helps the inference algorithm understand specifically which type
-    /// you're trying to parse into.
-    ///
-    /// `parse` can parse any type that implements the [`FromStr`] trait.
-    ///
-    /// [`FromStr`]: str/trait.FromStr.html
-    ///
-    /// # Errors
-    ///
-    /// Will return [`Err`] if it's not possible to parse this string slice into
-    /// the desired type.
-    ///
-    /// [`Err`]: str/trait.FromStr.html#associatedtype.Err
-    ///
-    /// # Example
-    ///
-    /// Basic usage
-    ///
-    /// ```
-    /// let four: u32 = "4".parse().unwrap();
-    ///
-    /// assert_eq!(4, four);
-    /// ```
-    ///
-    /// Using the 'turbofish' instead of annotating `four`:
-    ///
-    /// ```
-    /// let four = "4".parse::<u32>();
-    ///
-    /// assert_eq!(Ok(4), four);
-    /// ```
-    ///
-    /// Failing to parse:
-    ///
-    /// ```
-    /// let nope = "j".parse::<u32>();
-    ///
-    /// assert!(nope.is_err());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn parse<F: FromStr>(&self) -> Result<F, F::Err> {
-        core_str::StrExt::parse(self)
-    }
-
-    /// Converts a `Box<str>` into a `Box<[u8]>` without copying or allocating.
-    #[unstable(feature = "str_box_extras", issue = "41119")]
-    pub fn into_boxed_bytes(self: Box<str>) -> Box<[u8]> {
-        self.into()
-    }
-
-    /// Replaces all matches of a pattern with another string.
-    ///
-    /// `replace` creates a new [`String`], and copies the data from this string slice into it.
-    /// While doing so, it attempts to find matches of a pattern. If it finds any, it
-    /// replaces them with the replacement string slice.
-    ///
-    /// [`String`]: string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "this is old";
-    ///
-    /// assert_eq!("this is new", s.replace("old", "new"));
-    /// ```
-    ///
-    /// When the pattern doesn't match:
-    ///
-    /// ```
-    /// let s = "this is old";
-    /// assert_eq!(s, s.replace("cookie monster", "little lamb"));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn replace<'a, P: Pattern<'a>>(&'a self, from: P, to: &str) -> String {
-        let mut result = String::new();
-        let mut last_end = 0;
-        for (start, part) in self.match_indices(from) {
-            result.push_str(unsafe { self.slice_unchecked(last_end, start) });
-            result.push_str(to);
-            last_end = start + part.len();
-        }
-        result.push_str(unsafe { self.slice_unchecked(last_end, self.len()) });
-        result
-    }
-
-    /// Replaces first N matches of a pattern with another string.
-    ///
-    /// `replacen` creates a new [`String`], and copies the data from this string slice into it.
-    /// While doing so, it attempts to find matches of a pattern. If it finds any, it
-    /// replaces them with the replacement string slice at most `count` times.
-    ///
-    /// [`String`]: string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "foo foo 123 foo";
-    /// assert_eq!("new new 123 foo", s.replacen("foo", "new", 2));
-    /// assert_eq!("faa fao 123 foo", s.replacen('o', "a", 3));
-    /// assert_eq!("foo foo new23 foo", s.replacen(char::is_numeric, "new", 1));
-    /// ```
-    ///
-    /// When the pattern doesn't match:
-    ///
-    /// ```
-    /// let s = "this is old";
-    /// assert_eq!(s, s.replacen("cookie monster", "little lamb", 10));
-    /// ```
-    #[stable(feature = "str_replacen", since = "1.16.0")]
-    pub fn replacen<'a, P: Pattern<'a>>(&'a self, pat: P, to: &str, count: usize) -> String {
-        // Hope to reduce the times of re-allocation
-        let mut result = String::with_capacity(32);
-        let mut last_end = 0;
-        for (start, part) in self.match_indices(pat).take(count) {
-            result.push_str(unsafe { self.slice_unchecked(last_end, start) });
-            result.push_str(to);
-            last_end = start + part.len();
-        }
-        result.push_str(unsafe { self.slice_unchecked(last_end, self.len()) });
-        result
-    }
-
-    /// Returns the lowercase equivalent of this string slice, as a new [`String`].
-    ///
-    /// 'Lowercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Lowercase`.
-    ///
-    /// Since some characters can expand into multiple characters when changing
-    /// the case, this function returns a [`String`] instead of modifying the
-    /// parameter in-place.
-    ///
-    /// [`String`]: string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "HELLO";
-    ///
-    /// assert_eq!("hello", s.to_lowercase());
-    /// ```
-    ///
-    /// A tricky example, with sigma:
-    ///
-    /// ```
-    /// let sigma = "Σ";
-    ///
-    /// assert_eq!("σ", sigma.to_lowercase());
-    ///
-    /// // but at the end of a word, it's ς, not σ:
-    /// let odysseus = "ὈΔΥΣΣΕΎΣ";
-    ///
-    /// assert_eq!("ὀδυσσεύς", odysseus.to_lowercase());
-    /// ```
-    ///
-    /// Languages without case are not changed:
-    ///
-    /// ```
-    /// let new_year = "农历新年";
-    ///
-    /// assert_eq!(new_year, new_year.to_lowercase());
-    /// ```
-    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
-    pub fn to_lowercase(&self) -> String {
-        let mut s = String::with_capacity(self.len());
-        for (i, c) in self[..].char_indices() {
-            if c == 'Σ' {
-                // Σ maps to σ, except at the end of a word where it maps to ς.
-                // This is the only conditional (contextual) but language-independent mapping
-                // in `SpecialCasing.txt`,
-                // so hard-code it rather than have a generic "condition" mechanism.
-                // See https://github.com/rust-lang/rust/issues/26035
-                map_uppercase_sigma(self, i, &mut s)
-            } else {
-                s.extend(c.to_lowercase());
-            }
-        }
-        return s;
-
-        fn map_uppercase_sigma(from: &str, i: usize, to: &mut String) {
-            // See http://www.unicode.org/versions/Unicode7.0.0/ch03.pdf#G33992
-            // for the definition of `Final_Sigma`.
-            debug_assert!('Σ'.len_utf8() == 2);
-            let is_word_final = case_ignoreable_then_cased(from[..i].chars().rev()) &&
-                                !case_ignoreable_then_cased(from[i + 2..].chars());
-            to.push_str(if is_word_final { "ς" } else { "σ" });
-        }
-
-        fn case_ignoreable_then_cased<I: Iterator<Item = char>>(iter: I) -> bool {
-            use std_unicode::derived_property::{Cased, Case_Ignorable};
-            match iter.skip_while(|&c| Case_Ignorable(c)).next() {
-                Some(c) => Cased(c),
-                None => false,
-            }
-        }
-    }
-
-    /// Returns the uppercase equivalent of this string slice, as a new [`String`].
-    ///
-    /// 'Uppercase' is defined according to the terms of the Unicode Derived Core Property
-    /// `Uppercase`.
-    ///
-    /// Since some characters can expand into multiple characters when changing
-    /// the case, this function returns a [`String`] instead of modifying the
-    /// parameter in-place.
-    ///
-    /// [`String`]: string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = "hello";
-    ///
-    /// assert_eq!("HELLO", s.to_uppercase());
-    /// ```
-    ///
-    /// Scripts without case are not changed:
-    ///
-    /// ```
-    /// let new_year = "农历新年";
-    ///
-    /// assert_eq!(new_year, new_year.to_uppercase());
-    /// ```
-    #[stable(feature = "unicode_case_mapping", since = "1.2.0")]
-    pub fn to_uppercase(&self) -> String {
-        let mut s = String::with_capacity(self.len());
-        s.extend(self.chars().flat_map(|c| c.to_uppercase()));
-        return s;
-    }
-
-    /// Escapes each char in `s` with [`char::escape_debug`].
-    ///
-    /// [`char::escape_debug`]: primitive.char.html#method.escape_debug
-    #[unstable(feature = "str_escape",
-               reason = "return type may change to be an iterator",
-               issue = "27791")]
-    pub fn escape_debug(&self) -> String {
-        self.chars().flat_map(|c| c.escape_debug()).collect()
-    }
-
-    /// Escapes each char in `s` with [`char::escape_default`].
-    ///
-    /// [`char::escape_default`]: primitive.char.html#method.escape_default
-    #[unstable(feature = "str_escape",
-               reason = "return type may change to be an iterator",
-               issue = "27791")]
-    pub fn escape_default(&self) -> String {
-        self.chars().flat_map(|c| c.escape_default()).collect()
-    }
-
-    /// Escapes each char in `s` with [`char::escape_unicode`].
-    ///
-    /// [`char::escape_unicode`]: primitive.char.html#method.escape_unicode
-    #[unstable(feature = "str_escape",
-               reason = "return type may change to be an iterator",
-               issue = "27791")]
-    pub fn escape_unicode(&self) -> String {
-        self.chars().flat_map(|c| c.escape_unicode()).collect()
-    }
-
-    /// Converts a [`Box<str>`] into a [`String`] without copying or allocating.
-    ///
-    /// [`String`]: string/struct.String.html
-    /// [`Box<str>`]: boxed/struct.Box.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let string = String::from("birthday gift");
-    /// let boxed_str = string.clone().into_boxed_str();
-    ///
-    /// assert_eq!(boxed_str.into_string(), string);
-    /// ```
-    #[stable(feature = "box_str", since = "1.4.0")]
-    pub fn into_string(self: Box<str>) -> String {
-        unsafe {
-            let slice = mem::transmute::<Box<str>, Box<[u8]>>(self);
-            String::from_utf8_unchecked(slice.into_vec())
-        }
-    }
-
-    /// Create a [`String`] by repeating a string `n` times.
-    ///
-    /// [`String`]: string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// assert_eq!("abc".repeat(4), String::from("abcabcabcabc"));
-    /// ```
-    #[stable(feature = "repeat_str", since = "1.16.0")]
-    pub fn repeat(&self, n: usize) -> String {
-        let mut s = String::with_capacity(self.len() * n);
-        s.extend((0..n).map(|_| self));
-        s
-    }
-}
diff --git a/src/libcollections/string.rs b/src/libcollections/string.rs
deleted file mode 100644
index 55f0e01548f..00000000000
--- a/src/libcollections/string.rs
+++ /dev/null
@@ -1,2289 +0,0 @@
-// Copyright 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.
-
-//! A UTF-8 encoded, growable string.
-//!
-//! This module contains the [`String`] type, a trait for converting
-//! [`ToString`]s, and several error types that may result from working with
-//! [`String`]s.
-//!
-//! [`ToString`]: trait.ToString.html
-//!
-//! # Examples
-//!
-//! There are multiple ways to create a new [`String`] from a string literal:
-//!
-//! ```
-//! let s = "Hello".to_string();
-//!
-//! let s = String::from("world");
-//! let s: String = "also this".into();
-//! ```
-//!
-//! You can create a new [`String`] from an existing one by concatenating with
-//! `+`:
-//!
-//! [`String`]: struct.String.html
-//!
-//! ```
-//! let s = "Hello".to_string();
-//!
-//! let message = s + " world!";
-//! ```
-//!
-//! If you have a vector of valid UTF-8 bytes, you can make a `String` out of
-//! it. You can do the reverse too.
-//!
-//! ```
-//! let sparkle_heart = vec![240, 159, 146, 150];
-//!
-//! // We know these bytes are valid, so we'll use `unwrap()`.
-//! let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
-//!
-//! assert_eq!("💖", sparkle_heart);
-//!
-//! let bytes = sparkle_heart.into_bytes();
-//!
-//! assert_eq!(bytes, [240, 159, 146, 150]);
-//! ```
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use alloc::str as alloc_str;
-
-use core::fmt;
-use core::hash;
-use core::iter::{FromIterator, FusedIterator};
-use core::ops::{self, Add, AddAssign, Index, IndexMut};
-use core::ptr;
-use core::str as core_str;
-use core::str::pattern::Pattern;
-use std_unicode::char::{decode_utf16, REPLACEMENT_CHARACTER};
-
-use borrow::{Cow, ToOwned};
-use range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
-use str::{self, FromStr, Utf8Error, Chars};
-use vec::Vec;
-use boxed::Box;
-
-/// A UTF-8 encoded, growable string.
-///
-/// The `String` type is the most common string type that has ownership over the
-/// contents of the string. It has a close relationship with its borrowed
-/// counterpart, the primitive [`str`].
-///
-/// [`str`]: ../../std/primitive.str.html
-///
-/// # Examples
-///
-/// You can create a `String` from a literal string with `String::from`:
-///
-/// ```
-/// let hello = String::from("Hello, world!");
-/// ```
-///
-/// You can append a [`char`] to a `String` with the [`push`] method, and
-/// append a [`&str`] with the [`push_str`] method:
-///
-/// ```
-/// let mut hello = String::from("Hello, ");
-///
-/// hello.push('w');
-/// hello.push_str("orld!");
-/// ```
-///
-/// [`char`]: ../../std/primitive.char.html
-/// [`push`]: #method.push
-/// [`push_str`]: #method.push_str
-///
-/// If you have a vector of UTF-8 bytes, you can create a `String` from it with
-/// the [`from_utf8`] method:
-///
-/// ```
-/// // some bytes, in a vector
-/// let sparkle_heart = vec![240, 159, 146, 150];
-///
-/// // We know these bytes are valid, so we'll use `unwrap()`.
-/// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
-///
-/// assert_eq!("💖", sparkle_heart);
-/// ```
-///
-/// [`from_utf8`]: #method.from_utf8
-///
-/// # UTF-8
-///
-/// `String`s are always valid UTF-8. This has a few implications, the first of
-/// which is that if you need a non-UTF-8 string, consider [`OsString`]. It is
-/// similar, but without the UTF-8 constraint. The second implication is that
-/// you cannot index into a `String`:
-///
-/// ```ignore
-/// let s = "hello";
-///
-/// println!("The first letter of s is {}", s[0]); // ERROR!!!
-/// ```
-///
-/// [`OsString`]: ../../std/ffi/struct.OsString.html
-///
-/// Indexing is intended to be a constant-time operation, but UTF-8 encoding
-/// does not allow us to do this. Furthermore, it's not clear what sort of
-/// thing the index should return: a byte, a codepoint, or a grapheme cluster.
-/// The [`bytes`] and [`chars`] methods return iterators over the first
-/// two, respectively.
-///
-/// [`bytes`]: #method.bytes
-/// [`chars`]: #method.chars
-///
-/// # Deref
-///
-/// `String`s implement [`Deref`]`<Target=str>`, and so inherit all of [`str`]'s
-/// methods. In addition, this means that you can pass a `String` to any
-/// function which takes a [`&str`] by using an ampersand (`&`):
-///
-/// ```
-/// fn takes_str(s: &str) { }
-///
-/// let s = String::from("Hello");
-///
-/// takes_str(&s);
-/// ```
-///
-/// [`&str`]: ../../std/primitive.str.html
-/// [`Deref`]: ../../std/ops/trait.Deref.html
-///
-/// This will create a [`&str`] from the `String` and pass it in. This
-/// conversion is very inexpensive, and so generally, functions will accept
-/// [`&str`]s as arguments unless they need a `String` for some specific reason.
-///
-///
-/// # Representation
-///
-/// A `String` is made up of three components: a pointer to some bytes, a
-/// length, and a capacity. The pointer points to an internal buffer `String`
-/// uses to store its data. The length is the number of bytes currently stored
-/// in the buffer, and the capacity is the size of the buffer in bytes. As such,
-/// the length will always be less than or equal to the capacity.
-///
-/// This buffer is always stored on the heap.
-///
-/// You can look at these with the [`as_ptr`], [`len`], and [`capacity`]
-/// methods:
-///
-/// ```
-/// use std::mem;
-///
-/// let story = String::from("Once upon a time...");
-///
-/// let ptr = story.as_ptr();
-/// let len = story.len();
-/// let capacity = story.capacity();
-///
-/// // story has nineteen bytes
-/// assert_eq!(19, len);
-///
-/// // Now that we have our parts, we throw the story away.
-/// mem::forget(story);
-///
-/// // We can re-build a String out of ptr, len, and capacity. This is all
-/// // unsafe because we are responsible for making sure the components are
-/// // valid:
-/// let s = unsafe { String::from_raw_parts(ptr as *mut _, len, capacity) } ;
-///
-/// assert_eq!(String::from("Once upon a time..."), s);
-/// ```
-///
-/// [`as_ptr`]: #method.as_ptr
-/// [`len`]: #method.len
-/// [`capacity`]: #method.capacity
-///
-/// If a `String` has enough capacity, adding elements to it will not
-/// re-allocate. For example, consider this program:
-///
-/// ```
-/// let mut s = String::new();
-///
-/// println!("{}", s.capacity());
-///
-/// for _ in 0..5 {
-///     s.push_str("hello");
-///     println!("{}", s.capacity());
-/// }
-/// ```
-///
-/// This will output the following:
-///
-/// ```text
-/// 0
-/// 5
-/// 10
-/// 20
-/// 20
-/// 40
-/// ```
-///
-/// At first, we have no memory allocated at all, but as we append to the
-/// string, it increases its capacity appropriately. If we instead use the
-/// [`with_capacity`] method to allocate the correct capacity initially:
-///
-/// ```
-/// let mut s = String::with_capacity(25);
-///
-/// println!("{}", s.capacity());
-///
-/// for _ in 0..5 {
-///     s.push_str("hello");
-///     println!("{}", s.capacity());
-/// }
-/// ```
-///
-/// [`with_capacity`]: #method.with_capacity
-///
-/// We end up with a different output:
-///
-/// ```text
-/// 25
-/// 25
-/// 25
-/// 25
-/// 25
-/// 25
-/// ```
-///
-/// Here, there's no need to allocate more memory inside the loop.
-#[derive(PartialOrd, Eq, Ord)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct String {
-    vec: Vec<u8>,
-}
-
-/// A possible error value when converting a `String` from a UTF-8 byte vector.
-///
-/// This type is the error type for the [`from_utf8`] method on [`String`]. It
-/// is designed in such a way to carefully avoid reallocations: the
-/// [`into_bytes`] method will give back the byte vector that was used in the
-/// conversion attempt.
-///
-/// [`from_utf8`]: struct.String.html#method.from_utf8
-/// [`String`]: struct.String.html
-/// [`into_bytes`]: struct.FromUtf8Error.html#method.into_bytes
-///
-/// The [`Utf8Error`] type provided by [`std::str`] represents an error that may
-/// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's
-/// an analogue to `FromUtf8Error`, and you can get one from a `FromUtf8Error`
-/// through the [`utf8_error`] method.
-///
-/// [`Utf8Error`]: ../../std/str/struct.Utf8Error.html
-/// [`std::str`]: ../../std/str/index.html
-/// [`u8`]: ../../std/primitive.u8.html
-/// [`&str`]: ../../std/primitive.str.html
-/// [`utf8_error`]: #method.utf8_error
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// // some invalid bytes, in a vector
-/// let bytes = vec![0, 159];
-///
-/// let value = String::from_utf8(bytes);
-///
-/// assert!(value.is_err());
-/// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Debug)]
-pub struct FromUtf8Error {
-    bytes: Vec<u8>,
-    error: Utf8Error,
-}
-
-/// A possible error value when converting a `String` from a UTF-16 byte slice.
-///
-/// This type is the error type for the [`from_utf16`] method on [`String`].
-///
-/// [`from_utf16`]: struct.String.html#method.from_utf16
-/// [`String`]: struct.String.html
-///
-/// # Examples
-///
-/// Basic usage:
-///
-/// ```
-/// // 𝄞mu<invalid>ic
-/// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
-///           0xD800, 0x0069, 0x0063];
-///
-/// assert!(String::from_utf16(v).is_err());
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-#[derive(Debug)]
-pub struct FromUtf16Error(());
-
-impl String {
-    /// Creates a new empty `String`.
-    ///
-    /// Given that the `String` is empty, this will not allocate any initial
-    /// buffer. While that means that this initial operation is very
-    /// inexpensive, but may cause excessive allocation later, when you add
-    /// data. If you have an idea of how much data the `String` will hold,
-    /// consider the [`with_capacity`] method to prevent excessive
-    /// re-allocation.
-    ///
-    /// [`with_capacity`]: #method.with_capacity
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = String::new();
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> String {
-        String { vec: Vec::new() }
-    }
-
-    /// Creates a new empty `String` with a particular capacity.
-    ///
-    /// `String`s have an internal buffer to hold their data. The capacity is
-    /// the length of that buffer, and can be queried with the [`capacity`]
-    /// method. This method creates an empty `String`, but one with an initial
-    /// buffer that can hold `capacity` bytes. This is useful when you may be
-    /// appending a bunch of data to the `String`, reducing the number of
-    /// reallocations it needs to do.
-    ///
-    /// [`capacity`]: #method.capacity
-    ///
-    /// If the given capacity is `0`, no allocation will occur, and this method
-    /// is identical to the [`new`] method.
-    ///
-    /// [`new`]: #method.new
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::with_capacity(10);
-    ///
-    /// // The String contains no chars, even though it has capacity for more
-    /// assert_eq!(s.len(), 0);
-    ///
-    /// // These are all done without reallocating...
-    /// let cap = s.capacity();
-    /// for i in 0..10 {
-    ///     s.push('a');
-    /// }
-    ///
-    /// assert_eq!(s.capacity(), cap);
-    ///
-    /// // ...but this may make the vector reallocate
-    /// s.push('a');
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: usize) -> String {
-        String { vec: Vec::with_capacity(capacity) }
-    }
-
-    // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
-    // required for this method definition, is not available. Since we don't
-    // require this method for testing purposes, I'll just stub it
-    // NB see the slice::hack module in slice.rs for more information
-    #[inline]
-    #[cfg(test)]
-    pub fn from_str(_: &str) -> String {
-        panic!("not available with cfg(test)");
-    }
-
-    /// Converts a vector of bytes to a `String`.
-    ///
-    /// A string slice ([`&str`]) is made of bytes ([`u8`]), and a vector of bytes
-    /// ([`Vec<u8>`]) is made of bytes, so this function converts between the
-    /// two. Not all byte slices are valid `String`s, however: `String`
-    /// requires that it is valid UTF-8. `from_utf8()` checks to ensure that
-    /// the bytes are valid UTF-8, and then does the conversion.
-    ///
-    /// [`&str`]: ../../std/primitive.str.html
-    /// [`u8`]: ../../std/primitive.u8.html
-    /// [`Vec<u8>`]: ../../std/vec/struct.Vec.html
-    ///
-    /// If you are sure that the byte slice is valid UTF-8, and you don't want
-    /// to incur the overhead of the validity check, there is an unsafe version
-    /// of this function, [`from_utf8_unchecked`], which has the same behavior
-    /// but skips the check.
-    ///
-    /// [`from_utf8_unchecked`]: struct.String.html#method.from_utf8_unchecked
-    ///
-    /// This method will take care to not copy the vector, for efficiency's
-    /// sake.
-    ///
-    /// If you need a `&str` instead of a `String`, consider
-    /// [`str::from_utf8`].
-    ///
-    /// [`str::from_utf8`]: ../../std/str/fn.from_utf8.html
-    ///
-    /// The inverse of this method is [`as_bytes`].
-    ///
-    /// [`as_bytes`]: #method.as_bytes
-    ///
-    /// # Errors
-    ///
-    /// Returns `Err` if the slice is not UTF-8 with a description as to why the
-    /// provided bytes are not UTF-8. The vector you moved in is also included.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // some bytes, in a vector
-    /// let sparkle_heart = vec![240, 159, 146, 150];
-    ///
-    /// // We know these bytes are valid, so we'll use `unwrap()`.
-    /// let sparkle_heart = String::from_utf8(sparkle_heart).unwrap();
-    ///
-    /// assert_eq!("💖", sparkle_heart);
-    /// ```
-    ///
-    /// Incorrect bytes:
-    ///
-    /// ```
-    /// // some invalid bytes, in a vector
-    /// let sparkle_heart = vec![0, 159, 146, 150];
-    ///
-    /// assert!(String::from_utf8(sparkle_heart).is_err());
-    /// ```
-    ///
-    /// See the docs for [`FromUtf8Error`] for more details on what you can do
-    /// with this error.
-    ///
-    /// [`FromUtf8Error`]: struct.FromUtf8Error.html
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn from_utf8(vec: Vec<u8>) -> Result<String, FromUtf8Error> {
-        match str::from_utf8(&vec) {
-            Ok(..) => Ok(String { vec: vec }),
-            Err(e) => {
-                Err(FromUtf8Error {
-                    bytes: vec,
-                    error: e,
-                })
-            }
-        }
-    }
-
-    /// Converts a slice of bytes to a string, including invalid characters.
-    ///
-    /// Strings are made of bytes ([`u8`]), and a slice of bytes
-    /// ([`&[u8]`][byteslice]) is made of bytes, so this function converts
-    /// between the two. Not all byte slices are valid strings, however: strings
-    /// are required to be valid UTF-8. During this conversion,
-    /// `from_utf8_lossy()` will replace any invalid UTF-8 sequences with
-    /// `U+FFFD REPLACEMENT CHARACTER`, which looks like this: �
-    ///
-    /// [`u8`]: ../../std/primitive.u8.html
-    /// [byteslice]: ../../std/primitive.slice.html
-    ///
-    /// If you are sure that the byte slice is valid UTF-8, and you don't want
-    /// to incur the overhead of the conversion, there is an unsafe version
-    /// of this function, [`from_utf8_unchecked`], which has the same behavior
-    /// but skips the checks.
-    ///
-    /// [`from_utf8_unchecked`]: struct.String.html#method.from_utf8_unchecked
-    ///
-    /// This function returns a [`Cow<'a, str>`]. If our byte slice is invalid
-    /// UTF-8, then we need to insert the replacement characters, which will
-    /// change the size of the string, and hence, require a `String`. But if
-    /// it's already valid UTF-8, we don't need a new allocation. This return
-    /// type allows us to handle both cases.
-    ///
-    /// [`Cow<'a, str>`]: ../../std/borrow/enum.Cow.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // some bytes, in a vector
-    /// let sparkle_heart = vec![240, 159, 146, 150];
-    ///
-    /// let sparkle_heart = String::from_utf8_lossy(&sparkle_heart);
-    ///
-    /// assert_eq!("💖", sparkle_heart);
-    /// ```
-    ///
-    /// Incorrect bytes:
-    ///
-    /// ```
-    /// // some invalid bytes
-    /// let input = b"Hello \xF0\x90\x80World";
-    /// let output = String::from_utf8_lossy(input);
-    ///
-    /// assert_eq!("Hello �World", output);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn from_utf8_lossy<'a>(v: &'a [u8]) -> Cow<'a, str> {
-        let mut i;
-        match str::from_utf8(v) {
-            Ok(s) => return Cow::Borrowed(s),
-            Err(e) => i = e.valid_up_to(),
-        }
-
-        const TAG_CONT_U8: u8 = 128;
-        const REPLACEMENT: &'static [u8] = b"\xEF\xBF\xBD"; // U+FFFD in UTF-8
-        let total = v.len();
-        fn unsafe_get(xs: &[u8], i: usize) -> u8 {
-            unsafe { *xs.get_unchecked(i) }
-        }
-        fn safe_get(xs: &[u8], i: usize, total: usize) -> u8 {
-            if i >= total { 0 } else { unsafe_get(xs, i) }
-        }
-
-        let mut res = String::with_capacity(total);
-
-        if i > 0 {
-            unsafe { res.as_mut_vec().extend_from_slice(&v[..i]) };
-        }
-
-        // subseqidx is the index of the first byte of the subsequence we're
-        // looking at.  It's used to copy a bunch of contiguous good codepoints
-        // at once instead of copying them one by one.
-        let mut subseqidx = i;
-
-        while i < total {
-            let i_ = i;
-            let byte = unsafe_get(v, i);
-            i += 1;
-
-            macro_rules! error { () => ({
-                unsafe {
-                    if subseqidx != i_ {
-                        res.as_mut_vec().extend_from_slice(&v[subseqidx..i_]);
-                    }
-                    subseqidx = i;
-                    res.as_mut_vec().extend_from_slice(REPLACEMENT);
-                }
-            })}
-
-            if byte < 128 {
-                // subseqidx handles this
-            } else {
-                let w = core_str::utf8_char_width(byte);
-
-                match w {
-                    2 => {
-                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
-                            error!();
-                            continue;
-                        }
-                        i += 1;
-                    }
-                    3 => {
-                        match (byte, safe_get(v, i, total)) {
-                            (0xE0, 0xA0...0xBF) => (),
-                            (0xE1...0xEC, 0x80...0xBF) => (),
-                            (0xED, 0x80...0x9F) => (),
-                            (0xEE...0xEF, 0x80...0xBF) => (),
-                            _ => {
-                                error!();
-                                continue;
-                            }
-                        }
-                        i += 1;
-                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
-                            error!();
-                            continue;
-                        }
-                        i += 1;
-                    }
-                    4 => {
-                        match (byte, safe_get(v, i, total)) {
-                            (0xF0, 0x90...0xBF) => (),
-                            (0xF1...0xF3, 0x80...0xBF) => (),
-                            (0xF4, 0x80...0x8F) => (),
-                            _ => {
-                                error!();
-                                continue;
-                            }
-                        }
-                        i += 1;
-                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
-                            error!();
-                            continue;
-                        }
-                        i += 1;
-                        if safe_get(v, i, total) & 192 != TAG_CONT_U8 {
-                            error!();
-                            continue;
-                        }
-                        i += 1;
-                    }
-                    _ => {
-                        error!();
-                        continue;
-                    }
-                }
-            }
-        }
-        if subseqidx < total {
-            unsafe { res.as_mut_vec().extend_from_slice(&v[subseqidx..total]) };
-        }
-        Cow::Owned(res)
-    }
-
-    /// Decode a UTF-16 encoded vector `v` into a `String`, returning `Err`
-    /// if `v` contains any invalid data.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // 𝄞music
-    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
-    ///           0x0073, 0x0069, 0x0063];
-    /// assert_eq!(String::from("𝄞music"),
-    ///            String::from_utf16(v).unwrap());
-    ///
-    /// // 𝄞mu<invalid>ic
-    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
-    ///           0xD800, 0x0069, 0x0063];
-    /// assert!(String::from_utf16(v).is_err());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn from_utf16(v: &[u16]) -> Result<String, FromUtf16Error> {
-        decode_utf16(v.iter().cloned()).collect::<Result<_, _>>().map_err(|_| FromUtf16Error(()))
-    }
-
-    /// Decode a UTF-16 encoded vector `v` into a string, replacing
-    /// invalid data with the replacement character (U+FFFD).
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // 𝄞mus<invalid>ic<invalid>
-    /// let v = &[0xD834, 0xDD1E, 0x006d, 0x0075,
-    ///           0x0073, 0xDD1E, 0x0069, 0x0063,
-    ///           0xD834];
-    ///
-    /// assert_eq!(String::from("𝄞mus\u{FFFD}ic\u{FFFD}"),
-    ///            String::from_utf16_lossy(v));
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn from_utf16_lossy(v: &[u16]) -> String {
-        decode_utf16(v.iter().cloned()).map(|r| r.unwrap_or(REPLACEMENT_CHARACTER)).collect()
-    }
-
-    /// Creates a new `String` from a length, capacity, and pointer.
-    ///
-    /// # Safety
-    ///
-    /// This is highly unsafe, due to the number of invariants that aren't
-    /// checked:
-    ///
-    /// * The memory at `ptr` needs to have been previously allocated by the
-    ///   same allocator the standard library uses.
-    /// * `length` needs to be less than or equal to `capacity`.
-    /// * `capacity` needs to be the correct value.
-    ///
-    /// Violating these may cause problems like corrupting the allocator's
-    /// internal datastructures.
-    ///
-    /// The ownership of `ptr` is effectively transferred to the
-    /// `String` which may then deallocate, reallocate or change the
-    /// contents of memory pointed to by the pointer at will. Ensure
-    /// that nothing else uses the pointer after calling this
-    /// function.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// use std::mem;
-    ///
-    /// unsafe {
-    ///     let s = String::from("hello");
-    ///     let ptr = s.as_ptr();
-    ///     let len = s.len();
-    ///     let capacity = s.capacity();
-    ///
-    ///     mem::forget(s);
-    ///
-    ///     let s = String::from_raw_parts(ptr as *mut _, len, capacity);
-    ///
-    ///     assert_eq!(String::from("hello"), s);
-    /// }
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_raw_parts(buf: *mut u8, length: usize, capacity: usize) -> String {
-        String { vec: Vec::from_raw_parts(buf, length, capacity) }
-    }
-
-    /// Converts a vector of bytes to a `String` without checking that the
-    /// string contains valid UTF-8.
-    ///
-    /// See the safe version, [`from_utf8`], for more details.
-    ///
-    /// [`from_utf8`]: struct.String.html#method.from_utf8
-    ///
-    /// # Safety
-    ///
-    /// This function is unsafe because it does not check that the bytes passed
-    /// to it are valid UTF-8. If this constraint is violated, it may cause
-    /// memory unsafety issues with future users of the `String`, as the rest of
-    /// the standard library assumes that `String`s are valid UTF-8.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // some bytes, in a vector
-    /// let sparkle_heart = vec![240, 159, 146, 150];
-    ///
-    /// let sparkle_heart = unsafe {
-    ///     String::from_utf8_unchecked(sparkle_heart)
-    /// };
-    ///
-    /// assert_eq!("💖", sparkle_heart);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_utf8_unchecked(bytes: Vec<u8>) -> String {
-        String { vec: bytes }
-    }
-
-    /// Converts a `String` into a byte vector.
-    ///
-    /// This consumes the `String`, so we do not need to copy its contents.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = String::from("hello");
-    /// let bytes = s.into_bytes();
-    ///
-    /// assert_eq!(&[104, 101, 108, 108, 111][..], &bytes[..]);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.vec
-    }
-
-    /// Extracts a string slice containing the entire string.
-    #[inline]
-    #[stable(feature = "string_as_str", since = "1.7.0")]
-    pub fn as_str(&self) -> &str {
-        self
-    }
-
-    /// Extracts a string slice containing the entire string.
-    #[inline]
-    #[stable(feature = "string_as_str", since = "1.7.0")]
-    pub fn as_mut_str(&mut self) -> &mut str {
-        self
-    }
-
-    /// Appends a given string slice onto the end of this `String`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("foo");
-    ///
-    /// s.push_str("bar");
-    ///
-    /// assert_eq!("foobar", s);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_str(&mut self, string: &str) {
-        self.vec.extend_from_slice(string.as_bytes())
-    }
-
-    /// Returns this `String`'s capacity, in bytes.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = String::with_capacity(10);
-    ///
-    /// assert!(s.capacity() >= 10);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> usize {
-        self.vec.capacity()
-    }
-
-    /// Ensures that this `String`'s capacity is at least `additional` bytes
-    /// larger than its length.
-    ///
-    /// The capacity may be increased by more than `additional` bytes if it
-    /// chooses, to prevent frequent reallocations.
-    ///
-    /// If you do not want this "at least" behavior, see the [`reserve_exact`]
-    /// method.
-    ///
-    /// [`reserve_exact`]: #method.reserve_exact
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::new();
-    ///
-    /// s.reserve(10);
-    ///
-    /// assert!(s.capacity() >= 10);
-    /// ```
-    ///
-    /// This may not actually increase the capacity:
-    ///
-    /// ```
-    /// let mut s = String::with_capacity(10);
-    /// s.push('a');
-    /// s.push('b');
-    ///
-    /// // s now has a length of 2 and a capacity of 10
-    /// assert_eq!(2, s.len());
-    /// assert_eq!(10, s.capacity());
-    ///
-    /// // Since we already have an extra 8 capacity, calling this...
-    /// s.reserve(8);
-    ///
-    /// // ... doesn't actually increase.
-    /// assert_eq!(10, s.capacity());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: usize) {
-        self.vec.reserve(additional)
-    }
-
-    /// Ensures that this `String`'s capacity is `additional` bytes
-    /// larger than its length.
-    ///
-    /// Consider using the [`reserve`] method unless you absolutely know
-    /// better than the allocator.
-    ///
-    /// [`reserve`]: #method.reserve
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::new();
-    ///
-    /// s.reserve_exact(10);
-    ///
-    /// assert!(s.capacity() >= 10);
-    /// ```
-    ///
-    /// This may not actually increase the capacity:
-    ///
-    /// ```
-    /// let mut s = String::with_capacity(10);
-    /// s.push('a');
-    /// s.push('b');
-    ///
-    /// // s now has a length of 2 and a capacity of 10
-    /// assert_eq!(2, s.len());
-    /// assert_eq!(10, s.capacity());
-    ///
-    /// // Since we already have an extra 8 capacity, calling this...
-    /// s.reserve_exact(8);
-    ///
-    /// // ... doesn't actually increase.
-    /// assert_eq!(10, s.capacity());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.vec.reserve_exact(additional)
-    }
-
-    /// Shrinks the capacity of this `String` to match its length.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("foo");
-    ///
-    /// s.reserve(100);
-    /// assert!(s.capacity() >= 100);
-    ///
-    /// s.shrink_to_fit();
-    /// assert_eq!(3, s.capacity());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn shrink_to_fit(&mut self) {
-        self.vec.shrink_to_fit()
-    }
-
-    /// Appends the given `char` to the end of this `String`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("abc");
-    ///
-    /// s.push('1');
-    /// s.push('2');
-    /// s.push('3');
-    ///
-    /// assert_eq!("abc123", s);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push(&mut self, ch: char) {
-        match ch.len_utf8() {
-            1 => self.vec.push(ch as u8),
-            _ => self.vec.extend_from_slice(ch.encode_utf8(&mut [0; 4]).as_bytes()),
-        }
-    }
-
-    /// Returns a byte slice of this `String`'s contents.
-    ///
-    /// The inverse of this method is [`from_utf8`].
-    ///
-    /// [`from_utf8`]: #method.from_utf8
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = String::from("hello");
-    ///
-    /// assert_eq!(&[104, 101, 108, 108, 111], s.as_bytes());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.vec
-    }
-
-    /// Shortens this `String` to the specified length.
-    ///
-    /// If `new_len` is greater than the string's current length, this has no
-    /// effect.
-    ///
-    /// Note that this method has no effect on the allocated capacity
-    /// of the string
-    ///
-    /// # Panics
-    ///
-    /// Panics if `new_len` does not lie on a [`char`] boundary.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("hello");
-    ///
-    /// s.truncate(2);
-    ///
-    /// assert_eq!("he", s);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn truncate(&mut self, new_len: usize) {
-        if new_len <= self.len() {
-            assert!(self.is_char_boundary(new_len));
-            self.vec.truncate(new_len)
-        }
-    }
-
-    /// Removes the last character from the string buffer and returns it.
-    ///
-    /// Returns `None` if this `String` is empty.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("foo");
-    ///
-    /// assert_eq!(s.pop(), Some('o'));
-    /// assert_eq!(s.pop(), Some('o'));
-    /// assert_eq!(s.pop(), Some('f'));
-    ///
-    /// assert_eq!(s.pop(), None);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop(&mut self) -> Option<char> {
-        let ch = match self.chars().rev().next() {
-            Some(ch) => ch,
-            None => return None,
-        };
-        let newlen = self.len() - ch.len_utf8();
-        unsafe {
-            self.vec.set_len(newlen);
-        }
-        Some(ch)
-    }
-
-    /// Removes a `char` from this `String` at a byte position and returns it.
-    ///
-    /// This is an `O(n)` operation, as it requires copying every element in the
-    /// buffer.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `idx` is larger than or equal to the `String`'s length,
-    /// or if it does not lie on a [`char`] boundary.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("foo");
-    ///
-    /// assert_eq!(s.remove(0), 'f');
-    /// assert_eq!(s.remove(1), 'o');
-    /// assert_eq!(s.remove(0), 'o');
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, idx: usize) -> char {
-        let ch = match self[idx..].chars().next() {
-            Some(ch) => ch,
-            None => panic!("cannot remove a char from the end of a string"),
-        };
-
-        let next = idx + ch.len_utf8();
-        let len = self.len();
-        unsafe {
-            ptr::copy(self.vec.as_ptr().offset(next as isize),
-                      self.vec.as_mut_ptr().offset(idx as isize),
-                      len - next);
-            self.vec.set_len(len - (next - idx));
-        }
-        ch
-    }
-
-    /// Inserts a character into this `String` at a byte position.
-    ///
-    /// This is an `O(n)` operation as it requires copying every element in the
-    /// buffer.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `idx` is larger than the `String`'s length, or if it does not
-    /// lie on a [`char`] boundary.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::with_capacity(3);
-    ///
-    /// s.insert(0, 'f');
-    /// s.insert(1, 'o');
-    /// s.insert(2, 'o');
-    ///
-    /// assert_eq!("foo", s);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, idx: usize, ch: char) {
-        assert!(self.is_char_boundary(idx));
-        let mut bits = [0; 4];
-        let bits = ch.encode_utf8(&mut bits).as_bytes();
-
-        unsafe {
-            self.insert_bytes(idx, bits);
-        }
-    }
-
-    unsafe fn insert_bytes(&mut self, idx: usize, bytes: &[u8]) {
-        let len = self.len();
-        let amt = bytes.len();
-        self.vec.reserve(amt);
-
-        ptr::copy(self.vec.as_ptr().offset(idx as isize),
-                  self.vec.as_mut_ptr().offset((idx + amt) as isize),
-                  len - idx);
-        ptr::copy(bytes.as_ptr(),
-                  self.vec.as_mut_ptr().offset(idx as isize),
-                  amt);
-        self.vec.set_len(len + amt);
-    }
-
-    /// Inserts a string slice into this `String` at a byte position.
-    ///
-    /// This is an `O(n)` operation as it requires copying every element in the
-    /// buffer.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `idx` is larger than the `String`'s length, or if it does not
-    /// lie on a [`char`] boundary.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("bar");
-    ///
-    /// s.insert_str(0, "foo");
-    ///
-    /// assert_eq!("foobar", s);
-    /// ```
-    #[inline]
-    #[stable(feature = "insert_str", since = "1.16.0")]
-    pub fn insert_str(&mut self, idx: usize, string: &str) {
-        assert!(self.is_char_boundary(idx));
-
-        unsafe {
-            self.insert_bytes(idx, string.as_bytes());
-        }
-    }
-
-    /// Returns a mutable reference to the contents of this `String`.
-    ///
-    /// # Safety
-    ///
-    /// This function is unsafe because it does not check that the bytes passed
-    /// to it are valid UTF-8. If this constraint is violated, it may cause
-    /// memory unsafety issues with future users of the `String`, as the rest of
-    /// the standard library assumes that `String`s are valid UTF-8.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("hello");
-    ///
-    /// unsafe {
-    ///     let vec = s.as_mut_vec();
-    ///     assert_eq!(&[104, 101, 108, 108, 111][..], &vec[..]);
-    ///
-    ///     vec.reverse();
-    /// }
-    /// assert_eq!(s, "olleh");
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn as_mut_vec(&mut self) -> &mut Vec<u8> {
-        &mut self.vec
-    }
-
-    /// Returns the length of this `String`, in bytes.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let a = String::from("foo");
-    ///
-    /// assert_eq!(a.len(), 3);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.vec.len()
-    }
-
-    /// Returns `true` if this `String` has a length of zero.
-    ///
-    /// Returns `false` otherwise.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut v = String::new();
-    /// assert!(v.is_empty());
-    ///
-    /// v.push('a');
-    /// assert!(!v.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Splits the string into two at the given index.
-    ///
-    /// Returns a newly allocated `String`. `self` contains bytes `[0, at)`, and
-    /// the returned `String` contains bytes `[at, len)`. `at` must be on the
-    /// boundary of a UTF-8 code point.
-    ///
-    /// Note that the capacity of `self` does not change.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at` is not on a `UTF-8` code point boundary, or if it is beyond the last
-    /// code point of the string.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # fn main() {
-    /// let mut hello = String::from("Hello, World!");
-    /// let world = hello.split_off(7);
-    /// assert_eq!(hello, "Hello, ");
-    /// assert_eq!(world, "World!");
-    /// # }
-    /// ```
-    #[inline]
-    #[stable(feature = "string_split_off", since = "1.16.0")]
-    pub fn split_off(&mut self, at: usize) -> String {
-        assert!(self.is_char_boundary(at));
-        let other = self.vec.split_off(at);
-        unsafe { String::from_utf8_unchecked(other) }
-    }
-
-    /// Truncates this `String`, removing all contents.
-    ///
-    /// While this means the `String` will have a length of zero, it does not
-    /// touch its capacity.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("foo");
-    ///
-    /// s.clear();
-    ///
-    /// assert!(s.is_empty());
-    /// assert_eq!(0, s.len());
-    /// assert_eq!(3, s.capacity());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        self.vec.clear()
-    }
-
-    /// Creates a draining iterator that removes the specified range in the string
-    /// and yields the removed chars.
-    ///
-    /// Note: The element range is removed even if the iterator is not
-    /// consumed until the end.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let mut s = String::from("α is alpha, β is beta");
-    /// let beta_offset = s.find('β').unwrap_or(s.len());
-    ///
-    /// // Remove the range up until the β from the string
-    /// let t: String = s.drain(..beta_offset).collect();
-    /// assert_eq!(t, "α is alpha, ");
-    /// assert_eq!(s, "β is beta");
-    ///
-    /// // A full range clears the string
-    /// s.drain(..);
-    /// assert_eq!(s, "");
-    /// ```
-    #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain<R>(&mut self, range: R) -> Drain
-        where R: RangeArgument<usize>
-    {
-        // Memory safety
-        //
-        // The String version of Drain does not have the memory safety issues
-        // of the vector version. The data is just plain bytes.
-        // Because the range removal happens in Drop, if the Drain iterator is leaked,
-        // the removal will not happen.
-        let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
-            Unbounded => 0,
-        };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
-            Unbounded => len,
-        };
-
-        // Take out two simultaneous borrows. The &mut String won't be accessed
-        // until iteration is over, in Drop.
-        let self_ptr = self as *mut _;
-        // slicing does the appropriate bounds checks
-        let chars_iter = self[start..end].chars();
-
-        Drain {
-            start: start,
-            end: end,
-            iter: chars_iter,
-            string: self_ptr,
-        }
-    }
-
-    /// Creates a splicing iterator that removes the specified range in the string,
-    /// replaces with the given string, and yields the removed chars.
-    /// The given string doesn’t need to be the same length as the range.
-    ///
-    /// Note: The element range is removed when the `Splice` is dropped,
-    /// even if the iterator is not consumed until the end.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point or end point do not lie on a [`char`]
-    /// boundary, or if they're out of bounds.
-    ///
-    /// [`char`]: ../../std/primitive.char.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(splice)]
-    /// let mut s = String::from("α is alpha, β is beta");
-    /// let beta_offset = s.find('β').unwrap_or(s.len());
-    ///
-    /// // Replace the range up until the β from the string
-    /// let t: String = s.splice(..beta_offset, "Α is capital alpha; ").collect();
-    /// assert_eq!(t, "α is alpha, ");
-    /// assert_eq!(s, "Α is capital alpha; β is beta");
-    /// ```
-    #[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-    pub fn splice<'a, 'b, R>(&'a mut self, range: R, replace_with: &'b str) -> Splice<'a, 'b>
-        where R: RangeArgument<usize>
-    {
-        // Memory safety
-        //
-        // The String version of Splice does not have the memory safety issues
-        // of the vector version. The data is just plain bytes.
-        // Because the range removal happens in Drop, if the Splice iterator is leaked,
-        // the removal will not happen.
-        let len = self.len();
-        let start = match range.start() {
-             Included(&n) => n,
-             Excluded(&n) => n + 1,
-             Unbounded => 0,
-        };
-        let end = match range.end() {
-             Included(&n) => n + 1,
-             Excluded(&n) => n,
-             Unbounded => len,
-        };
-
-        // Take out two simultaneous borrows. The &mut String won't be accessed
-        // until iteration is over, in Drop.
-        let self_ptr = self as *mut _;
-        // slicing does the appropriate bounds checks
-        let chars_iter = self[start..end].chars();
-
-        Splice {
-            start: start,
-            end: end,
-            iter: chars_iter,
-            string: self_ptr,
-            replace_with: replace_with
-        }
-    }
-
-    /// Converts this `String` into a `Box<str>`.
-    ///
-    /// This will drop any excess capacity.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let s = String::from("hello");
-    ///
-    /// let b = s.into_boxed_str();
-    /// ```
-    #[stable(feature = "box_str", since = "1.4.0")]
-    pub fn into_boxed_str(self) -> Box<str> {
-        let slice = self.vec.into_boxed_slice();
-        unsafe { alloc_str::from_boxed_utf8_unchecked(slice) }
-    }
-}
-
-impl FromUtf8Error {
-    /// Returns a slice of [`u8`]s bytes that were attempted to convert to a `String`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// #![feature(from_utf8_error_as_bytes)]
-    /// // some invalid bytes, in a vector
-    /// let bytes = vec![0, 159];
-    ///
-    /// let value = String::from_utf8(bytes);
-    ///
-    /// assert_eq!(&[0, 159], value.unwrap_err().as_bytes());
-    /// ```
-    #[unstable(feature = "from_utf8_error_as_bytes", reason = "recently added", issue = "40895")]
-    pub fn as_bytes(&self) -> &[u8] {
-        &self.bytes[..]
-    }
-
-    /// Returns the bytes that were attempted to convert to a `String`.
-    ///
-    /// This method is carefully constructed to avoid allocation. It will
-    /// consume the error, moving out the bytes, so that a copy of the bytes
-    /// does not need to be made.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // some invalid bytes, in a vector
-    /// let bytes = vec![0, 159];
-    ///
-    /// let value = String::from_utf8(bytes);
-    ///
-    /// assert_eq!(vec![0, 159], value.unwrap_err().into_bytes());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_bytes(self) -> Vec<u8> {
-        self.bytes
-    }
-
-    /// Fetch a `Utf8Error` to get more details about the conversion failure.
-    ///
-    /// The [`Utf8Error`] type provided by [`std::str`] represents an error that may
-    /// occur when converting a slice of [`u8`]s to a [`&str`]. In this sense, it's
-    /// an analogue to `FromUtf8Error`. See its documentation for more details
-    /// on using it.
-    ///
-    /// [`Utf8Error`]: ../../std/str/struct.Utf8Error.html
-    /// [`std::str`]: ../../std/str/index.html
-    /// [`u8`]: ../../std/primitive.u8.html
-    /// [`&str`]: ../../std/primitive.str.html
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// // some invalid bytes, in a vector
-    /// let bytes = vec![0, 159];
-    ///
-    /// let error = String::from_utf8(bytes).unwrap_err().utf8_error();
-    ///
-    /// // the first byte is invalid here
-    /// assert_eq!(1, error.valid_up_to());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn utf8_error(&self) -> Utf8Error {
-        self.error
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for FromUtf8Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&self.error, f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for FromUtf16Error {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt("invalid utf-16: lone surrogate found", f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Clone for String {
-    fn clone(&self) -> Self {
-        String { vec: self.vec.clone() }
-    }
-
-    fn clone_from(&mut self, source: &Self) {
-        self.vec.clone_from(&source.vec);
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl FromIterator<char> for String {
-    fn from_iter<I: IntoIterator<Item = char>>(iter: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-#[stable(feature = "string_from_iter_by_ref", since = "1.17.0")]
-impl<'a> FromIterator<&'a char> for String {
-    fn from_iter<I: IntoIterator<Item = &'a char>>(iter: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> FromIterator<&'a str> for String {
-    fn from_iter<I: IntoIterator<Item = &'a str>>(iter: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-#[stable(feature = "extend_string", since = "1.4.0")]
-impl FromIterator<String> for String {
-    fn from_iter<I: IntoIterator<Item = String>>(iter: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-#[stable(feature = "herd_cows", since = "1.19.0")]
-impl<'a> FromIterator<Cow<'a, str>> for String {
-    fn from_iter<I: IntoIterator<Item = Cow<'a, str>>>(iter: I) -> String {
-        let mut buf = String::new();
-        buf.extend(iter);
-        buf
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Extend<char> for String {
-    fn extend<I: IntoIterator<Item = char>>(&mut self, iter: I) {
-        let iterator = iter.into_iter();
-        let (lower_bound, _) = iterator.size_hint();
-        self.reserve(lower_bound);
-        for ch in iterator {
-            self.push(ch)
-        }
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a> Extend<&'a char> for String {
-    fn extend<I: IntoIterator<Item = &'a char>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> Extend<&'a str> for String {
-    fn extend<I: IntoIterator<Item = &'a str>>(&mut self, iter: I) {
-        for s in iter {
-            self.push_str(s)
-        }
-    }
-}
-
-#[stable(feature = "extend_string", since = "1.4.0")]
-impl Extend<String> for String {
-    fn extend<I: IntoIterator<Item = String>>(&mut self, iter: I) {
-        for s in iter {
-            self.push_str(&s)
-        }
-    }
-}
-
-#[stable(feature = "herd_cows", since = "1.19.0")]
-impl<'a> Extend<Cow<'a, str>> for String {
-    fn extend<I: IntoIterator<Item = Cow<'a, str>>>(&mut self, iter: I) {
-        for s in iter {
-            self.push_str(&s)
-        }
-    }
-}
-
-/// A convenience impl that delegates to the impl for `&str`
-#[unstable(feature = "pattern",
-           reason = "API not fully fleshed out and ready to be stabilized",
-           issue = "27721")]
-impl<'a, 'b> Pattern<'a> for &'b String {
-    type Searcher = <&'b str as Pattern<'a>>::Searcher;
-
-    fn into_searcher(self, haystack: &'a str) -> <&'b str as Pattern<'a>>::Searcher {
-        self[..].into_searcher(haystack)
-    }
-
-    #[inline]
-    fn is_contained_in(self, haystack: &'a str) -> bool {
-        self[..].is_contained_in(haystack)
-    }
-
-    #[inline]
-    fn is_prefix_of(self, haystack: &'a str) -> bool {
-        self[..].is_prefix_of(haystack)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl PartialEq for String {
-    #[inline]
-    fn eq(&self, other: &String) -> bool {
-        PartialEq::eq(&self[..], &other[..])
-    }
-    #[inline]
-    fn ne(&self, other: &String) -> bool {
-        PartialEq::ne(&self[..], &other[..])
-    }
-}
-
-macro_rules! impl_eq {
-    ($lhs:ty, $rhs: ty) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl<'a, 'b> PartialEq<$rhs> for $lhs {
-            #[inline]
-            fn eq(&self, other: &$rhs) -> bool { PartialEq::eq(&self[..], &other[..]) }
-            #[inline]
-            fn ne(&self, other: &$rhs) -> bool { PartialEq::ne(&self[..], &other[..]) }
-        }
-
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl<'a, 'b> PartialEq<$lhs> for $rhs {
-            #[inline]
-            fn eq(&self, other: &$lhs) -> bool { PartialEq::eq(&self[..], &other[..]) }
-            #[inline]
-            fn ne(&self, other: &$lhs) -> bool { PartialEq::ne(&self[..], &other[..]) }
-        }
-
-    }
-}
-
-impl_eq! { String, str }
-impl_eq! { String, &'a str }
-impl_eq! { Cow<'a, str>, str }
-impl_eq! { Cow<'a, str>, &'b str }
-impl_eq! { Cow<'a, str>, String }
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl Default for String {
-    /// Creates an empty `String`.
-    #[inline]
-    fn default() -> String {
-        String::new()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Display for String {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Display::fmt(&**self, f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Debug for String {
-    #[inline]
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl hash::Hash for String {
-    #[inline]
-    fn hash<H: hash::Hasher>(&self, hasher: &mut H) {
-        (**self).hash(hasher)
-    }
-}
-
-/// Implements the `+` operator for concatenating two strings.
-///
-/// This consumes the `String` on the left-hand side and re-uses its buffer (growing it if
-/// necessary). This is done to avoid allocating a new `String` and copying the entire contents on
-/// every operation, which would lead to `O(n^2)` running time when building an `n`-byte string by
-/// repeated concatenation.
-///
-/// The string on the right-hand side is only borrowed; its contents are copied into the returned
-/// `String`.
-///
-/// # Examples
-///
-/// Concatenating two `String`s takes the first by value and borrows the second:
-///
-/// ```
-/// let a = String::from("hello");
-/// let b = String::from(" world");
-/// let c = a + &b;
-/// // `a` is moved and can no longer be used here.
-/// ```
-///
-/// If you want to keep using the first `String`, you can clone it and append to the clone instead:
-///
-/// ```
-/// let a = String::from("hello");
-/// let b = String::from(" world");
-/// let c = a.clone() + &b;
-/// // `a` is still valid here.
-/// ```
-///
-/// Concatenating `&str` slices can be done by converting the first to a `String`:
-///
-/// ```
-/// let a = "hello";
-/// let b = " world";
-/// let c = a.to_string() + b;
-/// ```
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> Add<&'a str> for String {
-    type Output = String;
-
-    #[inline]
-    fn add(mut self, other: &str) -> String {
-        self.push_str(other);
-        self
-    }
-}
-
-/// Implements the `+=` operator for appending to a `String`.
-///
-/// This has the same behavior as the [`push_str`] method.
-///
-/// [`push_str`]: struct.String.html#method.push_str
-#[stable(feature = "stringaddassign", since = "1.12.0")]
-impl<'a> AddAssign<&'a str> for String {
-    #[inline]
-    fn add_assign(&mut self, other: &str) {
-        self.push_str(other);
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::Range<usize>> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, index: ops::Range<usize>) -> &str {
-        &self[..][index]
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeTo<usize>> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, index: ops::RangeTo<usize>) -> &str {
-        &self[..][index]
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFrom<usize>> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, index: ops::RangeFrom<usize>) -> &str {
-        &self[..][index]
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Index<ops::RangeFull> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &str {
-        unsafe { str::from_utf8_unchecked(&self.vec) }
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl ops::Index<ops::RangeInclusive<usize>> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, index: ops::RangeInclusive<usize>) -> &str {
-        Index::index(&**self, index)
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl ops::Index<ops::RangeToInclusive<usize>> for String {
-    type Output = str;
-
-    #[inline]
-    fn index(&self, index: ops::RangeToInclusive<usize>) -> &str {
-        Index::index(&**self, index)
-    }
-}
-
-#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::Range<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::Range<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeTo<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeFrom<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut str {
-        &mut self[..][index]
-    }
-}
-#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::IndexMut<ops::RangeFull> for String {
-    #[inline]
-    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut str {
-        unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl ops::IndexMut<ops::RangeInclusive<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut str {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl ops::IndexMut<ops::RangeToInclusive<usize>> for String {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut str {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl ops::Deref for String {
-    type Target = str;
-
-    #[inline]
-    fn deref(&self) -> &str {
-        unsafe { str::from_utf8_unchecked(&self.vec) }
-    }
-}
-
-#[stable(feature = "derefmut_for_string", since = "1.3.0")]
-impl ops::DerefMut for String {
-    #[inline]
-    fn deref_mut(&mut self) -> &mut str {
-        unsafe { str::from_utf8_unchecked_mut(&mut *self.vec) }
-    }
-}
-
-/// An error when parsing a `String`.
-///
-/// This `enum` is slightly awkward: it will never actually exist. This error is
-/// part of the type signature of the implementation of [`FromStr`] on
-/// [`String`]. The return type of [`from_str`], requires that an error be
-/// defined, but, given that a [`String`] can always be made into a new
-/// [`String`] without error, this type will never actually be returned. As
-/// such, it is only here to satisfy said signature, and is useless otherwise.
-///
-/// [`FromStr`]: ../../std/str/trait.FromStr.html
-/// [`String`]: struct.String.html
-/// [`from_str`]: ../../std/str/trait.FromStr.html#tymethod.from_str
-#[stable(feature = "str_parse_error", since = "1.5.0")]
-#[derive(Copy)]
-pub enum ParseError {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl FromStr for String {
-    type Err = ParseError;
-    #[inline]
-    fn from_str(s: &str) -> Result<String, ParseError> {
-        Ok(String::from(s))
-    }
-}
-
-#[stable(feature = "str_parse_error", since = "1.5.0")]
-impl Clone for ParseError {
-    fn clone(&self) -> ParseError {
-        match *self {}
-    }
-}
-
-#[stable(feature = "str_parse_error", since = "1.5.0")]
-impl fmt::Debug for ParseError {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "str_parse_error2", since = "1.8.0")]
-impl fmt::Display for ParseError {
-    fn fmt(&self, _: &mut fmt::Formatter) -> fmt::Result {
-        match *self {}
-    }
-}
-
-#[stable(feature = "str_parse_error", since = "1.5.0")]
-impl PartialEq for ParseError {
-    fn eq(&self, _: &ParseError) -> bool {
-        match *self {}
-    }
-}
-
-#[stable(feature = "str_parse_error", since = "1.5.0")]
-impl Eq for ParseError {}
-
-/// A trait for converting a value to a `String`.
-///
-/// This trait is automatically implemented for any type which implements the
-/// [`Display`] trait. As such, `ToString` shouldn't be implemented directly:
-/// [`Display`] should be implemented instead, and you get the `ToString`
-/// implementation for free.
-///
-/// [`Display`]: ../../std/fmt/trait.Display.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub trait ToString {
-    /// Converts the given value to a `String`.
-    ///
-    /// # Examples
-    ///
-    /// Basic usage:
-    ///
-    /// ```
-    /// let i = 5;
-    /// let five = String::from("5");
-    ///
-    /// assert_eq!(five, i.to_string());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    fn to_string(&self) -> String;
-}
-
-/// # Panics
-///
-/// In this implementation, the `to_string` method panics
-/// if the `Display` implementation returns an error.
-/// This indicates an incorrect `Display` implementation
-/// since `fmt::Write for String` never returns an error itself.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Display + ?Sized> ToString for T {
-    #[inline]
-    default fn to_string(&self) -> String {
-        use core::fmt::Write;
-        let mut buf = String::new();
-        buf.write_fmt(format_args!("{}", self))
-           .expect("a Display implementation return an error unexpectedly");
-        buf.shrink_to_fit();
-        buf
-    }
-}
-
-#[stable(feature = "str_to_string_specialization", since = "1.9.0")]
-impl ToString for str {
-    #[inline]
-    fn to_string(&self) -> String {
-        String::from(self)
-    }
-}
-
-#[stable(feature = "cow_str_to_string_specialization", since = "1.17.0")]
-impl<'a> ToString for Cow<'a, str> {
-    #[inline]
-    fn to_string(&self) -> String {
-        self[..].to_owned()
-    }
-}
-
-#[stable(feature = "string_to_string_specialization", since = "1.17.0")]
-impl ToString for String {
-    #[inline]
-    fn to_string(&self) -> String {
-        self.to_owned()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<str> for String {
-    #[inline]
-    fn as_ref(&self) -> &str {
-        self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl AsRef<[u8]> for String {
-    #[inline]
-    fn as_ref(&self) -> &[u8] {
-        self.as_bytes()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for String {
-    fn from(s: &'a str) -> String {
-        s.to_owned()
-    }
-}
-
-// note: test pulls in libstd, which causes errors here
-#[cfg(not(test))]
-#[stable(feature = "string_from_box", since = "1.18.0")]
-impl From<Box<str>> for String {
-    fn from(s: Box<str>) -> String {
-        s.into_string()
-    }
-}
-
-#[stable(feature = "box_from_str", since = "1.18.0")]
-impl Into<Box<str>> for String {
-    fn into(self) -> Box<str> {
-        self.into_boxed_str()
-    }
-}
-
-#[stable(feature = "string_from_cow_str", since = "1.14.0")]
-impl<'a> From<Cow<'a, str>> for String {
-    fn from(s: Cow<'a, str>) -> String {
-        s.into_owned()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for Cow<'a, str> {
-    #[inline]
-    fn from(s: &'a str) -> Cow<'a, str> {
-        Cow::Borrowed(s)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<String> for Cow<'a, str> {
-    #[inline]
-    fn from(s: String) -> Cow<'a, str> {
-        Cow::Owned(s)
-    }
-}
-
-#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a> FromIterator<char> for Cow<'a, str> {
-    fn from_iter<I: IntoIterator<Item = char>>(it: I) -> Cow<'a, str> {
-        Cow::Owned(FromIterator::from_iter(it))
-    }
-}
-
-#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a, 'b> FromIterator<&'b str> for Cow<'a, str> {
-    fn from_iter<I: IntoIterator<Item = &'b str>>(it: I) -> Cow<'a, str> {
-        Cow::Owned(FromIterator::from_iter(it))
-    }
-}
-
-#[stable(feature = "cow_str_from_iter", since = "1.12.0")]
-impl<'a> FromIterator<String> for Cow<'a, str> {
-    fn from_iter<I: IntoIterator<Item = String>>(it: I) -> Cow<'a, str> {
-        Cow::Owned(FromIterator::from_iter(it))
-    }
-}
-
-#[stable(feature = "from_string_for_vec_u8", since = "1.14.0")]
-impl From<String> for Vec<u8> {
-    fn from(string: String) -> Vec<u8> {
-        string.into_bytes()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl fmt::Write for String {
-    #[inline]
-    fn write_str(&mut self, s: &str) -> fmt::Result {
-        self.push_str(s);
-        Ok(())
-    }
-
-    #[inline]
-    fn write_char(&mut self, c: char) -> fmt::Result {
-        self.push(c);
-        Ok(())
-    }
-}
-
-/// A draining iterator for `String`.
-///
-/// This struct is created by the [`drain`] method on [`String`]. See its
-/// documentation for more.
-///
-/// [`drain`]: struct.String.html#method.drain
-/// [`String`]: struct.String.html
-#[stable(feature = "drain", since = "1.6.0")]
-pub struct Drain<'a> {
-    /// Will be used as &'a mut String in the destructor
-    string: *mut String,
-    /// Start of part to remove
-    start: usize,
-    /// End of part to remove
-    end: usize,
-    /// Current remaining range to remove
-    iter: Chars<'a>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a> fmt::Debug for Drain<'a> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.pad("Drain { .. }")
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a> Sync for Drain<'a> {}
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a> Send for Drain<'a> {}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a> Drop for Drain<'a> {
-    fn drop(&mut self) {
-        unsafe {
-            // Use Vec::drain. "Reaffirm" the bounds checks to avoid
-            // panic code being inserted again.
-            let self_vec = (*self.string).as_mut_vec();
-            if self.start <= self.end && self.end <= self_vec.len() {
-                self_vec.drain(self.start..self.end);
-            }
-        }
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a> Iterator for Drain<'a> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        self.iter.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a> DoubleEndedIterator for Drain<'a> {
-    #[inline]
-    fn next_back(&mut self) -> Option<char> {
-        self.iter.next_back()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a> FusedIterator for Drain<'a> {}
-
-/// A splicing iterator for `String`.
-///
-/// This struct is created by the [`splice()`] method on [`String`]. See its
-/// documentation for more.
-///
-/// [`splice()`]: struct.String.html#method.splice
-/// [`String`]: struct.String.html
-#[derive(Debug)]
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-pub struct Splice<'a, 'b> {
-    /// Will be used as &'a mut String in the destructor
-    string: *mut String,
-    /// Start of part to remove
-    start: usize,
-    /// End of part to remove
-    end: usize,
-    /// Current remaining range to remove
-    iter: Chars<'a>,
-    replace_with: &'b str,
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-unsafe impl<'a, 'b> Sync for Splice<'a, 'b> {}
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-unsafe impl<'a, 'b> Send for Splice<'a, 'b> {}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, 'b> Drop for Splice<'a, 'b> {
-    fn drop(&mut self) {
-        unsafe {
-            let vec = (*self.string).as_mut_vec();
-            vec.splice(self.start..self.end, self.replace_with.bytes());
-        }
-    }
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, 'b> Iterator for Splice<'a, 'b> {
-    type Item = char;
-
-    #[inline]
-    fn next(&mut self) -> Option<char> {
-        self.iter.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, 'b> DoubleEndedIterator for Splice<'a, 'b> {
-    #[inline]
-    fn next_back(&mut self) -> Option<char> {
-        self.iter.next_back()
-    }
-}
diff --git a/src/libcollections/tests/binary_heap.rs b/src/libcollections/tests/binary_heap.rs
deleted file mode 100644
index 06d585f8ea8..00000000000
--- a/src/libcollections/tests/binary_heap.rs
+++ /dev/null
@@ -1,302 +0,0 @@
-// Copyright 2013-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.
-
-use std::panic;
-use std::collections::BinaryHeap;
-use std::collections::binary_heap::{Drain, PeekMut};
-
-#[test]
-fn test_iterator() {
-    let data = vec![5, 9, 3];
-    let iterout = [9, 5, 3];
-    let heap = BinaryHeap::from(data);
-    let mut i = 0;
-    for el in &heap {
-        assert_eq!(*el, iterout[i]);
-        i += 1;
-    }
-}
-
-#[test]
-fn test_iterator_reverse() {
-    let data = vec![5, 9, 3];
-    let iterout = vec![3, 5, 9];
-    let pq = BinaryHeap::from(data);
-
-    let v: Vec<_> = pq.iter().rev().cloned().collect();
-    assert_eq!(v, iterout);
-}
-
-#[test]
-fn test_move_iter() {
-    let data = vec![5, 9, 3];
-    let iterout = vec![9, 5, 3];
-    let pq = BinaryHeap::from(data);
-
-    let v: Vec<_> = pq.into_iter().collect();
-    assert_eq!(v, iterout);
-}
-
-#[test]
-fn test_move_iter_size_hint() {
-    let data = vec![5, 9];
-    let pq = BinaryHeap::from(data);
-
-    let mut it = pq.into_iter();
-
-    assert_eq!(it.size_hint(), (2, Some(2)));
-    assert_eq!(it.next(), Some(9));
-
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next(), Some(5));
-
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_move_iter_reverse() {
-    let data = vec![5, 9, 3];
-    let iterout = vec![3, 5, 9];
-    let pq = BinaryHeap::from(data);
-
-    let v: Vec<_> = pq.into_iter().rev().collect();
-    assert_eq!(v, iterout);
-}
-
-#[test]
-fn test_peek_and_pop() {
-    let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-    let mut sorted = data.clone();
-    sorted.sort();
-    let mut heap = BinaryHeap::from(data);
-    while !heap.is_empty() {
-        assert_eq!(heap.peek().unwrap(), sorted.last().unwrap());
-        assert_eq!(heap.pop().unwrap(), sorted.pop().unwrap());
-    }
-}
-
-#[test]
-fn test_peek_mut() {
-    let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-    let mut heap = BinaryHeap::from(data);
-    assert_eq!(heap.peek(), Some(&10));
-    {
-        let mut top = heap.peek_mut().unwrap();
-        *top -= 2;
-    }
-    assert_eq!(heap.peek(), Some(&9));
-}
-
-#[test]
-fn test_peek_mut_pop() {
-    let data = vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1];
-    let mut heap = BinaryHeap::from(data);
-    assert_eq!(heap.peek(), Some(&10));
-    {
-        let mut top = heap.peek_mut().unwrap();
-        *top -= 2;
-        assert_eq!(PeekMut::pop(top), 8);
-    }
-    assert_eq!(heap.peek(), Some(&9));
-}
-
-#[test]
-fn test_push() {
-    let mut heap = BinaryHeap::from(vec![2, 4, 9]);
-    assert_eq!(heap.len(), 3);
-    assert!(*heap.peek().unwrap() == 9);
-    heap.push(11);
-    assert_eq!(heap.len(), 4);
-    assert!(*heap.peek().unwrap() == 11);
-    heap.push(5);
-    assert_eq!(heap.len(), 5);
-    assert!(*heap.peek().unwrap() == 11);
-    heap.push(27);
-    assert_eq!(heap.len(), 6);
-    assert!(*heap.peek().unwrap() == 27);
-    heap.push(3);
-    assert_eq!(heap.len(), 7);
-    assert!(*heap.peek().unwrap() == 27);
-    heap.push(103);
-    assert_eq!(heap.len(), 8);
-    assert!(*heap.peek().unwrap() == 103);
-}
-
-#[test]
-fn test_push_unique() {
-    let mut heap = BinaryHeap::<Box<_>>::from(vec![box 2, box 4, box 9]);
-    assert_eq!(heap.len(), 3);
-    assert!(**heap.peek().unwrap() == 9);
-    heap.push(box 11);
-    assert_eq!(heap.len(), 4);
-    assert!(**heap.peek().unwrap() == 11);
-    heap.push(box 5);
-    assert_eq!(heap.len(), 5);
-    assert!(**heap.peek().unwrap() == 11);
-    heap.push(box 27);
-    assert_eq!(heap.len(), 6);
-    assert!(**heap.peek().unwrap() == 27);
-    heap.push(box 3);
-    assert_eq!(heap.len(), 7);
-    assert!(**heap.peek().unwrap() == 27);
-    heap.push(box 103);
-    assert_eq!(heap.len(), 8);
-    assert!(**heap.peek().unwrap() == 103);
-}
-
-fn check_to_vec(mut data: Vec<i32>) {
-    let heap = BinaryHeap::from(data.clone());
-    let mut v = heap.clone().into_vec();
-    v.sort();
-    data.sort();
-
-    assert_eq!(v, data);
-    assert_eq!(heap.into_sorted_vec(), data);
-}
-
-#[test]
-fn test_to_vec() {
-    check_to_vec(vec![]);
-    check_to_vec(vec![5]);
-    check_to_vec(vec![3, 2]);
-    check_to_vec(vec![2, 3]);
-    check_to_vec(vec![5, 1, 2]);
-    check_to_vec(vec![1, 100, 2, 3]);
-    check_to_vec(vec![1, 3, 5, 7, 9, 2, 4, 6, 8, 0]);
-    check_to_vec(vec![2, 4, 6, 2, 1, 8, 10, 3, 5, 7, 0, 9, 1]);
-    check_to_vec(vec![9, 11, 9, 9, 9, 9, 11, 2, 3, 4, 11, 9, 0, 0, 0, 0]);
-    check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10]);
-    check_to_vec(vec![10, 9, 8, 7, 6, 5, 4, 3, 2, 1, 0]);
-    check_to_vec(vec![0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 0, 0, 0, 1, 2]);
-    check_to_vec(vec![5, 4, 3, 2, 1, 5, 4, 3, 2, 1, 5, 4, 3, 2, 1]);
-}
-
-#[test]
-fn test_empty_pop() {
-    let mut heap = BinaryHeap::<i32>::new();
-    assert!(heap.pop().is_none());
-}
-
-#[test]
-fn test_empty_peek() {
-    let empty = BinaryHeap::<i32>::new();
-    assert!(empty.peek().is_none());
-}
-
-#[test]
-fn test_empty_peek_mut() {
-    let mut empty = BinaryHeap::<i32>::new();
-    assert!(empty.peek_mut().is_none());
-}
-
-#[test]
-fn test_from_iter() {
-    let xs = vec![9, 8, 7, 6, 5, 4, 3, 2, 1];
-
-    let mut q: BinaryHeap<_> = xs.iter().rev().cloned().collect();
-
-    for &x in &xs {
-        assert_eq!(q.pop().unwrap(), x);
-    }
-}
-
-#[test]
-fn test_drain() {
-    let mut q: BinaryHeap<_> = [9, 8, 7, 6, 5, 4, 3, 2, 1].iter().cloned().collect();
-
-    assert_eq!(q.drain().take(5).count(), 5);
-
-    assert!(q.is_empty());
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut a = BinaryHeap::new();
-    a.push(1);
-    a.push(2);
-
-    a.extend(&[3, 4, 5]);
-
-    assert_eq!(a.len(), 5);
-    assert_eq!(a.into_sorted_vec(), [1, 2, 3, 4, 5]);
-
-    let mut a = BinaryHeap::new();
-    a.push(1);
-    a.push(2);
-    let mut b = BinaryHeap::new();
-    b.push(3);
-    b.push(4);
-    b.push(5);
-
-    a.extend(&b);
-
-    assert_eq!(a.len(), 5);
-    assert_eq!(a.into_sorted_vec(), [1, 2, 3, 4, 5]);
-}
-
-#[test]
-fn test_append() {
-    let mut a = BinaryHeap::from(vec![-10, 1, 2, 3, 3]);
-    let mut b = BinaryHeap::from(vec![-20, 5, 43]);
-
-    a.append(&mut b);
-
-    assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]);
-    assert!(b.is_empty());
-}
-
-#[test]
-fn test_append_to_empty() {
-    let mut a = BinaryHeap::new();
-    let mut b = BinaryHeap::from(vec![-20, 5, 43]);
-
-    a.append(&mut b);
-
-    assert_eq!(a.into_sorted_vec(), [-20, 5, 43]);
-    assert!(b.is_empty());
-}
-
-#[test]
-fn test_extend_specialization() {
-    let mut a = BinaryHeap::from(vec![-10, 1, 2, 3, 3]);
-    let b = BinaryHeap::from(vec![-20, 5, 43]);
-
-    a.extend(b);
-
-    assert_eq!(a.into_sorted_vec(), [-20, -10, 1, 2, 3, 3, 5, 43]);
-}
-
-#[test]
-fn test_placement() {
-    let mut a = BinaryHeap::new();
-    &mut a <- 2;
-    &mut a <- 4;
-    &mut a <- 3;
-    assert_eq!(a.peek(), Some(&4));
-    assert_eq!(a.len(), 3);
-    &mut a <- 1;
-    assert_eq!(a.into_sorted_vec(), vec![1, 2, 3, 4]);
-}
-
-#[test]
-fn test_placement_panic() {
-    let mut heap = BinaryHeap::from(vec![1, 2, 3]);
-    fn mkpanic() -> usize { panic!() }
-    let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { &mut heap <- mkpanic(); }));
-    assert_eq!(heap.len(), 3);
-}
-
-#[allow(dead_code)]
-fn assert_covariance() {
-    fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
-        d
-    }
-}
diff --git a/src/libcollections/tests/btree/map.rs b/src/libcollections/tests/btree/map.rs
deleted file mode 100644
index 2c899d96940..00000000000
--- a/src/libcollections/tests/btree/map.rs
+++ /dev/null
@@ -1,687 +0,0 @@
-// Copyright 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.
-
-use std::collections::BTreeMap;
-use std::collections::Bound::{self, Excluded, Included, Unbounded};
-use std::collections::btree_map::Entry::{Occupied, Vacant};
-use std::rc::Rc;
-
-use std::iter::FromIterator;
-use super::DeterministicRng;
-
-#[test]
-fn test_basic_large() {
-    let mut map = BTreeMap::new();
-    let size = 10000;
-    assert_eq!(map.len(), 0);
-
-    for i in 0..size {
-        assert_eq!(map.insert(i, 10 * i), None);
-        assert_eq!(map.len(), i + 1);
-    }
-
-    for i in 0..size {
-        assert_eq!(map.get(&i).unwrap(), &(i * 10));
-    }
-
-    for i in size..size * 2 {
-        assert_eq!(map.get(&i), None);
-    }
-
-    for i in 0..size {
-        assert_eq!(map.insert(i, 100 * i), Some(10 * i));
-        assert_eq!(map.len(), size);
-    }
-
-    for i in 0..size {
-        assert_eq!(map.get(&i).unwrap(), &(i * 100));
-    }
-
-    for i in 0..size / 2 {
-        assert_eq!(map.remove(&(i * 2)), Some(i * 200));
-        assert_eq!(map.len(), size - i - 1);
-    }
-
-    for i in 0..size / 2 {
-        assert_eq!(map.get(&(2 * i)), None);
-        assert_eq!(map.get(&(2 * i + 1)).unwrap(), &(i * 200 + 100));
-    }
-
-    for i in 0..size / 2 {
-        assert_eq!(map.remove(&(2 * i)), None);
-        assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100));
-        assert_eq!(map.len(), size / 2 - i - 1);
-    }
-}
-
-#[test]
-fn test_basic_small() {
-    let mut map = BTreeMap::new();
-    assert_eq!(map.remove(&1), None);
-    assert_eq!(map.get(&1), None);
-    assert_eq!(map.insert(1, 1), None);
-    assert_eq!(map.get(&1), Some(&1));
-    assert_eq!(map.insert(1, 2), Some(1));
-    assert_eq!(map.get(&1), Some(&2));
-    assert_eq!(map.insert(2, 4), None);
-    assert_eq!(map.get(&2), Some(&4));
-    assert_eq!(map.remove(&1), Some(2));
-    assert_eq!(map.remove(&2), Some(4));
-    assert_eq!(map.remove(&1), None);
-}
-
-#[test]
-fn test_iter() {
-    let size = 10000;
-
-    // Forwards
-    let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)>
-    {
-        for i in 0..size {
-            assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
-            assert_eq!(iter.next().unwrap(), (i, i));
-        }
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert_eq!(iter.next(), None);
-    }
-    test(size, map.iter().map(|(&k, &v)| (k, v)));
-    test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
-    test(size, map.into_iter());
-}
-
-#[test]
-fn test_iter_rev() {
-    let size = 10000;
-
-    // Forwards
-    let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)>
-    {
-        for i in 0..size {
-            assert_eq!(iter.size_hint(), (size - i, Some(size - i)));
-            assert_eq!(iter.next().unwrap(), (size - i - 1, size - i - 1));
-        }
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert_eq!(iter.next(), None);
-    }
-    test(size, map.iter().rev().map(|(&k, &v)| (k, v)));
-    test(size, map.iter_mut().rev().map(|(&k, &mut v)| (k, v)));
-    test(size, map.into_iter().rev());
-}
-
-#[test]
-fn test_values_mut() {
-    let mut a = BTreeMap::new();
-    a.insert(1, String::from("hello"));
-    a.insert(2, String::from("goodbye"));
-
-    for value in a.values_mut() {
-        value.push_str("!");
-    }
-
-    let values: Vec<String> = a.values().cloned().collect();
-    assert_eq!(values, [String::from("hello!"), String::from("goodbye!")]);
-}
-
-#[test]
-fn test_iter_mixed() {
-    let size = 10000;
-
-    // Forwards
-    let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    fn test<T>(size: usize, mut iter: T)
-        where T: Iterator<Item = (usize, usize)> + DoubleEndedIterator
-    {
-        for i in 0..size / 4 {
-            assert_eq!(iter.size_hint(), (size - i * 2, Some(size - i * 2)));
-            assert_eq!(iter.next().unwrap(), (i, i));
-            assert_eq!(iter.next_back().unwrap(), (size - i - 1, size - i - 1));
-        }
-        for i in size / 4..size * 3 / 4 {
-            assert_eq!(iter.size_hint(), (size * 3 / 4 - i, Some(size * 3 / 4 - i)));
-            assert_eq!(iter.next().unwrap(), (i, i));
-        }
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert_eq!(iter.next(), None);
-    }
-    test(size, map.iter().map(|(&k, &v)| (k, v)));
-    test(size, map.iter_mut().map(|(&k, &mut v)| (k, v)));
-    test(size, map.into_iter());
-}
-
-#[test]
-fn test_range_small() {
-    let size = 5;
-
-    // Forwards
-    let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    let mut j = 0;
-    for ((&k, &v), i) in map.range(2..).zip(2..size) {
-        assert_eq!(k, i);
-        assert_eq!(v, i);
-        j += 1;
-    }
-    assert_eq!(j, size - 2);
-}
-
-#[test]
-fn test_range_inclusive() {
-    let size = 500;
-
-    let map: BTreeMap<_, _> = (0...size).map(|i| (i, i)).collect();
-
-    fn check<'a, L, R>(lhs: L, rhs: R)
-        where L: IntoIterator<Item=(&'a i32, &'a i32)>,
-              R: IntoIterator<Item=(&'a i32, &'a i32)>,
-    {
-        let lhs: Vec<_> = lhs.into_iter().collect();
-        let rhs: Vec<_> = rhs.into_iter().collect();
-        assert_eq!(lhs, rhs);
-    }
-
-    check(map.range(size + 1...size + 1), vec![]);
-    check(map.range(size...size), vec![(&size, &size)]);
-    check(map.range(size...size + 1), vec![(&size, &size)]);
-    check(map.range(0...0), vec![(&0, &0)]);
-    check(map.range(0...size - 1), map.range(..size));
-    check(map.range(-1...-1), vec![]);
-    check(map.range(-1...size), map.range(..));
-    check(map.range(...size), map.range(..));
-    check(map.range(...200), map.range(..201));
-    check(map.range(5...8), vec![(&5, &5), (&6, &6), (&7, &7), (&8, &8)]);
-    check(map.range(-1...0), vec![(&0, &0)]);
-    check(map.range(-1...2), vec![(&0, &0), (&1, &1), (&2, &2)]);
-}
-
-#[test]
-fn test_range_inclusive_max_value() {
-    let max = ::std::usize::MAX;
-    let map: BTreeMap<_, _> = vec![(max, 0)].into_iter().collect();
-
-    assert_eq!(map.range(max...max).collect::<Vec<_>>(), &[(&max, &0)]);
-}
-
-#[test]
-fn test_range_equal_empty_cases() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    assert_eq!(map.range((Included(2), Excluded(2))).next(), None);
-    assert_eq!(map.range((Excluded(2), Included(2))).next(), None);
-}
-
-#[test]
-#[should_panic]
-fn test_range_equal_excluded() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    map.range((Excluded(2), Excluded(2)));
-}
-
-#[test]
-#[should_panic]
-fn test_range_backwards_1() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    map.range((Included(3), Included(2)));
-}
-
-#[test]
-#[should_panic]
-fn test_range_backwards_2() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    map.range((Included(3), Excluded(2)));
-}
-
-#[test]
-#[should_panic]
-fn test_range_backwards_3() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    map.range((Excluded(3), Included(2)));
-}
-
-#[test]
-#[should_panic]
-fn test_range_backwards_4() {
-    let map: BTreeMap<_, _> = (0..5).map(|i| (i, i)).collect();
-    map.range((Excluded(3), Excluded(2)));
-}
-
-#[test]
-fn test_range_1000() {
-    let size = 1000;
-    let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    fn test(map: &BTreeMap<u32, u32>, size: u32, min: Bound<&u32>, max: Bound<&u32>) {
-        let mut kvs = map.range((min, max)).map(|(&k, &v)| (k, v));
-        let mut pairs = (0..size).map(|i| (i, i));
-
-        for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
-            assert_eq!(kv, pair);
-        }
-        assert_eq!(kvs.next(), None);
-        assert_eq!(pairs.next(), None);
-    }
-    test(&map, size, Included(&0), Excluded(&size));
-    test(&map, size, Unbounded, Excluded(&size));
-    test(&map, size, Included(&0), Included(&(size - 1)));
-    test(&map, size, Unbounded, Included(&(size - 1)));
-    test(&map, size, Included(&0), Unbounded);
-    test(&map, size, Unbounded, Unbounded);
-}
-
-#[test]
-fn test_range_borrowed_key() {
-    let mut map = BTreeMap::new();
-    map.insert("aardvark".to_string(), 1);
-    map.insert("baboon".to_string(), 2);
-    map.insert("coyote".to_string(), 3);
-    map.insert("dingo".to_string(), 4);
-    // NOTE: would like to use simply "b".."d" here...
-    let mut iter = map.range::<str, _>((Included("b"),Excluded("d")));
-    assert_eq!(iter.next(), Some((&"baboon".to_string(), &2)));
-    assert_eq!(iter.next(), Some((&"coyote".to_string(), &3)));
-    assert_eq!(iter.next(), None);
-}
-
-#[test]
-fn test_range() {
-    let size = 200;
-    let map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    for i in 0..size {
-        for j in i..size {
-            let mut kvs = map.range((Included(&i), Included(&j))).map(|(&k, &v)| (k, v));
-            let mut pairs = (i..j + 1).map(|i| (i, i));
-
-            for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
-                assert_eq!(kv, pair);
-            }
-            assert_eq!(kvs.next(), None);
-            assert_eq!(pairs.next(), None);
-        }
-    }
-}
-
-#[test]
-fn test_range_mut() {
-    let size = 200;
-    let mut map: BTreeMap<_, _> = (0..size).map(|i| (i, i)).collect();
-
-    for i in 0..size {
-        for j in i..size {
-            let mut kvs = map.range_mut((Included(&i), Included(&j))).map(|(&k, &mut v)| (k, v));
-            let mut pairs = (i..j + 1).map(|i| (i, i));
-
-            for (kv, pair) in kvs.by_ref().zip(pairs.by_ref()) {
-                assert_eq!(kv, pair);
-            }
-            assert_eq!(kvs.next(), None);
-            assert_eq!(pairs.next(), None);
-        }
-    }
-}
-
-#[test]
-fn test_borrow() {
-    // make sure these compile -- using the Borrow trait
-    {
-        let mut map = BTreeMap::new();
-        map.insert("0".to_string(), 1);
-        assert_eq!(map["0"], 1);
-    }
-
-    {
-        let mut map = BTreeMap::new();
-        map.insert(Box::new(0), 1);
-        assert_eq!(map[&0], 1);
-    }
-
-    {
-        let mut map = BTreeMap::new();
-        map.insert(Box::new([0, 1]) as Box<[i32]>, 1);
-        assert_eq!(map[&[0, 1][..]], 1);
-    }
-
-    {
-        let mut map = BTreeMap::new();
-        map.insert(Rc::new(0), 1);
-        assert_eq!(map[&0], 1);
-    }
-}
-
-#[test]
-fn test_entry() {
-    let xs = [(1, 10), (2, 20), (3, 30), (4, 40), (5, 50), (6, 60)];
-
-    let mut map: BTreeMap<_, _> = xs.iter().cloned().collect();
-
-    // Existing key (insert)
-    match map.entry(1) {
-        Vacant(_) => unreachable!(),
-        Occupied(mut view) => {
-            assert_eq!(view.get(), &10);
-            assert_eq!(view.insert(100), 10);
-        }
-    }
-    assert_eq!(map.get(&1).unwrap(), &100);
-    assert_eq!(map.len(), 6);
-
-
-    // Existing key (update)
-    match map.entry(2) {
-        Vacant(_) => unreachable!(),
-        Occupied(mut view) => {
-            let v = view.get_mut();
-            *v *= 10;
-        }
-    }
-    assert_eq!(map.get(&2).unwrap(), &200);
-    assert_eq!(map.len(), 6);
-
-    // Existing key (take)
-    match map.entry(3) {
-        Vacant(_) => unreachable!(),
-        Occupied(view) => {
-            assert_eq!(view.remove(), 30);
-        }
-    }
-    assert_eq!(map.get(&3), None);
-    assert_eq!(map.len(), 5);
-
-
-    // Inexistent key (insert)
-    match map.entry(10) {
-        Occupied(_) => unreachable!(),
-        Vacant(view) => {
-            assert_eq!(*view.insert(1000), 1000);
-        }
-    }
-    assert_eq!(map.get(&10).unwrap(), &1000);
-    assert_eq!(map.len(), 6);
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut a = BTreeMap::new();
-    a.insert(1, "one");
-    let mut b = BTreeMap::new();
-    b.insert(2, "two");
-    b.insert(3, "three");
-
-    a.extend(&b);
-
-    assert_eq!(a.len(), 3);
-    assert_eq!(a[&1], "one");
-    assert_eq!(a[&2], "two");
-    assert_eq!(a[&3], "three");
-}
-
-#[test]
-fn test_zst() {
-    let mut m = BTreeMap::new();
-    assert_eq!(m.len(), 0);
-
-    assert_eq!(m.insert((), ()), None);
-    assert_eq!(m.len(), 1);
-
-    assert_eq!(m.insert((), ()), Some(()));
-    assert_eq!(m.len(), 1);
-    assert_eq!(m.iter().count(), 1);
-
-    m.clear();
-    assert_eq!(m.len(), 0);
-
-    for _ in 0..100 {
-        m.insert((), ());
-    }
-
-    assert_eq!(m.len(), 1);
-    assert_eq!(m.iter().count(), 1);
-}
-
-// This test's only purpose is to ensure that zero-sized keys with nonsensical orderings
-// do not cause segfaults when used with zero-sized values. All other map behavior is
-// undefined.
-#[test]
-fn test_bad_zst() {
-    use std::cmp::Ordering;
-
-    struct Bad;
-
-    impl PartialEq for Bad {
-        fn eq(&self, _: &Self) -> bool {
-            false
-        }
-    }
-
-    impl Eq for Bad {}
-
-    impl PartialOrd for Bad {
-        fn partial_cmp(&self, _: &Self) -> Option<Ordering> {
-            Some(Ordering::Less)
-        }
-    }
-
-    impl Ord for Bad {
-        fn cmp(&self, _: &Self) -> Ordering {
-            Ordering::Less
-        }
-    }
-
-    let mut m = BTreeMap::new();
-
-    for _ in 0..100 {
-        m.insert(Bad, Bad);
-    }
-}
-
-#[test]
-fn test_clone() {
-    let mut map = BTreeMap::new();
-    let size = 100;
-    assert_eq!(map.len(), 0);
-
-    for i in 0..size {
-        assert_eq!(map.insert(i, 10 * i), None);
-        assert_eq!(map.len(), i + 1);
-        assert_eq!(map, map.clone());
-    }
-
-    for i in 0..size {
-        assert_eq!(map.insert(i, 100 * i), Some(10 * i));
-        assert_eq!(map.len(), size);
-        assert_eq!(map, map.clone());
-    }
-
-    for i in 0..size / 2 {
-        assert_eq!(map.remove(&(i * 2)), Some(i * 200));
-        assert_eq!(map.len(), size - i - 1);
-        assert_eq!(map, map.clone());
-    }
-
-    for i in 0..size / 2 {
-        assert_eq!(map.remove(&(2 * i)), None);
-        assert_eq!(map.remove(&(2 * i + 1)), Some(i * 200 + 100));
-        assert_eq!(map.len(), size / 2 - i - 1);
-        assert_eq!(map, map.clone());
-    }
-}
-
-#[test]
-#[allow(dead_code)]
-fn test_variance() {
-    use std::collections::btree_map::{Iter, IntoIter, Range, Keys, Values};
-
-    fn map_key<'new>(v: BTreeMap<&'static str, ()>) -> BTreeMap<&'new str, ()> {
-        v
-    }
-    fn map_val<'new>(v: BTreeMap<(), &'static str>) -> BTreeMap<(), &'new str> {
-        v
-    }
-    fn iter_key<'a, 'new>(v: Iter<'a, &'static str, ()>) -> Iter<'a, &'new str, ()> {
-        v
-    }
-    fn iter_val<'a, 'new>(v: Iter<'a, (), &'static str>) -> Iter<'a, (), &'new str> {
-        v
-    }
-    fn into_iter_key<'new>(v: IntoIter<&'static str, ()>) -> IntoIter<&'new str, ()> {
-        v
-    }
-    fn into_iter_val<'new>(v: IntoIter<(), &'static str>) -> IntoIter<(), &'new str> {
-        v
-    }
-    fn range_key<'a, 'new>(v: Range<'a, &'static str, ()>) -> Range<'a, &'new str, ()> {
-        v
-    }
-    fn range_val<'a, 'new>(v: Range<'a, (), &'static str>) -> Range<'a, (), &'new str> {
-        v
-    }
-    fn keys<'a, 'new>(v: Keys<'a, &'static str, ()>) -> Keys<'a, &'new str, ()> {
-        v
-    }
-    fn vals<'a, 'new>(v: Values<'a, (), &'static str>) -> Values<'a, (), &'new str> {
-        v
-    }
-}
-
-#[test]
-fn test_occupied_entry_key() {
-    let mut a = BTreeMap::new();
-    let key = "hello there";
-    let value = "value goes here";
-    assert!(a.is_empty());
-    a.insert(key.clone(), value.clone());
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-
-    match a.entry(key.clone()) {
-        Vacant(_) => panic!(),
-        Occupied(e) => assert_eq!(key, *e.key()),
-    }
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-}
-
-#[test]
-fn test_vacant_entry_key() {
-    let mut a = BTreeMap::new();
-    let key = "hello there";
-    let value = "value goes here";
-
-    assert!(a.is_empty());
-    match a.entry(key.clone()) {
-        Occupied(_) => panic!(),
-        Vacant(e) => {
-            assert_eq!(key, *e.key());
-            e.insert(value.clone());
-        }
-    }
-    assert_eq!(a.len(), 1);
-    assert_eq!(a[key], value);
-}
-
-macro_rules! create_append_test {
-    ($name:ident, $len:expr) => {
-        #[test]
-        fn $name() {
-            let mut a = BTreeMap::new();
-            for i in 0..8 {
-                a.insert(i, i);
-            }
-
-            let mut b = BTreeMap::new();
-            for i in 5..$len {
-                b.insert(i, 2*i);
-            }
-
-            a.append(&mut b);
-
-            assert_eq!(a.len(), $len);
-            assert_eq!(b.len(), 0);
-
-            for i in 0..$len {
-                if i < 5 {
-                    assert_eq!(a[&i], i);
-                } else {
-                    assert_eq!(a[&i], 2*i);
-                }
-            }
-
-            assert_eq!(a.remove(&($len-1)), Some(2*($len-1)));
-            assert_eq!(a.insert($len-1, 20), None);
-        }
-    };
-}
-
-// These are mostly for testing the algorithm that "fixes" the right edge after insertion.
-// Single node.
-create_append_test!(test_append_9, 9);
-// Two leafs that don't need fixing.
-create_append_test!(test_append_17, 17);
-// Two leafs where the second one ends up underfull and needs stealing at the end.
-create_append_test!(test_append_14, 14);
-// Two leafs where the second one ends up empty because the insertion finished at the root.
-create_append_test!(test_append_12, 12);
-// Three levels; insertion finished at the root.
-create_append_test!(test_append_144, 144);
-// Three levels; insertion finished at leaf while there is an empty node on the second level.
-create_append_test!(test_append_145, 145);
-// Tests for several randomly chosen sizes.
-create_append_test!(test_append_170, 170);
-create_append_test!(test_append_181, 181);
-create_append_test!(test_append_239, 239);
-create_append_test!(test_append_1700, 1700);
-
-fn rand_data(len: usize) -> Vec<(u32, u32)> {
-    let mut rng = DeterministicRng::new();
-    Vec::from_iter((0..len).map(|_| (rng.next(), rng.next())))
-}
-
-#[test]
-fn test_split_off_empty_right() {
-    let mut data = rand_data(173);
-
-    let mut map = BTreeMap::from_iter(data.clone());
-    let right = map.split_off(&(data.iter().max().unwrap().0 + 1));
-
-    data.sort();
-    assert!(map.into_iter().eq(data));
-    assert!(right.into_iter().eq(None));
-}
-
-#[test]
-fn test_split_off_empty_left() {
-    let mut data = rand_data(314);
-
-    let mut map = BTreeMap::from_iter(data.clone());
-    let right = map.split_off(&data.iter().min().unwrap().0);
-
-    data.sort();
-    assert!(map.into_iter().eq(None));
-    assert!(right.into_iter().eq(data));
-}
-
-#[test]
-fn test_split_off_large_random_sorted() {
-    let mut data = rand_data(1529);
-    // special case with maximum height.
-    data.sort();
-
-    let mut map = BTreeMap::from_iter(data.clone());
-    let key = data[data.len() / 2].0;
-    let right = map.split_off(&key);
-
-    assert!(map.into_iter().eq(data.clone().into_iter().filter(|x| x.0 < key)));
-    assert!(right.into_iter().eq(data.into_iter().filter(|x| x.0 >= key)));
-}
diff --git a/src/libcollections/tests/btree/mod.rs b/src/libcollections/tests/btree/mod.rs
deleted file mode 100644
index ae8b18d0c9f..00000000000
--- a/src/libcollections/tests/btree/mod.rs
+++ /dev/null
@@ -1,42 +0,0 @@
-// Copyright 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.
-
-mod map;
-mod set;
-
-/// XorShiftRng
-struct DeterministicRng {
-    x: u32,
-    y: u32,
-    z: u32,
-    w: u32,
-}
-
-impl DeterministicRng {
-    fn new() -> Self {
-        DeterministicRng {
-            x: 0x193a6754,
-            y: 0xa8a7d469,
-            z: 0x97830e05,
-            w: 0x113ba7bb,
-        }
-    }
-
-    fn next(&mut self) -> u32 {
-        let x = self.x;
-        let t = x ^ (x << 11);
-        self.x = self.y;
-        self.y = self.z;
-        self.z = self.w;
-        let w_ = self.w;
-        self.w = w_ ^ (w_ >> 19) ^ (t ^ (t >> 8));
-        self.w
-    }
-}
diff --git a/src/libcollections/tests/btree/set.rs b/src/libcollections/tests/btree/set.rs
deleted file mode 100644
index 6171b8ba624..00000000000
--- a/src/libcollections/tests/btree/set.rs
+++ /dev/null
@@ -1,331 +0,0 @@
-// Copyright 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.
-
-use std::collections::BTreeSet;
-
-use std::iter::FromIterator;
-use super::DeterministicRng;
-
-#[test]
-fn test_clone_eq() {
-    let mut m = BTreeSet::new();
-
-    m.insert(1);
-    m.insert(2);
-
-    assert!(m.clone() == m);
-}
-
-#[test]
-fn test_hash() {
-    let mut x = BTreeSet::new();
-    let mut y = BTreeSet::new();
-
-    x.insert(1);
-    x.insert(2);
-    x.insert(3);
-
-    y.insert(3);
-    y.insert(2);
-    y.insert(1);
-
-    assert!(::hash(&x) == ::hash(&y));
-}
-
-fn check<F>(a: &[i32], b: &[i32], expected: &[i32], f: F)
-    where F: FnOnce(&BTreeSet<i32>, &BTreeSet<i32>, &mut FnMut(&i32) -> bool) -> bool
-{
-    let mut set_a = BTreeSet::new();
-    let mut set_b = BTreeSet::new();
-
-    for x in a {
-        assert!(set_a.insert(*x))
-    }
-    for y in b {
-        assert!(set_b.insert(*y))
-    }
-
-    let mut i = 0;
-    f(&set_a,
-      &set_b,
-      &mut |&x| {
-          assert_eq!(x, expected[i]);
-          i += 1;
-          true
-      });
-    assert_eq!(i, expected.len());
-}
-
-#[test]
-fn test_intersection() {
-    fn check_intersection(a: &[i32], b: &[i32], expected: &[i32]) {
-        check(a, b, expected, |x, y, f| x.intersection(y).all(f))
-    }
-
-    check_intersection(&[], &[], &[]);
-    check_intersection(&[1, 2, 3], &[], &[]);
-    check_intersection(&[], &[1, 2, 3], &[]);
-    check_intersection(&[2], &[1, 2, 3], &[2]);
-    check_intersection(&[1, 2, 3], &[2], &[2]);
-    check_intersection(&[11, 1, 3, 77, 103, 5, -5],
-                       &[2, 11, 77, -9, -42, 5, 3],
-                       &[3, 5, 11, 77]);
-}
-
-#[test]
-fn test_difference() {
-    fn check_difference(a: &[i32], b: &[i32], expected: &[i32]) {
-        check(a, b, expected, |x, y, f| x.difference(y).all(f))
-    }
-
-    check_difference(&[], &[], &[]);
-    check_difference(&[1, 12], &[], &[1, 12]);
-    check_difference(&[], &[1, 2, 3, 9], &[]);
-    check_difference(&[1, 3, 5, 9, 11], &[3, 9], &[1, 5, 11]);
-    check_difference(&[-5, 11, 22, 33, 40, 42],
-                     &[-12, -5, 14, 23, 34, 38, 39, 50],
-                     &[11, 22, 33, 40, 42]);
-}
-
-#[test]
-fn test_symmetric_difference() {
-    fn check_symmetric_difference(a: &[i32], b: &[i32], expected: &[i32]) {
-        check(a, b, expected, |x, y, f| x.symmetric_difference(y).all(f))
-    }
-
-    check_symmetric_difference(&[], &[], &[]);
-    check_symmetric_difference(&[1, 2, 3], &[2], &[1, 3]);
-    check_symmetric_difference(&[2], &[1, 2, 3], &[1, 3]);
-    check_symmetric_difference(&[1, 3, 5, 9, 11],
-                               &[-2, 3, 9, 14, 22],
-                               &[-2, 1, 5, 11, 14, 22]);
-}
-
-#[test]
-fn test_union() {
-    fn check_union(a: &[i32], b: &[i32], expected: &[i32]) {
-        check(a, b, expected, |x, y, f| x.union(y).all(f))
-    }
-
-    check_union(&[], &[], &[]);
-    check_union(&[1, 2, 3], &[2], &[1, 2, 3]);
-    check_union(&[2], &[1, 2, 3], &[1, 2, 3]);
-    check_union(&[1, 3, 5, 9, 11, 16, 19, 24],
-                &[-2, 1, 5, 9, 13, 19],
-                &[-2, 1, 3, 5, 9, 11, 13, 16, 19, 24]);
-}
-
-#[test]
-fn test_zip() {
-    let mut x = BTreeSet::new();
-    x.insert(5);
-    x.insert(12);
-    x.insert(11);
-
-    let mut y = BTreeSet::new();
-    y.insert("foo");
-    y.insert("bar");
-
-    let x = x;
-    let y = y;
-    let mut z = x.iter().zip(&y);
-
-    assert_eq!(z.next().unwrap(), (&5, &("bar")));
-    assert_eq!(z.next().unwrap(), (&11, &("foo")));
-    assert!(z.next().is_none());
-}
-
-#[test]
-fn test_from_iter() {
-    let xs = [1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-    let set: BTreeSet<_> = xs.iter().cloned().collect();
-
-    for x in &xs {
-        assert!(set.contains(x));
-    }
-}
-
-#[test]
-fn test_show() {
-    let mut set = BTreeSet::new();
-    let empty = BTreeSet::<i32>::new();
-
-    set.insert(1);
-    set.insert(2);
-
-    let set_str = format!("{:?}", set);
-
-    assert_eq!(set_str, "{1, 2}");
-    assert_eq!(format!("{:?}", empty), "{}");
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut a = BTreeSet::new();
-    a.insert(1);
-
-    a.extend(&[2, 3, 4]);
-
-    assert_eq!(a.len(), 4);
-    assert!(a.contains(&1));
-    assert!(a.contains(&2));
-    assert!(a.contains(&3));
-    assert!(a.contains(&4));
-
-    let mut b = BTreeSet::new();
-    b.insert(5);
-    b.insert(6);
-
-    a.extend(&b);
-
-    assert_eq!(a.len(), 6);
-    assert!(a.contains(&1));
-    assert!(a.contains(&2));
-    assert!(a.contains(&3));
-    assert!(a.contains(&4));
-    assert!(a.contains(&5));
-    assert!(a.contains(&6));
-}
-
-#[test]
-fn test_recovery() {
-    use std::cmp::Ordering;
-
-    #[derive(Debug)]
-    struct Foo(&'static str, i32);
-
-    impl PartialEq for Foo {
-        fn eq(&self, other: &Self) -> bool {
-            self.0 == other.0
-        }
-    }
-
-    impl Eq for Foo {}
-
-    impl PartialOrd for Foo {
-        fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
-            self.0.partial_cmp(&other.0)
-        }
-    }
-
-    impl Ord for Foo {
-        fn cmp(&self, other: &Self) -> Ordering {
-            self.0.cmp(&other.0)
-        }
-    }
-
-    let mut s = BTreeSet::new();
-    assert_eq!(s.replace(Foo("a", 1)), None);
-    assert_eq!(s.len(), 1);
-    assert_eq!(s.replace(Foo("a", 2)), Some(Foo("a", 1)));
-    assert_eq!(s.len(), 1);
-
-    {
-        let mut it = s.iter();
-        assert_eq!(it.next(), Some(&Foo("a", 2)));
-        assert_eq!(it.next(), None);
-    }
-
-    assert_eq!(s.get(&Foo("a", 1)), Some(&Foo("a", 2)));
-    assert_eq!(s.take(&Foo("a", 1)), Some(Foo("a", 2)));
-    assert_eq!(s.len(), 0);
-
-    assert_eq!(s.get(&Foo("a", 1)), None);
-    assert_eq!(s.take(&Foo("a", 1)), None);
-
-    assert_eq!(s.iter().next(), None);
-}
-
-#[test]
-#[allow(dead_code)]
-fn test_variance() {
-    use std::collections::btree_set::{IntoIter, Iter, Range};
-
-    fn set<'new>(v: BTreeSet<&'static str>) -> BTreeSet<&'new str> {
-        v
-    }
-    fn iter<'a, 'new>(v: Iter<'a, &'static str>) -> Iter<'a, &'new str> {
-        v
-    }
-    fn into_iter<'new>(v: IntoIter<&'static str>) -> IntoIter<&'new str> {
-        v
-    }
-    fn range<'a, 'new>(v: Range<'a, &'static str>) -> Range<'a, &'new str> {
-        v
-    }
-}
-
-#[test]
-fn test_append() {
-    let mut a = BTreeSet::new();
-    a.insert(1);
-    a.insert(2);
-    a.insert(3);
-
-    let mut b = BTreeSet::new();
-    b.insert(3);
-    b.insert(4);
-    b.insert(5);
-
-    a.append(&mut b);
-
-    assert_eq!(a.len(), 5);
-    assert_eq!(b.len(), 0);
-
-    assert_eq!(a.contains(&1), true);
-    assert_eq!(a.contains(&2), true);
-    assert_eq!(a.contains(&3), true);
-    assert_eq!(a.contains(&4), true);
-    assert_eq!(a.contains(&5), true);
-}
-
-fn rand_data(len: usize) -> Vec<u32> {
-    let mut rng = DeterministicRng::new();
-    Vec::from_iter((0..len).map(|_| rng.next()))
-}
-
-#[test]
-fn test_split_off_empty_right() {
-    let mut data = rand_data(173);
-
-    let mut set = BTreeSet::from_iter(data.clone());
-    let right = set.split_off(&(data.iter().max().unwrap() + 1));
-
-    data.sort();
-    assert!(set.into_iter().eq(data));
-    assert!(right.into_iter().eq(None));
-}
-
-#[test]
-fn test_split_off_empty_left() {
-    let mut data = rand_data(314);
-
-    let mut set = BTreeSet::from_iter(data.clone());
-    let right = set.split_off(data.iter().min().unwrap());
-
-    data.sort();
-    assert!(set.into_iter().eq(None));
-    assert!(right.into_iter().eq(data));
-}
-
-#[test]
-fn test_split_off_large_random_sorted() {
-    let mut data = rand_data(1529);
-    // special case with maximum height.
-    data.sort();
-
-    let mut set = BTreeSet::from_iter(data.clone());
-    let key = data[data.len() / 2];
-    let right = set.split_off(&key);
-
-    assert!(set.into_iter().eq(data.clone().into_iter().filter(|x| *x < key)));
-    assert!(right.into_iter().eq(data.into_iter().filter(|x| *x >= key)));
-}
diff --git a/src/libcollections/tests/cow_str.rs b/src/libcollections/tests/cow_str.rs
deleted file mode 100644
index aa87ee84b3e..00000000000
--- a/src/libcollections/tests/cow_str.rs
+++ /dev/null
@@ -1,151 +0,0 @@
-// Copyright 2016 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.
-
-use std::borrow::Cow;
-
-// check that Cow<'a, str> implements addition
-#[test]
-fn check_cow_add_cow() {
-    let borrowed1 = Cow::Borrowed("Hello, ");
-    let borrowed2 = Cow::Borrowed("World!");
-    let borrow_empty = Cow::Borrowed("");
-
-    let owned1: Cow<str> = Cow::Owned(String::from("Hi, "));
-    let owned2: Cow<str> = Cow::Owned(String::from("Rustaceans!"));
-    let owned_empty: Cow<str> = Cow::Owned(String::new());
-
-    assert_eq!("Hello, World!", borrowed1.clone() + borrowed2.clone());
-    assert_eq!("Hello, Rustaceans!", borrowed1.clone() + owned2.clone());
-
-    assert_eq!("Hi, World!", owned1.clone() + borrowed2.clone());
-    assert_eq!("Hi, Rustaceans!", owned1.clone() + owned2.clone());
-
-    if let Cow::Owned(_) = borrowed1.clone() + borrow_empty.clone() {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    if let Cow::Owned(_) = borrow_empty.clone() + borrowed1.clone() {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    if let Cow::Owned(_) = borrowed1.clone() + owned_empty.clone() {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    if let Cow::Owned(_) = owned_empty.clone() + borrowed1.clone() {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-}
-
-#[test]
-fn check_cow_add_str() {
-    let borrowed = Cow::Borrowed("Hello, ");
-    let borrow_empty = Cow::Borrowed("");
-
-    let owned: Cow<str> = Cow::Owned(String::from("Hi, "));
-    let owned_empty: Cow<str> = Cow::Owned(String::new());
-
-    assert_eq!("Hello, World!", borrowed.clone() + "World!");
-
-    assert_eq!("Hi, World!", owned.clone() + "World!");
-
-    if let Cow::Owned(_) = borrowed.clone() + "" {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    if let Cow::Owned(_) = borrow_empty.clone() + "Hello, " {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    if let Cow::Owned(_) = owned_empty.clone() + "Hello, " {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-}
-
-#[test]
-fn check_cow_add_assign_cow() {
-    let mut borrowed1 = Cow::Borrowed("Hello, ");
-    let borrowed2 = Cow::Borrowed("World!");
-    let borrow_empty = Cow::Borrowed("");
-
-    let mut owned1: Cow<str> = Cow::Owned(String::from("Hi, "));
-    let owned2: Cow<str> = Cow::Owned(String::from("Rustaceans!"));
-    let owned_empty: Cow<str> = Cow::Owned(String::new());
-
-    let mut s = borrowed1.clone();
-    s += borrow_empty.clone();
-    assert_eq!("Hello, ", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    let mut s = borrow_empty.clone();
-    s += borrowed1.clone();
-    assert_eq!("Hello, ", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    let mut s = borrowed1.clone();
-    s += owned_empty.clone();
-    assert_eq!("Hello, ", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    let mut s = owned_empty.clone();
-    s += borrowed1.clone();
-    assert_eq!("Hello, ", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-
-    owned1 += borrowed2;
-    borrowed1 += owned2;
-
-    assert_eq!("Hi, World!", owned1);
-    assert_eq!("Hello, Rustaceans!", borrowed1);
-}
-
-#[test]
-fn check_cow_add_assign_str() {
-    let mut borrowed = Cow::Borrowed("Hello, ");
-    let borrow_empty = Cow::Borrowed("");
-
-    let mut owned: Cow<str> = Cow::Owned(String::from("Hi, "));
-    let owned_empty: Cow<str> = Cow::Owned(String::new());
-
-    let mut s = borrowed.clone();
-    s += "";
-    assert_eq!("Hello, ", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    let mut s = borrow_empty.clone();
-    s += "World!";
-    assert_eq!("World!", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-    let mut s = owned_empty.clone();
-    s += "World!";
-    assert_eq!("World!", s);
-    if let Cow::Owned(_) = s {
-        panic!("Adding empty strings to a borrow should note allocate");
-    }
-
-    owned += "World!";
-    borrowed += "World!";
-
-    assert_eq!("Hi, World!", owned);
-    assert_eq!("Hello, World!", borrowed);
-}
-
-#[test]
-fn check_cow_clone_from() {
-    let mut c1: Cow<str> = Cow::Owned(String::with_capacity(25));
-    let s: String = "hi".to_string();
-    assert!(s.capacity() < 25);
-    let c2: Cow<str> = Cow::Owned(s);
-    c1.clone_from(&c2);
-    assert!(c1.into_owned().capacity() >= 25);
-}
\ No newline at end of file
diff --git a/src/libcollections/tests/fmt.rs b/src/libcollections/tests/fmt.rs
deleted file mode 100644
index 70e21c65a18..00000000000
--- a/src/libcollections/tests/fmt.rs
+++ /dev/null
@@ -1,17 +0,0 @@
-// Copyright 2013-2015 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.
-
-use std::fmt;
-
-#[test]
-fn test_format() {
-    let s = fmt::format(format_args!("Hello, {}!", "world"));
-    assert_eq!(s, "Hello, world!");
-}
diff --git a/src/libcollections/tests/lib.rs b/src/libcollections/tests/lib.rs
deleted file mode 100644
index c6f0b4436bb..00000000000
--- a/src/libcollections/tests/lib.rs
+++ /dev/null
@@ -1,57 +0,0 @@
-// Copyright 2015 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.
-
-#![deny(warnings)]
-
-#![feature(attr_literals)]
-#![feature(box_syntax)]
-#![feature(inclusive_range_syntax)]
-#![feature(collection_placement)]
-#![feature(collections)]
-#![feature(const_fn)]
-#![feature(exact_size_is_empty)]
-#![feature(iterator_step_by)]
-#![feature(pattern)]
-#![feature(placement_in_syntax)]
-#![feature(rand)]
-#![feature(repr_align)]
-#![feature(slice_rotate)]
-#![feature(splice)]
-#![feature(str_checked_slicing)]
-#![feature(str_escape)]
-#![feature(test)]
-#![feature(unboxed_closures)]
-#![feature(unicode)]
-#![feature(utf8_error_error_len)]
-
-extern crate collections;
-extern crate test;
-extern crate std_unicode;
-extern crate core;
-
-use std::hash::{Hash, Hasher};
-use std::collections::hash_map::DefaultHasher;
-
-mod binary_heap;
-mod btree;
-mod cow_str;
-mod fmt;
-mod linked_list;
-mod slice;
-mod str;
-mod string;
-mod vec_deque;
-mod vec;
-
-fn hash<T: Hash>(t: &T) -> u64 {
-    let mut s = DefaultHasher::new();
-    t.hash(&mut s);
-    s.finish()
-}
diff --git a/src/libcollections/tests/linked_list.rs b/src/libcollections/tests/linked_list.rs
deleted file mode 100644
index a59724a017b..00000000000
--- a/src/libcollections/tests/linked_list.rs
+++ /dev/null
@@ -1,368 +0,0 @@
-// Copyright 2012-2015 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.
-
-use std::collections::LinkedList;
-
-#[test]
-fn test_basic() {
-    let mut m = LinkedList::<Box<_>>::new();
-    assert_eq!(m.pop_front(), None);
-    assert_eq!(m.pop_back(), None);
-    assert_eq!(m.pop_front(), None);
-    m.push_front(box 1);
-    assert_eq!(m.pop_front(), Some(box 1));
-    m.push_back(box 2);
-    m.push_back(box 3);
-    assert_eq!(m.len(), 2);
-    assert_eq!(m.pop_front(), Some(box 2));
-    assert_eq!(m.pop_front(), Some(box 3));
-    assert_eq!(m.len(), 0);
-    assert_eq!(m.pop_front(), None);
-    m.push_back(box 1);
-    m.push_back(box 3);
-    m.push_back(box 5);
-    m.push_back(box 7);
-    assert_eq!(m.pop_front(), Some(box 1));
-
-    let mut n = LinkedList::new();
-    n.push_front(2);
-    n.push_front(3);
-    {
-        assert_eq!(n.front().unwrap(), &3);
-        let x = n.front_mut().unwrap();
-        assert_eq!(*x, 3);
-        *x = 0;
-    }
-    {
-        assert_eq!(n.back().unwrap(), &2);
-        let y = n.back_mut().unwrap();
-        assert_eq!(*y, 2);
-        *y = 1;
-    }
-    assert_eq!(n.pop_front(), Some(0));
-    assert_eq!(n.pop_front(), Some(1));
-}
-
-#[cfg(test)]
-fn generate_test() -> LinkedList<i32> {
-    list_from(&[0, 1, 2, 3, 4, 5, 6])
-}
-
-#[cfg(test)]
-fn list_from<T: Clone>(v: &[T]) -> LinkedList<T> {
-    v.iter().cloned().collect()
-}
-
-#[test]
-fn test_split_off() {
-    // singleton
-    {
-        let mut m = LinkedList::new();
-        m.push_back(1);
-
-        let p = m.split_off(0);
-        assert_eq!(m.len(), 0);
-        assert_eq!(p.len(), 1);
-        assert_eq!(p.back(), Some(&1));
-        assert_eq!(p.front(), Some(&1));
-    }
-
-    // not singleton, forwards
-    {
-        let u = vec![1, 2, 3, 4, 5];
-        let mut m = list_from(&u);
-        let mut n = m.split_off(2);
-        assert_eq!(m.len(), 2);
-        assert_eq!(n.len(), 3);
-        for elt in 1..3 {
-            assert_eq!(m.pop_front(), Some(elt));
-        }
-        for elt in 3..6 {
-            assert_eq!(n.pop_front(), Some(elt));
-        }
-    }
-    // not singleton, backwards
-    {
-        let u = vec![1, 2, 3, 4, 5];
-        let mut m = list_from(&u);
-        let mut n = m.split_off(4);
-        assert_eq!(m.len(), 4);
-        assert_eq!(n.len(), 1);
-        for elt in 1..5 {
-            assert_eq!(m.pop_front(), Some(elt));
-        }
-        for elt in 5..6 {
-            assert_eq!(n.pop_front(), Some(elt));
-        }
-    }
-
-    // no-op on the last index
-    {
-        let mut m = LinkedList::new();
-        m.push_back(1);
-
-        let p = m.split_off(1);
-        assert_eq!(m.len(), 1);
-        assert_eq!(p.len(), 0);
-        assert_eq!(m.back(), Some(&1));
-        assert_eq!(m.front(), Some(&1));
-    }
-
-}
-
-#[test]
-fn test_iterator() {
-    let m = generate_test();
-    for (i, elt) in m.iter().enumerate() {
-        assert_eq!(i as i32, *elt);
-    }
-    let mut n = LinkedList::new();
-    assert_eq!(n.iter().next(), None);
-    n.push_front(4);
-    let mut it = n.iter();
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next().unwrap(), &4);
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_iterator_clone() {
-    let mut n = LinkedList::new();
-    n.push_back(2);
-    n.push_back(3);
-    n.push_back(4);
-    let mut it = n.iter();
-    it.next();
-    let mut jt = it.clone();
-    assert_eq!(it.next(), jt.next());
-    assert_eq!(it.next_back(), jt.next_back());
-    assert_eq!(it.next(), jt.next());
-}
-
-#[test]
-fn test_iterator_double_end() {
-    let mut n = LinkedList::new();
-    assert_eq!(n.iter().next(), None);
-    n.push_front(4);
-    n.push_front(5);
-    n.push_front(6);
-    let mut it = n.iter();
-    assert_eq!(it.size_hint(), (3, Some(3)));
-    assert_eq!(it.next().unwrap(), &6);
-    assert_eq!(it.size_hint(), (2, Some(2)));
-    assert_eq!(it.next_back().unwrap(), &4);
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next_back().unwrap(), &5);
-    assert_eq!(it.next_back(), None);
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_rev_iter() {
-    let m = generate_test();
-    for (i, elt) in m.iter().rev().enumerate() {
-        assert_eq!((6 - i) as i32, *elt);
-    }
-    let mut n = LinkedList::new();
-    assert_eq!(n.iter().rev().next(), None);
-    n.push_front(4);
-    let mut it = n.iter().rev();
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next().unwrap(), &4);
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_mut_iter() {
-    let mut m = generate_test();
-    let mut len = m.len();
-    for (i, elt) in m.iter_mut().enumerate() {
-        assert_eq!(i as i32, *elt);
-        len -= 1;
-    }
-    assert_eq!(len, 0);
-    let mut n = LinkedList::new();
-    assert!(n.iter_mut().next().is_none());
-    n.push_front(4);
-    n.push_back(5);
-    let mut it = n.iter_mut();
-    assert_eq!(it.size_hint(), (2, Some(2)));
-    assert!(it.next().is_some());
-    assert!(it.next().is_some());
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-}
-
-#[test]
-fn test_iterator_mut_double_end() {
-    let mut n = LinkedList::new();
-    assert!(n.iter_mut().next_back().is_none());
-    n.push_front(4);
-    n.push_front(5);
-    n.push_front(6);
-    let mut it = n.iter_mut();
-    assert_eq!(it.size_hint(), (3, Some(3)));
-    assert_eq!(*it.next().unwrap(), 6);
-    assert_eq!(it.size_hint(), (2, Some(2)));
-    assert_eq!(*it.next_back().unwrap(), 4);
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(*it.next_back().unwrap(), 5);
-    assert!(it.next_back().is_none());
-    assert!(it.next().is_none());
-}
-
-#[test]
-fn test_mut_rev_iter() {
-    let mut m = generate_test();
-    for (i, elt) in m.iter_mut().rev().enumerate() {
-        assert_eq!((6 - i) as i32, *elt);
-    }
-    let mut n = LinkedList::new();
-    assert!(n.iter_mut().rev().next().is_none());
-    n.push_front(4);
-    let mut it = n.iter_mut().rev();
-    assert!(it.next().is_some());
-    assert!(it.next().is_none());
-}
-
-#[test]
-fn test_eq() {
-    let mut n = list_from(&[]);
-    let mut m = list_from(&[]);
-    assert!(n == m);
-    n.push_front(1);
-    assert!(n != m);
-    m.push_back(1);
-    assert!(n == m);
-
-    let n = list_from(&[2, 3, 4]);
-    let m = list_from(&[1, 2, 3]);
-    assert!(n != m);
-}
-
-#[test]
-fn test_hash() {
-    let mut x = LinkedList::new();
-    let mut y = LinkedList::new();
-
-    assert!(::hash(&x) == ::hash(&y));
-
-    x.push_back(1);
-    x.push_back(2);
-    x.push_back(3);
-
-    y.push_front(3);
-    y.push_front(2);
-    y.push_front(1);
-
-    assert!(::hash(&x) == ::hash(&y));
-}
-
-#[test]
-fn test_ord() {
-    let n = list_from(&[]);
-    let m = list_from(&[1, 2, 3]);
-    assert!(n < m);
-    assert!(m > n);
-    assert!(n <= n);
-    assert!(n >= n);
-}
-
-#[test]
-fn test_ord_nan() {
-    let nan = 0.0f64 / 0.0;
-    let n = list_from(&[nan]);
-    let m = list_from(&[nan]);
-    assert!(!(n < m));
-    assert!(!(n > m));
-    assert!(!(n <= m));
-    assert!(!(n >= m));
-
-    let n = list_from(&[nan]);
-    let one = list_from(&[1.0f64]);
-    assert!(!(n < one));
-    assert!(!(n > one));
-    assert!(!(n <= one));
-    assert!(!(n >= one));
-
-    let u = list_from(&[1.0f64, 2.0, nan]);
-    let v = list_from(&[1.0f64, 2.0, 3.0]);
-    assert!(!(u < v));
-    assert!(!(u > v));
-    assert!(!(u <= v));
-    assert!(!(u >= v));
-
-    let s = list_from(&[1.0f64, 2.0, 4.0, 2.0]);
-    let t = list_from(&[1.0f64, 2.0, 3.0, 2.0]);
-    assert!(!(s < t));
-    assert!(s > one);
-    assert!(!(s <= one));
-    assert!(s >= one);
-}
-
-#[test]
-fn test_show() {
-    let list: LinkedList<_> = (0..10).collect();
-    assert_eq!(format!("{:?}", list), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
-
-    let list: LinkedList<_> = vec!["just", "one", "test", "more"].iter().cloned().collect();
-    assert_eq!(format!("{:?}", list),
-               "[\"just\", \"one\", \"test\", \"more\"]");
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut a = LinkedList::new();
-    a.push_back(1);
-
-    a.extend(&[2, 3, 4]);
-
-    assert_eq!(a.len(), 4);
-    assert_eq!(a, list_from(&[1, 2, 3, 4]));
-
-    let mut b = LinkedList::new();
-    b.push_back(5);
-    b.push_back(6);
-    a.extend(&b);
-
-    assert_eq!(a.len(), 6);
-    assert_eq!(a, list_from(&[1, 2, 3, 4, 5, 6]));
-}
-
-#[test]
-fn test_extend() {
-    let mut a = LinkedList::new();
-    a.push_back(1);
-    a.extend(vec![2, 3, 4]); // uses iterator
-
-    assert_eq!(a.len(), 4);
-    assert!(a.iter().eq(&[1, 2, 3, 4]));
-
-    let b: LinkedList<_> = vec![5, 6, 7].into_iter().collect();
-    a.extend(b); // specializes to `append`
-
-    assert_eq!(a.len(), 7);
-    assert!(a.iter().eq(&[1, 2, 3, 4, 5, 6, 7]));
-}
-
-#[test]
-fn test_contains() {
-    let mut l = LinkedList::new();
-    l.extend(&[2, 3, 4]);
-
-    assert!(l.contains(&3));
-    assert!(!l.contains(&1));
-
-    l.clear();
-
-    assert!(!l.contains(&3));
-}
diff --git a/src/libcollections/tests/slice.rs b/src/libcollections/tests/slice.rs
deleted file mode 100644
index 7fa65a2144e..00000000000
--- a/src/libcollections/tests/slice.rs
+++ /dev/null
@@ -1,1225 +0,0 @@
-// Copyright 2012-2015 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.
-
-use std::cmp::Ordering::{Equal, Greater, Less};
-use std::mem;
-use std::__rand::{Rng, thread_rng};
-use std::rc::Rc;
-
-fn square(n: usize) -> usize {
-    n * n
-}
-
-fn is_odd(n: &usize) -> bool {
-    *n % 2 == 1
-}
-
-#[test]
-fn test_from_fn() {
-    // Test on-stack from_fn.
-    let mut v: Vec<_> = (0..3).map(square).collect();
-    {
-        let v = v;
-        assert_eq!(v.len(), 3);
-        assert_eq!(v[0], 0);
-        assert_eq!(v[1], 1);
-        assert_eq!(v[2], 4);
-    }
-
-    // Test on-heap from_fn.
-    v = (0..5).map(square).collect();
-    {
-        let v = v;
-        assert_eq!(v.len(), 5);
-        assert_eq!(v[0], 0);
-        assert_eq!(v[1], 1);
-        assert_eq!(v[2], 4);
-        assert_eq!(v[3], 9);
-        assert_eq!(v[4], 16);
-    }
-}
-
-#[test]
-fn test_from_elem() {
-    // Test on-stack from_elem.
-    let mut v = vec![10, 10];
-    {
-        let v = v;
-        assert_eq!(v.len(), 2);
-        assert_eq!(v[0], 10);
-        assert_eq!(v[1], 10);
-    }
-
-    // Test on-heap from_elem.
-    v = vec![20; 6];
-    {
-        let v = &v[..];
-        assert_eq!(v[0], 20);
-        assert_eq!(v[1], 20);
-        assert_eq!(v[2], 20);
-        assert_eq!(v[3], 20);
-        assert_eq!(v[4], 20);
-        assert_eq!(v[5], 20);
-    }
-}
-
-#[test]
-fn test_is_empty() {
-    let xs: [i32; 0] = [];
-    assert!(xs.is_empty());
-    assert!(![0].is_empty());
-}
-
-#[test]
-fn test_len_divzero() {
-    type Z = [i8; 0];
-    let v0: &[Z] = &[];
-    let v1: &[Z] = &[[]];
-    let v2: &[Z] = &[[], []];
-    assert_eq!(mem::size_of::<Z>(), 0);
-    assert_eq!(v0.len(), 0);
-    assert_eq!(v1.len(), 1);
-    assert_eq!(v2.len(), 2);
-}
-
-#[test]
-fn test_get() {
-    let mut a = vec![11];
-    assert_eq!(a.get(1), None);
-    a = vec![11, 12];
-    assert_eq!(a.get(1).unwrap(), &12);
-    a = vec![11, 12, 13];
-    assert_eq!(a.get(1).unwrap(), &12);
-}
-
-#[test]
-fn test_first() {
-    let mut a = vec![];
-    assert_eq!(a.first(), None);
-    a = vec![11];
-    assert_eq!(a.first().unwrap(), &11);
-    a = vec![11, 12];
-    assert_eq!(a.first().unwrap(), &11);
-}
-
-#[test]
-fn test_first_mut() {
-    let mut a = vec![];
-    assert_eq!(a.first_mut(), None);
-    a = vec![11];
-    assert_eq!(*a.first_mut().unwrap(), 11);
-    a = vec![11, 12];
-    assert_eq!(*a.first_mut().unwrap(), 11);
-}
-
-#[test]
-fn test_split_first() {
-    let mut a = vec![11];
-    let b: &[i32] = &[];
-    assert!(b.split_first().is_none());
-    assert_eq!(a.split_first(), Some((&11, b)));
-    a = vec![11, 12];
-    let b: &[i32] = &[12];
-    assert_eq!(a.split_first(), Some((&11, b)));
-}
-
-#[test]
-fn test_split_first_mut() {
-    let mut a = vec![11];
-    let b: &mut [i32] = &mut [];
-    assert!(b.split_first_mut().is_none());
-    assert!(a.split_first_mut() == Some((&mut 11, b)));
-    a = vec![11, 12];
-    let b: &mut [_] = &mut [12];
-    assert!(a.split_first_mut() == Some((&mut 11, b)));
-}
-
-#[test]
-fn test_split_last() {
-    let mut a = vec![11];
-    let b: &[i32] = &[];
-    assert!(b.split_last().is_none());
-    assert_eq!(a.split_last(), Some((&11, b)));
-    a = vec![11, 12];
-    let b: &[_] = &[11];
-    assert_eq!(a.split_last(), Some((&12, b)));
-}
-
-#[test]
-fn test_split_last_mut() {
-    let mut a = vec![11];
-    let b: &mut [i32] = &mut [];
-    assert!(b.split_last_mut().is_none());
-    assert!(a.split_last_mut() == Some((&mut 11, b)));
-
-    a = vec![11, 12];
-    let b: &mut [_] = &mut [11];
-    assert!(a.split_last_mut() == Some((&mut 12, b)));
-}
-
-#[test]
-fn test_last() {
-    let mut a = vec![];
-    assert_eq!(a.last(), None);
-    a = vec![11];
-    assert_eq!(a.last().unwrap(), &11);
-    a = vec![11, 12];
-    assert_eq!(a.last().unwrap(), &12);
-}
-
-#[test]
-fn test_last_mut() {
-    let mut a = vec![];
-    assert_eq!(a.last_mut(), None);
-    a = vec![11];
-    assert_eq!(*a.last_mut().unwrap(), 11);
-    a = vec![11, 12];
-    assert_eq!(*a.last_mut().unwrap(), 12);
-}
-
-#[test]
-fn test_slice() {
-    // Test fixed length vector.
-    let vec_fixed = [1, 2, 3, 4];
-    let v_a = vec_fixed[1..vec_fixed.len()].to_vec();
-    assert_eq!(v_a.len(), 3);
-
-    assert_eq!(v_a[0], 2);
-    assert_eq!(v_a[1], 3);
-    assert_eq!(v_a[2], 4);
-
-    // Test on stack.
-    let vec_stack: &[_] = &[1, 2, 3];
-    let v_b = vec_stack[1..3].to_vec();
-    assert_eq!(v_b.len(), 2);
-
-    assert_eq!(v_b[0], 2);
-    assert_eq!(v_b[1], 3);
-
-    // Test `Box<[T]>`
-    let vec_unique = vec![1, 2, 3, 4, 5, 6];
-    let v_d = vec_unique[1..6].to_vec();
-    assert_eq!(v_d.len(), 5);
-
-    assert_eq!(v_d[0], 2);
-    assert_eq!(v_d[1], 3);
-    assert_eq!(v_d[2], 4);
-    assert_eq!(v_d[3], 5);
-    assert_eq!(v_d[4], 6);
-}
-
-#[test]
-fn test_slice_from() {
-    let vec: &[_] = &[1, 2, 3, 4];
-    assert_eq!(&vec[..], vec);
-    let b: &[_] = &[3, 4];
-    assert_eq!(&vec[2..], b);
-    let b: &[_] = &[];
-    assert_eq!(&vec[4..], b);
-}
-
-#[test]
-fn test_slice_to() {
-    let vec: &[_] = &[1, 2, 3, 4];
-    assert_eq!(&vec[..4], vec);
-    let b: &[_] = &[1, 2];
-    assert_eq!(&vec[..2], b);
-    let b: &[_] = &[];
-    assert_eq!(&vec[..0], b);
-}
-
-
-#[test]
-fn test_pop() {
-    let mut v = vec![5];
-    let e = v.pop();
-    assert_eq!(v.len(), 0);
-    assert_eq!(e, Some(5));
-    let f = v.pop();
-    assert_eq!(f, None);
-    let g = v.pop();
-    assert_eq!(g, None);
-}
-
-#[test]
-fn test_swap_remove() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let mut e = v.swap_remove(0);
-    assert_eq!(e, 1);
-    assert_eq!(v, [5, 2, 3, 4]);
-    e = v.swap_remove(3);
-    assert_eq!(e, 4);
-    assert_eq!(v, [5, 2, 3]);
-}
-
-#[test]
-#[should_panic]
-fn test_swap_remove_fail() {
-    let mut v = vec![1];
-    let _ = v.swap_remove(0);
-    let _ = v.swap_remove(0);
-}
-
-#[test]
-fn test_swap_remove_noncopyable() {
-    // Tests that we don't accidentally run destructors twice.
-    let mut v: Vec<Box<_>> = Vec::new();
-    v.push(box 0);
-    v.push(box 0);
-    v.push(box 0);
-    let mut _e = v.swap_remove(0);
-    assert_eq!(v.len(), 2);
-    _e = v.swap_remove(1);
-    assert_eq!(v.len(), 1);
-    _e = v.swap_remove(0);
-    assert_eq!(v.len(), 0);
-}
-
-#[test]
-fn test_push() {
-    // Test on-stack push().
-    let mut v = vec![];
-    v.push(1);
-    assert_eq!(v.len(), 1);
-    assert_eq!(v[0], 1);
-
-    // Test on-heap push().
-    v.push(2);
-    assert_eq!(v.len(), 2);
-    assert_eq!(v[0], 1);
-    assert_eq!(v[1], 2);
-}
-
-#[test]
-fn test_truncate() {
-    let mut v: Vec<Box<_>> = vec![box 6, box 5, box 4];
-    v.truncate(1);
-    let v = v;
-    assert_eq!(v.len(), 1);
-    assert_eq!(*(v[0]), 6);
-    // If the unsafe block didn't drop things properly, we blow up here.
-}
-
-#[test]
-fn test_clear() {
-    let mut v: Vec<Box<_>> = vec![box 6, box 5, box 4];
-    v.clear();
-    assert_eq!(v.len(), 0);
-    // If the unsafe block didn't drop things properly, we blow up here.
-}
-
-#[test]
-fn test_retain() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    v.retain(is_odd);
-    assert_eq!(v, [1, 3, 5]);
-}
-
-#[test]
-fn test_binary_search() {
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&5).ok(), Some(4));
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&4).ok(), Some(3));
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&3).ok(), Some(2));
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&2).ok(), Some(1));
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&1).ok(), Some(0));
-
-    assert_eq!([2, 4, 6, 8, 10].binary_search(&1).ok(), None);
-    assert_eq!([2, 4, 6, 8, 10].binary_search(&5).ok(), None);
-    assert_eq!([2, 4, 6, 8, 10].binary_search(&4).ok(), Some(1));
-    assert_eq!([2, 4, 6, 8, 10].binary_search(&10).ok(), Some(4));
-
-    assert_eq!([2, 4, 6, 8].binary_search(&1).ok(), None);
-    assert_eq!([2, 4, 6, 8].binary_search(&5).ok(), None);
-    assert_eq!([2, 4, 6, 8].binary_search(&4).ok(), Some(1));
-    assert_eq!([2, 4, 6, 8].binary_search(&8).ok(), Some(3));
-
-    assert_eq!([2, 4, 6].binary_search(&1).ok(), None);
-    assert_eq!([2, 4, 6].binary_search(&5).ok(), None);
-    assert_eq!([2, 4, 6].binary_search(&4).ok(), Some(1));
-    assert_eq!([2, 4, 6].binary_search(&6).ok(), Some(2));
-
-    assert_eq!([2, 4].binary_search(&1).ok(), None);
-    assert_eq!([2, 4].binary_search(&5).ok(), None);
-    assert_eq!([2, 4].binary_search(&2).ok(), Some(0));
-    assert_eq!([2, 4].binary_search(&4).ok(), Some(1));
-
-    assert_eq!([2].binary_search(&1).ok(), None);
-    assert_eq!([2].binary_search(&5).ok(), None);
-    assert_eq!([2].binary_search(&2).ok(), Some(0));
-
-    assert_eq!([].binary_search(&1).ok(), None);
-    assert_eq!([].binary_search(&5).ok(), None);
-
-    assert!([1, 1, 1, 1, 1].binary_search(&1).ok() != None);
-    assert!([1, 1, 1, 1, 2].binary_search(&1).ok() != None);
-    assert!([1, 1, 1, 2, 2].binary_search(&1).ok() != None);
-    assert!([1, 1, 2, 2, 2].binary_search(&1).ok() != None);
-    assert_eq!([1, 2, 2, 2, 2].binary_search(&1).ok(), Some(0));
-
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&6).ok(), None);
-    assert_eq!([1, 2, 3, 4, 5].binary_search(&0).ok(), None);
-}
-
-#[test]
-fn test_reverse() {
-    let mut v = vec![10, 20];
-    assert_eq!(v[0], 10);
-    assert_eq!(v[1], 20);
-    v.reverse();
-    assert_eq!(v[0], 20);
-    assert_eq!(v[1], 10);
-
-    let mut v3 = Vec::<i32>::new();
-    v3.reverse();
-    assert!(v3.is_empty());
-
-    // check the 1-byte-types path
-    let mut v = (-50..51i8).collect::<Vec<_>>();
-    v.reverse();
-    assert_eq!(v, (-50..51i8).rev().collect::<Vec<_>>());
-
-    // check the 2-byte-types path
-    let mut v = (-50..51i16).collect::<Vec<_>>();
-    v.reverse();
-    assert_eq!(v, (-50..51i16).rev().collect::<Vec<_>>());
-}
-
-#[test]
-fn test_sort() {
-    let mut rng = thread_rng();
-
-    for len in (2..25).chain(500..510) {
-        for _ in 0..100 {
-            let mut v: Vec<_> = rng.gen_iter::<i32>().take(len).collect();
-            let mut v1 = v.clone();
-
-            v.sort();
-            assert!(v.windows(2).all(|w| w[0] <= w[1]));
-
-            v1.sort_by(|a, b| a.cmp(b));
-            assert!(v1.windows(2).all(|w| w[0] <= w[1]));
-
-            v1.sort_by(|a, b| b.cmp(a));
-            assert!(v1.windows(2).all(|w| w[0] >= w[1]));
-        }
-    }
-
-    // Sort using a completely random comparison function.
-    // This will reorder the elements *somehow*, but won't panic.
-    let mut v = [0; 500];
-    for i in 0..v.len() {
-        v[i] = i as i32;
-    }
-    v.sort_by(|_, _| *rng.choose(&[Less, Equal, Greater]).unwrap());
-    v.sort();
-    for i in 0..v.len() {
-        assert_eq!(v[i], i as i32);
-    }
-
-    // Should not panic.
-    [0i32; 0].sort();
-    [(); 10].sort();
-    [(); 100].sort();
-
-    let mut v = [0xDEADBEEFu64];
-    v.sort();
-    assert!(v == [0xDEADBEEF]);
-}
-
-#[test]
-fn test_sort_stability() {
-    for len in (2..25).chain(500..510) {
-        for _ in 0..10 {
-            let mut counts = [0; 10];
-
-            // create a vector like [(6, 1), (5, 1), (6, 2), ...],
-            // where the first item of each tuple is random, but
-            // the second item represents which occurrence of that
-            // number this element is, i.e. the second elements
-            // will occur in sorted order.
-            let mut v: Vec<_> = (0..len)
-                .map(|_| {
-                    let n = thread_rng().gen::<usize>() % 10;
-                    counts[n] += 1;
-                    (n, counts[n])
-                })
-                .collect();
-
-            // only sort on the first element, so an unstable sort
-            // may mix up the counts.
-            v.sort_by(|&(a, _), &(b, _)| a.cmp(&b));
-
-            // this comparison includes the count (the second item
-            // of the tuple), so elements with equal first items
-            // will need to be ordered with increasing
-            // counts... i.e. exactly asserting that this sort is
-            // stable.
-            assert!(v.windows(2).all(|w| w[0] <= w[1]));
-        }
-    }
-}
-
-#[test]
-fn test_rotate() {
-    let expected: Vec<_> = (0..13).collect();
-    let mut v = Vec::new();
-
-    // no-ops
-    v.clone_from(&expected);
-    v.rotate(0);
-    assert_eq!(v, expected);
-    v.rotate(expected.len());
-    assert_eq!(v, expected);
-    let mut zst_array = [(), (), ()];
-    zst_array.rotate(2);
-
-    // happy path
-    v = (5..13).chain(0..5).collect();
-    v.rotate(8);
-    assert_eq!(v, expected);
-
-    let expected: Vec<_> = (0..1000).collect();
-
-    // small rotations in large slice, uses ptr::copy
-    v = (2..1000).chain(0..2).collect();
-    v.rotate(998);
-    assert_eq!(v, expected);
-    v = (998..1000).chain(0..998).collect();
-    v.rotate(2);
-    assert_eq!(v, expected);
-
-    // non-small prime rotation, has a few rounds of swapping
-    v = (389..1000).chain(0..389).collect();
-    v.rotate(1000-389);
-    assert_eq!(v, expected);
-}
-
-#[test]
-fn test_concat() {
-    let v: [Vec<i32>; 0] = [];
-    let c = v.concat();
-    assert_eq!(c, []);
-    let d = [vec![1], vec![2, 3]].concat();
-    assert_eq!(d, [1, 2, 3]);
-
-    let v: &[&[_]] = &[&[1], &[2, 3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 3]);
-    let v: &[&[_]] = &[&[1], &[2], &[3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
-}
-
-#[test]
-fn test_join() {
-    let v: [Vec<i32>; 0] = [];
-    assert_eq!(v.join(&0), []);
-    assert_eq!([vec![1], vec![2, 3]].join(&0), [1, 0, 2, 3]);
-    assert_eq!([vec![1], vec![2], vec![3]].join(&0), [1, 0, 2, 0, 3]);
-
-    let v: [&[_]; 2] = [&[1], &[2, 3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 3]);
-    let v: [&[_]; 3] = [&[1], &[2], &[3]];
-    assert_eq!(v.join(&0), [1, 0, 2, 0, 3]);
-}
-
-#[test]
-fn test_insert() {
-    let mut a = vec![1, 2, 4];
-    a.insert(2, 3);
-    assert_eq!(a, [1, 2, 3, 4]);
-
-    let mut a = vec![1, 2, 3];
-    a.insert(0, 0);
-    assert_eq!(a, [0, 1, 2, 3]);
-
-    let mut a = vec![1, 2, 3];
-    a.insert(3, 4);
-    assert_eq!(a, [1, 2, 3, 4]);
-
-    let mut a = vec![];
-    a.insert(0, 1);
-    assert_eq!(a, [1]);
-}
-
-#[test]
-#[should_panic]
-fn test_insert_oob() {
-    let mut a = vec![1, 2, 3];
-    a.insert(4, 5);
-}
-
-#[test]
-fn test_remove() {
-    let mut a = vec![1, 2, 3, 4];
-
-    assert_eq!(a.remove(2), 3);
-    assert_eq!(a, [1, 2, 4]);
-
-    assert_eq!(a.remove(2), 4);
-    assert_eq!(a, [1, 2]);
-
-    assert_eq!(a.remove(0), 1);
-    assert_eq!(a, [2]);
-
-    assert_eq!(a.remove(0), 2);
-    assert_eq!(a, []);
-}
-
-#[test]
-#[should_panic]
-fn test_remove_fail() {
-    let mut a = vec![1];
-    let _ = a.remove(0);
-    let _ = a.remove(0);
-}
-
-#[test]
-fn test_capacity() {
-    let mut v = vec![0];
-    v.reserve_exact(10);
-    assert!(v.capacity() >= 11);
-}
-
-#[test]
-fn test_slice_2() {
-    let v = vec![1, 2, 3, 4, 5];
-    let v = &v[1..3];
-    assert_eq!(v.len(), 2);
-    assert_eq!(v[0], 2);
-    assert_eq!(v[1], 3);
-}
-
-macro_rules! assert_order {
-    (Greater, $a:expr, $b:expr) => {
-        assert_eq!($a.cmp($b), Greater);
-        assert!($a > $b);
-    };
-    (Less, $a:expr, $b:expr) => {
-        assert_eq!($a.cmp($b), Less);
-        assert!($a < $b);
-    };
-    (Equal, $a:expr, $b:expr) => {
-        assert_eq!($a.cmp($b), Equal);
-        assert_eq!($a, $b);
-    }
-}
-
-#[test]
-fn test_total_ord_u8() {
-    let c = &[1u8, 2, 3];
-    assert_order!(Greater, &[1u8, 2, 3, 4][..], &c[..]);
-    let c = &[1u8, 2, 3, 4];
-    assert_order!(Less, &[1u8, 2, 3][..], &c[..]);
-    let c = &[1u8, 2, 3, 6];
-    assert_order!(Equal, &[1u8, 2, 3, 6][..], &c[..]);
-    let c = &[1u8, 2, 3, 4, 5, 6];
-    assert_order!(Less, &[1u8, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
-    let c = &[1u8, 2, 3, 4];
-    assert_order!(Greater, &[2u8, 2][..], &c[..]);
-}
-
-
-#[test]
-fn test_total_ord_i32() {
-    let c = &[1, 2, 3];
-    assert_order!(Greater, &[1, 2, 3, 4][..], &c[..]);
-    let c = &[1, 2, 3, 4];
-    assert_order!(Less, &[1, 2, 3][..], &c[..]);
-    let c = &[1, 2, 3, 6];
-    assert_order!(Equal, &[1, 2, 3, 6][..], &c[..]);
-    let c = &[1, 2, 3, 4, 5, 6];
-    assert_order!(Less, &[1, 2, 3, 4, 5, 5, 5, 5][..], &c[..]);
-    let c = &[1, 2, 3, 4];
-    assert_order!(Greater, &[2, 2][..], &c[..]);
-}
-
-#[test]
-fn test_iterator() {
-    let xs = [1, 2, 5, 10, 11];
-    let mut it = xs.iter();
-    assert_eq!(it.size_hint(), (5, Some(5)));
-    assert_eq!(it.next().unwrap(), &1);
-    assert_eq!(it.size_hint(), (4, Some(4)));
-    assert_eq!(it.next().unwrap(), &2);
-    assert_eq!(it.size_hint(), (3, Some(3)));
-    assert_eq!(it.next().unwrap(), &5);
-    assert_eq!(it.size_hint(), (2, Some(2)));
-    assert_eq!(it.next().unwrap(), &10);
-    assert_eq!(it.size_hint(), (1, Some(1)));
-    assert_eq!(it.next().unwrap(), &11);
-    assert_eq!(it.size_hint(), (0, Some(0)));
-    assert!(it.next().is_none());
-}
-
-#[test]
-fn test_iter_size_hints() {
-    let mut xs = [1, 2, 5, 10, 11];
-    assert_eq!(xs.iter().size_hint(), (5, Some(5)));
-    assert_eq!(xs.iter_mut().size_hint(), (5, Some(5)));
-}
-
-#[test]
-fn test_iter_as_slice() {
-    let xs = [1, 2, 5, 10, 11];
-    let mut iter = xs.iter();
-    assert_eq!(iter.as_slice(), &[1, 2, 5, 10, 11]);
-    iter.next();
-    assert_eq!(iter.as_slice(), &[2, 5, 10, 11]);
-}
-
-#[test]
-fn test_iter_as_ref() {
-    let xs = [1, 2, 5, 10, 11];
-    let mut iter = xs.iter();
-    assert_eq!(iter.as_ref(), &[1, 2, 5, 10, 11]);
-    iter.next();
-    assert_eq!(iter.as_ref(), &[2, 5, 10, 11]);
-}
-
-#[test]
-fn test_iter_clone() {
-    let xs = [1, 2, 5];
-    let mut it = xs.iter();
-    it.next();
-    let mut jt = it.clone();
-    assert_eq!(it.next(), jt.next());
-    assert_eq!(it.next(), jt.next());
-    assert_eq!(it.next(), jt.next());
-}
-
-#[test]
-fn test_iter_is_empty() {
-    let xs = [1, 2, 5, 10, 11];
-    for i in 0..xs.len() {
-        for j in i..xs.len() {
-            assert_eq!(xs[i..j].iter().is_empty(), xs[i..j].is_empty());
-        }
-    }
-}
-
-#[test]
-fn test_mut_iterator() {
-    let mut xs = [1, 2, 3, 4, 5];
-    for x in &mut xs {
-        *x += 1;
-    }
-    assert!(xs == [2, 3, 4, 5, 6])
-}
-
-#[test]
-fn test_rev_iterator() {
-
-    let xs = [1, 2, 5, 10, 11];
-    let ys = [11, 10, 5, 2, 1];
-    let mut i = 0;
-    for &x in xs.iter().rev() {
-        assert_eq!(x, ys[i]);
-        i += 1;
-    }
-    assert_eq!(i, 5);
-}
-
-#[test]
-fn test_mut_rev_iterator() {
-    let mut xs = [1, 2, 3, 4, 5];
-    for (i, x) in xs.iter_mut().rev().enumerate() {
-        *x += i;
-    }
-    assert!(xs == [5, 5, 5, 5, 5])
-}
-
-#[test]
-fn test_move_iterator() {
-    let xs = vec![1, 2, 3, 4, 5];
-    assert_eq!(xs.into_iter().fold(0, |a: usize, b: usize| 10 * a + b),
-               12345);
-}
-
-#[test]
-fn test_move_rev_iterator() {
-    let xs = vec![1, 2, 3, 4, 5];
-    assert_eq!(xs.into_iter().rev().fold(0, |a: usize, b: usize| 10 * a + b),
-               54321);
-}
-
-#[test]
-fn test_splitator() {
-    let xs = &[1, 2, 3, 4, 5];
-
-    let splits: &[&[_]] = &[&[1], &[3], &[5]];
-    assert_eq!(xs.split(|x| *x % 2 == 0).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[], &[2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 1).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[1, 2, 3, 4], &[]];
-    assert_eq!(xs.split(|x| *x == 5).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 10).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[], &[], &[], &[], &[], &[]];
-    assert_eq!(xs.split(|_| true).collect::<Vec<&[i32]>>(), splits);
-
-    let xs: &[i32] = &[];
-    let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.split(|x| *x == 5).collect::<Vec<&[i32]>>(), splits);
-}
-
-#[test]
-fn test_splitnator() {
-    let xs = &[1, 2, 3, 4, 5];
-
-    let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.splitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[1], &[3, 4, 5]];
-    assert_eq!(xs.splitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[], &[], &[], &[4, 5]];
-    assert_eq!(xs.splitn(4, |_| true).collect::<Vec<_>>(), splits);
-
-    let xs: &[i32] = &[];
-    let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.splitn(2, |x| *x == 5).collect::<Vec<_>>(), splits);
-}
-
-#[test]
-fn test_splitnator_mut() {
-    let xs = &mut [1, 2, 3, 4, 5];
-
-    let splits: &[&mut [_]] = &[&mut [1, 2, 3, 4, 5]];
-    assert_eq!(xs.splitn_mut(1, |x| *x % 2 == 0).collect::<Vec<_>>(),
-               splits);
-    let splits: &[&mut [_]] = &[&mut [1], &mut [3, 4, 5]];
-    assert_eq!(xs.splitn_mut(2, |x| *x % 2 == 0).collect::<Vec<_>>(),
-               splits);
-    let splits: &[&mut [_]] = &[&mut [], &mut [], &mut [], &mut [4, 5]];
-    assert_eq!(xs.splitn_mut(4, |_| true).collect::<Vec<_>>(), splits);
-
-    let xs: &mut [i32] = &mut [];
-    let splits: &[&mut [i32]] = &[&mut []];
-    assert_eq!(xs.splitn_mut(2, |x| *x == 5).collect::<Vec<_>>(), splits);
-}
-
-#[test]
-fn test_rsplitator() {
-    let xs = &[1, 2, 3, 4, 5];
-
-    let splits: &[&[_]] = &[&[5], &[3], &[1]];
-    assert_eq!(xs.split(|x| *x % 2 == 0).rev().collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[2, 3, 4, 5], &[]];
-    assert_eq!(xs.split(|x| *x == 1).rev().collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[], &[1, 2, 3, 4]];
-    assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.split(|x| *x == 10).rev().collect::<Vec<_>>(), splits);
-
-    let xs: &[i32] = &[];
-    let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.split(|x| *x == 5).rev().collect::<Vec<&[i32]>>(), splits);
-}
-
-#[test]
-fn test_rsplitnator() {
-    let xs = &[1, 2, 3, 4, 5];
-
-    let splits: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(xs.rsplitn(1, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[5], &[1, 2, 3]];
-    assert_eq!(xs.rsplitn(2, |x| *x % 2 == 0).collect::<Vec<_>>(), splits);
-    let splits: &[&[_]] = &[&[], &[], &[], &[1, 2]];
-    assert_eq!(xs.rsplitn(4, |_| true).collect::<Vec<_>>(), splits);
-
-    let xs: &[i32] = &[];
-    let splits: &[&[i32]] = &[&[]];
-    assert_eq!(xs.rsplitn(2, |x| *x == 5).collect::<Vec<&[i32]>>(), splits);
-    assert!(xs.rsplitn(0, |x| *x % 2 == 0).next().is_none());
-}
-
-#[test]
-fn test_windowsator() {
-    let v = &[1, 2, 3, 4];
-
-    let wins: &[&[_]] = &[&[1, 2], &[2, 3], &[3, 4]];
-    assert_eq!(v.windows(2).collect::<Vec<_>>(), wins);
-
-    let wins: &[&[_]] = &[&[1, 2, 3], &[2, 3, 4]];
-    assert_eq!(v.windows(3).collect::<Vec<_>>(), wins);
-    assert!(v.windows(6).next().is_none());
-
-    let wins: &[&[_]] = &[&[3, 4], &[2, 3], &[1, 2]];
-    assert_eq!(v.windows(2).rev().collect::<Vec<&[_]>>(), wins);
-}
-
-#[test]
-#[should_panic]
-fn test_windowsator_0() {
-    let v = &[1, 2, 3, 4];
-    let _it = v.windows(0);
-}
-
-#[test]
-fn test_chunksator() {
-    let v = &[1, 2, 3, 4, 5];
-
-    assert_eq!(v.chunks(2).len(), 3);
-
-    let chunks: &[&[_]] = &[&[1, 2], &[3, 4], &[5]];
-    assert_eq!(v.chunks(2).collect::<Vec<_>>(), chunks);
-    let chunks: &[&[_]] = &[&[1, 2, 3], &[4, 5]];
-    assert_eq!(v.chunks(3).collect::<Vec<_>>(), chunks);
-    let chunks: &[&[_]] = &[&[1, 2, 3, 4, 5]];
-    assert_eq!(v.chunks(6).collect::<Vec<_>>(), chunks);
-
-    let chunks: &[&[_]] = &[&[5], &[3, 4], &[1, 2]];
-    assert_eq!(v.chunks(2).rev().collect::<Vec<_>>(), chunks);
-}
-
-#[test]
-#[should_panic]
-fn test_chunksator_0() {
-    let v = &[1, 2, 3, 4];
-    let _it = v.chunks(0);
-}
-
-#[test]
-fn test_reverse_part() {
-    let mut values = [1, 2, 3, 4, 5];
-    values[1..4].reverse();
-    assert!(values == [1, 4, 3, 2, 5]);
-}
-
-#[test]
-fn test_show() {
-    macro_rules! test_show_vec {
-        ($x:expr, $x_str:expr) => ({
-            let (x, x_str) = ($x, $x_str);
-            assert_eq!(format!("{:?}", x), x_str);
-            assert_eq!(format!("{:?}", x), x_str);
-        })
-    }
-    let empty = Vec::<i32>::new();
-    test_show_vec!(empty, "[]");
-    test_show_vec!(vec![1], "[1]");
-    test_show_vec!(vec![1, 2, 3], "[1, 2, 3]");
-    test_show_vec!(vec![vec![], vec![1], vec![1, 1]], "[[], [1], [1, 1]]");
-
-    let empty_mut: &mut [i32] = &mut [];
-    test_show_vec!(empty_mut, "[]");
-    let v = &mut [1];
-    test_show_vec!(v, "[1]");
-    let v = &mut [1, 2, 3];
-    test_show_vec!(v, "[1, 2, 3]");
-    let v: &mut [&mut [_]] = &mut [&mut [], &mut [1], &mut [1, 1]];
-    test_show_vec!(v, "[[], [1], [1, 1]]");
-}
-
-#[test]
-fn test_vec_default() {
-    macro_rules! t {
-        ($ty:ty) => {{
-            let v: $ty = Default::default();
-            assert!(v.is_empty());
-        }}
-    }
-
-    t!(&[i32]);
-    t!(Vec<i32>);
-}
-
-#[test]
-#[should_panic]
-fn test_overflow_does_not_cause_segfault() {
-    let mut v = vec![];
-    v.reserve_exact(!0);
-    v.push(1);
-    v.push(2);
-}
-
-#[test]
-#[should_panic]
-fn test_overflow_does_not_cause_segfault_managed() {
-    let mut v = vec![Rc::new(1)];
-    v.reserve_exact(!0);
-    v.push(Rc::new(2));
-}
-
-#[test]
-fn test_mut_split_at() {
-    let mut values = [1, 2, 3, 4, 5];
-    {
-        let (left, right) = values.split_at_mut(2);
-        {
-            let left: &[_] = left;
-            assert!(left[..left.len()] == [1, 2]);
-        }
-        for p in left {
-            *p += 1;
-        }
-
-        {
-            let right: &[_] = right;
-            assert!(right[..right.len()] == [3, 4, 5]);
-        }
-        for p in right {
-            *p += 2;
-        }
-    }
-
-    assert!(values == [2, 3, 5, 6, 7]);
-}
-
-#[derive(Clone, PartialEq)]
-struct Foo;
-
-#[test]
-fn test_iter_zero_sized() {
-    let mut v = vec![Foo, Foo, Foo];
-    assert_eq!(v.len(), 3);
-    let mut cnt = 0;
-
-    for f in &v {
-        assert!(*f == Foo);
-        cnt += 1;
-    }
-    assert_eq!(cnt, 3);
-
-    for f in &v[1..3] {
-        assert!(*f == Foo);
-        cnt += 1;
-    }
-    assert_eq!(cnt, 5);
-
-    for f in &mut v {
-        assert!(*f == Foo);
-        cnt += 1;
-    }
-    assert_eq!(cnt, 8);
-
-    for f in v {
-        assert!(f == Foo);
-        cnt += 1;
-    }
-    assert_eq!(cnt, 11);
-
-    let xs: [Foo; 3] = [Foo, Foo, Foo];
-    cnt = 0;
-    for f in &xs {
-        assert!(*f == Foo);
-        cnt += 1;
-    }
-    assert!(cnt == 3);
-}
-
-#[test]
-fn test_shrink_to_fit() {
-    let mut xs = vec![0, 1, 2, 3];
-    for i in 4..100 {
-        xs.push(i)
-    }
-    assert_eq!(xs.capacity(), 128);
-    xs.shrink_to_fit();
-    assert_eq!(xs.capacity(), 100);
-    assert_eq!(xs, (0..100).collect::<Vec<_>>());
-}
-
-#[test]
-fn test_starts_with() {
-    assert!(b"foobar".starts_with(b"foo"));
-    assert!(!b"foobar".starts_with(b"oob"));
-    assert!(!b"foobar".starts_with(b"bar"));
-    assert!(!b"foo".starts_with(b"foobar"));
-    assert!(!b"bar".starts_with(b"foobar"));
-    assert!(b"foobar".starts_with(b"foobar"));
-    let empty: &[u8] = &[];
-    assert!(empty.starts_with(empty));
-    assert!(!empty.starts_with(b"foo"));
-    assert!(b"foobar".starts_with(empty));
-}
-
-#[test]
-fn test_ends_with() {
-    assert!(b"foobar".ends_with(b"bar"));
-    assert!(!b"foobar".ends_with(b"oba"));
-    assert!(!b"foobar".ends_with(b"foo"));
-    assert!(!b"foo".ends_with(b"foobar"));
-    assert!(!b"bar".ends_with(b"foobar"));
-    assert!(b"foobar".ends_with(b"foobar"));
-    let empty: &[u8] = &[];
-    assert!(empty.ends_with(empty));
-    assert!(!empty.ends_with(b"foo"));
-    assert!(b"foobar".ends_with(empty));
-}
-
-#[test]
-fn test_mut_splitator() {
-    let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0];
-    assert_eq!(xs.split_mut(|x| *x == 0).count(), 6);
-    for slice in xs.split_mut(|x| *x == 0) {
-        slice.reverse();
-    }
-    assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0]);
-
-    let mut xs = [0, 1, 0, 2, 3, 0, 0, 4, 5, 0, 6, 7];
-    for slice in xs.split_mut(|x| *x == 0).take(5) {
-        slice.reverse();
-    }
-    assert!(xs == [0, 1, 0, 3, 2, 0, 0, 5, 4, 0, 6, 7]);
-}
-
-#[test]
-fn test_mut_splitator_rev() {
-    let mut xs = [1, 2, 0, 3, 4, 0, 0, 5, 6, 0];
-    for slice in xs.split_mut(|x| *x == 0).rev().take(4) {
-        slice.reverse();
-    }
-    assert!(xs == [1, 2, 0, 4, 3, 0, 0, 6, 5, 0]);
-}
-
-#[test]
-fn test_get_mut() {
-    let mut v = [0, 1, 2];
-    assert_eq!(v.get_mut(3), None);
-    v.get_mut(1).map(|e| *e = 7);
-    assert_eq!(v[1], 7);
-    let mut x = 2;
-    assert_eq!(v.get_mut(2), Some(&mut x));
-}
-
-#[test]
-fn test_mut_chunks() {
-    let mut v = [0, 1, 2, 3, 4, 5, 6];
-    assert_eq!(v.chunks_mut(2).len(), 4);
-    for (i, chunk) in v.chunks_mut(3).enumerate() {
-        for x in chunk {
-            *x = i as u8;
-        }
-    }
-    let result = [0, 0, 0, 1, 1, 1, 2];
-    assert!(v == result);
-}
-
-#[test]
-fn test_mut_chunks_rev() {
-    let mut v = [0, 1, 2, 3, 4, 5, 6];
-    for (i, chunk) in v.chunks_mut(3).rev().enumerate() {
-        for x in chunk {
-            *x = i as u8;
-        }
-    }
-    let result = [2, 2, 2, 1, 1, 1, 0];
-    assert!(v == result);
-}
-
-#[test]
-#[should_panic]
-fn test_mut_chunks_0() {
-    let mut v = [1, 2, 3, 4];
-    let _it = v.chunks_mut(0);
-}
-
-#[test]
-fn test_mut_last() {
-    let mut x = [1, 2, 3, 4, 5];
-    let h = x.last_mut();
-    assert_eq!(*h.unwrap(), 5);
-
-    let y: &mut [i32] = &mut [];
-    assert!(y.last_mut().is_none());
-}
-
-#[test]
-fn test_to_vec() {
-    let xs: Box<_> = box [1, 2, 3];
-    let ys = xs.to_vec();
-    assert_eq!(ys, [1, 2, 3]);
-}
-
-#[test]
-fn test_box_slice_clone() {
-    let data = vec![vec![0, 1], vec![0], vec![1]];
-    let data2 = data.clone().into_boxed_slice().clone().to_vec();
-
-    assert_eq!(data, data2);
-}
-
-#[test]
-#[cfg_attr(target_os = "emscripten", ignore)]
-fn test_box_slice_clone_panics() {
-    use std::sync::Arc;
-    use std::sync::atomic::{AtomicUsize, Ordering};
-    use std::thread::spawn;
-
-    struct Canary {
-        count: Arc<AtomicUsize>,
-        panics: bool,
-    }
-
-    impl Drop for Canary {
-        fn drop(&mut self) {
-            self.count.fetch_add(1, Ordering::SeqCst);
-        }
-    }
-
-    impl Clone for Canary {
-        fn clone(&self) -> Self {
-            if self.panics {
-                panic!()
-            }
-
-            Canary {
-                count: self.count.clone(),
-                panics: self.panics,
-            }
-        }
-    }
-
-    let drop_count = Arc::new(AtomicUsize::new(0));
-    let canary = Canary {
-        count: drop_count.clone(),
-        panics: false,
-    };
-    let panic = Canary {
-        count: drop_count.clone(),
-        panics: true,
-    };
-
-    spawn(move || {
-            // When xs is dropped, +5.
-            let xs = vec![canary.clone(), canary.clone(), canary.clone(), panic, canary]
-                .into_boxed_slice();
-
-            // When panic is cloned, +3.
-            xs.clone();
-        })
-        .join()
-        .unwrap_err();
-
-    // Total = 8
-    assert_eq!(drop_count.load(Ordering::SeqCst), 8);
-}
-
-#[test]
-fn test_copy_from_slice() {
-    let src = [0, 1, 2, 3, 4, 5];
-    let mut dst = [0; 6];
-    dst.copy_from_slice(&src);
-    assert_eq!(src, dst)
-}
-
-#[test]
-#[should_panic(expected = "destination and source slices have different lengths")]
-fn test_copy_from_slice_dst_longer() {
-    let src = [0, 1, 2, 3];
-    let mut dst = [0; 5];
-    dst.copy_from_slice(&src);
-}
-
-#[test]
-#[should_panic(expected = "destination and source slices have different lengths")]
-fn test_copy_from_slice_dst_shorter() {
-    let src = [0, 1, 2, 3];
-    let mut dst = [0; 3];
-    dst.copy_from_slice(&src);
-}
diff --git a/src/libcollections/tests/str.rs b/src/libcollections/tests/str.rs
deleted file mode 100644
index 9d8ca38b20e..00000000000
--- a/src/libcollections/tests/str.rs
+++ /dev/null
@@ -1,1573 +0,0 @@
-// Copyright 2012-2015 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.
-
-use std::borrow::Cow;
-use std::cmp::Ordering::{Equal, Greater, Less};
-use std::str::from_utf8;
-
-#[test]
-fn test_le() {
-    assert!("" <= "");
-    assert!("" <= "foo");
-    assert!("foo" <= "foo");
-    assert!("foo" != "bar");
-}
-
-#[test]
-fn test_find() {
-    assert_eq!("hello".find('l'), Some(2));
-    assert_eq!("hello".find(|c:char| c == 'o'), Some(4));
-    assert!("hello".find('x').is_none());
-    assert!("hello".find(|c:char| c == 'x').is_none());
-    assert_eq!("ประเทศไทย中华Việt Nam".find('华'), Some(30));
-    assert_eq!("ประเทศไทย中华Việt Nam".find(|c: char| c == '华'), Some(30));
-}
-
-#[test]
-fn test_rfind() {
-    assert_eq!("hello".rfind('l'), Some(3));
-    assert_eq!("hello".rfind(|c:char| c == 'o'), Some(4));
-    assert!("hello".rfind('x').is_none());
-    assert!("hello".rfind(|c:char| c == 'x').is_none());
-    assert_eq!("ประเทศไทย中华Việt Nam".rfind('华'), Some(30));
-    assert_eq!("ประเทศไทย中华Việt Nam".rfind(|c: char| c == '华'), Some(30));
-}
-
-#[test]
-fn test_collect() {
-    let empty = "";
-    let s: String = empty.chars().collect();
-    assert_eq!(empty, s);
-    let data = "ประเทศไทย中";
-    let s: String = data.chars().collect();
-    assert_eq!(data, s);
-}
-
-#[test]
-fn test_into_bytes() {
-    let data = String::from("asdf");
-    let buf = data.into_bytes();
-    assert_eq!(buf, b"asdf");
-}
-
-#[test]
-fn test_find_str() {
-    // byte positions
-    assert_eq!("".find(""), Some(0));
-    assert!("banana".find("apple pie").is_none());
-
-    let data = "abcabc";
-    assert_eq!(data[0..6].find("ab"), Some(0));
-    assert_eq!(data[2..6].find("ab"), Some(3 - 2));
-    assert!(data[2..4].find("ab").is_none());
-
-    let string = "ประเทศไทย中华Việt Nam";
-    let mut data = String::from(string);
-    data.push_str(string);
-    assert!(data.find("ไท华").is_none());
-    assert_eq!(data[0..43].find(""), Some(0));
-    assert_eq!(data[6..43].find(""), Some(6 - 6));
-
-    assert_eq!(data[0..43].find("ประ"), Some( 0));
-    assert_eq!(data[0..43].find("ทศไ"), Some(12));
-    assert_eq!(data[0..43].find("ย中"), Some(24));
-    assert_eq!(data[0..43].find("iệt"), Some(34));
-    assert_eq!(data[0..43].find("Nam"), Some(40));
-
-    assert_eq!(data[43..86].find("ประ"), Some(43 - 43));
-    assert_eq!(data[43..86].find("ทศไ"), Some(55 - 43));
-    assert_eq!(data[43..86].find("ย中"), Some(67 - 43));
-    assert_eq!(data[43..86].find("iệt"), Some(77 - 43));
-    assert_eq!(data[43..86].find("Nam"), Some(83 - 43));
-
-    // find every substring -- assert that it finds it, or an earlier occurrence.
-    let string = "Việt Namacbaabcaabaaba";
-    for (i, ci) in string.char_indices() {
-        let ip = i + ci.len_utf8();
-        for j in string[ip..].char_indices()
-                             .map(|(i, _)| i)
-                             .chain(Some(string.len() - ip))
-        {
-            let pat = &string[i..ip + j];
-            assert!(match string.find(pat) {
-                None => false,
-                Some(x) => x <= i,
-            });
-            assert!(match string.rfind(pat) {
-                None => false,
-                Some(x) => x >= i,
-            });
-        }
-    }
-}
-
-fn s(x: &str) -> String { x.to_string() }
-
-macro_rules! test_concat {
-    ($expected: expr, $string: expr) => {
-        {
-            let s: String = $string.concat();
-            assert_eq!($expected, s);
-        }
-    }
-}
-
-#[test]
-fn test_concat_for_different_types() {
-    test_concat!("ab", vec![s("a"), s("b")]);
-    test_concat!("ab", vec!["a", "b"]);
-}
-
-#[test]
-fn test_concat_for_different_lengths() {
-    let empty: &[&str] = &[];
-    test_concat!("", empty);
-    test_concat!("a", ["a"]);
-    test_concat!("ab", ["a", "b"]);
-    test_concat!("abc", ["", "a", "bc"]);
-}
-
-macro_rules! test_join {
-    ($expected: expr, $string: expr, $delim: expr) => {
-        {
-            let s = $string.join($delim);
-            assert_eq!($expected, s);
-        }
-    }
-}
-
-#[test]
-fn test_join_for_different_types() {
-    test_join!("a-b", ["a", "b"], "-");
-    let hyphen = "-".to_string();
-    test_join!("a-b", [s("a"), s("b")], &*hyphen);
-    test_join!("a-b", vec!["a", "b"], &*hyphen);
-    test_join!("a-b", &*vec!["a", "b"], "-");
-    test_join!("a-b", vec![s("a"), s("b")], "-");
-}
-
-#[test]
-fn test_join_for_different_lengths() {
-    let empty: &[&str] = &[];
-    test_join!("", empty, "-");
-    test_join!("a", ["a"], "-");
-    test_join!("a-b", ["a", "b"], "-");
-    test_join!("-a-bc", ["", "a", "bc"], "-");
-}
-
-#[test]
-fn test_unsafe_slice() {
-    assert_eq!("ab", unsafe {"abc".slice_unchecked(0, 2)});
-    assert_eq!("bc", unsafe {"abc".slice_unchecked(1, 3)});
-    assert_eq!("", unsafe {"abc".slice_unchecked(1, 1)});
-    fn a_million_letter_a() -> String {
-        let mut i = 0;
-        let mut rs = String::new();
-        while i < 100000 {
-            rs.push_str("aaaaaaaaaa");
-            i += 1;
-        }
-        rs
-    }
-    fn half_a_million_letter_a() -> String {
-        let mut i = 0;
-        let mut rs = String::new();
-        while i < 100000 {
-            rs.push_str("aaaaa");
-            i += 1;
-        }
-        rs
-    }
-    let letters = a_million_letter_a();
-    assert_eq!(half_a_million_letter_a(),
-        unsafe { letters.slice_unchecked(0, 500000)});
-}
-
-#[test]
-fn test_starts_with() {
-    assert!("".starts_with(""));
-    assert!("abc".starts_with(""));
-    assert!("abc".starts_with("a"));
-    assert!(!"a".starts_with("abc"));
-    assert!(!"".starts_with("abc"));
-    assert!(!"ödd".starts_with("-"));
-    assert!("ödd".starts_with("öd"));
-}
-
-#[test]
-fn test_ends_with() {
-    assert!("".ends_with(""));
-    assert!("abc".ends_with(""));
-    assert!("abc".ends_with("c"));
-    assert!(!"a".ends_with("abc"));
-    assert!(!"".ends_with("abc"));
-    assert!(!"ddö".ends_with("-"));
-    assert!("ddö".ends_with("dö"));
-}
-
-#[test]
-fn test_is_empty() {
-    assert!("".is_empty());
-    assert!(!"a".is_empty());
-}
-
-#[test]
-fn test_replacen() {
-    assert_eq!("".replacen('a', "b", 5), "");
-    assert_eq!("acaaa".replacen("a", "b", 3), "bcbba");
-    assert_eq!("aaaa".replacen("a", "b", 0), "aaaa");
-
-    let test = "test";
-    assert_eq!(" test test ".replacen(test, "toast", 3), " toast toast ");
-    assert_eq!(" test test ".replacen(test, "toast", 0), " test test ");
-    assert_eq!(" test test ".replacen(test, "", 5), "   ");
-
-    assert_eq!("qwer123zxc789".replacen(char::is_numeric, "", 3), "qwerzxc789");
-}
-
-#[test]
-fn test_replace() {
-    let a = "a";
-    assert_eq!("".replace(a, "b"), "");
-    assert_eq!("a".replace(a, "b"), "b");
-    assert_eq!("ab".replace(a, "b"), "bb");
-    let test = "test";
-    assert_eq!(" test test ".replace(test, "toast"), " toast toast ");
-    assert_eq!(" test test ".replace(test, ""), "   ");
-}
-
-#[test]
-fn test_replace_2a() {
-    let data = "ประเทศไทย中华";
-    let repl = "دولة الكويت";
-
-    let a = "ประเ";
-    let a2 = "دولة الكويتทศไทย中华";
-    assert_eq!(data.replace(a, repl), a2);
-}
-
-#[test]
-fn test_replace_2b() {
-    let data = "ประเทศไทย中华";
-    let repl = "دولة الكويت";
-
-    let b = "ะเ";
-    let b2 = "ปรدولة الكويتทศไทย中华";
-    assert_eq!(data.replace(b, repl), b2);
-}
-
-#[test]
-fn test_replace_2c() {
-    let data = "ประเทศไทย中华";
-    let repl = "دولة الكويت";
-
-    let c = "中华";
-    let c2 = "ประเทศไทยدولة الكويت";
-    assert_eq!(data.replace(c, repl), c2);
-}
-
-#[test]
-fn test_replace_2d() {
-    let data = "ประเทศไทย中华";
-    let repl = "دولة الكويت";
-
-    let d = "ไท华";
-    assert_eq!(data.replace(d, repl), data);
-}
-
-#[test]
-fn test_replace_pattern() {
-    let data = "abcdαβγδabcdαβγδ";
-    assert_eq!(data.replace("dαβ", "😺😺😺"), "abc😺😺😺γδabc😺😺😺γδ");
-    assert_eq!(data.replace('γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
-    assert_eq!(data.replace(&['a', 'γ'] as &[_], "😺😺😺"), "😺😺😺bcdαβ😺😺😺δ😺😺😺bcdαβ😺😺😺δ");
-    assert_eq!(data.replace(|c| c == 'γ', "😺😺😺"), "abcdαβ😺😺😺δabcdαβ😺😺😺δ");
-}
-
-#[test]
-fn test_slice() {
-    assert_eq!("ab", &"abc"[0..2]);
-    assert_eq!("bc", &"abc"[1..3]);
-    assert_eq!("", &"abc"[1..1]);
-    assert_eq!("\u{65e5}", &"\u{65e5}\u{672c}"[0..3]);
-
-    let data = "ประเทศไทย中华";
-    assert_eq!("ป", &data[0..3]);
-    assert_eq!("ร", &data[3..6]);
-    assert_eq!("", &data[3..3]);
-    assert_eq!("华", &data[30..33]);
-
-    fn a_million_letter_x() -> String {
-        let mut i = 0;
-        let mut rs = String::new();
-        while i < 100000 {
-            rs.push_str("华华华华华华华华华华");
-            i += 1;
-        }
-        rs
-    }
-    fn half_a_million_letter_x() -> String {
-        let mut i = 0;
-        let mut rs = String::new();
-        while i < 100000 {
-            rs.push_str("华华华华华");
-            i += 1;
-        }
-        rs
-    }
-    let letters = a_million_letter_x();
-    assert_eq!(half_a_million_letter_x(), &letters[0..3 * 500000]);
-}
-
-#[test]
-fn test_slice_2() {
-    let ss = "中华Việt Nam";
-
-    assert_eq!("华", &ss[3..6]);
-    assert_eq!("Việt Nam", &ss[6..16]);
-
-    assert_eq!("ab", &"abc"[0..2]);
-    assert_eq!("bc", &"abc"[1..3]);
-    assert_eq!("", &"abc"[1..1]);
-
-    assert_eq!("中", &ss[0..3]);
-    assert_eq!("华V", &ss[3..7]);
-    assert_eq!("", &ss[3..3]);
-    /*0: 中
-      3: 华
-      6: V
-      7: i
-      8: ệ
-     11: t
-     12:
-     13: N
-     14: a
-     15: m */
-}
-
-#[test]
-#[should_panic]
-fn test_slice_fail() {
-    &"中华Việt Nam"[0..2];
-}
-
-#[test]
-#[should_panic]
-fn test_str_slice_rangetoinclusive_max_panics() {
-    &"hello"[...usize::max_value()];
-}
-
-#[test]
-#[should_panic]
-fn test_str_slice_rangeinclusive_max_panics() {
-    &"hello"[1...usize::max_value()];
-}
-
-#[test]
-#[should_panic]
-fn test_str_slicemut_rangetoinclusive_max_panics() {
-    let mut s = "hello".to_owned();
-    let s: &mut str = &mut s;
-    &mut s[...usize::max_value()];
-}
-
-#[test]
-#[should_panic]
-fn test_str_slicemut_rangeinclusive_max_panics() {
-    let mut s = "hello".to_owned();
-    let s: &mut str = &mut s;
-    &mut s[1...usize::max_value()];
-}
-
-#[test]
-fn test_str_get_maxinclusive() {
-    let mut s = "hello".to_owned();
-    {
-        let s: &str = &s;
-        assert_eq!(s.get(...usize::max_value()), None);
-        assert_eq!(s.get(1...usize::max_value()), None);
-    }
-    {
-        let s: &mut str = &mut s;
-        assert_eq!(s.get(...usize::max_value()), None);
-        assert_eq!(s.get(1...usize::max_value()), None);
-    }
-}
-
-#[test]
-fn test_is_char_boundary() {
-    let s = "ศไทย中华Việt Nam β-release 🐱123";
-    assert!(s.is_char_boundary(0));
-    assert!(s.is_char_boundary(s.len()));
-    assert!(!s.is_char_boundary(s.len() + 1));
-    for (i, ch) in s.char_indices() {
-        // ensure character locations are boundaries and continuation bytes are not
-        assert!(s.is_char_boundary(i), "{} is a char boundary in {:?}", i, s);
-        for j in 1..ch.len_utf8() {
-            assert!(!s.is_char_boundary(i + j),
-                    "{} should not be a char boundary in {:?}", i + j, s);
-        }
-    }
-}
-const LOREM_PARAGRAPH: &'static str = "\
-Lorem ipsum dolor sit amet, consectetur adipiscing elit. Suspendisse quis lorem sit amet dolor \
-ultricies condimentum. Praesent iaculis purus elit, ac malesuada quam malesuada in. Duis sed orci \
-eros. Suspendisse sit amet magna mollis, mollis nunc luctus, imperdiet mi. Integer fringilla non \
-sem ut lacinia. Fusce varius tortor a risus porttitor hendrerit. Morbi mauris dui, ultricies nec \
-tempus vel, gravida nec quam.";
-
-// check the panic includes the prefix of the sliced string
-#[test]
-#[should_panic(expected="byte index 1024 is out of bounds of `Lorem ipsum dolor sit amet")]
-fn test_slice_fail_truncated_1() {
-    &LOREM_PARAGRAPH[..1024];
-}
-// check the truncation in the panic message
-#[test]
-#[should_panic(expected="luctus, im`[...]")]
-fn test_slice_fail_truncated_2() {
-    &LOREM_PARAGRAPH[..1024];
-}
-
-#[test]
-#[should_panic(expected="byte index 4 is not a char boundary; it is inside 'α' (bytes 3..5) of")]
-fn test_slice_fail_boundary_1() {
-    &"abcαβγ"[4..];
-}
-
-#[test]
-#[should_panic(expected="byte index 6 is not a char boundary; it is inside 'β' (bytes 5..7) of")]
-fn test_slice_fail_boundary_2() {
-    &"abcαβγ"[2..6];
-}
-
-#[test]
-fn test_slice_from() {
-    assert_eq!(&"abcd"[0..], "abcd");
-    assert_eq!(&"abcd"[2..], "cd");
-    assert_eq!(&"abcd"[4..], "");
-}
-#[test]
-fn test_slice_to() {
-    assert_eq!(&"abcd"[..0], "");
-    assert_eq!(&"abcd"[..2], "ab");
-    assert_eq!(&"abcd"[..4], "abcd");
-}
-
-#[test]
-fn test_trim_left_matches() {
-    let v: &[char] = &[];
-    assert_eq!(" *** foo *** ".trim_left_matches(v), " *** foo *** ");
-    let chars: &[char] = &['*', ' '];
-    assert_eq!(" *** foo *** ".trim_left_matches(chars), "foo *** ");
-    assert_eq!(" ***  *** ".trim_left_matches(chars), "");
-    assert_eq!("foo *** ".trim_left_matches(chars), "foo *** ");
-
-    assert_eq!("11foo1bar11".trim_left_matches('1'), "foo1bar11");
-    let chars: &[char] = &['1', '2'];
-    assert_eq!("12foo1bar12".trim_left_matches(chars), "foo1bar12");
-    assert_eq!("123foo1bar123".trim_left_matches(|c: char| c.is_numeric()), "foo1bar123");
-}
-
-#[test]
-fn test_trim_right_matches() {
-    let v: &[char] = &[];
-    assert_eq!(" *** foo *** ".trim_right_matches(v), " *** foo *** ");
-    let chars: &[char] = &['*', ' '];
-    assert_eq!(" *** foo *** ".trim_right_matches(chars), " *** foo");
-    assert_eq!(" ***  *** ".trim_right_matches(chars), "");
-    assert_eq!(" *** foo".trim_right_matches(chars), " *** foo");
-
-    assert_eq!("11foo1bar11".trim_right_matches('1'), "11foo1bar");
-    let chars: &[char] = &['1', '2'];
-    assert_eq!("12foo1bar12".trim_right_matches(chars), "12foo1bar");
-    assert_eq!("123foo1bar123".trim_right_matches(|c: char| c.is_numeric()), "123foo1bar");
-}
-
-#[test]
-fn test_trim_matches() {
-    let v: &[char] = &[];
-    assert_eq!(" *** foo *** ".trim_matches(v), " *** foo *** ");
-    let chars: &[char] = &['*', ' '];
-    assert_eq!(" *** foo *** ".trim_matches(chars), "foo");
-    assert_eq!(" ***  *** ".trim_matches(chars), "");
-    assert_eq!("foo".trim_matches(chars), "foo");
-
-    assert_eq!("11foo1bar11".trim_matches('1'), "foo1bar");
-    let chars: &[char] = &['1', '2'];
-    assert_eq!("12foo1bar12".trim_matches(chars), "foo1bar");
-    assert_eq!("123foo1bar123".trim_matches(|c: char| c.is_numeric()), "foo1bar");
-}
-
-#[test]
-fn test_trim_left() {
-    assert_eq!("".trim_left(), "");
-    assert_eq!("a".trim_left(), "a");
-    assert_eq!("    ".trim_left(), "");
-    assert_eq!("     blah".trim_left(), "blah");
-    assert_eq!("   \u{3000}  wut".trim_left(), "wut");
-    assert_eq!("hey ".trim_left(), "hey ");
-}
-
-#[test]
-fn test_trim_right() {
-    assert_eq!("".trim_right(), "");
-    assert_eq!("a".trim_right(), "a");
-    assert_eq!("    ".trim_right(), "");
-    assert_eq!("blah     ".trim_right(), "blah");
-    assert_eq!("wut   \u{3000}  ".trim_right(), "wut");
-    assert_eq!(" hey".trim_right(), " hey");
-}
-
-#[test]
-fn test_trim() {
-    assert_eq!("".trim(), "");
-    assert_eq!("a".trim(), "a");
-    assert_eq!("    ".trim(), "");
-    assert_eq!("    blah     ".trim(), "blah");
-    assert_eq!("\nwut   \u{3000}  ".trim(), "wut");
-    assert_eq!(" hey dude ".trim(), "hey dude");
-}
-
-#[test]
-fn test_is_whitespace() {
-    assert!("".chars().all(|c| c.is_whitespace()));
-    assert!(" ".chars().all(|c| c.is_whitespace()));
-    assert!("\u{2009}".chars().all(|c| c.is_whitespace())); // Thin space
-    assert!("  \n\t   ".chars().all(|c| c.is_whitespace()));
-    assert!(!"   _   ".chars().all(|c| c.is_whitespace()));
-}
-
-#[test]
-fn test_is_utf8() {
-    // deny overlong encodings
-    assert!(from_utf8(&[0xc0, 0x80]).is_err());
-    assert!(from_utf8(&[0xc0, 0xae]).is_err());
-    assert!(from_utf8(&[0xe0, 0x80, 0x80]).is_err());
-    assert!(from_utf8(&[0xe0, 0x80, 0xaf]).is_err());
-    assert!(from_utf8(&[0xe0, 0x81, 0x81]).is_err());
-    assert!(from_utf8(&[0xf0, 0x82, 0x82, 0xac]).is_err());
-    assert!(from_utf8(&[0xf4, 0x90, 0x80, 0x80]).is_err());
-
-    // deny surrogates
-    assert!(from_utf8(&[0xED, 0xA0, 0x80]).is_err());
-    assert!(from_utf8(&[0xED, 0xBF, 0xBF]).is_err());
-
-    assert!(from_utf8(&[0xC2, 0x80]).is_ok());
-    assert!(from_utf8(&[0xDF, 0xBF]).is_ok());
-    assert!(from_utf8(&[0xE0, 0xA0, 0x80]).is_ok());
-    assert!(from_utf8(&[0xED, 0x9F, 0xBF]).is_ok());
-    assert!(from_utf8(&[0xEE, 0x80, 0x80]).is_ok());
-    assert!(from_utf8(&[0xEF, 0xBF, 0xBF]).is_ok());
-    assert!(from_utf8(&[0xF0, 0x90, 0x80, 0x80]).is_ok());
-    assert!(from_utf8(&[0xF4, 0x8F, 0xBF, 0xBF]).is_ok());
-}
-
-#[test]
-fn from_utf8_mostly_ascii() {
-    // deny invalid bytes embedded in long stretches of ascii
-    for i in 32..64 {
-        let mut data = [0; 128];
-        data[i] = 0xC0;
-        assert!(from_utf8(&data).is_err());
-        data[i] = 0xC2;
-        assert!(from_utf8(&data).is_err());
-    }
-}
-
-#[test]
-fn from_utf8_error() {
-    macro_rules! test {
-        ($input: expr, $expected_valid_up_to: expr, $expected_error_len: expr) => {
-            let error = from_utf8($input).unwrap_err();
-            assert_eq!(error.valid_up_to(), $expected_valid_up_to);
-            assert_eq!(error.error_len(), $expected_error_len);
-        }
-    }
-    test!(b"A\xC3\xA9 \xFF ", 4, Some(1));
-    test!(b"A\xC3\xA9 \x80 ", 4, Some(1));
-    test!(b"A\xC3\xA9 \xC1 ", 4, Some(1));
-    test!(b"A\xC3\xA9 \xC1", 4, Some(1));
-    test!(b"A\xC3\xA9 \xC2", 4, None);
-    test!(b"A\xC3\xA9 \xC2 ", 4, Some(1));
-    test!(b"A\xC3\xA9 \xC2\xC0", 4, Some(1));
-    test!(b"A\xC3\xA9 \xE0", 4, None);
-    test!(b"A\xC3\xA9 \xE0\x9F", 4, Some(1));
-    test!(b"A\xC3\xA9 \xE0\xA0", 4, None);
-    test!(b"A\xC3\xA9 \xE0\xA0\xC0", 4, Some(2));
-    test!(b"A\xC3\xA9 \xE0\xA0 ", 4, Some(2));
-    test!(b"A\xC3\xA9 \xED\xA0\x80 ", 4, Some(1));
-    test!(b"A\xC3\xA9 \xF1", 4, None);
-    test!(b"A\xC3\xA9 \xF1\x80", 4, None);
-    test!(b"A\xC3\xA9 \xF1\x80\x80", 4, None);
-    test!(b"A\xC3\xA9 \xF1 ", 4, Some(1));
-    test!(b"A\xC3\xA9 \xF1\x80 ", 4, Some(2));
-    test!(b"A\xC3\xA9 \xF1\x80\x80 ", 4, Some(3));
-}
-
-#[test]
-fn test_as_bytes() {
-    // no null
-    let v = [
-        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
-        184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
-        109
-    ];
-    let b: &[u8] = &[];
-    assert_eq!("".as_bytes(), b);
-    assert_eq!("abc".as_bytes(), b"abc");
-    assert_eq!("ศไทย中华Việt Nam".as_bytes(), v);
-}
-
-#[test]
-#[should_panic]
-fn test_as_bytes_fail() {
-    // Don't double free. (I'm not sure if this exercises the
-    // original problem code path anymore.)
-    let s = String::from("");
-    let _bytes = s.as_bytes();
-    panic!();
-}
-
-#[test]
-fn test_as_ptr() {
-    let buf = "hello".as_ptr();
-    unsafe {
-        assert_eq!(*buf.offset(0), b'h');
-        assert_eq!(*buf.offset(1), b'e');
-        assert_eq!(*buf.offset(2), b'l');
-        assert_eq!(*buf.offset(3), b'l');
-        assert_eq!(*buf.offset(4), b'o');
-    }
-}
-
-#[test]
-fn vec_str_conversions() {
-    let s1: String = String::from("All mimsy were the borogoves");
-
-    let v: Vec<u8> = s1.as_bytes().to_vec();
-    let s2: String = String::from(from_utf8(&v).unwrap());
-    let mut i = 0;
-    let n1 = s1.len();
-    let n2 = v.len();
-    assert_eq!(n1, n2);
-    while i < n1 {
-        let a: u8 = s1.as_bytes()[i];
-        let b: u8 = s2.as_bytes()[i];
-        assert_eq!(a, b);
-        i += 1;
-    }
-}
-
-#[test]
-fn test_contains() {
-    assert!("abcde".contains("bcd"));
-    assert!("abcde".contains("abcd"));
-    assert!("abcde".contains("bcde"));
-    assert!("abcde".contains(""));
-    assert!("".contains(""));
-    assert!(!"abcde".contains("def"));
-    assert!(!"".contains("a"));
-
-    let data = "ประเทศไทย中华Việt Nam";
-    assert!(data.contains("ประเ"));
-    assert!(data.contains("ะเ"));
-    assert!(data.contains("中华"));
-    assert!(!data.contains("ไท华"));
-}
-
-#[test]
-fn test_contains_char() {
-    assert!("abc".contains('b'));
-    assert!("a".contains('a'));
-    assert!(!"abc".contains('d'));
-    assert!(!"".contains('a'));
-}
-
-#[test]
-fn test_split_at() {
-    let s = "ศไทย中华Việt Nam";
-    for (index, _) in s.char_indices() {
-        let (a, b) = s.split_at(index);
-        assert_eq!(&s[..a.len()], a);
-        assert_eq!(&s[a.len()..], b);
-    }
-    let (a, b) = s.split_at(s.len());
-    assert_eq!(a, s);
-    assert_eq!(b, "");
-}
-
-#[test]
-fn test_split_at_mut() {
-    use std::ascii::AsciiExt;
-    let mut s = "Hello World".to_string();
-    {
-        let (a, b) = s.split_at_mut(5);
-        a.make_ascii_uppercase();
-        b.make_ascii_lowercase();
-    }
-    assert_eq!(s, "HELLO world");
-}
-
-#[test]
-#[should_panic]
-fn test_split_at_boundscheck() {
-    let s = "ศไทย中华Việt Nam";
-    s.split_at(1);
-}
-
-#[test]
-fn test_escape_unicode() {
-    assert_eq!("abc".escape_unicode(), "\\u{61}\\u{62}\\u{63}");
-    assert_eq!("a c".escape_unicode(), "\\u{61}\\u{20}\\u{63}");
-    assert_eq!("\r\n\t".escape_unicode(), "\\u{d}\\u{a}\\u{9}");
-    assert_eq!("'\"\\".escape_unicode(), "\\u{27}\\u{22}\\u{5c}");
-    assert_eq!("\x00\x01\u{fe}\u{ff}".escape_unicode(), "\\u{0}\\u{1}\\u{fe}\\u{ff}");
-    assert_eq!("\u{100}\u{ffff}".escape_unicode(), "\\u{100}\\u{ffff}");
-    assert_eq!("\u{10000}\u{10ffff}".escape_unicode(), "\\u{10000}\\u{10ffff}");
-    assert_eq!("ab\u{fb00}".escape_unicode(), "\\u{61}\\u{62}\\u{fb00}");
-    assert_eq!("\u{1d4ea}\r".escape_unicode(), "\\u{1d4ea}\\u{d}");
-}
-
-#[test]
-fn test_escape_debug() {
-    assert_eq!("abc".escape_debug(), "abc");
-    assert_eq!("a c".escape_debug(), "a c");
-    assert_eq!("éèê".escape_debug(), "éèê");
-    assert_eq!("\r\n\t".escape_debug(), "\\r\\n\\t");
-    assert_eq!("'\"\\".escape_debug(), "\\'\\\"\\\\");
-    assert_eq!("\u{7f}\u{ff}".escape_debug(), "\\u{7f}\u{ff}");
-    assert_eq!("\u{100}\u{ffff}".escape_debug(), "\u{100}\\u{ffff}");
-    assert_eq!("\u{10000}\u{10ffff}".escape_debug(), "\u{10000}\\u{10ffff}");
-    assert_eq!("ab\u{200b}".escape_debug(), "ab\\u{200b}");
-    assert_eq!("\u{10d4ea}\r".escape_debug(), "\\u{10d4ea}\\r");
-}
-
-#[test]
-fn test_escape_default() {
-    assert_eq!("abc".escape_default(), "abc");
-    assert_eq!("a c".escape_default(), "a c");
-    assert_eq!("éèê".escape_default(), "\\u{e9}\\u{e8}\\u{ea}");
-    assert_eq!("\r\n\t".escape_default(), "\\r\\n\\t");
-    assert_eq!("'\"\\".escape_default(), "\\'\\\"\\\\");
-    assert_eq!("\u{7f}\u{ff}".escape_default(), "\\u{7f}\\u{ff}");
-    assert_eq!("\u{100}\u{ffff}".escape_default(), "\\u{100}\\u{ffff}");
-    assert_eq!("\u{10000}\u{10ffff}".escape_default(), "\\u{10000}\\u{10ffff}");
-    assert_eq!("ab\u{200b}".escape_default(), "ab\\u{200b}");
-    assert_eq!("\u{10d4ea}\r".escape_default(), "\\u{10d4ea}\\r");
-}
-
-#[test]
-fn test_total_ord() {
-    assert_eq!("1234".cmp("123"), Greater);
-    assert_eq!("123".cmp("1234"), Less);
-    assert_eq!("1234".cmp("1234"), Equal);
-    assert_eq!("12345555".cmp("123456"), Less);
-    assert_eq!("22".cmp("1234"), Greater);
-}
-
-#[test]
-fn test_iterator() {
-    let s = "ศไทย中华Việt Nam";
-    let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
-
-    let mut pos = 0;
-    let it = s.chars();
-
-    for c in it {
-        assert_eq!(c, v[pos]);
-        pos += 1;
-    }
-    assert_eq!(pos, v.len());
-    assert_eq!(s.chars().count(), v.len());
-}
-
-#[test]
-fn test_rev_iterator() {
-    let s = "ศไทย中华Việt Nam";
-    let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
-
-    let mut pos = 0;
-    let it = s.chars().rev();
-
-    for c in it {
-        assert_eq!(c, v[pos]);
-        pos += 1;
-    }
-    assert_eq!(pos, v.len());
-}
-
-#[test]
-fn test_chars_decoding() {
-    let mut bytes = [0; 4];
-    for c in (0..0x110000).filter_map(::std::char::from_u32) {
-        let s = c.encode_utf8(&mut bytes);
-        if Some(c) != s.chars().next() {
-            panic!("character {:x}={} does not decode correctly", c as u32, c);
-        }
-    }
-}
-
-#[test]
-fn test_chars_rev_decoding() {
-    let mut bytes = [0; 4];
-    for c in (0..0x110000).filter_map(::std::char::from_u32) {
-        let s = c.encode_utf8(&mut bytes);
-        if Some(c) != s.chars().rev().next() {
-            panic!("character {:x}={} does not decode correctly", c as u32, c);
-        }
-    }
-}
-
-#[test]
-fn test_iterator_clone() {
-    let s = "ศไทย中华Việt Nam";
-    let mut it = s.chars();
-    it.next();
-    assert!(it.clone().zip(it).all(|(x,y)| x == y));
-}
-
-#[test]
-fn test_iterator_last() {
-    let s = "ศไทย中华Việt Nam";
-    let mut it = s.chars();
-    it.next();
-    assert_eq!(it.last(), Some('m'));
-}
-
-#[test]
-fn test_bytesator() {
-    let s = "ศไทย中华Việt Nam";
-    let v = [
-        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
-        184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
-        109
-    ];
-    let mut pos = 0;
-
-    for b in s.bytes() {
-        assert_eq!(b, v[pos]);
-        pos += 1;
-    }
-}
-
-#[test]
-fn test_bytes_revator() {
-    let s = "ศไทย中华Việt Nam";
-    let v = [
-        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
-        184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
-        109
-    ];
-    let mut pos = v.len();
-
-    for b in s.bytes().rev() {
-        pos -= 1;
-        assert_eq!(b, v[pos]);
-    }
-}
-
-#[test]
-fn test_bytesator_nth() {
-    let s = "ศไทย中华Việt Nam";
-    let v = [
-        224, 184, 168, 224, 185, 132, 224, 184, 151, 224, 184, 162, 228,
-        184, 173, 229, 141, 142, 86, 105, 225, 187, 135, 116, 32, 78, 97,
-        109
-    ];
-
-    let mut b = s.bytes();
-    assert_eq!(b.nth(2).unwrap(), v[2]);
-    assert_eq!(b.nth(10).unwrap(), v[10]);
-    assert_eq!(b.nth(200), None);
-}
-
-#[test]
-fn test_bytesator_count() {
-    let s = "ศไทย中华Việt Nam";
-
-    let b = s.bytes();
-    assert_eq!(b.count(), 28)
-}
-
-#[test]
-fn test_bytesator_last() {
-    let s = "ศไทย中华Việt Nam";
-
-    let b = s.bytes();
-    assert_eq!(b.last().unwrap(), 109)
-}
-
-#[test]
-fn test_char_indicesator() {
-    let s = "ศไทย中华Việt Nam";
-    let p = [0, 3, 6, 9, 12, 15, 18, 19, 20, 23, 24, 25, 26, 27];
-    let v = ['ศ','ไ','ท','ย','中','华','V','i','ệ','t',' ','N','a','m'];
-
-    let mut pos = 0;
-    let it = s.char_indices();
-
-    for c in it {
-        assert_eq!(c, (p[pos], v[pos]));
-        pos += 1;
-    }
-    assert_eq!(pos, v.len());
-    assert_eq!(pos, p.len());
-}
-
-#[test]
-fn test_char_indices_revator() {
-    let s = "ศไทย中华Việt Nam";
-    let p = [27, 26, 25, 24, 23, 20, 19, 18, 15, 12, 9, 6, 3, 0];
-    let v = ['m', 'a', 'N', ' ', 't', 'ệ','i','V','华','中','ย','ท','ไ','ศ'];
-
-    let mut pos = 0;
-    let it = s.char_indices().rev();
-
-    for c in it {
-        assert_eq!(c, (p[pos], v[pos]));
-        pos += 1;
-    }
-    assert_eq!(pos, v.len());
-    assert_eq!(pos, p.len());
-}
-
-#[test]
-fn test_char_indices_last() {
-    let s = "ศไทย中华Việt Nam";
-    let mut it = s.char_indices();
-    it.next();
-    assert_eq!(it.last(), Some((27, 'm')));
-}
-
-#[test]
-fn test_splitn_char_iterator() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let split: Vec<&str> = data.splitn(4, ' ').collect();
-    assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
-
-    let split: Vec<&str> = data.splitn(4, |c: char| c == ' ').collect();
-    assert_eq!(split, ["\nMäry", "häd", "ä", "little lämb\nLittle lämb\n"]);
-
-    // Unicode
-    let split: Vec<&str> = data.splitn(4, 'ä').collect();
-    assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
-
-    let split: Vec<&str> = data.splitn(4, |c: char| c == 'ä').collect();
-    assert_eq!(split, ["\nM", "ry h", "d ", " little lämb\nLittle lämb\n"]);
-}
-
-#[test]
-fn test_split_char_iterator_no_trailing() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let split: Vec<&str> = data.split('\n').collect();
-    assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
-
-    let split: Vec<&str> = data.split_terminator('\n').collect();
-    assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
-}
-
-#[test]
-fn test_rsplit() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let split: Vec<&str> = data.rsplit(' ').collect();
-    assert_eq!(split, ["lämb\n", "lämb\nLittle", "little", "ä", "häd", "\nMäry"]);
-
-    let split: Vec<&str> = data.rsplit("lämb").collect();
-    assert_eq!(split, ["\n", "\nLittle ", "\nMäry häd ä little "]);
-
-    let split: Vec<&str> = data.rsplit(|c: char| c == 'ä').collect();
-    assert_eq!(split, ["mb\n", "mb\nLittle l", " little l", "d ", "ry h", "\nM"]);
-}
-
-#[test]
-fn test_rsplitn() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let split: Vec<&str> = data.rsplitn(2, ' ').collect();
-    assert_eq!(split, ["lämb\n", "\nMäry häd ä little lämb\nLittle"]);
-
-    let split: Vec<&str> = data.rsplitn(2, "lämb").collect();
-    assert_eq!(split, ["\n", "\nMäry häd ä little lämb\nLittle "]);
-
-    let split: Vec<&str> = data.rsplitn(2, |c: char| c == 'ä').collect();
-    assert_eq!(split, ["mb\n", "\nMäry häd ä little lämb\nLittle l"]);
-}
-
-#[test]
-fn test_split_whitespace() {
-    let data = "\n \tMäry   häd\tä  little lämb\nLittle lämb\n";
-    let words: Vec<&str> = data.split_whitespace().collect();
-    assert_eq!(words, ["Märy", "häd", "ä", "little", "lämb", "Little", "lämb"])
-}
-
-#[test]
-fn test_lines() {
-    let data = "\nMäry häd ä little lämb\n\r\nLittle lämb\n";
-    let lines: Vec<&str> = data.lines().collect();
-    assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
-
-    let data = "\r\nMäry häd ä little lämb\n\nLittle lämb"; // no trailing \n
-    let lines: Vec<&str> = data.lines().collect();
-    assert_eq!(lines, ["", "Märy häd ä little lämb", "", "Little lämb"]);
-}
-
-#[test]
-fn test_splitator() {
-    fn t(s: &str, sep: &str, u: &[&str]) {
-        let v: Vec<&str> = s.split(sep).collect();
-        assert_eq!(v, u);
-    }
-    t("--1233345--", "12345", &["--1233345--"]);
-    t("abc::hello::there", "::", &["abc", "hello", "there"]);
-    t("::hello::there", "::", &["", "hello", "there"]);
-    t("hello::there::", "::", &["hello", "there", ""]);
-    t("::hello::there::", "::", &["", "hello", "there", ""]);
-    t("ประเทศไทย中华Việt Nam", "中华", &["ประเทศไทย", "Việt Nam"]);
-    t("zzXXXzzYYYzz", "zz", &["", "XXX", "YYY", ""]);
-    t("zzXXXzYYYz", "XXX", &["zz", "zYYYz"]);
-    t(".XXX.YYY.", ".", &["", "XXX", "YYY", ""]);
-    t("", ".", &[""]);
-    t("zz", "zz", &["",""]);
-    t("ok", "z", &["ok"]);
-    t("zzz", "zz", &["","z"]);
-    t("zzzzz", "zz", &["","","z"]);
-}
-
-#[test]
-fn test_str_default() {
-    use std::default::Default;
-
-    fn t<S: Default + AsRef<str>>() {
-        let s: S = Default::default();
-        assert_eq!(s.as_ref(), "");
-    }
-
-    t::<&str>();
-    t::<String>();
-}
-
-#[test]
-fn test_str_container() {
-    fn sum_len(v: &[&str]) -> usize {
-        v.iter().map(|x| x.len()).sum()
-    }
-
-    let s = "01234";
-    assert_eq!(5, sum_len(&["012", "", "34"]));
-    assert_eq!(5, sum_len(&["01", "2", "34", ""]));
-    assert_eq!(5, sum_len(&[s]));
-}
-
-#[test]
-fn test_str_from_utf8() {
-    let xs = b"hello";
-    assert_eq!(from_utf8(xs), Ok("hello"));
-
-    let xs = "ศไทย中华Việt Nam".as_bytes();
-    assert_eq!(from_utf8(xs), Ok("ศไทย中华Việt Nam"));
-
-    let xs = b"hello\xFF";
-    assert!(from_utf8(xs).is_err());
-}
-
-#[test]
-fn test_pattern_deref_forward() {
-    let data = "aabcdaa";
-    assert!(data.contains("bcd"));
-    assert!(data.contains(&"bcd"));
-    assert!(data.contains(&"bcd".to_string()));
-}
-
-#[test]
-fn test_empty_match_indices() {
-    let data = "aä中!";
-    let vec: Vec<_> = data.match_indices("").collect();
-    assert_eq!(vec, [(0, ""), (1, ""), (3, ""), (6, ""), (7, "")]);
-}
-
-#[test]
-fn test_bool_from_str() {
-    assert_eq!("true".parse().ok(), Some(true));
-    assert_eq!("false".parse().ok(), Some(false));
-    assert_eq!("not even a boolean".parse::<bool>().ok(), None);
-}
-
-fn check_contains_all_substrings(s: &str) {
-    assert!(s.contains(""));
-    for i in 0..s.len() {
-        for j in i+1..s.len() + 1 {
-            assert!(s.contains(&s[i..j]));
-        }
-    }
-}
-
-#[test]
-fn strslice_issue_16589() {
-    assert!("bananas".contains("nana"));
-
-    // prior to the fix for #16589, x.contains("abcdabcd") returned false
-    // test all substrings for good measure
-    check_contains_all_substrings("012345678901234567890123456789bcdabcdabcd");
-}
-
-#[test]
-fn strslice_issue_16878() {
-    assert!(!"1234567ah012345678901ah".contains("hah"));
-    assert!(!"00abc01234567890123456789abc".contains("bcabc"));
-}
-
-
-#[test]
-fn test_strslice_contains() {
-    let x = "There are moments, Jeeves, when one asks oneself, 'Do trousers matter?'";
-    check_contains_all_substrings(x);
-}
-
-#[test]
-fn test_rsplitn_char_iterator() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let mut split: Vec<&str> = data.rsplitn(4, ' ').collect();
-    split.reverse();
-    assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == ' ').collect();
-    split.reverse();
-    assert_eq!(split, ["\nMäry häd ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    // Unicode
-    let mut split: Vec<&str> = data.rsplitn(4, 'ä').collect();
-    split.reverse();
-    assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
-
-    let mut split: Vec<&str> = data.rsplitn(4, |c: char| c == 'ä').collect();
-    split.reverse();
-    assert_eq!(split, ["\nMäry häd ", " little l", "mb\nLittle l", "mb\n"]);
-}
-
-#[test]
-fn test_split_char_iterator() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let split: Vec<&str> = data.split(' ').collect();
-    assert_eq!( split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    let mut rsplit: Vec<&str> = data.split(' ').rev().collect();
-    rsplit.reverse();
-    assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    let split: Vec<&str> = data.split(|c: char| c == ' ').collect();
-    assert_eq!( split, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    let mut rsplit: Vec<&str> = data.split(|c: char| c == ' ').rev().collect();
-    rsplit.reverse();
-    assert_eq!(rsplit, ["\nMäry", "häd", "ä", "little", "lämb\nLittle", "lämb\n"]);
-
-    // Unicode
-    let split: Vec<&str> = data.split('ä').collect();
-    assert_eq!( split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
-
-    let mut rsplit: Vec<&str> = data.split('ä').rev().collect();
-    rsplit.reverse();
-    assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
-
-    let split: Vec<&str> = data.split(|c: char| c == 'ä').collect();
-    assert_eq!( split, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
-
-    let mut rsplit: Vec<&str> = data.split(|c: char| c == 'ä').rev().collect();
-    rsplit.reverse();
-    assert_eq!(rsplit, ["\nM", "ry h", "d ", " little l", "mb\nLittle l", "mb\n"]);
-}
-
-#[test]
-fn test_rev_split_char_iterator_no_trailing() {
-    let data = "\nMäry häd ä little lämb\nLittle lämb\n";
-
-    let mut split: Vec<&str> = data.split('\n').rev().collect();
-    split.reverse();
-    assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb", ""]);
-
-    let mut split: Vec<&str> = data.split_terminator('\n').rev().collect();
-    split.reverse();
-    assert_eq!(split, ["", "Märy häd ä little lämb", "Little lämb"]);
-}
-
-#[test]
-fn test_utf16_code_units() {
-    use std_unicode::str::Utf16Encoder;
-    assert_eq!(Utf16Encoder::new(vec!['é', '\u{1F4A9}'].into_iter()).collect::<Vec<u16>>(),
-               [0xE9, 0xD83D, 0xDCA9])
-}
-
-#[test]
-fn starts_with_in_unicode() {
-    assert!(!"├── Cargo.toml".starts_with("# "));
-}
-
-#[test]
-fn starts_short_long() {
-    assert!(!"".starts_with("##"));
-    assert!(!"##".starts_with("####"));
-    assert!("####".starts_with("##"));
-    assert!(!"##ä".starts_with("####"));
-    assert!("####ä".starts_with("##"));
-    assert!(!"##".starts_with("####ä"));
-    assert!("##ä##".starts_with("##ä"));
-
-    assert!("".starts_with(""));
-    assert!("ä".starts_with(""));
-    assert!("#ä".starts_with(""));
-    assert!("##ä".starts_with(""));
-    assert!("ä###".starts_with(""));
-    assert!("#ä##".starts_with(""));
-    assert!("##ä#".starts_with(""));
-}
-
-#[test]
-fn contains_weird_cases() {
-    assert!("* \t".contains(' '));
-    assert!(!"* \t".contains('?'));
-    assert!(!"* \t".contains('\u{1F4A9}'));
-}
-
-#[test]
-fn trim_ws() {
-    assert_eq!(" \t  a \t  ".trim_left_matches(|c: char| c.is_whitespace()),
-                    "a \t  ");
-    assert_eq!(" \t  a \t  ".trim_right_matches(|c: char| c.is_whitespace()),
-               " \t  a");
-    assert_eq!(" \t  a \t  ".trim_matches(|c: char| c.is_whitespace()),
-                    "a");
-    assert_eq!(" \t   \t  ".trim_left_matches(|c: char| c.is_whitespace()),
-                         "");
-    assert_eq!(" \t   \t  ".trim_right_matches(|c: char| c.is_whitespace()),
-               "");
-    assert_eq!(" \t   \t  ".trim_matches(|c: char| c.is_whitespace()),
-               "");
-}
-
-#[test]
-fn to_lowercase() {
-    assert_eq!("".to_lowercase(), "");
-    assert_eq!("AÉDžaé ".to_lowercase(), "aédžaé ");
-
-    // https://github.com/rust-lang/rust/issues/26035
-    assert_eq!("ΑΣ".to_lowercase(), "ας");
-    assert_eq!("Α'Σ".to_lowercase(), "α'ς");
-    assert_eq!("Α''Σ".to_lowercase(), "α''ς");
-
-    assert_eq!("ΑΣ Α".to_lowercase(), "ας α");
-    assert_eq!("Α'Σ Α".to_lowercase(), "α'ς α");
-    assert_eq!("Α''Σ Α".to_lowercase(), "α''ς α");
-
-    assert_eq!("ΑΣ' Α".to_lowercase(), "ας' α");
-    assert_eq!("ΑΣ'' Α".to_lowercase(), "ας'' α");
-
-    assert_eq!("Α'Σ' Α".to_lowercase(), "α'ς' α");
-    assert_eq!("Α''Σ'' Α".to_lowercase(), "α''ς'' α");
-
-    assert_eq!("Α Σ".to_lowercase(), "α σ");
-    assert_eq!("Α 'Σ".to_lowercase(), "α 'σ");
-    assert_eq!("Α ''Σ".to_lowercase(), "α ''σ");
-
-    assert_eq!("Σ".to_lowercase(), "σ");
-    assert_eq!("'Σ".to_lowercase(), "'σ");
-    assert_eq!("''Σ".to_lowercase(), "''σ");
-
-    assert_eq!("ΑΣΑ".to_lowercase(), "ασα");
-    assert_eq!("ΑΣ'Α".to_lowercase(), "ασ'α");
-    assert_eq!("ΑΣ''Α".to_lowercase(), "ασ''α");
-}
-
-#[test]
-fn to_uppercase() {
-    assert_eq!("".to_uppercase(), "");
-    assert_eq!("aéDžßfiᾀ".to_uppercase(), "AÉDŽSSFIἈΙ");
-}
-
-#[test]
-fn test_into_string() {
-    // The only way to acquire a Box<str> in the first place is through a String, so just
-    // test that we can round-trip between Box<str> and String.
-    let string = String::from("Some text goes here");
-    assert_eq!(string.clone().into_boxed_str().into_string(), string);
-}
-
-#[test]
-fn test_box_slice_clone() {
-    let data = String::from("hello HELLO hello HELLO yes YES 5 中ä华!!!");
-    let data2 = data.clone().into_boxed_str().clone().into_string();
-
-    assert_eq!(data, data2);
-}
-
-#[test]
-fn test_cow_from() {
-    let borrowed = "borrowed";
-    let owned = String::from("owned");
-    match (Cow::from(owned.clone()), Cow::from(borrowed)) {
-        (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
-        _ => panic!("invalid `Cow::from`"),
-    }
-}
-
-#[test]
-fn test_repeat() {
-    assert_eq!("".repeat(3), "");
-    assert_eq!("abc".repeat(0), "");
-    assert_eq!("α".repeat(3), "ααα");
-}
-
-mod pattern {
-    use std::str::pattern::Pattern;
-    use std::str::pattern::{Searcher, ReverseSearcher};
-    use std::str::pattern::SearchStep::{self, Match, Reject, Done};
-
-    macro_rules! make_test {
-        ($name:ident, $p:expr, $h:expr, [$($e:expr,)*]) => {
-            #[allow(unused_imports)]
-            mod $name {
-                use std::str::pattern::SearchStep::{Match, Reject};
-                use super::{cmp_search_to_vec};
-                #[test]
-                fn fwd() {
-                    cmp_search_to_vec(false, $p, $h, vec![$($e),*]);
-                }
-                #[test]
-                fn bwd() {
-                    cmp_search_to_vec(true, $p, $h, vec![$($e),*]);
-                }
-            }
-        }
-    }
-
-    fn cmp_search_to_vec<'a, P: Pattern<'a>>(rev: bool, pat: P, haystack: &'a str,
-                                             right: Vec<SearchStep>)
-    where P::Searcher: ReverseSearcher<'a>
-    {
-        let mut searcher = pat.into_searcher(haystack);
-        let mut v = vec![];
-        loop {
-            match if !rev {searcher.next()} else {searcher.next_back()} {
-                Match(a, b) => v.push(Match(a, b)),
-                Reject(a, b) => v.push(Reject(a, b)),
-                Done => break,
-            }
-        }
-        if rev {
-            v.reverse();
-        }
-
-        let mut first_index = 0;
-        let mut err = None;
-
-        for (i, e) in right.iter().enumerate() {
-            match *e {
-                Match(a, b) | Reject(a, b)
-                if a <= b && a == first_index => {
-                    first_index = b;
-                }
-                _ => {
-                    err = Some(i);
-                    break;
-                }
-            }
-        }
-
-        if let Some(err) = err {
-            panic!("Input skipped range at {}", err);
-        }
-
-        if first_index != haystack.len() {
-            panic!("Did not cover whole input");
-        }
-
-        assert_eq!(v, right);
-    }
-
-    make_test!(str_searcher_ascii_haystack, "bb", "abbcbbd", [
-        Reject(0, 1),
-        Match (1, 3),
-        Reject(3, 4),
-        Match (4, 6),
-        Reject(6, 7),
-    ]);
-    make_test!(str_searcher_ascii_haystack_seq, "bb", "abbcbbbbd", [
-        Reject(0, 1),
-        Match (1, 3),
-        Reject(3, 4),
-        Match (4, 6),
-        Match (6, 8),
-        Reject(8, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_ascii_haystack, "", "abbcbbd", [
-        Match (0, 0),
-        Reject(0, 1),
-        Match (1, 1),
-        Reject(1, 2),
-        Match (2, 2),
-        Reject(2, 3),
-        Match (3, 3),
-        Reject(3, 4),
-        Match (4, 4),
-        Reject(4, 5),
-        Match (5, 5),
-        Reject(5, 6),
-        Match (6, 6),
-        Reject(6, 7),
-        Match (7, 7),
-    ]);
-    make_test!(str_searcher_mulibyte_haystack, " ", "├──", [
-        Reject(0, 3),
-        Reject(3, 6),
-        Reject(6, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_mulibyte_haystack, "", "├──", [
-        Match (0, 0),
-        Reject(0, 3),
-        Match (3, 3),
-        Reject(3, 6),
-        Match (6, 6),
-        Reject(6, 9),
-        Match (9, 9),
-    ]);
-    make_test!(str_searcher_empty_needle_empty_haystack, "", "", [
-        Match(0, 0),
-    ]);
-    make_test!(str_searcher_nonempty_needle_empty_haystack, "├", "", [
-    ]);
-    make_test!(char_searcher_ascii_haystack, 'b', "abbcbbd", [
-        Reject(0, 1),
-        Match (1, 2),
-        Match (2, 3),
-        Reject(3, 4),
-        Match (4, 5),
-        Match (5, 6),
-        Reject(6, 7),
-    ]);
-    make_test!(char_searcher_mulibyte_haystack, ' ', "├──", [
-        Reject(0, 3),
-        Reject(3, 6),
-        Reject(6, 9),
-    ]);
-    make_test!(char_searcher_short_haystack, '\u{1F4A9}', "* \t", [
-        Reject(0, 1),
-        Reject(1, 2),
-        Reject(2, 3),
-    ]);
-
-}
-
-macro_rules! generate_iterator_test {
-    {
-        $name:ident {
-            $(
-                ($($arg:expr),*) -> [$($t:tt)*];
-            )*
-        }
-        with $fwd:expr, $bwd:expr;
-    } => {
-        #[test]
-        fn $name() {
-            $(
-                {
-                    let res = vec![$($t)*];
-
-                    let fwd_vec: Vec<_> = ($fwd)($($arg),*).collect();
-                    assert_eq!(fwd_vec, res);
-
-                    let mut bwd_vec: Vec<_> = ($bwd)($($arg),*).collect();
-                    bwd_vec.reverse();
-                    assert_eq!(bwd_vec, res);
-                }
-            )*
-        }
-    };
-    {
-        $name:ident {
-            $(
-                ($($arg:expr),*) -> [$($t:tt)*];
-            )*
-        }
-        with $fwd:expr;
-    } => {
-        #[test]
-        fn $name() {
-            $(
-                {
-                    let res = vec![$($t)*];
-
-                    let fwd_vec: Vec<_> = ($fwd)($($arg),*).collect();
-                    assert_eq!(fwd_vec, res);
-                }
-            )*
-        }
-    }
-}
-
-generate_iterator_test! {
-    double_ended_split {
-        ("foo.bar.baz", '.') -> ["foo", "bar", "baz"];
-        ("foo::bar::baz", "::") -> ["foo", "bar", "baz"];
-    }
-    with str::split, str::rsplit;
-}
-
-generate_iterator_test! {
-    double_ended_split_terminator {
-        ("foo;bar;baz;", ';') -> ["foo", "bar", "baz"];
-    }
-    with str::split_terminator, str::rsplit_terminator;
-}
-
-generate_iterator_test! {
-    double_ended_matches {
-        ("a1b2c3", char::is_numeric) -> ["1", "2", "3"];
-    }
-    with str::matches, str::rmatches;
-}
-
-generate_iterator_test! {
-    double_ended_match_indices {
-        ("a1b2c3", char::is_numeric) -> [(1, "1"), (3, "2"), (5, "3")];
-    }
-    with str::match_indices, str::rmatch_indices;
-}
-
-generate_iterator_test! {
-    not_double_ended_splitn {
-        ("foo::bar::baz", 2, "::") -> ["foo", "bar::baz"];
-    }
-    with str::splitn;
-}
-
-generate_iterator_test! {
-    not_double_ended_rsplitn {
-        ("foo::bar::baz", 2, "::") -> ["baz", "foo::bar"];
-    }
-    with str::rsplitn;
-}
-
-#[test]
-fn different_str_pattern_forwarding_lifetimes() {
-    use std::str::pattern::Pattern;
-
-    fn foo<'a, P>(p: P) where for<'b> &'b P: Pattern<'a> {
-        for _ in 0..3 {
-            "asdf".find(&p);
-        }
-    }
-
-    foo::<&str>("x");
-}
diff --git a/src/libcollections/tests/string.rs b/src/libcollections/tests/string.rs
deleted file mode 100644
index b1731b2a5dc..00000000000
--- a/src/libcollections/tests/string.rs
+++ /dev/null
@@ -1,498 +0,0 @@
-// Copyright 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.
-
-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)
-    }
-}
-
-impl<'a> IntoCow<'a, str> for &'a str {
-    fn into_cow(self) -> Cow<'a, str> {
-        Cow::Borrowed(self)
-    }
-}
-
-#[test]
-fn test_from_str() {
-    let owned: Option<::std::string::String> = "string".parse().ok();
-    assert_eq!(owned.as_ref().map(|s| &**s), Some("string"));
-}
-
-#[test]
-fn test_from_cow_str() {
-    assert_eq!(String::from(Cow::Borrowed("string")), "string");
-    assert_eq!(String::from(Cow::Owned(String::from("string"))), "string");
-}
-
-#[test]
-fn test_unsized_to_string() {
-    let s: &str = "abc";
-    let _: String = (*s).to_string();
-}
-
-#[test]
-fn test_from_utf8() {
-    let xs = b"hello".to_vec();
-    assert_eq!(String::from_utf8(xs).unwrap(), String::from("hello"));
-
-    let xs = "ศไทย中华Việt Nam".as_bytes().to_vec();
-    assert_eq!(String::from_utf8(xs).unwrap(),
-               String::from("ศไทย中华Việt Nam"));
-
-    let xs = b"hello\xFF".to_vec();
-    let err = String::from_utf8(xs).unwrap_err();
-    assert_eq!(err.into_bytes(), b"hello\xff".to_vec());
-}
-
-#[test]
-fn test_from_utf8_lossy() {
-    let xs = b"hello";
-    let ys: Cow<str> = "hello".into_cow();
-    assert_eq!(String::from_utf8_lossy(xs), ys);
-
-    let xs = "ศไทย中华Việt Nam".as_bytes();
-    let ys: Cow<str> = "ศไทย中华Việt Nam".into_cow();
-    assert_eq!(String::from_utf8_lossy(xs), ys);
-
-    let xs = b"Hello\xC2 There\xFF Goodbye";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("Hello\u{FFFD} There\u{FFFD} Goodbye").into_cow());
-
-    let xs = b"Hello\xC0\x80 There\xE6\x83 Goodbye";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("Hello\u{FFFD}\u{FFFD} There\u{FFFD} Goodbye").into_cow());
-
-    let xs = b"\xF5foo\xF5\x80bar";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("\u{FFFD}foo\u{FFFD}\u{FFFD}bar").into_cow());
-
-    let xs = b"\xF1foo\xF1\x80bar\xF1\x80\x80baz";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}baz").into_cow());
-
-    let xs = b"\xF4foo\xF4\x80bar\xF4\xBFbaz";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("\u{FFFD}foo\u{FFFD}bar\u{FFFD}\u{FFFD}baz").into_cow());
-
-    let xs = b"\xF0\x80\x80\x80foo\xF0\x90\x80\x80bar";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("\u{FFFD}\u{FFFD}\u{FFFD}\u{FFFD}foo\u{10000}bar").into_cow());
-
-    // surrogates
-    let xs = b"\xED\xA0\x80foo\xED\xBF\xBFbar";
-    assert_eq!(String::from_utf8_lossy(xs),
-               String::from("\u{FFFD}\u{FFFD}\u{FFFD}foo\u{FFFD}\u{FFFD}\u{FFFD}bar").into_cow());
-}
-
-#[test]
-fn test_from_utf16() {
-    let pairs = [(String::from("𐍅𐌿𐌻𐍆𐌹𐌻𐌰\n"),
-                  vec![0xd800, 0xdf45, 0xd800, 0xdf3f, 0xd800, 0xdf3b, 0xd800, 0xdf46, 0xd800,
-                       0xdf39, 0xd800, 0xdf3b, 0xd800, 0xdf30, 0x000a]),
-
-                 (String::from("𐐒𐑉𐐮𐑀𐐲𐑋 𐐏𐐲𐑍\n"),
-                  vec![0xd801, 0xdc12, 0xd801, 0xdc49, 0xd801, 0xdc2e, 0xd801, 0xdc40, 0xd801,
-                       0xdc32, 0xd801, 0xdc4b, 0x0020, 0xd801, 0xdc0f, 0xd801, 0xdc32, 0xd801,
-                       0xdc4d, 0x000a]),
-
-                 (String::from("𐌀𐌖𐌋𐌄𐌑𐌉·𐌌𐌄𐌕𐌄𐌋𐌉𐌑\n"),
-                  vec![0xd800, 0xdf00, 0xd800, 0xdf16, 0xd800, 0xdf0b, 0xd800, 0xdf04, 0xd800,
-                       0xdf11, 0xd800, 0xdf09, 0x00b7, 0xd800, 0xdf0c, 0xd800, 0xdf04, 0xd800,
-                       0xdf15, 0xd800, 0xdf04, 0xd800, 0xdf0b, 0xd800, 0xdf09, 0xd800, 0xdf11,
-                       0x000a]),
-
-                 (String::from("𐒋𐒘𐒈𐒑𐒛𐒒 𐒕𐒓 𐒈𐒚𐒍 𐒏𐒜𐒒𐒖𐒆 𐒕𐒆\n"),
-                  vec![0xd801, 0xdc8b, 0xd801, 0xdc98, 0xd801, 0xdc88, 0xd801, 0xdc91, 0xd801,
-                       0xdc9b, 0xd801, 0xdc92, 0x0020, 0xd801, 0xdc95, 0xd801, 0xdc93, 0x0020,
-                       0xd801, 0xdc88, 0xd801, 0xdc9a, 0xd801, 0xdc8d, 0x0020, 0xd801, 0xdc8f,
-                       0xd801, 0xdc9c, 0xd801, 0xdc92, 0xd801, 0xdc96, 0xd801, 0xdc86, 0x0020,
-                       0xd801, 0xdc95, 0xd801, 0xdc86, 0x000a]),
-                 // Issue #12318, even-numbered non-BMP planes
-                 (String::from("\u{20000}"), vec![0xD840, 0xDC00])];
-
-    for p in &pairs {
-        let (s, u) = (*p).clone();
-        let s_as_utf16 = s.encode_utf16().collect::<Vec<u16>>();
-        let u_as_string = String::from_utf16(&u).unwrap();
-
-        assert!(::std_unicode::char::decode_utf16(u.iter().cloned()).all(|r| r.is_ok()));
-        assert_eq!(s_as_utf16, u);
-
-        assert_eq!(u_as_string, s);
-        assert_eq!(String::from_utf16_lossy(&u), s);
-
-        assert_eq!(String::from_utf16(&s_as_utf16).unwrap(), s);
-        assert_eq!(u_as_string.encode_utf16().collect::<Vec<u16>>(), u);
-    }
-}
-
-#[test]
-fn test_utf16_invalid() {
-    // completely positive cases tested above.
-    // lead + eof
-    assert!(String::from_utf16(&[0xD800]).is_err());
-    // lead + lead
-    assert!(String::from_utf16(&[0xD800, 0xD800]).is_err());
-
-    // isolated trail
-    assert!(String::from_utf16(&[0x0061, 0xDC00]).is_err());
-
-    // general
-    assert!(String::from_utf16(&[0xD800, 0xd801, 0xdc8b, 0xD800]).is_err());
-}
-
-#[test]
-fn test_from_utf16_lossy() {
-    // completely positive cases tested above.
-    // lead + eof
-    assert_eq!(String::from_utf16_lossy(&[0xD800]),
-               String::from("\u{FFFD}"));
-    // lead + lead
-    assert_eq!(String::from_utf16_lossy(&[0xD800, 0xD800]),
-               String::from("\u{FFFD}\u{FFFD}"));
-
-    // isolated trail
-    assert_eq!(String::from_utf16_lossy(&[0x0061, 0xDC00]),
-               String::from("a\u{FFFD}"));
-
-    // general
-    assert_eq!(String::from_utf16_lossy(&[0xD800, 0xd801, 0xdc8b, 0xD800]),
-               String::from("\u{FFFD}𐒋\u{FFFD}"));
-}
-
-#[test]
-fn test_push_bytes() {
-    let mut s = String::from("ABC");
-    unsafe {
-        let mv = s.as_mut_vec();
-        mv.extend_from_slice(&[b'D']);
-    }
-    assert_eq!(s, "ABCD");
-}
-
-#[test]
-fn test_push_str() {
-    let mut s = String::new();
-    s.push_str("");
-    assert_eq!(&s[0..], "");
-    s.push_str("abc");
-    assert_eq!(&s[0..], "abc");
-    s.push_str("ประเทศไทย中华Việt Nam");
-    assert_eq!(&s[0..], "abcประเทศไทย中华Việt Nam");
-}
-
-#[test]
-fn test_add_assign() {
-    let mut s = String::new();
-    s += "";
-    assert_eq!(s.as_str(), "");
-    s += "abc";
-    assert_eq!(s.as_str(), "abc");
-    s += "ประเทศไทย中华Việt Nam";
-    assert_eq!(s.as_str(), "abcประเทศไทย中华Việt Nam");
-}
-
-#[test]
-fn test_push() {
-    let mut data = String::from("ประเทศไทย中");
-    data.push('华');
-    data.push('b'); // 1 byte
-    data.push('¢'); // 2 byte
-    data.push('€'); // 3 byte
-    data.push('𤭢'); // 4 byte
-    assert_eq!(data, "ประเทศไทย中华b¢€𤭢");
-}
-
-#[test]
-fn test_pop() {
-    let mut data = String::from("ประเทศไทย中华b¢€𤭢");
-    assert_eq!(data.pop().unwrap(), '𤭢'); // 4 bytes
-    assert_eq!(data.pop().unwrap(), '€'); // 3 bytes
-    assert_eq!(data.pop().unwrap(), '¢'); // 2 bytes
-    assert_eq!(data.pop().unwrap(), 'b'); // 1 bytes
-    assert_eq!(data.pop().unwrap(), '华');
-    assert_eq!(data, "ประเทศไทย中");
-}
-
-#[test]
-fn test_split_off_empty() {
-    let orig = "Hello, world!";
-    let mut split = String::from(orig);
-    let empty: String = split.split_off(orig.len());
-    assert!(empty.is_empty());
-}
-
-#[test]
-#[should_panic]
-fn test_split_off_past_end() {
-    let orig = "Hello, world!";
-    let mut split = String::from(orig);
-    split.split_off(orig.len() + 1);
-}
-
-#[test]
-#[should_panic]
-fn test_split_off_mid_char() {
-    let mut orig = String::from("山");
-    orig.split_off(1);
-}
-
-#[test]
-fn test_split_off_ascii() {
-    let mut ab = String::from("ABCD");
-    let cd = ab.split_off(2);
-    assert_eq!(ab, "AB");
-    assert_eq!(cd, "CD");
-}
-
-#[test]
-fn test_split_off_unicode() {
-    let mut nihon = String::from("日本語");
-    let go = nihon.split_off("日本".len());
-    assert_eq!(nihon, "日本");
-    assert_eq!(go, "語");
-}
-
-#[test]
-fn test_str_truncate() {
-    let mut s = String::from("12345");
-    s.truncate(5);
-    assert_eq!(s, "12345");
-    s.truncate(3);
-    assert_eq!(s, "123");
-    s.truncate(0);
-    assert_eq!(s, "");
-
-    let mut s = String::from("12345");
-    let p = s.as_ptr();
-    s.truncate(3);
-    s.push_str("6");
-    let p_ = s.as_ptr();
-    assert_eq!(p_, p);
-}
-
-#[test]
-fn test_str_truncate_invalid_len() {
-    let mut s = String::from("12345");
-    s.truncate(6);
-    assert_eq!(s, "12345");
-}
-
-#[test]
-#[should_panic]
-fn test_str_truncate_split_codepoint() {
-    let mut s = String::from("\u{FC}"); // ü
-    s.truncate(1);
-}
-
-#[test]
-fn test_str_clear() {
-    let mut s = String::from("12345");
-    s.clear();
-    assert_eq!(s.len(), 0);
-    assert_eq!(s, "");
-}
-
-#[test]
-fn test_str_add() {
-    let a = String::from("12345");
-    let b = a + "2";
-    let b = b + "2";
-    assert_eq!(b.len(), 7);
-    assert_eq!(b, "1234522");
-}
-
-#[test]
-fn remove() {
-    let mut s = "ศไทย中华Việt Nam; foobar".to_string();
-    assert_eq!(s.remove(0), 'ศ');
-    assert_eq!(s.len(), 33);
-    assert_eq!(s, "ไทย中华Việt Nam; foobar");
-    assert_eq!(s.remove(17), 'ệ');
-    assert_eq!(s, "ไทย中华Vit Nam; foobar");
-}
-
-#[test]
-#[should_panic]
-fn remove_bad() {
-    "ศ".to_string().remove(1);
-}
-
-#[test]
-fn insert() {
-    let mut s = "foobar".to_string();
-    s.insert(0, 'ệ');
-    assert_eq!(s, "ệfoobar");
-    s.insert(6, 'ย');
-    assert_eq!(s, "ệfooยbar");
-}
-
-#[test]
-#[should_panic]
-fn insert_bad1() {
-    "".to_string().insert(1, 't');
-}
-#[test]
-#[should_panic]
-fn insert_bad2() {
-    "ệ".to_string().insert(1, 't');
-}
-
-#[test]
-fn test_slicing() {
-    let s = "foobar".to_string();
-    assert_eq!("foobar", &s[..]);
-    assert_eq!("foo", &s[..3]);
-    assert_eq!("bar", &s[3..]);
-    assert_eq!("oob", &s[1..4]);
-}
-
-#[test]
-fn test_simple_types() {
-    assert_eq!(1.to_string(), "1");
-    assert_eq!((-1).to_string(), "-1");
-    assert_eq!(200.to_string(), "200");
-    assert_eq!(2.to_string(), "2");
-    assert_eq!(true.to_string(), "true");
-    assert_eq!(false.to_string(), "false");
-    assert_eq!(("hi".to_string()).to_string(), "hi");
-}
-
-#[test]
-fn test_vectors() {
-    let x: Vec<i32> = vec![];
-    assert_eq!(format!("{:?}", x), "[]");
-    assert_eq!(format!("{:?}", vec![1]), "[1]");
-    assert_eq!(format!("{:?}", vec![1, 2, 3]), "[1, 2, 3]");
-    assert!(format!("{:?}", vec![vec![], vec![1], vec![1, 1]]) == "[[], [1], [1, 1]]");
-}
-
-#[test]
-fn test_from_iterator() {
-    let s = "ศไทย中华Việt Nam".to_string();
-    let t = "ศไทย中华";
-    let u = "Việt Nam";
-
-    let a: String = s.chars().collect();
-    assert_eq!(s, a);
-
-    let mut b = t.to_string();
-    b.extend(u.chars());
-    assert_eq!(s, b);
-
-    let c: String = vec![t, u].into_iter().collect();
-    assert_eq!(s, c);
-
-    let mut d = t.to_string();
-    d.extend(vec![u]);
-    assert_eq!(s, d);
-}
-
-#[test]
-fn test_drain() {
-    let mut s = String::from("αβγ");
-    assert_eq!(s.drain(2..4).collect::<String>(), "β");
-    assert_eq!(s, "αγ");
-
-    let mut t = String::from("abcd");
-    t.drain(..0);
-    assert_eq!(t, "abcd");
-    t.drain(..1);
-    assert_eq!(t, "bcd");
-    t.drain(3..);
-    assert_eq!(t, "bcd");
-    t.drain(..);
-    assert_eq!(t, "");
-}
-
-#[test]
-fn test_splice() {
-    let mut s = "Hello, world!".to_owned();
-    let t: String = s.splice(7..12, "世界").collect();
-    assert_eq!(s, "Hello, 世界!");
-    assert_eq!(t, "world");
-}
-
-#[test]
-#[should_panic]
-fn test_splice_char_boundary() {
-    let mut s = "Hello, 世界!".to_owned();
-    s.splice(..8, "");
-}
-
-#[test]
-fn test_splice_inclusive_range() {
-    let mut v = String::from("12345");
-    let t: String = v.splice(2...3, "789").collect();
-    assert_eq!(v, "127895");
-    assert_eq!(t, "34");
-    let t2: String = v.splice(1...2, "A").collect();
-    assert_eq!(v, "1A895");
-    assert_eq!(t2, "27");
-}
-
-#[test]
-#[should_panic]
-fn test_splice_out_of_bounds() {
-    let mut s = String::from("12345");
-    s.splice(5..6, "789");
-}
-
-#[test]
-#[should_panic]
-fn test_splice_inclusive_out_of_bounds() {
-    let mut s = String::from("12345");
-    s.splice(5...5, "789");
-}
-
-#[test]
-fn test_splice_empty() {
-    let mut s = String::from("12345");
-    let t: String = s.splice(1..2, "").collect();
-    assert_eq!(s, "1345");
-    assert_eq!(t, "2");
-}
-
-#[test]
-fn test_splice_unbounded() {
-    let mut s = String::from("12345");
-    let t: String = s.splice(.., "").collect();
-    assert_eq!(s, "");
-    assert_eq!(t, "12345");
-}
-
-#[test]
-fn test_splice_forget() {
-    let mut s = String::from("12345");
-    ::std::mem::forget(s.splice(2..4, "789"));
-    assert_eq!(s, "12345");
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut a = "foo".to_string();
-    a.extend(&['b', 'a', 'r']);
-
-    assert_eq!(&a, "foobar");
-}
-
-#[test]
-fn test_into_boxed_str() {
-    let xs = String::from("hello my name is bob");
-    let ys = xs.into_boxed_str();
-    assert_eq!(&*ys, "hello my name is bob");
-}
diff --git a/src/libcollections/tests/vec.rs b/src/libcollections/tests/vec.rs
deleted file mode 100644
index fdf453b39cf..00000000000
--- a/src/libcollections/tests/vec.rs
+++ /dev/null
@@ -1,798 +0,0 @@
-// Copyright 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.
-
-use std::ascii::AsciiExt;
-use std::borrow::Cow;
-use std::mem::size_of;
-use std::panic;
-use std::vec::{Drain, IntoIter};
-
-struct DropCounter<'a> {
-    count: &'a mut u32,
-}
-
-impl<'a> Drop for DropCounter<'a> {
-    fn drop(&mut self) {
-        *self.count += 1;
-    }
-}
-
-#[test]
-fn test_small_vec_struct() {
-    assert!(size_of::<Vec<u8>>() == size_of::<usize>() * 3);
-}
-
-#[test]
-fn test_double_drop() {
-    struct TwoVec<T> {
-        x: Vec<T>,
-        y: Vec<T>,
-    }
-
-    let (mut count_x, mut count_y) = (0, 0);
-    {
-        let mut tv = TwoVec {
-            x: Vec::new(),
-            y: Vec::new(),
-        };
-        tv.x.push(DropCounter { count: &mut count_x });
-        tv.y.push(DropCounter { count: &mut count_y });
-
-        // If Vec had a drop flag, here is where it would be zeroed.
-        // Instead, it should rely on its internal state to prevent
-        // doing anything significant when dropped multiple times.
-        drop(tv.x);
-
-        // Here tv goes out of scope, tv.y should be dropped, but not tv.x.
-    }
-
-    assert_eq!(count_x, 1);
-    assert_eq!(count_y, 1);
-}
-
-#[test]
-fn test_reserve() {
-    let mut v = Vec::new();
-    assert_eq!(v.capacity(), 0);
-
-    v.reserve(2);
-    assert!(v.capacity() >= 2);
-
-    for i in 0..16 {
-        v.push(i);
-    }
-
-    assert!(v.capacity() >= 16);
-    v.reserve(16);
-    assert!(v.capacity() >= 32);
-
-    v.push(16);
-
-    v.reserve(16);
-    assert!(v.capacity() >= 33)
-}
-
-#[test]
-fn test_extend() {
-    let mut v = Vec::new();
-    let mut w = Vec::new();
-
-    v.extend(w.clone());
-    assert_eq!(v, &[]);
-
-    v.extend(0..3);
-    for i in 0..3 {
-        w.push(i)
-    }
-
-    assert_eq!(v, w);
-
-    v.extend(3..10);
-    for i in 3..10 {
-        w.push(i)
-    }
-
-    assert_eq!(v, w);
-
-    v.extend(w.clone()); // specializes to `append`
-    assert!(v.iter().eq(w.iter().chain(w.iter())));
-
-    // Zero sized types
-    #[derive(PartialEq, Debug)]
-    struct Foo;
-
-    let mut a = Vec::new();
-    let b = vec![Foo, Foo];
-
-    a.extend(b);
-    assert_eq!(a, &[Foo, Foo]);
-
-    // Double drop
-    let mut count_x = 0;
-    {
-        let mut x = Vec::new();
-        let y = vec![DropCounter { count: &mut count_x }];
-        x.extend(y);
-    }
-    assert_eq!(count_x, 1);
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut v = vec![1, 2];
-    v.extend(&[3, 4, 5]);
-
-    assert_eq!(v.len(), 5);
-    assert_eq!(v, [1, 2, 3, 4, 5]);
-
-    let w = vec![6, 7];
-    v.extend(&w);
-
-    assert_eq!(v.len(), 7);
-    assert_eq!(v, [1, 2, 3, 4, 5, 6, 7]);
-}
-
-#[test]
-fn test_slice_from_mut() {
-    let mut values = vec![1, 2, 3, 4, 5];
-    {
-        let slice = &mut values[2..];
-        assert!(slice == [3, 4, 5]);
-        for p in slice {
-            *p += 2;
-        }
-    }
-
-    assert!(values == [1, 2, 5, 6, 7]);
-}
-
-#[test]
-fn test_slice_to_mut() {
-    let mut values = vec![1, 2, 3, 4, 5];
-    {
-        let slice = &mut values[..2];
-        assert!(slice == [1, 2]);
-        for p in slice {
-            *p += 1;
-        }
-    }
-
-    assert!(values == [2, 3, 3, 4, 5]);
-}
-
-#[test]
-fn test_split_at_mut() {
-    let mut values = vec![1, 2, 3, 4, 5];
-    {
-        let (left, right) = values.split_at_mut(2);
-        {
-            let left: &[_] = left;
-            assert!(&left[..left.len()] == &[1, 2]);
-        }
-        for p in left {
-            *p += 1;
-        }
-
-        {
-            let right: &[_] = right;
-            assert!(&right[..right.len()] == &[3, 4, 5]);
-        }
-        for p in right {
-            *p += 2;
-        }
-    }
-
-    assert_eq!(values, [2, 3, 5, 6, 7]);
-}
-
-#[test]
-fn test_clone() {
-    let v: Vec<i32> = vec![];
-    let w = vec![1, 2, 3];
-
-    assert_eq!(v, v.clone());
-
-    let z = w.clone();
-    assert_eq!(w, z);
-    // they should be disjoint in memory.
-    assert!(w.as_ptr() != z.as_ptr())
-}
-
-#[test]
-fn test_clone_from() {
-    let mut v = vec![];
-    let three: Vec<Box<_>> = vec![box 1, box 2, box 3];
-    let two: Vec<Box<_>> = vec![box 4, box 5];
-    // zero, long
-    v.clone_from(&three);
-    assert_eq!(v, three);
-
-    // equal
-    v.clone_from(&three);
-    assert_eq!(v, three);
-
-    // long, short
-    v.clone_from(&two);
-    assert_eq!(v, two);
-
-    // short, long
-    v.clone_from(&three);
-    assert_eq!(v, three)
-}
-
-#[test]
-fn test_retain() {
-    let mut vec = vec![1, 2, 3, 4];
-    vec.retain(|&x| x % 2 == 0);
-    assert_eq!(vec, [2, 4]);
-}
-
-#[test]
-fn test_dedup() {
-    fn case(a: Vec<i32>, b: Vec<i32>) {
-        let mut v = a;
-        v.dedup();
-        assert_eq!(v, b);
-    }
-    case(vec![], vec![]);
-    case(vec![1], vec![1]);
-    case(vec![1, 1], vec![1]);
-    case(vec![1, 2, 3], vec![1, 2, 3]);
-    case(vec![1, 1, 2, 3], vec![1, 2, 3]);
-    case(vec![1, 2, 2, 3], vec![1, 2, 3]);
-    case(vec![1, 2, 3, 3], vec![1, 2, 3]);
-    case(vec![1, 1, 2, 2, 2, 3, 3], vec![1, 2, 3]);
-}
-
-#[test]
-fn test_dedup_by_key() {
-    fn case(a: Vec<i32>, b: Vec<i32>) {
-        let mut v = a;
-        v.dedup_by_key(|i| *i / 10);
-        assert_eq!(v, b);
-    }
-    case(vec![], vec![]);
-    case(vec![10], vec![10]);
-    case(vec![10, 11], vec![10]);
-    case(vec![10, 20, 30], vec![10, 20, 30]);
-    case(vec![10, 11, 20, 30], vec![10, 20, 30]);
-    case(vec![10, 20, 21, 30], vec![10, 20, 30]);
-    case(vec![10, 20, 30, 31], vec![10, 20, 30]);
-    case(vec![10, 11, 20, 21, 22, 30, 31], vec![10, 20, 30]);
-}
-
-#[test]
-fn test_dedup_by() {
-    let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
-    vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
-
-    assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
-}
-
-#[test]
-fn test_dedup_unique() {
-    let mut v0: Vec<Box<_>> = vec![box 1, box 1, box 2, box 3];
-    v0.dedup();
-    let mut v1: Vec<Box<_>> = vec![box 1, box 2, box 2, box 3];
-    v1.dedup();
-    let mut v2: Vec<Box<_>> = vec![box 1, box 2, box 3, box 3];
-    v2.dedup();
-    // If the boxed pointers were leaked or otherwise misused, valgrind
-    // and/or rt should raise errors.
-}
-
-#[test]
-fn zero_sized_values() {
-    let mut v = Vec::new();
-    assert_eq!(v.len(), 0);
-    v.push(());
-    assert_eq!(v.len(), 1);
-    v.push(());
-    assert_eq!(v.len(), 2);
-    assert_eq!(v.pop(), Some(()));
-    assert_eq!(v.pop(), Some(()));
-    assert_eq!(v.pop(), None);
-
-    assert_eq!(v.iter().count(), 0);
-    v.push(());
-    assert_eq!(v.iter().count(), 1);
-    v.push(());
-    assert_eq!(v.iter().count(), 2);
-
-    for &() in &v {}
-
-    assert_eq!(v.iter_mut().count(), 2);
-    v.push(());
-    assert_eq!(v.iter_mut().count(), 3);
-    v.push(());
-    assert_eq!(v.iter_mut().count(), 4);
-
-    for &mut () in &mut v {}
-    unsafe {
-        v.set_len(0);
-    }
-    assert_eq!(v.iter_mut().count(), 0);
-}
-
-#[test]
-fn test_partition() {
-    assert_eq!(vec![].into_iter().partition(|x: &i32| *x < 3),
-               (vec![], vec![]));
-    assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 4),
-               (vec![1, 2, 3], vec![]));
-    assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 2),
-               (vec![1], vec![2, 3]));
-    assert_eq!(vec![1, 2, 3].into_iter().partition(|x| *x < 0),
-               (vec![], vec![1, 2, 3]));
-}
-
-#[test]
-fn test_zip_unzip() {
-    let z1 = vec![(1, 4), (2, 5), (3, 6)];
-
-    let (left, right): (Vec<_>, Vec<_>) = z1.iter().cloned().unzip();
-
-    assert_eq!((1, 4), (left[0], right[0]));
-    assert_eq!((2, 5), (left[1], right[1]));
-    assert_eq!((3, 6), (left[2], right[2]));
-}
-
-#[test]
-fn test_vec_truncate_drop() {
-    static mut DROPS: u32 = 0;
-    struct Elem(i32);
-    impl Drop for Elem {
-        fn drop(&mut self) {
-            unsafe {
-                DROPS += 1;
-            }
-        }
-    }
-
-    let mut v = vec![Elem(1), Elem(2), Elem(3), Elem(4), Elem(5)];
-    assert_eq!(unsafe { DROPS }, 0);
-    v.truncate(3);
-    assert_eq!(unsafe { DROPS }, 2);
-    v.truncate(0);
-    assert_eq!(unsafe { DROPS }, 5);
-}
-
-#[test]
-#[should_panic]
-fn test_vec_truncate_fail() {
-    struct BadElem(i32);
-    impl Drop for BadElem {
-        fn drop(&mut self) {
-            let BadElem(ref mut x) = *self;
-            if *x == 0xbadbeef {
-                panic!("BadElem panic: 0xbadbeef")
-            }
-        }
-    }
-
-    let mut v = vec![BadElem(1), BadElem(2), BadElem(0xbadbeef), BadElem(4)];
-    v.truncate(0);
-}
-
-#[test]
-fn test_index() {
-    let vec = vec![1, 2, 3];
-    assert!(vec[1] == 2);
-}
-
-#[test]
-#[should_panic]
-fn test_index_out_of_bounds() {
-    let vec = vec![1, 2, 3];
-    let _ = vec[3];
-}
-
-#[test]
-#[should_panic]
-fn test_slice_out_of_bounds_1() {
-    let x = vec![1, 2, 3, 4, 5];
-    &x[!0..];
-}
-
-#[test]
-#[should_panic]
-fn test_slice_out_of_bounds_2() {
-    let x = vec![1, 2, 3, 4, 5];
-    &x[..6];
-}
-
-#[test]
-#[should_panic]
-fn test_slice_out_of_bounds_3() {
-    let x = vec![1, 2, 3, 4, 5];
-    &x[!0..4];
-}
-
-#[test]
-#[should_panic]
-fn test_slice_out_of_bounds_4() {
-    let x = vec![1, 2, 3, 4, 5];
-    &x[1..6];
-}
-
-#[test]
-#[should_panic]
-fn test_slice_out_of_bounds_5() {
-    let x = vec![1, 2, 3, 4, 5];
-    &x[3..2];
-}
-
-#[test]
-#[should_panic]
-fn test_swap_remove_empty() {
-    let mut vec = Vec::<i32>::new();
-    vec.swap_remove(0);
-}
-
-#[test]
-fn test_move_items() {
-    let vec = vec![1, 2, 3];
-    let mut vec2 = vec![];
-    for i in vec {
-        vec2.push(i);
-    }
-    assert_eq!(vec2, [1, 2, 3]);
-}
-
-#[test]
-fn test_move_items_reverse() {
-    let vec = vec![1, 2, 3];
-    let mut vec2 = vec![];
-    for i in vec.into_iter().rev() {
-        vec2.push(i);
-    }
-    assert_eq!(vec2, [3, 2, 1]);
-}
-
-#[test]
-fn test_move_items_zero_sized() {
-    let vec = vec![(), (), ()];
-    let mut vec2 = vec![];
-    for i in vec {
-        vec2.push(i);
-    }
-    assert_eq!(vec2, [(), (), ()]);
-}
-
-#[test]
-fn test_drain_items() {
-    let mut vec = vec![1, 2, 3];
-    let mut vec2 = vec![];
-    for i in vec.drain(..) {
-        vec2.push(i);
-    }
-    assert_eq!(vec, []);
-    assert_eq!(vec2, [1, 2, 3]);
-}
-
-#[test]
-fn test_drain_items_reverse() {
-    let mut vec = vec![1, 2, 3];
-    let mut vec2 = vec![];
-    for i in vec.drain(..).rev() {
-        vec2.push(i);
-    }
-    assert_eq!(vec, []);
-    assert_eq!(vec2, [3, 2, 1]);
-}
-
-#[test]
-fn test_drain_items_zero_sized() {
-    let mut vec = vec![(), (), ()];
-    let mut vec2 = vec![];
-    for i in vec.drain(..) {
-        vec2.push(i);
-    }
-    assert_eq!(vec, []);
-    assert_eq!(vec2, [(), (), ()]);
-}
-
-#[test]
-#[should_panic]
-fn test_drain_out_of_bounds() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    v.drain(5..6);
-}
-
-#[test]
-fn test_drain_range() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    for _ in v.drain(4..) {
-    }
-    assert_eq!(v, &[1, 2, 3, 4]);
-
-    let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
-    for _ in v.drain(1..4) {
-    }
-    assert_eq!(v, &[1.to_string(), 5.to_string()]);
-
-    let mut v: Vec<_> = (1..6).map(|x| x.to_string()).collect();
-    for _ in v.drain(1..4).rev() {
-    }
-    assert_eq!(v, &[1.to_string(), 5.to_string()]);
-
-    let mut v: Vec<_> = vec![(); 5];
-    for _ in v.drain(1..4).rev() {
-    }
-    assert_eq!(v, &[(), ()]);
-}
-
-#[test]
-fn test_drain_inclusive_range() {
-    let mut v = vec!['a', 'b', 'c', 'd', 'e'];
-    for _ in v.drain(1...3) {
-    }
-    assert_eq!(v, &['a', 'e']);
-
-    let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
-    for _ in v.drain(1...5) {
-    }
-    assert_eq!(v, &["0".to_string()]);
-
-    let mut v: Vec<String> = (0...5).map(|x| x.to_string()).collect();
-    for _ in v.drain(0...5) {
-    }
-    assert_eq!(v, Vec::<String>::new());
-
-    let mut v: Vec<_> = (0...5).map(|x| x.to_string()).collect();
-    for _ in v.drain(0...3) {
-    }
-    assert_eq!(v, &["4".to_string(), "5".to_string()]);
-
-    let mut v: Vec<_> = (0...1).map(|x| x.to_string()).collect();
-    for _ in v.drain(...0) {
-    }
-    assert_eq!(v, &["1".to_string()]);
-}
-
-#[test]
-fn test_drain_max_vec_size() {
-    let mut v = Vec::<()>::with_capacity(usize::max_value());
-    unsafe { v.set_len(usize::max_value()); }
-    for _ in v.drain(usize::max_value() - 1..) {
-    }
-    assert_eq!(v.len(), usize::max_value() - 1);
-
-    let mut v = Vec::<()>::with_capacity(usize::max_value());
-    unsafe { v.set_len(usize::max_value()); }
-    for _ in v.drain(usize::max_value() - 1...usize::max_value() - 1) {
-    }
-    assert_eq!(v.len(), usize::max_value() - 1);
-}
-
-#[test]
-#[should_panic]
-fn test_drain_inclusive_out_of_bounds() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    v.drain(5...5);
-}
-
-#[test]
-fn test_splice() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let a = [10, 11, 12];
-    v.splice(2..4, a.iter().cloned());
-    assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
-    v.splice(1..3, Some(20));
-    assert_eq!(v, &[1, 20, 11, 12, 5]);
-}
-
-#[test]
-fn test_splice_inclusive_range() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let a = [10, 11, 12];
-    let t1: Vec<_> = v.splice(2...3, a.iter().cloned()).collect();
-    assert_eq!(v, &[1, 2, 10, 11, 12, 5]);
-    assert_eq!(t1, &[3, 4]);
-    let t2: Vec<_> = v.splice(1...2, Some(20)).collect();
-    assert_eq!(v, &[1, 20, 11, 12, 5]);
-    assert_eq!(t2, &[2, 10]);
-}
-
-#[test]
-#[should_panic]
-fn test_splice_out_of_bounds() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let a = [10, 11, 12];
-    v.splice(5..6, a.iter().cloned());
-}
-
-#[test]
-#[should_panic]
-fn test_splice_inclusive_out_of_bounds() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let a = [10, 11, 12];
-    v.splice(5...5, a.iter().cloned());
-}
-
-#[test]
-fn test_splice_items_zero_sized() {
-    let mut vec = vec![(), (), ()];
-    let vec2 = vec![];
-    let t: Vec<_> = vec.splice(1..2, vec2.iter().cloned()).collect();
-    assert_eq!(vec, &[(), ()]);
-    assert_eq!(t, &[()]);
-}
-
-#[test]
-fn test_splice_unbounded() {
-    let mut vec = vec![1, 2, 3, 4, 5];
-    let t: Vec<_> = vec.splice(.., None).collect();
-    assert_eq!(vec, &[]);
-    assert_eq!(t, &[1, 2, 3, 4, 5]);
-}
-
-#[test]
-fn test_splice_forget() {
-    let mut v = vec![1, 2, 3, 4, 5];
-    let a = [10, 11, 12];
-    ::std::mem::forget(v.splice(2..4, a.iter().cloned()));
-    assert_eq!(v, &[1, 2]);
-}
-
-#[test]
-fn test_into_boxed_slice() {
-    let xs = vec![1, 2, 3];
-    let ys = xs.into_boxed_slice();
-    assert_eq!(&*ys, [1, 2, 3]);
-}
-
-#[test]
-fn test_append() {
-    let mut vec = vec![1, 2, 3];
-    let mut vec2 = vec![4, 5, 6];
-    vec.append(&mut vec2);
-    assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
-    assert_eq!(vec2, []);
-}
-
-#[test]
-fn test_split_off() {
-    let mut vec = vec![1, 2, 3, 4, 5, 6];
-    let vec2 = vec.split_off(4);
-    assert_eq!(vec, [1, 2, 3, 4]);
-    assert_eq!(vec2, [5, 6]);
-}
-
-#[test]
-fn test_into_iter_as_slice() {
-    let vec = vec!['a', 'b', 'c'];
-    let mut into_iter = vec.into_iter();
-    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    let _ = into_iter.next().unwrap();
-    assert_eq!(into_iter.as_slice(), &['b', 'c']);
-    let _ = into_iter.next().unwrap();
-    let _ = into_iter.next().unwrap();
-    assert_eq!(into_iter.as_slice(), &[]);
-}
-
-#[test]
-fn test_into_iter_as_mut_slice() {
-    let vec = vec!['a', 'b', 'c'];
-    let mut into_iter = vec.into_iter();
-    assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    into_iter.as_mut_slice()[0] = 'x';
-    into_iter.as_mut_slice()[1] = 'y';
-    assert_eq!(into_iter.next().unwrap(), 'x');
-    assert_eq!(into_iter.as_slice(), &['y', 'c']);
-}
-
-#[test]
-fn test_into_iter_debug() {
-    let vec = vec!['a', 'b', 'c'];
-    let into_iter = vec.into_iter();
-    let debug = format!("{:?}", into_iter);
-    assert_eq!(debug, "IntoIter(['a', 'b', 'c'])");
-}
-
-#[test]
-fn test_into_iter_count() {
-    assert_eq!(vec![1, 2, 3].into_iter().count(), 3);
-}
-
-#[test]
-fn test_into_iter_clone() {
-    fn iter_equal<I: Iterator<Item = i32>>(it: I, slice: &[i32]) {
-        let v: Vec<i32> = it.collect();
-        assert_eq!(&v[..], slice);
-    }
-    let mut it = vec![1, 2, 3].into_iter();
-    iter_equal(it.clone(), &[1, 2, 3]);
-    assert_eq!(it.next(), Some(1));
-    let mut it = it.rev();
-    iter_equal(it.clone(), &[3, 2]);
-    assert_eq!(it.next(), Some(3));
-    iter_equal(it.clone(), &[2]);
-    assert_eq!(it.next(), Some(2));
-    iter_equal(it.clone(), &[]);
-    assert_eq!(it.next(), None);
-}
-
-#[test]
-fn test_cow_from() {
-    let borrowed: &[_] = &["borrowed", "(slice)"];
-    let owned = vec!["owned", "(vec)"];
-    match (Cow::from(owned.clone()), Cow::from(borrowed)) {
-        (Cow::Owned(o), Cow::Borrowed(b)) => assert!(o == owned && b == borrowed),
-        _ => panic!("invalid `Cow::from`"),
-    }
-}
-
-#[test]
-fn test_from_cow() {
-    let borrowed: &[_] = &["borrowed", "(slice)"];
-    let owned = vec!["owned", "(vec)"];
-    assert_eq!(Vec::from(Cow::Borrowed(borrowed)), vec!["borrowed", "(slice)"]);
-    assert_eq!(Vec::from(Cow::Owned(owned)), vec!["owned", "(vec)"]);
-}
-
-#[allow(dead_code)]
-fn assert_covariance() {
-    fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
-        d
-    }
-    fn into_iter<'new>(i: IntoIter<&'static str>) -> IntoIter<&'new str> {
-        i
-    }
-}
-
-#[test]
-fn test_placement() {
-    let mut vec = vec![1];
-    assert_eq!(vec.place_back() <- 2, &2);
-    assert_eq!(vec.len(), 2);
-    assert_eq!(vec.place_back() <- 3, &3);
-    assert_eq!(vec.len(), 3);
-    assert_eq!(&vec, &[1, 2, 3]);
-}
-
-#[test]
-fn test_placement_panic() {
-    let mut vec = vec![1, 2, 3];
-    fn mkpanic() -> usize { panic!() }
-    let _ = panic::catch_unwind(panic::AssertUnwindSafe(|| { vec.place_back() <- mkpanic(); }));
-    assert_eq!(vec.len(), 3);
-}
-
-#[test]
-fn from_into_inner() {
-    let vec = vec![1, 2, 3];
-    let ptr = vec.as_ptr();
-    let vec = vec.into_iter().collect::<Vec<_>>();
-    assert_eq!(vec, [1, 2, 3]);
-    assert_eq!(vec.as_ptr(), ptr);
-
-    let ptr = &vec[1] as *const _;
-    let mut it = vec.into_iter();
-    it.next().unwrap();
-    let vec = it.collect::<Vec<_>>();
-    assert_eq!(vec, [2, 3]);
-    assert!(ptr != vec.as_ptr());
-}
-
-#[test]
-fn overaligned_allocations() {
-    #[repr(align(256))]
-    struct Foo(usize);
-    let mut v = vec![Foo(273)];
-    for i in 0..0x1000 {
-        v.reserve_exact(i);
-        assert!(v[0].0 == 273);
-        assert!(v.as_ptr() as usize & 0xff == 0);
-        v.shrink_to_fit();
-        assert!(v[0].0 == 273);
-        assert!(v.as_ptr() as usize & 0xff == 0);
-    }
-}
diff --git a/src/libcollections/tests/vec_deque.rs b/src/libcollections/tests/vec_deque.rs
deleted file mode 100644
index a992351653d..00000000000
--- a/src/libcollections/tests/vec_deque.rs
+++ /dev/null
@@ -1,1025 +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.
-
-use std::collections::VecDeque;
-use std::fmt::Debug;
-use std::collections::vec_deque::{Drain};
-
-use self::Taggy::*;
-use self::Taggypar::*;
-
-#[test]
-fn test_simple() {
-    let mut d = VecDeque::new();
-    assert_eq!(d.len(), 0);
-    d.push_front(17);
-    d.push_front(42);
-    d.push_back(137);
-    assert_eq!(d.len(), 3);
-    d.push_back(137);
-    assert_eq!(d.len(), 4);
-    assert_eq!(*d.front().unwrap(), 42);
-    assert_eq!(*d.back().unwrap(), 137);
-    let mut i = d.pop_front();
-    assert_eq!(i, Some(42));
-    i = d.pop_back();
-    assert_eq!(i, Some(137));
-    i = d.pop_back();
-    assert_eq!(i, Some(137));
-    i = d.pop_back();
-    assert_eq!(i, Some(17));
-    assert_eq!(d.len(), 0);
-    d.push_back(3);
-    assert_eq!(d.len(), 1);
-    d.push_front(2);
-    assert_eq!(d.len(), 2);
-    d.push_back(4);
-    assert_eq!(d.len(), 3);
-    d.push_front(1);
-    assert_eq!(d.len(), 4);
-    assert_eq!(d[0], 1);
-    assert_eq!(d[1], 2);
-    assert_eq!(d[2], 3);
-    assert_eq!(d[3], 4);
-}
-
-#[cfg(test)]
-fn test_parameterized<T: Clone + PartialEq + Debug>(a: T, b: T, c: T, d: T) {
-    let mut deq = VecDeque::new();
-    assert_eq!(deq.len(), 0);
-    deq.push_front(a.clone());
-    deq.push_front(b.clone());
-    deq.push_back(c.clone());
-    assert_eq!(deq.len(), 3);
-    deq.push_back(d.clone());
-    assert_eq!(deq.len(), 4);
-    assert_eq!((*deq.front().unwrap()).clone(), b.clone());
-    assert_eq!((*deq.back().unwrap()).clone(), d.clone());
-    assert_eq!(deq.pop_front().unwrap(), b.clone());
-    assert_eq!(deq.pop_back().unwrap(), d.clone());
-    assert_eq!(deq.pop_back().unwrap(), c.clone());
-    assert_eq!(deq.pop_back().unwrap(), a.clone());
-    assert_eq!(deq.len(), 0);
-    deq.push_back(c.clone());
-    assert_eq!(deq.len(), 1);
-    deq.push_front(b.clone());
-    assert_eq!(deq.len(), 2);
-    deq.push_back(d.clone());
-    assert_eq!(deq.len(), 3);
-    deq.push_front(a.clone());
-    assert_eq!(deq.len(), 4);
-    assert_eq!(deq[0].clone(), a.clone());
-    assert_eq!(deq[1].clone(), b.clone());
-    assert_eq!(deq[2].clone(), c.clone());
-    assert_eq!(deq[3].clone(), d.clone());
-}
-
-#[test]
-fn test_push_front_grow() {
-    let mut deq = VecDeque::new();
-    for i in 0..66 {
-        deq.push_front(i);
-    }
-    assert_eq!(deq.len(), 66);
-
-    for i in 0..66 {
-        assert_eq!(deq[i], 65 - i);
-    }
-
-    let mut deq = VecDeque::new();
-    for i in 0..66 {
-        deq.push_back(i);
-    }
-
-    for i in 0..66 {
-        assert_eq!(deq[i], i);
-    }
-}
-
-#[test]
-fn test_index() {
-    let mut deq = VecDeque::new();
-    for i in 1..4 {
-        deq.push_front(i);
-    }
-    assert_eq!(deq[1], 2);
-}
-
-#[test]
-#[should_panic]
-fn test_index_out_of_bounds() {
-    let mut deq = VecDeque::new();
-    for i in 1..4 {
-        deq.push_front(i);
-    }
-    deq[3];
-}
-
-#[derive(Clone, PartialEq, Debug)]
-enum Taggy {
-    One(i32),
-    Two(i32, i32),
-    Three(i32, i32, i32),
-}
-
-#[derive(Clone, PartialEq, Debug)]
-enum Taggypar<T> {
-    Onepar(T),
-    Twopar(T, T),
-    Threepar(T, T, T),
-}
-
-#[derive(Clone, PartialEq, Debug)]
-struct RecCy {
-    x: i32,
-    y: i32,
-    t: Taggy,
-}
-
-#[test]
-fn test_param_int() {
-    test_parameterized::<i32>(5, 72, 64, 175);
-}
-
-#[test]
-fn test_param_taggy() {
-    test_parameterized::<Taggy>(One(1), Two(1, 2), Three(1, 2, 3), Two(17, 42));
-}
-
-#[test]
-fn test_param_taggypar() {
-    test_parameterized::<Taggypar<i32>>(Onepar::<i32>(1),
-                                        Twopar::<i32>(1, 2),
-                                        Threepar::<i32>(1, 2, 3),
-                                        Twopar::<i32>(17, 42));
-}
-
-#[test]
-fn test_param_reccy() {
-    let reccy1 = RecCy {
-        x: 1,
-        y: 2,
-        t: One(1),
-    };
-    let reccy2 = RecCy {
-        x: 345,
-        y: 2,
-        t: Two(1, 2),
-    };
-    let reccy3 = RecCy {
-        x: 1,
-        y: 777,
-        t: Three(1, 2, 3),
-    };
-    let reccy4 = RecCy {
-        x: 19,
-        y: 252,
-        t: Two(17, 42),
-    };
-    test_parameterized::<RecCy>(reccy1, reccy2, reccy3, reccy4);
-}
-
-#[test]
-fn test_with_capacity() {
-    let mut d = VecDeque::with_capacity(0);
-    d.push_back(1);
-    assert_eq!(d.len(), 1);
-    let mut d = VecDeque::with_capacity(50);
-    d.push_back(1);
-    assert_eq!(d.len(), 1);
-}
-
-#[test]
-fn test_with_capacity_non_power_two() {
-    let mut d3 = VecDeque::with_capacity(3);
-    d3.push_back(1);
-
-    // X = None, | = lo
-    // [|1, X, X]
-    assert_eq!(d3.pop_front(), Some(1));
-    // [X, |X, X]
-    assert_eq!(d3.front(), None);
-
-    // [X, |3, X]
-    d3.push_back(3);
-    // [X, |3, 6]
-    d3.push_back(6);
-    // [X, X, |6]
-    assert_eq!(d3.pop_front(), Some(3));
-
-    // Pushing the lo past half way point to trigger
-    // the 'B' scenario for growth
-    // [9, X, |6]
-    d3.push_back(9);
-    // [9, 12, |6]
-    d3.push_back(12);
-
-    d3.push_back(15);
-    // There used to be a bug here about how the
-    // VecDeque made growth assumptions about the
-    // underlying Vec which didn't hold and lead
-    // to corruption.
-    // (Vec grows to next power of two)
-    // good- [9, 12, 15, X, X, X, X, |6]
-    // bug-  [15, 12, X, X, X, |6, X, X]
-    assert_eq!(d3.pop_front(), Some(6));
-
-    // Which leads us to the following state which
-    // would be a failure case.
-    // bug-  [15, 12, X, X, X, X, |X, X]
-    assert_eq!(d3.front(), Some(&9));
-}
-
-#[test]
-fn test_reserve_exact() {
-    let mut d = VecDeque::new();
-    d.push_back(0);
-    d.reserve_exact(50);
-    assert!(d.capacity() >= 51);
-}
-
-#[test]
-fn test_reserve() {
-    let mut d = VecDeque::new();
-    d.push_back(0);
-    d.reserve(50);
-    assert!(d.capacity() >= 51);
-}
-
-#[test]
-fn test_swap() {
-    let mut d: VecDeque<_> = (0..5).collect();
-    d.pop_front();
-    d.swap(0, 3);
-    assert_eq!(d.iter().cloned().collect::<Vec<_>>(), [4, 2, 3, 1]);
-}
-
-#[test]
-fn test_iter() {
-    let mut d = VecDeque::new();
-    assert_eq!(d.iter().next(), None);
-    assert_eq!(d.iter().size_hint(), (0, Some(0)));
-
-    for i in 0..5 {
-        d.push_back(i);
-    }
-    {
-        let b: &[_] = &[&0, &1, &2, &3, &4];
-        assert_eq!(d.iter().collect::<Vec<_>>(), b);
-    }
-
-    for i in 6..9 {
-        d.push_front(i);
-    }
-    {
-        let b: &[_] = &[&8, &7, &6, &0, &1, &2, &3, &4];
-        assert_eq!(d.iter().collect::<Vec<_>>(), b);
-    }
-
-    let mut it = d.iter();
-    let mut len = d.len();
-    loop {
-        match it.next() {
-            None => break,
-            _ => {
-                len -= 1;
-                assert_eq!(it.size_hint(), (len, Some(len)))
-            }
-        }
-    }
-}
-
-#[test]
-fn test_rev_iter() {
-    let mut d = VecDeque::new();
-    assert_eq!(d.iter().rev().next(), None);
-
-    for i in 0..5 {
-        d.push_back(i);
-    }
-    {
-        let b: &[_] = &[&4, &3, &2, &1, &0];
-        assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
-    }
-
-    for i in 6..9 {
-        d.push_front(i);
-    }
-    let b: &[_] = &[&4, &3, &2, &1, &0, &6, &7, &8];
-    assert_eq!(d.iter().rev().collect::<Vec<_>>(), b);
-}
-
-#[test]
-fn test_mut_rev_iter_wrap() {
-    let mut d = VecDeque::with_capacity(3);
-    assert!(d.iter_mut().rev().next().is_none());
-
-    d.push_back(1);
-    d.push_back(2);
-    d.push_back(3);
-    assert_eq!(d.pop_front(), Some(1));
-    d.push_back(4);
-
-    assert_eq!(d.iter_mut().rev().map(|x| *x).collect::<Vec<_>>(),
-               vec![4, 3, 2]);
-}
-
-#[test]
-fn test_mut_iter() {
-    let mut d = VecDeque::new();
-    assert!(d.iter_mut().next().is_none());
-
-    for i in 0..3 {
-        d.push_front(i);
-    }
-
-    for (i, elt) in d.iter_mut().enumerate() {
-        assert_eq!(*elt, 2 - i);
-        *elt = i;
-    }
-
-    {
-        let mut it = d.iter_mut();
-        assert_eq!(*it.next().unwrap(), 0);
-        assert_eq!(*it.next().unwrap(), 1);
-        assert_eq!(*it.next().unwrap(), 2);
-        assert!(it.next().is_none());
-    }
-}
-
-#[test]
-fn test_mut_rev_iter() {
-    let mut d = VecDeque::new();
-    assert!(d.iter_mut().rev().next().is_none());
-
-    for i in 0..3 {
-        d.push_front(i);
-    }
-
-    for (i, elt) in d.iter_mut().rev().enumerate() {
-        assert_eq!(*elt, i);
-        *elt = i;
-    }
-
-    {
-        let mut it = d.iter_mut().rev();
-        assert_eq!(*it.next().unwrap(), 0);
-        assert_eq!(*it.next().unwrap(), 1);
-        assert_eq!(*it.next().unwrap(), 2);
-        assert!(it.next().is_none());
-    }
-}
-
-#[test]
-fn test_into_iter() {
-
-    // Empty iter
-    {
-        let d: VecDeque<i32> = VecDeque::new();
-        let mut iter = d.into_iter();
-
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-        assert_eq!(iter.next(), None);
-        assert_eq!(iter.size_hint(), (0, Some(0)));
-    }
-
-    // simple iter
-    {
-        let mut d = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-
-        let b = vec![0, 1, 2, 3, 4];
-        assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
-    }
-
-    // wrapped iter
-    {
-        let mut d = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-        for i in 6..9 {
-            d.push_front(i);
-        }
-
-        let b = vec![8, 7, 6, 0, 1, 2, 3, 4];
-        assert_eq!(d.into_iter().collect::<Vec<_>>(), b);
-    }
-
-    // partially used
-    {
-        let mut d = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-        for i in 6..9 {
-            d.push_front(i);
-        }
-
-        let mut it = d.into_iter();
-        assert_eq!(it.size_hint(), (8, Some(8)));
-        assert_eq!(it.next(), Some(8));
-        assert_eq!(it.size_hint(), (7, Some(7)));
-        assert_eq!(it.next_back(), Some(4));
-        assert_eq!(it.size_hint(), (6, Some(6)));
-        assert_eq!(it.next(), Some(7));
-        assert_eq!(it.size_hint(), (5, Some(5)));
-    }
-}
-
-#[test]
-fn test_drain() {
-
-    // Empty iter
-    {
-        let mut d: VecDeque<i32> = VecDeque::new();
-
-        {
-            let mut iter = d.drain(..);
-
-            assert_eq!(iter.size_hint(), (0, Some(0)));
-            assert_eq!(iter.next(), None);
-            assert_eq!(iter.size_hint(), (0, Some(0)));
-        }
-
-        assert!(d.is_empty());
-    }
-
-    // simple iter
-    {
-        let mut d = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-
-        assert_eq!(d.drain(..).collect::<Vec<_>>(), [0, 1, 2, 3, 4]);
-        assert!(d.is_empty());
-    }
-
-    // wrapped iter
-    {
-        let mut d = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-        for i in 6..9 {
-            d.push_front(i);
-        }
-
-        assert_eq!(d.drain(..).collect::<Vec<_>>(), [8, 7, 6, 0, 1, 2, 3, 4]);
-        assert!(d.is_empty());
-    }
-
-    // partially used
-    {
-        let mut d: VecDeque<_> = VecDeque::new();
-        for i in 0..5 {
-            d.push_back(i);
-        }
-        for i in 6..9 {
-            d.push_front(i);
-        }
-
-        {
-            let mut it = d.drain(..);
-            assert_eq!(it.size_hint(), (8, Some(8)));
-            assert_eq!(it.next(), Some(8));
-            assert_eq!(it.size_hint(), (7, Some(7)));
-            assert_eq!(it.next_back(), Some(4));
-            assert_eq!(it.size_hint(), (6, Some(6)));
-            assert_eq!(it.next(), Some(7));
-            assert_eq!(it.size_hint(), (5, Some(5)));
-        }
-        assert!(d.is_empty());
-    }
-}
-
-#[test]
-fn test_from_iter() {
-    let v = vec![1, 2, 3, 4, 5, 6, 7];
-    let deq: VecDeque<_> = v.iter().cloned().collect();
-    let u: Vec<_> = deq.iter().cloned().collect();
-    assert_eq!(u, v);
-
-    // FIXME #27741: Remove `.skip(0)` when Range::step_by is fully removed
-    let seq = (0..).skip(0).step_by(2).take(256);
-    let deq: VecDeque<_> = seq.collect();
-    for (i, &x) in deq.iter().enumerate() {
-        assert_eq!(2 * i, x);
-    }
-    assert_eq!(deq.len(), 256);
-}
-
-#[test]
-fn test_clone() {
-    let mut d = VecDeque::new();
-    d.push_front(17);
-    d.push_front(42);
-    d.push_back(137);
-    d.push_back(137);
-    assert_eq!(d.len(), 4);
-    let mut e = d.clone();
-    assert_eq!(e.len(), 4);
-    while !d.is_empty() {
-        assert_eq!(d.pop_back(), e.pop_back());
-    }
-    assert_eq!(d.len(), 0);
-    assert_eq!(e.len(), 0);
-}
-
-#[test]
-fn test_eq() {
-    let mut d = VecDeque::new();
-    assert!(d == VecDeque::with_capacity(0));
-    d.push_front(137);
-    d.push_front(17);
-    d.push_front(42);
-    d.push_back(137);
-    let mut e = VecDeque::with_capacity(0);
-    e.push_back(42);
-    e.push_back(17);
-    e.push_back(137);
-    e.push_back(137);
-    assert!(&e == &d);
-    e.pop_back();
-    e.push_back(0);
-    assert!(e != d);
-    e.clear();
-    assert!(e == VecDeque::new());
-}
-
-#[test]
-fn test_partial_eq_array() {
-    let d = VecDeque::<char>::new();
-    assert!(d == []);
-
-    let mut d = VecDeque::new();
-    d.push_front('a');
-    assert!(d == ['a']);
-
-    let mut d = VecDeque::new();
-    d.push_back('a');
-    assert!(d == ['a']);
-
-    let mut d = VecDeque::new();
-    d.push_back('a');
-    d.push_back('b');
-    assert!(d == ['a', 'b']);
-}
-
-#[test]
-fn test_hash() {
-    let mut x = VecDeque::new();
-    let mut y = VecDeque::new();
-
-    x.push_back(1);
-    x.push_back(2);
-    x.push_back(3);
-
-    y.push_back(0);
-    y.push_back(1);
-    y.pop_front();
-    y.push_back(2);
-    y.push_back(3);
-
-    assert!(::hash(&x) == ::hash(&y));
-}
-
-#[test]
-fn test_hash_after_rotation() {
-    // test that two deques hash equal even if elements are laid out differently
-    let len = 28;
-    let mut ring: VecDeque<i32> = (0..len as i32).collect();
-    let orig = ring.clone();
-    for _ in 0..ring.capacity() {
-        // shift values 1 step to the right by pop, sub one, push
-        ring.pop_front();
-        for elt in &mut ring {
-            *elt -= 1;
-        }
-        ring.push_back(len - 1);
-        assert_eq!(::hash(&orig), ::hash(&ring));
-        assert_eq!(orig, ring);
-        assert_eq!(ring, orig);
-    }
-}
-
-#[test]
-fn test_eq_after_rotation() {
-    // test that two deques are equal even if elements are laid out differently
-    let len = 28;
-    let mut ring: VecDeque<i32> = (0..len as i32).collect();
-    let mut shifted = ring.clone();
-    for _ in 0..10 {
-        // shift values 1 step to the right by pop, sub one, push
-        ring.pop_front();
-        for elt in &mut ring {
-            *elt -= 1;
-        }
-        ring.push_back(len - 1);
-    }
-
-    // try every shift
-    for _ in 0..shifted.capacity() {
-        shifted.pop_front();
-        for elt in &mut shifted {
-            *elt -= 1;
-        }
-        shifted.push_back(len - 1);
-        assert_eq!(shifted, ring);
-        assert_eq!(ring, shifted);
-    }
-}
-
-#[test]
-fn test_ord() {
-    let x = VecDeque::new();
-    let mut y = VecDeque::new();
-    y.push_back(1);
-    y.push_back(2);
-    y.push_back(3);
-    assert!(x < y);
-    assert!(y > x);
-    assert!(x <= x);
-    assert!(x >= x);
-}
-
-#[test]
-fn test_show() {
-    let ringbuf: VecDeque<_> = (0..10).collect();
-    assert_eq!(format!("{:?}", ringbuf), "[0, 1, 2, 3, 4, 5, 6, 7, 8, 9]");
-
-    let ringbuf: VecDeque<_> = vec!["just", "one", "test", "more"]
-        .iter()
-        .cloned()
-        .collect();
-    assert_eq!(format!("{:?}", ringbuf),
-               "[\"just\", \"one\", \"test\", \"more\"]");
-}
-
-#[test]
-fn test_drop() {
-    static mut DROPS: i32 = 0;
-    struct Elem;
-    impl Drop for Elem {
-        fn drop(&mut self) {
-            unsafe {
-                DROPS += 1;
-            }
-        }
-    }
-
-    let mut ring = VecDeque::new();
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-    drop(ring);
-
-    assert_eq!(unsafe { DROPS }, 4);
-}
-
-#[test]
-fn test_drop_with_pop() {
-    static mut DROPS: i32 = 0;
-    struct Elem;
-    impl Drop for Elem {
-        fn drop(&mut self) {
-            unsafe {
-                DROPS += 1;
-            }
-        }
-    }
-
-    let mut ring = VecDeque::new();
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-
-    drop(ring.pop_back());
-    drop(ring.pop_front());
-    assert_eq!(unsafe { DROPS }, 2);
-
-    drop(ring);
-    assert_eq!(unsafe { DROPS }, 4);
-}
-
-#[test]
-fn test_drop_clear() {
-    static mut DROPS: i32 = 0;
-    struct Elem;
-    impl Drop for Elem {
-        fn drop(&mut self) {
-            unsafe {
-                DROPS += 1;
-            }
-        }
-    }
-
-    let mut ring = VecDeque::new();
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-    ring.push_back(Elem);
-    ring.push_front(Elem);
-    ring.clear();
-    assert_eq!(unsafe { DROPS }, 4);
-
-    drop(ring);
-    assert_eq!(unsafe { DROPS }, 4);
-}
-
-#[test]
-fn test_reserve_grow() {
-    // test growth path A
-    // [T o o H] -> [T o o H . . . . ]
-    let mut ring = VecDeque::with_capacity(4);
-    for i in 0..3 {
-        ring.push_back(i);
-    }
-    ring.reserve(7);
-    for i in 0..3 {
-        assert_eq!(ring.pop_front(), Some(i));
-    }
-
-    // test growth path B
-    // [H T o o] -> [. T o o H . . . ]
-    let mut ring = VecDeque::with_capacity(4);
-    for i in 0..1 {
-        ring.push_back(i);
-        assert_eq!(ring.pop_front(), Some(i));
-    }
-    for i in 0..3 {
-        ring.push_back(i);
-    }
-    ring.reserve(7);
-    for i in 0..3 {
-        assert_eq!(ring.pop_front(), Some(i));
-    }
-
-    // test growth path C
-    // [o o H T] -> [o o H . . . . T ]
-    let mut ring = VecDeque::with_capacity(4);
-    for i in 0..3 {
-        ring.push_back(i);
-        assert_eq!(ring.pop_front(), Some(i));
-    }
-    for i in 0..3 {
-        ring.push_back(i);
-    }
-    ring.reserve(7);
-    for i in 0..3 {
-        assert_eq!(ring.pop_front(), Some(i));
-    }
-}
-
-#[test]
-fn test_get() {
-    let mut ring = VecDeque::new();
-    ring.push_back(0);
-    assert_eq!(ring.get(0), Some(&0));
-    assert_eq!(ring.get(1), None);
-
-    ring.push_back(1);
-    assert_eq!(ring.get(0), Some(&0));
-    assert_eq!(ring.get(1), Some(&1));
-    assert_eq!(ring.get(2), None);
-
-    ring.push_back(2);
-    assert_eq!(ring.get(0), Some(&0));
-    assert_eq!(ring.get(1), Some(&1));
-    assert_eq!(ring.get(2), Some(&2));
-    assert_eq!(ring.get(3), None);
-
-    assert_eq!(ring.pop_front(), Some(0));
-    assert_eq!(ring.get(0), Some(&1));
-    assert_eq!(ring.get(1), Some(&2));
-    assert_eq!(ring.get(2), None);
-
-    assert_eq!(ring.pop_front(), Some(1));
-    assert_eq!(ring.get(0), Some(&2));
-    assert_eq!(ring.get(1), None);
-
-    assert_eq!(ring.pop_front(), Some(2));
-    assert_eq!(ring.get(0), None);
-    assert_eq!(ring.get(1), None);
-}
-
-#[test]
-fn test_get_mut() {
-    let mut ring = VecDeque::new();
-    for i in 0..3 {
-        ring.push_back(i);
-    }
-
-    match ring.get_mut(1) {
-        Some(x) => *x = -1,
-        None => (),
-    };
-
-    assert_eq!(ring.get_mut(0), Some(&mut 0));
-    assert_eq!(ring.get_mut(1), Some(&mut -1));
-    assert_eq!(ring.get_mut(2), Some(&mut 2));
-    assert_eq!(ring.get_mut(3), None);
-
-    assert_eq!(ring.pop_front(), Some(0));
-    assert_eq!(ring.get_mut(0), Some(&mut -1));
-    assert_eq!(ring.get_mut(1), Some(&mut 2));
-    assert_eq!(ring.get_mut(2), None);
-}
-
-#[test]
-fn test_front() {
-    let mut ring = VecDeque::new();
-    ring.push_back(10);
-    ring.push_back(20);
-    assert_eq!(ring.front(), Some(&10));
-    ring.pop_front();
-    assert_eq!(ring.front(), Some(&20));
-    ring.pop_front();
-    assert_eq!(ring.front(), None);
-}
-
-#[test]
-fn test_as_slices() {
-    let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
-    let cap = ring.capacity() as i32;
-    let first = cap / 2;
-    let last = cap - first;
-    for i in 0..first {
-        ring.push_back(i);
-
-        let (left, right) = ring.as_slices();
-        let expected: Vec<_> = (0..i + 1).collect();
-        assert_eq!(left, &expected[..]);
-        assert_eq!(right, []);
-    }
-
-    for j in -last..0 {
-        ring.push_front(j);
-        let (left, right) = ring.as_slices();
-        let expected_left: Vec<_> = (-last..j + 1).rev().collect();
-        let expected_right: Vec<_> = (0..first).collect();
-        assert_eq!(left, &expected_left[..]);
-        assert_eq!(right, &expected_right[..]);
-    }
-
-    assert_eq!(ring.len() as i32, cap);
-    assert_eq!(ring.capacity() as i32, cap);
-}
-
-#[test]
-fn test_as_mut_slices() {
-    let mut ring: VecDeque<i32> = VecDeque::with_capacity(127);
-    let cap = ring.capacity() as i32;
-    let first = cap / 2;
-    let last = cap - first;
-    for i in 0..first {
-        ring.push_back(i);
-
-        let (left, right) = ring.as_mut_slices();
-        let expected: Vec<_> = (0..i + 1).collect();
-        assert_eq!(left, &expected[..]);
-        assert_eq!(right, []);
-    }
-
-    for j in -last..0 {
-        ring.push_front(j);
-        let (left, right) = ring.as_mut_slices();
-        let expected_left: Vec<_> = (-last..j + 1).rev().collect();
-        let expected_right: Vec<_> = (0..first).collect();
-        assert_eq!(left, &expected_left[..]);
-        assert_eq!(right, &expected_right[..]);
-    }
-
-    assert_eq!(ring.len() as i32, cap);
-    assert_eq!(ring.capacity() as i32, cap);
-}
-
-#[test]
-fn test_append() {
-    let mut a: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
-    let mut b: VecDeque<_> = vec![4, 5, 6].into_iter().collect();
-
-    // normal append
-    a.append(&mut b);
-    assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
-    assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
-
-    // append nothing to something
-    a.append(&mut b);
-    assert_eq!(a.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
-    assert_eq!(b.iter().cloned().collect::<Vec<_>>(), []);
-
-    // append something to nothing
-    b.append(&mut a);
-    assert_eq!(b.iter().cloned().collect::<Vec<_>>(), [1, 2, 3, 4, 5, 6]);
-    assert_eq!(a.iter().cloned().collect::<Vec<_>>(), []);
-}
-
-#[test]
-fn test_retain() {
-    let mut buf = VecDeque::new();
-    buf.extend(1..5);
-    buf.retain(|&x| x % 2 == 0);
-    let v: Vec<_> = buf.into_iter().collect();
-    assert_eq!(&v[..], &[2, 4]);
-}
-
-#[test]
-fn test_extend_ref() {
-    let mut v = VecDeque::new();
-    v.push_back(1);
-    v.extend(&[2, 3, 4]);
-
-    assert_eq!(v.len(), 4);
-    assert_eq!(v[0], 1);
-    assert_eq!(v[1], 2);
-    assert_eq!(v[2], 3);
-    assert_eq!(v[3], 4);
-
-    let mut w = VecDeque::new();
-    w.push_back(5);
-    w.push_back(6);
-    v.extend(&w);
-
-    assert_eq!(v.len(), 6);
-    assert_eq!(v[0], 1);
-    assert_eq!(v[1], 2);
-    assert_eq!(v[2], 3);
-    assert_eq!(v[3], 4);
-    assert_eq!(v[4], 5);
-    assert_eq!(v[5], 6);
-}
-
-#[test]
-fn test_contains() {
-    let mut v = VecDeque::new();
-    v.extend(&[2, 3, 4]);
-
-    assert!(v.contains(&3));
-    assert!(!v.contains(&1));
-
-    v.clear();
-
-    assert!(!v.contains(&3));
-}
-
-#[allow(dead_code)]
-fn assert_covariance() {
-    fn drain<'new>(d: Drain<'static, &'static str>) -> Drain<'new, &'new str> {
-        d
-    }
-}
-
-#[test]
-fn test_is_empty() {
-    let mut v = VecDeque::<i32>::new();
-    assert!(v.is_empty());
-    assert!(v.iter().is_empty());
-    assert!(v.iter_mut().is_empty());
-    v.extend(&[2, 3, 4]);
-    assert!(!v.is_empty());
-    assert!(!v.iter().is_empty());
-    assert!(!v.iter_mut().is_empty());
-    while let Some(_) = v.pop_front() {
-        assert_eq!(v.is_empty(), v.len() == 0);
-        assert_eq!(v.iter().is_empty(), v.iter().len() == 0);
-        assert_eq!(v.iter_mut().is_empty(), v.iter_mut().len() == 0);
-    }
-    assert!(v.is_empty());
-    assert!(v.iter().is_empty());
-    assert!(v.iter_mut().is_empty());
-    assert!(v.into_iter().is_empty());
-}
-
-#[test]
-fn test_placement_in() {
-    let mut buf: VecDeque<isize> = VecDeque::new();
-    buf.place_back() <- 1;
-    buf.place_back() <- 2;
-    assert_eq!(buf, [1,2]);
-
-    buf.place_front() <- 3;
-    buf.place_front() <- 4;
-    assert_eq!(buf, [4,3,1,2]);
-
-    {
-        let ptr_head = buf.place_front() <- 5;
-        assert_eq!(*ptr_head, 5);
-    }
-    {
-        let ptr_tail = buf.place_back() <- 6;
-        assert_eq!(*ptr_tail, 6);
-    }
-    assert_eq!(buf, [5,4,3,1,2,6]);
-}
diff --git a/src/libcollections/vec.rs b/src/libcollections/vec.rs
deleted file mode 100644
index 2de27725e95..00000000000
--- a/src/libcollections/vec.rs
+++ /dev/null
@@ -1,2593 +0,0 @@
-// Copyright 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.
-
-//! A contiguous growable array type with heap-allocated contents, written
-//! `Vec<T>`.
-//!
-//! Vectors have `O(1)` indexing, amortized `O(1)` push (to the end) and
-//! `O(1)` pop (from the end).
-//!
-//! # Examples
-//!
-//! You can explicitly create a [`Vec<T>`] with [`new`]:
-//!
-//! ```
-//! let v: Vec<i32> = Vec::new();
-//! ```
-//!
-//! ...or by using the [`vec!`] macro:
-//!
-//! ```
-//! let v: Vec<i32> = vec![];
-//!
-//! let v = vec![1, 2, 3, 4, 5];
-//!
-//! let v = vec![0; 10]; // ten zeroes
-//! ```
-//!
-//! You can [`push`] values onto the end of a vector (which will grow the vector
-//! as needed):
-//!
-//! ```
-//! let mut v = vec![1, 2];
-//!
-//! v.push(3);
-//! ```
-//!
-//! Popping values works in much the same way:
-//!
-//! ```
-//! let mut v = vec![1, 2];
-//!
-//! let two = v.pop();
-//! ```
-//!
-//! Vectors also support indexing (through the [`Index`] and [`IndexMut`] traits):
-//!
-//! ```
-//! let mut v = vec![1, 2, 3];
-//! let three = v[2];
-//! v[1] = v[1] + 5;
-//! ```
-//!
-//! [`Vec<T>`]: ../../std/vec/struct.Vec.html
-//! [`new`]: ../../std/vec/struct.Vec.html#method.new
-//! [`push`]: ../../std/vec/struct.Vec.html#method.push
-//! [`Index`]: ../../std/ops/trait.Index.html
-//! [`IndexMut`]: ../../std/ops/trait.IndexMut.html
-//! [`vec!`]: ../../std/macro.vec.html
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use alloc::boxed::Box;
-use alloc::raw_vec::RawVec;
-use borrow::ToOwned;
-use borrow::Cow;
-use core::cmp::Ordering;
-use core::fmt;
-use core::hash::{self, Hash};
-use core::intrinsics::{arith_offset, assume};
-use core::iter::{FromIterator, FusedIterator, TrustedLen};
-use core::mem;
-#[cfg(not(test))]
-use core::num::Float;
-use core::ops::{InPlace, Index, IndexMut, Place, Placer};
-use core::ops;
-use core::ptr;
-use core::ptr::Shared;
-use core::slice;
-
-use super::range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
-
-/// A contiguous growable array type, written `Vec<T>` but pronounced 'vector'.
-///
-/// # Examples
-///
-/// ```
-/// let mut vec = Vec::new();
-/// vec.push(1);
-/// vec.push(2);
-///
-/// assert_eq!(vec.len(), 2);
-/// assert_eq!(vec[0], 1);
-///
-/// assert_eq!(vec.pop(), Some(2));
-/// assert_eq!(vec.len(), 1);
-///
-/// vec[0] = 7;
-/// assert_eq!(vec[0], 7);
-///
-/// vec.extend([1, 2, 3].iter().cloned());
-///
-/// for x in &vec {
-///     println!("{}", x);
-/// }
-/// assert_eq!(vec, [7, 1, 2, 3]);
-/// ```
-///
-/// The [`vec!`] macro is provided to make initialization more convenient:
-///
-/// ```
-/// let mut vec = vec![1, 2, 3];
-/// vec.push(4);
-/// assert_eq!(vec, [1, 2, 3, 4]);
-/// ```
-///
-/// It can also initialize each element of a `Vec<T>` with a given value:
-///
-/// ```
-/// let vec = vec![0; 5];
-/// assert_eq!(vec, [0, 0, 0, 0, 0]);
-/// ```
-///
-/// Use a `Vec<T>` as an efficient stack:
-///
-/// ```
-/// let mut stack = Vec::new();
-///
-/// stack.push(1);
-/// stack.push(2);
-/// stack.push(3);
-///
-/// while let Some(top) = stack.pop() {
-///     // Prints 3, 2, 1
-///     println!("{}", top);
-/// }
-/// ```
-///
-/// # Indexing
-///
-/// The `Vec` type allows to access values by index, because it implements the
-/// [`Index`] trait. An example will be more explicit:
-///
-/// ```
-/// let v = vec![0, 2, 4, 6];
-/// println!("{}", v[1]); // it will display '2'
-/// ```
-///
-/// However be careful: if you try to access an index which isn't in the `Vec`,
-/// your software will panic! You cannot do this:
-///
-/// ```ignore
-/// let v = vec![0, 2, 4, 6];
-/// println!("{}", v[6]); // it will panic!
-/// ```
-///
-/// In conclusion: always check if the index you want to get really exists
-/// before doing it.
-///
-/// # Slicing
-///
-/// A `Vec` can be mutable. Slices, on the other hand, are read-only objects.
-/// To get a slice, use `&`. Example:
-///
-/// ```
-/// fn read_slice(slice: &[usize]) {
-///     // ...
-/// }
-///
-/// let v = vec![0, 1];
-/// read_slice(&v);
-///
-/// // ... and that's all!
-/// // you can also do it like this:
-/// let x : &[usize] = &v;
-/// ```
-///
-/// In Rust, it's more common to pass slices as arguments rather than vectors
-/// when you just want to provide a read access. The same goes for [`String`] and
-/// [`&str`].
-///
-/// # Capacity and reallocation
-///
-/// The capacity of a vector is the amount of space allocated for any future
-/// elements that will be added onto the vector. This is not to be confused with
-/// the *length* of a vector, which specifies the number of actual elements
-/// within the vector. If a vector's length exceeds its capacity, its capacity
-/// will automatically be increased, but its elements will have to be
-/// reallocated.
-///
-/// For example, a vector with capacity 10 and length 0 would be an empty vector
-/// with space for 10 more elements. Pushing 10 or fewer elements onto the
-/// vector will not change its capacity or cause reallocation to occur. However,
-/// if the vector's length is increased to 11, it will have to reallocate, which
-/// can be slow. For this reason, it is recommended to use [`Vec::with_capacity`]
-/// whenever possible to specify how big the vector is expected to get.
-///
-/// # Guarantees
-///
-/// Due to its incredibly fundamental nature, `Vec` makes a lot of guarantees
-/// about its design. This ensures that it's as low-overhead as possible in
-/// the general case, and can be correctly manipulated in primitive ways
-/// by unsafe code. Note that these guarantees refer to an unqualified `Vec<T>`.
-/// If additional type parameters are added (e.g. to support custom allocators),
-/// overriding their defaults may change the behavior.
-///
-/// Most fundamentally, `Vec` is and always will be a (pointer, capacity, length)
-/// triplet. No more, no less. The order of these fields is completely
-/// unspecified, and you should use the appropriate methods to modify these.
-/// The pointer will never be null, so this type is null-pointer-optimized.
-///
-/// However, the pointer may not actually point to allocated memory. In particular,
-/// if you construct a `Vec` with capacity 0 via [`Vec::new`], [`vec![]`][`vec!`],
-/// [`Vec::with_capacity(0)`][`Vec::with_capacity`], or by calling [`shrink_to_fit`]
-/// on an empty Vec, it will not allocate memory. Similarly, if you store zero-sized
-/// types inside a `Vec`, it will not allocate space for them. *Note that in this case
-/// the `Vec` may not report a [`capacity`] of 0*. `Vec` will allocate if and only
-/// if [`mem::size_of::<T>`]` * capacity() > 0`. In general, `Vec`'s allocation
-/// details are subtle enough that it is strongly recommended that you only
-/// free memory allocated by a `Vec` by creating a new `Vec` and dropping it.
-///
-/// If a `Vec` *has* allocated memory, then the memory it points to is on the heap
-/// (as defined by the allocator Rust is configured to use by default), and its
-/// pointer points to [`len`] initialized elements in order (what you would see
-/// if you coerced it to a slice), followed by [`capacity`]` - `[`len`]
-/// logically uninitialized elements.
-///
-/// `Vec` will never perform a "small optimization" where elements are actually
-/// stored on the stack for two reasons:
-///
-/// * It would make it more difficult for unsafe code to correctly manipulate
-///   a `Vec`. The contents of a `Vec` wouldn't have a stable address if it were
-///   only moved, and it would be more difficult to determine if a `Vec` had
-///   actually allocated memory.
-///
-/// * It would penalize the general case, incurring an additional branch
-///   on every access.
-///
-/// `Vec` will never automatically shrink itself, even if completely empty. This
-/// ensures no unnecessary allocations or deallocations occur. Emptying a `Vec`
-/// and then filling it back up to the same [`len`] should incur no calls to
-/// the allocator. If you wish to free up unused memory, use
-/// [`shrink_to_fit`][`shrink_to_fit`].
-///
-/// [`push`] and [`insert`] will never (re)allocate if the reported capacity is
-/// sufficient. [`push`] and [`insert`] *will* (re)allocate if
-/// [`len`]` == `[`capacity`]. That is, the reported capacity is completely
-/// accurate, and can be relied on. It can even be used to manually free the memory
-/// allocated by a `Vec` if desired. Bulk insertion methods *may* reallocate, even
-/// when not necessary.
-///
-/// `Vec` does not guarantee any particular growth strategy when reallocating
-/// when full, nor when [`reserve`] is called. The current strategy is basic
-/// and it may prove desirable to use a non-constant growth factor. Whatever
-/// strategy is used will of course guarantee `O(1)` amortized [`push`].
-///
-/// `vec![x; n]`, `vec![a, b, c, d]`, and
-/// [`Vec::with_capacity(n)`][`Vec::with_capacity`], will all produce a `Vec`
-/// with exactly the requested capacity. If [`len`]` == `[`capacity`],
-/// (as is the case for the [`vec!`] macro), then a `Vec<T>` can be converted to
-/// and from a [`Box<[T]>`][owned slice] without reallocating or moving the elements.
-///
-/// `Vec` will not specifically overwrite any data that is removed from it,
-/// but also won't specifically preserve it. Its uninitialized memory is
-/// scratch space that it may use however it wants. It will generally just do
-/// whatever is most efficient or otherwise easy to implement. Do not rely on
-/// removed data to be erased for security purposes. Even if you drop a `Vec`, its
-/// buffer may simply be reused by another `Vec`. Even if you zero a `Vec`'s memory
-/// first, that may not actually happen because the optimizer does not consider
-/// this a side-effect that must be preserved. There is one case which we will
-/// not break, however: using `unsafe` code to write to the excess capacity,
-/// and then increasing the length to match, is always valid.
-///
-/// `Vec` does not currently guarantee the order in which elements are dropped
-/// (the order has changed in the past, and may change again).
-///
-/// [`vec!`]: ../../std/macro.vec.html
-/// [`Index`]: ../../std/ops/trait.Index.html
-/// [`String`]: ../../std/string/struct.String.html
-/// [`&str`]: ../../std/primitive.str.html
-/// [`Vec::with_capacity`]: ../../std/vec/struct.Vec.html#method.with_capacity
-/// [`Vec::new`]: ../../std/vec/struct.Vec.html#method.new
-/// [`shrink_to_fit`]: ../../std/vec/struct.Vec.html#method.shrink_to_fit
-/// [`capacity`]: ../../std/vec/struct.Vec.html#method.capacity
-/// [`mem::size_of::<T>`]: ../../std/mem/fn.size_of.html
-/// [`len`]: ../../std/vec/struct.Vec.html#method.len
-/// [`push`]: ../../std/vec/struct.Vec.html#method.push
-/// [`insert`]: ../../std/vec/struct.Vec.html#method.insert
-/// [`reserve`]: ../../std/vec/struct.Vec.html#method.reserve
-/// [owned slice]: ../../std/boxed/struct.Box.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Vec<T> {
-    buf: RawVec<T>,
-    len: usize,
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Inherent methods
-////////////////////////////////////////////////////////////////////////////////
-
-impl<T> Vec<T> {
-    /// Constructs a new, empty `Vec<T>`.
-    ///
-    /// The vector will not allocate until elements are pushed onto it.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![allow(unused_mut)]
-    /// let mut vec: Vec<i32> = Vec::new();
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> Vec<T> {
-        Vec {
-            buf: RawVec::new(),
-            len: 0,
-        }
-    }
-
-    /// Constructs a new, empty `Vec<T>` with the specified capacity.
-    ///
-    /// The vector will be able to hold exactly `capacity` elements without
-    /// reallocating. If `capacity` is 0, the vector will not allocate.
-    ///
-    /// It is important to note that this function does not specify the *length*
-    /// of the returned vector, but only the *capacity*. For an explanation of
-    /// the difference between length and capacity, see *[Capacity and reallocation]*.
-    ///
-    /// [Capacity and reallocation]: #capacity-and-reallocation
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = Vec::with_capacity(10);
-    ///
-    /// // The vector contains no items, even though it has capacity for more
-    /// assert_eq!(vec.len(), 0);
-    ///
-    /// // These are all done without reallocating...
-    /// for i in 0..10 {
-    ///     vec.push(i);
-    /// }
-    ///
-    /// // ...but this may make the vector reallocate
-    /// vec.push(11);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(capacity: usize) -> Vec<T> {
-        Vec {
-            buf: RawVec::with_capacity(capacity),
-            len: 0,
-        }
-    }
-
-    /// Creates a `Vec<T>` directly from the raw components of another vector.
-    ///
-    /// # Safety
-    ///
-    /// This is highly unsafe, due to the number of invariants that aren't
-    /// checked:
-    ///
-    /// * `ptr` needs to have been previously allocated via [`String`]/`Vec<T>`
-    ///   (at least, it's highly likely to be incorrect if it wasn't).
-    /// * `length` needs to be less than or equal to `capacity`.
-    /// * `capacity` needs to be the capacity that the pointer was allocated with.
-    ///
-    /// Violating these may cause problems like corrupting the allocator's
-    /// internal datastructures. For example it is **not** safe
-    /// to build a `Vec<u8>` from a pointer to a C `char` array and a `size_t`.
-    ///
-    /// The ownership of `ptr` is effectively transferred to the
-    /// `Vec<T>` which may then deallocate, reallocate or change the
-    /// contents of memory pointed to by the pointer at will. Ensure
-    /// that nothing else uses the pointer after calling this
-    /// function.
-    ///
-    /// [`String`]: ../../std/string/struct.String.html
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ptr;
-    /// use std::mem;
-    ///
-    /// fn main() {
-    ///     let mut v = vec![1, 2, 3];
-    ///
-    ///     // Pull out the various important pieces of information about `v`
-    ///     let p = v.as_mut_ptr();
-    ///     let len = v.len();
-    ///     let cap = v.capacity();
-    ///
-    ///     unsafe {
-    ///         // Cast `v` into the void: no destructor run, so we are in
-    ///         // complete control of the allocation to which `p` points.
-    ///         mem::forget(v);
-    ///
-    ///         // Overwrite memory with 4, 5, 6
-    ///         for i in 0..len as isize {
-    ///             ptr::write(p.offset(i), 4 + i);
-    ///         }
-    ///
-    ///         // Put everything back together into a Vec
-    ///         let rebuilt = Vec::from_raw_parts(p, len, cap);
-    ///         assert_eq!(rebuilt, [4, 5, 6]);
-    ///     }
-    /// }
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn from_raw_parts(ptr: *mut T, length: usize, capacity: usize) -> Vec<T> {
-        Vec {
-            buf: RawVec::from_raw_parts(ptr, capacity),
-            len: length,
-        }
-    }
-
-    /// Returns the number of elements the vector can hold without
-    /// reallocating.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let vec: Vec<i32> = Vec::with_capacity(10);
-    /// assert_eq!(vec.capacity(), 10);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> usize {
-        self.buf.cap()
-    }
-
-    /// Reserves capacity for at least `additional` more elements to be inserted
-    /// in the given `Vec<T>`. The collection may reserve more space to avoid
-    /// frequent reallocations. After calling `reserve`, capacity will be
-    /// greater than or equal to `self.len() + additional`. Does nothing if
-    /// capacity is already sufficient.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1];
-    /// vec.reserve(10);
-    /// assert!(vec.capacity() >= 11);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: usize) {
-        self.buf.reserve(self.len, additional);
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more elements to
-    /// be inserted in the given `Vec<T>`. After calling `reserve_exact`,
-    /// capacity will be greater than or equal to `self.len() + additional`.
-    /// Does nothing if the capacity is already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it
-    /// requests. Therefore capacity can not be relied upon to be precisely
-    /// minimal. Prefer `reserve` if future insertions are expected.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1];
-    /// vec.reserve_exact(10);
-    /// assert!(vec.capacity() >= 11);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.buf.reserve_exact(self.len, additional);
-    }
-
-    /// Shrinks the capacity of the vector as much as possible.
-    ///
-    /// It will drop down as close as possible to the length but the allocator
-    /// may still inform the vector that there is space for a few more elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = Vec::with_capacity(10);
-    /// vec.extend([1, 2, 3].iter().cloned());
-    /// assert_eq!(vec.capacity(), 10);
-    /// vec.shrink_to_fit();
-    /// assert!(vec.capacity() >= 3);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn shrink_to_fit(&mut self) {
-        self.buf.shrink_to_fit(self.len);
-    }
-
-    /// Converts the vector into [`Box<[T]>`][owned slice].
-    ///
-    /// Note that this will drop any excess capacity. Calling this and
-    /// converting back to a vector with [`into_vec`] is equivalent to calling
-    /// [`shrink_to_fit`].
-    ///
-    /// [owned slice]: ../../std/boxed/struct.Box.html
-    /// [`into_vec`]: ../../std/primitive.slice.html#method.into_vec
-    /// [`shrink_to_fit`]: #method.shrink_to_fit
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = vec![1, 2, 3];
-    ///
-    /// let slice = v.into_boxed_slice();
-    /// ```
-    ///
-    /// Any excess capacity is removed:
-    ///
-    /// ```
-    /// let mut vec = Vec::with_capacity(10);
-    /// vec.extend([1, 2, 3].iter().cloned());
-    ///
-    /// assert_eq!(vec.capacity(), 10);
-    /// let slice = vec.into_boxed_slice();
-    /// assert_eq!(slice.into_vec().capacity(), 3);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn into_boxed_slice(mut self) -> Box<[T]> {
-        unsafe {
-            self.shrink_to_fit();
-            let buf = ptr::read(&self.buf);
-            mem::forget(self);
-            buf.into_box()
-        }
-    }
-
-    /// Shortens the vector, keeping the first `len` elements and dropping
-    /// the rest.
-    ///
-    /// If `len` is greater than the vector's current length, this has no
-    /// effect.
-    ///
-    /// The [`drain`] method can emulate `truncate`, but causes the excess
-    /// elements to be returned instead of dropped.
-    ///
-    /// Note that this method has no effect on the allocated capacity
-    /// of the vector.
-    ///
-    /// # Examples
-    ///
-    /// Truncating a five element vector to two elements:
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3, 4, 5];
-    /// vec.truncate(2);
-    /// assert_eq!(vec, [1, 2]);
-    /// ```
-    ///
-    /// No truncation occurs when `len` is greater than the vector's current
-    /// length:
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3];
-    /// vec.truncate(8);
-    /// assert_eq!(vec, [1, 2, 3]);
-    /// ```
-    ///
-    /// Truncating when `len == 0` is equivalent to calling the [`clear`]
-    /// method.
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3];
-    /// vec.truncate(0);
-    /// assert_eq!(vec, []);
-    /// ```
-    ///
-    /// [`clear`]: #method.clear
-    /// [`drain`]: #method.drain
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn truncate(&mut self, len: usize) {
-        unsafe {
-            // drop any extra elements
-            while len < self.len {
-                // decrement len before the drop_in_place(), so a panic on Drop
-                // doesn't re-drop the just-failed value.
-                self.len -= 1;
-                let len = self.len;
-                ptr::drop_in_place(self.get_unchecked_mut(len));
-            }
-        }
-    }
-
-    /// Extracts a slice containing the entire vector.
-    ///
-    /// Equivalent to `&s[..]`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::{self, Write};
-    /// let buffer = vec![1, 2, 3, 5, 8];
-    /// io::sink().write(buffer.as_slice()).unwrap();
-    /// ```
-    #[inline]
-    #[stable(feature = "vec_as_slice", since = "1.7.0")]
-    pub fn as_slice(&self) -> &[T] {
-        self
-    }
-
-    /// Extracts a mutable slice of the entire vector.
-    ///
-    /// Equivalent to `&mut s[..]`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::io::{self, Read};
-    /// let mut buffer = vec![0; 3];
-    /// io::repeat(0b101).read_exact(buffer.as_mut_slice()).unwrap();
-    /// ```
-    #[inline]
-    #[stable(feature = "vec_as_slice", since = "1.7.0")]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        self
-    }
-
-    /// Sets the length of a vector.
-    ///
-    /// This will explicitly set the size of the vector, without actually
-    /// modifying its buffers, so it is up to the caller to ensure that the
-    /// vector is actually the specified size.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ptr;
-    ///
-    /// let mut vec = vec!['r', 'u', 's', 't'];
-    ///
-    /// unsafe {
-    ///     ptr::drop_in_place(&mut vec[3]);
-    ///     vec.set_len(3);
-    /// }
-    /// assert_eq!(vec, ['r', 'u', 's']);
-    /// ```
-    ///
-    /// In this example, there is a memory leak since the memory locations
-    /// owned by the inner vectors were not freed prior to the `set_len` call:
-    ///
-    /// ```
-    /// let mut vec = vec![vec![1, 0, 0],
-    ///                    vec![0, 1, 0],
-    ///                    vec![0, 0, 1]];
-    /// unsafe {
-    ///     vec.set_len(0);
-    /// }
-    /// ```
-    ///
-    /// In this example, the vector gets expanded from zero to four items
-    /// without any memory allocations occurring, resulting in vector
-    /// values of unallocated memory:
-    ///
-    /// ```
-    /// let mut vec: Vec<char> = Vec::new();
-    ///
-    /// unsafe {
-    ///     vec.set_len(4);
-    /// }
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub unsafe fn set_len(&mut self, len: usize) {
-        self.len = len;
-    }
-
-    /// Removes an element from the vector and returns it.
-    ///
-    /// The removed element is replaced by the last element of the vector.
-    ///
-    /// This does not preserve ordering, but is O(1).
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = vec!["foo", "bar", "baz", "qux"];
-    ///
-    /// assert_eq!(v.swap_remove(1), "bar");
-    /// assert_eq!(v, ["foo", "qux", "baz"]);
-    ///
-    /// assert_eq!(v.swap_remove(0), "foo");
-    /// assert_eq!(v, ["baz", "qux"]);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn swap_remove(&mut self, index: usize) -> T {
-        let length = self.len();
-        self.swap(index, length - 1);
-        self.pop().unwrap()
-    }
-
-    /// Inserts an element at position `index` within the vector, shifting all
-    /// elements after it to the right.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3];
-    /// vec.insert(1, 4);
-    /// assert_eq!(vec, [1, 4, 2, 3]);
-    /// vec.insert(4, 5);
-    /// assert_eq!(vec, [1, 4, 2, 3, 5]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn insert(&mut self, index: usize, element: T) {
-        let len = self.len();
-        assert!(index <= len);
-
-        // space for the new element
-        if len == self.buf.cap() {
-            self.buf.double();
-        }
-
-        unsafe {
-            // infallible
-            // The spot to put the new value
-            {
-                let p = self.as_mut_ptr().offset(index as isize);
-                // Shift everything over to make space. (Duplicating the
-                // `index`th element into two consecutive places.)
-                ptr::copy(p, p.offset(1), len - index);
-                // Write it in, overwriting the first copy of the `index`th
-                // element.
-                ptr::write(p, element);
-            }
-            self.set_len(len + 1);
-        }
-    }
-
-    /// Removes and returns the element at position `index` within the vector,
-    /// shifting all elements after it to the left.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is out of bounds.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = vec![1, 2, 3];
-    /// assert_eq!(v.remove(1), 2);
-    /// assert_eq!(v, [1, 3]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, index: usize) -> T {
-        let len = self.len();
-        assert!(index < len);
-        unsafe {
-            // infallible
-            let ret;
-            {
-                // the place we are taking from.
-                let ptr = self.as_mut_ptr().offset(index as isize);
-                // copy it out, unsafely having a copy of the value on
-                // the stack and in the vector at the same time.
-                ret = ptr::read(ptr);
-
-                // Shift everything down to fill in that spot.
-                ptr::copy(ptr.offset(1), ptr, len - index - 1);
-            }
-            self.set_len(len - 1);
-            ret
-        }
-    }
-
-    /// Retains only the elements specified by the predicate.
-    ///
-    /// In other words, remove all elements `e` such that `f(&e)` returns `false`.
-    /// This method operates in place and preserves the order of the retained
-    /// elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3, 4];
-    /// vec.retain(|&x| x%2 == 0);
-    /// assert_eq!(vec, [2, 4]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn retain<F>(&mut self, mut f: F)
-        where F: FnMut(&T) -> bool
-    {
-        let len = self.len();
-        let mut del = 0;
-        {
-            let v = &mut **self;
-
-            for i in 0..len {
-                if !f(&v[i]) {
-                    del += 1;
-                } else if del > 0 {
-                    v.swap(i - del, i);
-                }
-            }
-        }
-        if del > 0 {
-            self.truncate(len - del);
-        }
-    }
-
-    /// Removes consecutive elements in the vector that resolve to the same key.
-    ///
-    /// If the vector is sorted, this removes all duplicates.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![10, 20, 21, 30, 20];
-    ///
-    /// vec.dedup_by_key(|i| *i / 10);
-    ///
-    /// assert_eq!(vec, [10, 20, 30, 20]);
-    /// ```
-    #[stable(feature = "dedup_by", since = "1.16.0")]
-    #[inline]
-    pub fn dedup_by_key<F, K>(&mut self, mut key: F) where F: FnMut(&mut T) -> K, K: PartialEq {
-        self.dedup_by(|a, b| key(a) == key(b))
-    }
-
-    /// Removes consecutive elements in the vector according to a predicate.
-    ///
-    /// The `same_bucket` function is passed references to two elements from the vector, and
-    /// returns `true` if the elements compare equal, or `false` if they do not. Only the first
-    /// of adjacent equal items is kept.
-    ///
-    /// If the vector is sorted, this removes all duplicates.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::ascii::AsciiExt;
-    ///
-    /// let mut vec = vec!["foo", "bar", "Bar", "baz", "bar"];
-    ///
-    /// vec.dedup_by(|a, b| a.eq_ignore_ascii_case(b));
-    ///
-    /// assert_eq!(vec, ["foo", "bar", "baz", "bar"]);
-    /// ```
-    #[stable(feature = "dedup_by", since = "1.16.0")]
-    pub fn dedup_by<F>(&mut self, mut same_bucket: F) where F: FnMut(&mut T, &mut T) -> bool {
-        unsafe {
-            // Although we have a mutable reference to `self`, we cannot make
-            // *arbitrary* changes. The `same_bucket` calls could panic, so we
-            // must ensure that the vector is in a valid state at all time.
-            //
-            // The way that we handle this is by using swaps; we iterate
-            // over all the elements, swapping as we go so that at the end
-            // the elements we wish to keep are in the front, and those we
-            // wish to reject are at the back. We can then truncate the
-            // vector. This operation is still O(n).
-            //
-            // Example: We start in this state, where `r` represents "next
-            // read" and `w` represents "next_write`.
-            //
-            //           r
-            //     +---+---+---+---+---+---+
-            //     | 0 | 1 | 1 | 2 | 3 | 3 |
-            //     +---+---+---+---+---+---+
-            //           w
-            //
-            // Comparing self[r] against self[w-1], this is not a duplicate, so
-            // we swap self[r] and self[w] (no effect as r==w) and then increment both
-            // r and w, leaving us with:
-            //
-            //               r
-            //     +---+---+---+---+---+---+
-            //     | 0 | 1 | 1 | 2 | 3 | 3 |
-            //     +---+---+---+---+---+---+
-            //               w
-            //
-            // Comparing self[r] against self[w-1], this value is a duplicate,
-            // so we increment `r` but leave everything else unchanged:
-            //
-            //                   r
-            //     +---+---+---+---+---+---+
-            //     | 0 | 1 | 1 | 2 | 3 | 3 |
-            //     +---+---+---+---+---+---+
-            //               w
-            //
-            // Comparing self[r] against self[w-1], this is not a duplicate,
-            // so swap self[r] and self[w] and advance r and w:
-            //
-            //                       r
-            //     +---+---+---+---+---+---+
-            //     | 0 | 1 | 2 | 1 | 3 | 3 |
-            //     +---+---+---+---+---+---+
-            //                   w
-            //
-            // Not a duplicate, repeat:
-            //
-            //                           r
-            //     +---+---+---+---+---+---+
-            //     | 0 | 1 | 2 | 3 | 1 | 3 |
-            //     +---+---+---+---+---+---+
-            //                       w
-            //
-            // Duplicate, advance r. End of vec. Truncate to w.
-
-            let ln = self.len();
-            if ln <= 1 {
-                return;
-            }
-
-            // Avoid bounds checks by using raw pointers.
-            let p = self.as_mut_ptr();
-            let mut r: usize = 1;
-            let mut w: usize = 1;
-
-            while r < ln {
-                let p_r = p.offset(r as isize);
-                let p_wm1 = p.offset((w - 1) as isize);
-                if !same_bucket(&mut *p_r, &mut *p_wm1) {
-                    if r != w {
-                        let p_w = p_wm1.offset(1);
-                        mem::swap(&mut *p_r, &mut *p_w);
-                    }
-                    w += 1;
-                }
-                r += 1;
-            }
-
-            self.truncate(w);
-        }
-    }
-
-    /// Appends an element to the back of a collection.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the number of elements in the vector overflows a `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2];
-    /// vec.push(3);
-    /// assert_eq!(vec, [1, 2, 3]);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push(&mut self, value: T) {
-        // This will panic or abort if we would allocate > isize::MAX bytes
-        // or if the length increment would overflow for zero-sized types.
-        if self.len == self.buf.cap() {
-            self.buf.double();
-        }
-        unsafe {
-            let end = self.as_mut_ptr().offset(self.len as isize);
-            ptr::write(end, value);
-            self.len += 1;
-        }
-    }
-
-    /// Returns a place for insertion at the back of the `Vec`.
-    ///
-    /// Using this method with placement syntax is equivalent to [`push`](#method.push),
-    /// but may be more efficient.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collection_placement)]
-    /// #![feature(placement_in_syntax)]
-    ///
-    /// let mut vec = vec![1, 2];
-    /// vec.place_back() <- 3;
-    /// vec.place_back() <- 4;
-    /// assert_eq!(&vec, &[1, 2, 3, 4]);
-    /// ```
-    #[unstable(feature = "collection_placement",
-               reason = "placement protocol is subject to change",
-               issue = "30172")]
-    pub fn place_back(&mut self) -> PlaceBack<T> {
-        PlaceBack { vec: self }
-    }
-
-    /// Removes the last element from a vector and returns it, or [`None`] if it
-    /// is empty.
-    ///
-    /// [`None`]: ../../std/option/enum.Option.html#variant.None
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3];
-    /// assert_eq!(vec.pop(), Some(3));
-    /// assert_eq!(vec, [1, 2]);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop(&mut self) -> Option<T> {
-        if self.len == 0 {
-            None
-        } else {
-            unsafe {
-                self.len -= 1;
-                Some(ptr::read(self.get_unchecked(self.len())))
-            }
-        }
-    }
-
-    /// Moves all the elements of `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the number of elements in the vector overflows a `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 3];
-    /// let mut vec2 = vec![4, 5, 6];
-    /// vec.append(&mut vec2);
-    /// assert_eq!(vec, [1, 2, 3, 4, 5, 6]);
-    /// assert_eq!(vec2, []);
-    /// ```
-    #[inline]
-    #[stable(feature = "append", since = "1.4.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        unsafe {
-            self.append_elements(other.as_slice() as _);
-            other.set_len(0);
-        }
-    }
-
-    /// Appends elements to `Self` from other buffer.
-    #[inline]
-    unsafe fn append_elements(&mut self, other: *const [T]) {
-        let count = (*other).len();
-        self.reserve(count);
-        let len = self.len();
-        ptr::copy_nonoverlapping(other as *const T, self.get_unchecked_mut(len), count);
-        self.len += count;
-    }
-
-    /// Creates a draining iterator that removes the specified range in the vector
-    /// and yields the removed items.
-    ///
-    /// Note 1: The element range is removed even if the iterator is only
-    /// partially consumed or not consumed at all.
-    ///
-    /// Note 2: It is unspecified how many elements are removed from the vector
-    /// if the `Drain` value is leaked.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the vector.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = vec![1, 2, 3];
-    /// let u: Vec<_> = v.drain(1..).collect();
-    /// assert_eq!(v, &[1]);
-    /// assert_eq!(u, &[2, 3]);
-    ///
-    /// // A full range clears the vector
-    /// v.drain(..);
-    /// assert_eq!(v, &[]);
-    /// ```
-    #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain<R>(&mut self, range: R) -> Drain<T>
-        where R: RangeArgument<usize>
-    {
-        // Memory safety
-        //
-        // When the Drain is first created, it shortens the length of
-        // the source vector to make sure no uninitalized or moved-from elements
-        // are accessible at all if the Drain's destructor never gets to run.
-        //
-        // Drain will ptr::read out the values to remove.
-        // When finished, remaining tail of the vec is copied back to cover
-        // the hole, and the vector length is restored to the new length.
-        //
-        let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
-            Unbounded    => 0,
-        };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
-            Unbounded    => len,
-        };
-        assert!(start <= end);
-        assert!(end <= len);
-
-        unsafe {
-            // set self.vec length's to start, to be safe in case Drain is leaked
-            self.set_len(start);
-            // Use the borrow in the IterMut to indicate borrowing behavior of the
-            // whole Drain iterator (like &mut T).
-            let range_slice = slice::from_raw_parts_mut(self.as_mut_ptr().offset(start as isize),
-                                                        end - start);
-            Drain {
-                tail_start: end,
-                tail_len: len - end,
-                iter: range_slice.iter(),
-                vec: Shared::new(self as *mut _),
-            }
-        }
-    }
-
-    /// Clears the vector, removing all values.
-    ///
-    /// Note that this method has no effect on the allocated capacity
-    /// of the vector.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = vec![1, 2, 3];
-    ///
-    /// v.clear();
-    ///
-    /// assert!(v.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn clear(&mut self) {
-        self.truncate(0)
-    }
-
-    /// Returns the number of elements in the vector, also referred to
-    /// as its 'length'.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let a = vec![1, 2, 3];
-    /// assert_eq!(a.len(), 3);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        self.len
-    }
-
-    /// Returns `true` if the vector contains no elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut v = Vec::new();
-    /// assert!(v.is_empty());
-    ///
-    /// v.push(1);
-    /// assert!(!v.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.len() == 0
-    }
-
-    /// Splits the collection into two at the given index.
-    ///
-    /// Returns a newly allocated `Self`. `self` contains elements `[0, at)`,
-    /// and the returned `Self` contains elements `[at, len)`.
-    ///
-    /// Note that the capacity of `self` does not change.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1,2,3];
-    /// let vec2 = vec.split_off(1);
-    /// assert_eq!(vec, [1]);
-    /// assert_eq!(vec2, [2, 3]);
-    /// ```
-    #[inline]
-    #[stable(feature = "split_off", since = "1.4.0")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        assert!(at <= self.len(), "`at` out of bounds");
-
-        let other_len = self.len - at;
-        let mut other = Vec::with_capacity(other_len);
-
-        // Unsafely `set_len` and copy items to `other`.
-        unsafe {
-            self.set_len(at);
-            other.set_len(other_len);
-
-            ptr::copy_nonoverlapping(self.as_ptr().offset(at as isize),
-                                     other.as_mut_ptr(),
-                                     other.len());
-        }
-        other
-    }
-}
-
-impl<T: Clone> Vec<T> {
-    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
-    ///
-    /// If `new_len` is greater than `len`, the `Vec` is extended by the
-    /// difference, with each additional slot filled with `value`.
-    /// If `new_len` is less than `len`, the `Vec` is simply truncated.
-    ///
-    /// This method requires `Clone` to clone the passed value. If you'd
-    /// rather create a value with `Default` instead, see [`resize_default`].
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec!["hello"];
-    /// vec.resize(3, "world");
-    /// assert_eq!(vec, ["hello", "world", "world"]);
-    ///
-    /// let mut vec = vec![1, 2, 3, 4];
-    /// vec.resize(2, 0);
-    /// assert_eq!(vec, [1, 2]);
-    /// ```
-    ///
-    /// [`resize_default`]: #method.resize_default
-    #[stable(feature = "vec_resize", since = "1.5.0")]
-    pub fn resize(&mut self, new_len: usize, value: T) {
-        let len = self.len();
-
-        if new_len > len {
-            self.extend_with(new_len - len, ExtendElement(value))
-        } else {
-            self.truncate(new_len);
-        }
-    }
-
-    /// Clones and appends all elements in a slice to the `Vec`.
-    ///
-    /// Iterates over the slice `other`, clones each element, and then appends
-    /// it to this `Vec`. The `other` vector is traversed in-order.
-    ///
-    /// Note that this function is same as `extend` except that it is
-    /// specialized to work with slices instead. If and when Rust gets
-    /// specialization this function will likely be deprecated (but still
-    /// available).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1];
-    /// vec.extend_from_slice(&[2, 3, 4]);
-    /// assert_eq!(vec, [1, 2, 3, 4]);
-    /// ```
-    #[stable(feature = "vec_extend_from_slice", since = "1.6.0")]
-    pub fn extend_from_slice(&mut self, other: &[T]) {
-        self.spec_extend(other.iter())
-    }
-}
-
-impl<T: Default> Vec<T> {
-    /// Resizes the `Vec` in-place so that `len` is equal to `new_len`.
-    ///
-    /// If `new_len` is greater than `len`, the `Vec` is extended by the
-    /// difference, with each additional slot filled with `Default::default()`.
-    /// If `new_len` is less than `len`, the `Vec` is simply truncated.
-    ///
-    /// This method uses `Default` to create new values on every push. If
-    /// you'd rather `Clone` a given value, use [`resize`].
-    ///
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(vec_resize_default)]
-    ///
-    /// let mut vec = vec![1, 2, 3];
-    /// vec.resize_default(5);
-    /// assert_eq!(vec, [1, 2, 3, 0, 0]);
-    ///
-    /// let mut vec = vec![1, 2, 3, 4];
-    /// vec.resize_default(2);
-    /// assert_eq!(vec, [1, 2]);
-    /// ```
-    ///
-    /// [`resize`]: #method.resize
-    #[unstable(feature = "vec_resize_default", issue = "41758")]
-    pub fn resize_default(&mut self, new_len: usize) {
-        let len = self.len();
-
-        if new_len > len {
-            self.extend_with(new_len - len, ExtendDefault);
-        } else {
-            self.truncate(new_len);
-        }
-    }
-}
-
-// This code generalises `extend_with_{element,default}`.
-trait ExtendWith<T> {
-    fn next(&self) -> T;
-    fn last(self) -> T;
-}
-
-struct ExtendElement<T>(T);
-impl<T: Clone> ExtendWith<T> for ExtendElement<T> {
-    fn next(&self) -> T { self.0.clone() }
-    fn last(self) -> T { self.0 }
-}
-
-struct ExtendDefault;
-impl<T: Default> ExtendWith<T> for ExtendDefault {
-    fn next(&self) -> T { Default::default() }
-    fn last(self) -> T { Default::default() }
-}
-impl<T> Vec<T> {
-    /// Extend the vector by `n` values, using the given generator.
-    fn extend_with<E: ExtendWith<T>>(&mut self, n: usize, value: E) {
-        self.reserve(n);
-
-        unsafe {
-            let mut ptr = self.as_mut_ptr().offset(self.len() as isize);
-            // Use SetLenOnDrop to work around bug where compiler
-            // may not realize the store through `ptr` through self.set_len()
-            // don't alias.
-            let mut local_len = SetLenOnDrop::new(&mut self.len);
-
-            // Write all elements except the last one
-            for _ in 1..n {
-                ptr::write(ptr, value.next());
-                ptr = ptr.offset(1);
-                // Increment the length in every step in case next() panics
-                local_len.increment_len(1);
-            }
-
-            if n > 0 {
-                // We can write the last element directly without cloning needlessly
-                ptr::write(ptr, value.last());
-                local_len.increment_len(1);
-            }
-
-            // len set by scope guard
-        }
-    }
-}
-
-// Set the length of the vec when the `SetLenOnDrop` value goes out of scope.
-//
-// The idea is: The length field in SetLenOnDrop is a local variable
-// that the optimizer will see does not alias with any stores through the Vec's data
-// pointer. This is a workaround for alias analysis issue #32155
-struct SetLenOnDrop<'a> {
-    len: &'a mut usize,
-    local_len: usize,
-}
-
-impl<'a> SetLenOnDrop<'a> {
-    #[inline]
-    fn new(len: &'a mut usize) -> Self {
-        SetLenOnDrop { local_len: *len, len: len }
-    }
-
-    #[inline]
-    fn increment_len(&mut self, increment: usize) {
-        self.local_len += increment;
-    }
-}
-
-impl<'a> Drop for SetLenOnDrop<'a> {
-    #[inline]
-    fn drop(&mut self) {
-        *self.len = self.local_len;
-    }
-}
-
-impl<T: PartialEq> Vec<T> {
-    /// Removes consecutive repeated elements in the vector.
-    ///
-    /// If the vector is sorted, this removes all duplicates.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let mut vec = vec![1, 2, 2, 3, 2];
-    ///
-    /// vec.dedup();
-    ///
-    /// assert_eq!(vec, [1, 2, 3, 2]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn dedup(&mut self) {
-        self.dedup_by(|a, b| a == b)
-    }
-
-    /// Removes the first instance of `item` from the vector if the item exists.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # #![feature(vec_remove_item)]
-    /// let mut vec = vec![1, 2, 3, 1];
-    ///
-    /// vec.remove_item(&1);
-    ///
-    /// assert_eq!(vec, vec![2, 3, 1]);
-    /// ```
-    #[unstable(feature = "vec_remove_item", reason = "recently added", issue = "40062")]
-    pub fn remove_item(&mut self, item: &T) -> Option<T> {
-        let pos = match self.iter().position(|x| *x == *item) {
-            Some(x) => x,
-            None => return None,
-        };
-        Some(self.remove(pos))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Internal methods and functions
-////////////////////////////////////////////////////////////////////////////////
-
-#[doc(hidden)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub fn from_elem<T: Clone>(elem: T, n: usize) -> Vec<T> {
-    <T as SpecFromElem>::from_elem(elem, n)
-}
-
-// Specialization trait used for Vec::from_elem
-trait SpecFromElem: Sized {
-    fn from_elem(elem: Self, n: usize) -> Vec<Self>;
-}
-
-impl<T: Clone> SpecFromElem for T {
-    default fn from_elem(elem: Self, n: usize) -> Vec<Self> {
-        let mut v = Vec::with_capacity(n);
-        v.extend_with(n, ExtendElement(elem));
-        v
-    }
-}
-
-impl SpecFromElem for u8 {
-    #[inline]
-    fn from_elem(elem: u8, n: usize) -> Vec<u8> {
-        if elem == 0 {
-            return Vec {
-                buf: RawVec::with_capacity_zeroed(n),
-                len: n,
-            }
-        }
-        unsafe {
-            let mut v = Vec::with_capacity(n);
-            ptr::write_bytes(v.as_mut_ptr(), elem, n);
-            v.set_len(n);
-            v
-        }
-    }
-}
-
-macro_rules! impl_spec_from_elem {
-    ($t: ty, $is_zero: expr) => {
-        impl SpecFromElem for $t {
-            #[inline]
-            fn from_elem(elem: $t, n: usize) -> Vec<$t> {
-                if $is_zero(elem) {
-                    return Vec {
-                        buf: RawVec::with_capacity_zeroed(n),
-                        len: n,
-                    }
-                }
-                let mut v = Vec::with_capacity(n);
-                v.extend_with(n, ExtendElement(elem));
-                v
-            }
-        }
-    };
-}
-
-impl_spec_from_elem!(i8, |x| x == 0);
-impl_spec_from_elem!(i16, |x| x == 0);
-impl_spec_from_elem!(i32, |x| x == 0);
-impl_spec_from_elem!(i64, |x| x == 0);
-impl_spec_from_elem!(i128, |x| x == 0);
-impl_spec_from_elem!(isize, |x| x == 0);
-
-impl_spec_from_elem!(u16, |x| x == 0);
-impl_spec_from_elem!(u32, |x| x == 0);
-impl_spec_from_elem!(u64, |x| x == 0);
-impl_spec_from_elem!(u128, |x| x == 0);
-impl_spec_from_elem!(usize, |x| x == 0);
-
-impl_spec_from_elem!(f32, |x: f32| x == 0. && x.is_sign_positive());
-impl_spec_from_elem!(f64, |x: f64| x == 0. && x.is_sign_positive());
-
-////////////////////////////////////////////////////////////////////////////////
-// Common trait implementations for Vec
-////////////////////////////////////////////////////////////////////////////////
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> Clone for Vec<T> {
-    #[cfg(not(test))]
-    fn clone(&self) -> Vec<T> {
-        <[T]>::to_vec(&**self)
-    }
-
-    // HACK(japaric): with cfg(test) the inherent `[T]::to_vec` method, which is
-    // required for this method definition, is not available. Instead use the
-    // `slice::to_vec`  function which is only available with cfg(test)
-    // NB see the slice::hack module in slice.rs for more information
-    #[cfg(test)]
-    fn clone(&self) -> Vec<T> {
-        ::slice::to_vec(&**self)
-    }
-
-    fn clone_from(&mut self, other: &Vec<T>) {
-        other.as_slice().clone_into(self);
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Hash> Hash for Vec<T> {
-    #[inline]
-    fn hash<H: hash::Hasher>(&self, state: &mut H) {
-        Hash::hash(&**self, state)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Index<usize> for Vec<T> {
-    type Output = T;
-
-    #[inline]
-    fn index(&self, index: usize) -> &T {
-        // NB built-in indexing via `&[T]`
-        &(**self)[index]
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IndexMut<usize> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: usize) -> &mut T {
-        // NB built-in indexing via `&mut [T]`
-        &mut (**self)[index]
-    }
-}
-
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::Range<usize>> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, index: ops::Range<usize>) -> &[T] {
-        Index::index(&**self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeTo<usize>> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, index: ops::RangeTo<usize>) -> &[T] {
-        Index::index(&**self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeFrom<usize>> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, index: ops::RangeFrom<usize>) -> &[T] {
-        Index::index(&**self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Index<ops::RangeFull> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, _index: ops::RangeFull) -> &[T] {
-        self
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> ops::Index<ops::RangeInclusive<usize>> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, index: ops::RangeInclusive<usize>) -> &[T] {
-        Index::index(&**self, index)
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> ops::Index<ops::RangeToInclusive<usize>> for Vec<T> {
-    type Output = [T];
-
-    #[inline]
-    fn index(&self, index: ops::RangeToInclusive<usize>) -> &[T] {
-        Index::index(&**self, index)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::Range<usize>> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: ops::Range<usize>) -> &mut [T] {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeTo<usize>> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeTo<usize>) -> &mut [T] {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeFrom<usize>> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeFrom<usize>) -> &mut [T] {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::IndexMut<ops::RangeFull> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, _index: ops::RangeFull) -> &mut [T] {
-        self
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> ops::IndexMut<ops::RangeInclusive<usize>> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeInclusive<usize>) -> &mut [T] {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-#[unstable(feature = "inclusive_range", reason = "recently added, follows RFC", issue = "28237")]
-impl<T> ops::IndexMut<ops::RangeToInclusive<usize>> for Vec<T> {
-    #[inline]
-    fn index_mut(&mut self, index: ops::RangeToInclusive<usize>) -> &mut [T] {
-        IndexMut::index_mut(&mut **self, index)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::Deref for Vec<T> {
-    type Target = [T];
-
-    fn deref(&self) -> &[T] {
-        unsafe {
-            let p = self.buf.ptr();
-            assume(!p.is_null());
-            slice::from_raw_parts(p, self.len)
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ops::DerefMut for Vec<T> {
-    fn deref_mut(&mut self) -> &mut [T] {
-        unsafe {
-            let ptr = self.buf.ptr();
-            assume(!ptr.is_null());
-            slice::from_raw_parts_mut(ptr, self.len)
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> FromIterator<T> for Vec<T> {
-    #[inline]
-    fn from_iter<I: IntoIterator<Item = T>>(iter: I) -> Vec<T> {
-        <Self as SpecExtend<T, I::IntoIter>>::from_iter(iter.into_iter())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IntoIterator for Vec<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    /// Creates a consuming iterator, that is, one that moves each value out of
-    /// the vector (from start to end). The vector cannot be used after calling
-    /// this.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let v = vec!["a".to_string(), "b".to_string()];
-    /// for s in v.into_iter() {
-    ///     // s has type String, not &String
-    ///     println!("{}", s);
-    /// }
-    /// ```
-    #[inline]
-    fn into_iter(mut self) -> IntoIter<T> {
-        unsafe {
-            let begin = self.as_mut_ptr();
-            assume(!begin.is_null());
-            let end = if mem::size_of::<T>() == 0 {
-                arith_offset(begin as *const i8, self.len() as isize) as *const T
-            } else {
-                begin.offset(self.len() as isize) as *const T
-            };
-            let cap = self.buf.cap();
-            mem::forget(self);
-            IntoIter {
-                buf: Shared::new(begin),
-                cap: cap,
-                ptr: begin,
-                end: end,
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a Vec<T> {
-    type Item = &'a T;
-    type IntoIter = slice::Iter<'a, T>;
-
-    fn into_iter(self) -> slice::Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut Vec<T> {
-    type Item = &'a mut T;
-    type IntoIter = slice::IterMut<'a, T>;
-
-    fn into_iter(mut self) -> slice::IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Extend<T> for Vec<T> {
-    #[inline]
-    fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
-        <Self as SpecExtend<T, I::IntoIter>>::spec_extend(self, iter.into_iter())
-    }
-}
-
-// Specialization trait used for Vec::from_iter and Vec::extend
-trait SpecExtend<T, I> {
-    fn from_iter(iter: I) -> Self;
-    fn spec_extend(&mut self, iter: I);
-}
-
-impl<T, I> SpecExtend<T, I> for Vec<T>
-    where I: Iterator<Item=T>,
-{
-    default fn from_iter(mut iterator: I) -> Self {
-        // Unroll the first iteration, as the vector is going to be
-        // expanded on this iteration in every case when the iterable is not
-        // empty, but the loop in extend_desugared() is not going to see the
-        // vector being full in the few subsequent loop iterations.
-        // So we get better branch prediction.
-        let mut vector = match iterator.next() {
-            None => return Vec::new(),
-            Some(element) => {
-                let (lower, _) = iterator.size_hint();
-                let mut vector = Vec::with_capacity(lower.saturating_add(1));
-                unsafe {
-                    ptr::write(vector.get_unchecked_mut(0), element);
-                    vector.set_len(1);
-                }
-                vector
-            }
-        };
-        <Vec<T> as SpecExtend<T, I>>::spec_extend(&mut vector, iterator);
-        vector
-    }
-
-    default fn spec_extend(&mut self, iter: I) {
-        self.extend_desugared(iter)
-    }
-}
-
-impl<T, I> SpecExtend<T, I> for Vec<T>
-    where I: TrustedLen<Item=T>,
-{
-    default fn from_iter(iterator: I) -> Self {
-        let mut vector = Vec::new();
-        vector.spec_extend(iterator);
-        vector
-    }
-
-    default fn spec_extend(&mut self, iterator: I) {
-        // This is the case for a TrustedLen iterator.
-        let (low, high) = iterator.size_hint();
-        if let Some(high_value) = high {
-            debug_assert_eq!(low, high_value,
-                             "TrustedLen iterator's size hint is not exact: {:?}",
-                             (low, high));
-        }
-        if let Some(additional) = high {
-            self.reserve(additional);
-            unsafe {
-                let mut ptr = self.as_mut_ptr().offset(self.len() as isize);
-                let mut local_len = SetLenOnDrop::new(&mut self.len);
-                for element in iterator {
-                    ptr::write(ptr, element);
-                    ptr = ptr.offset(1);
-                    // NB can't overflow since we would have had to alloc the address space
-                    local_len.increment_len(1);
-                }
-            }
-        } else {
-            self.extend_desugared(iterator)
-        }
-    }
-}
-
-impl<T> SpecExtend<T, IntoIter<T>> for Vec<T> {
-    fn from_iter(iterator: IntoIter<T>) -> Self {
-        // A common case is passing a vector into a function which immediately
-        // re-collects into a vector. We can short circuit this if the IntoIter
-        // has not been advanced at all.
-        if iterator.buf.as_ptr() as *const _ == iterator.ptr {
-            unsafe {
-                let vec = Vec::from_raw_parts(iterator.buf.as_ptr(),
-                                              iterator.len(),
-                                              iterator.cap);
-                mem::forget(iterator);
-                vec
-            }
-        } else {
-            let mut vector = Vec::new();
-            vector.spec_extend(iterator);
-            vector
-        }
-    }
-
-    fn spec_extend(&mut self, mut iterator: IntoIter<T>) {
-        unsafe {
-            self.append_elements(iterator.as_slice() as _);
-        }
-        iterator.ptr = iterator.end;
-    }
-}
-
-impl<'a, T: 'a, I> SpecExtend<&'a T, I> for Vec<T>
-    where I: Iterator<Item=&'a T>,
-          T: Clone,
-{
-    default fn from_iter(iterator: I) -> Self {
-        SpecExtend::from_iter(iterator.cloned())
-    }
-
-    default fn spec_extend(&mut self, iterator: I) {
-        self.spec_extend(iterator.cloned())
-    }
-}
-
-impl<'a, T: 'a> SpecExtend<&'a T, slice::Iter<'a, T>> for Vec<T>
-    where T: Copy,
-{
-    fn spec_extend(&mut self, iterator: slice::Iter<'a, T>) {
-        let slice = iterator.as_slice();
-        self.reserve(slice.len());
-        unsafe {
-            let len = self.len();
-            self.set_len(len + slice.len());
-            self.get_unchecked_mut(len..).copy_from_slice(slice);
-        }
-    }
-}
-
-impl<T> Vec<T> {
-    fn extend_desugared<I: Iterator<Item = T>>(&mut self, mut iterator: I) {
-        // This is the case for a general iterator.
-        //
-        // This function should be the moral equivalent of:
-        //
-        //      for item in iterator {
-        //          self.push(item);
-        //      }
-        while let Some(element) = iterator.next() {
-            let len = self.len();
-            if len == self.capacity() {
-                let (lower, _) = iterator.size_hint();
-                self.reserve(lower.saturating_add(1));
-            }
-            unsafe {
-                ptr::write(self.get_unchecked_mut(len), element);
-                // NB can't overflow since we would have had to alloc the address space
-                self.set_len(len + 1);
-            }
-        }
-    }
-
-    /// Creates a splicing iterator that replaces the specified range in the vector
-    /// with the given `replace_with` iterator and yields the removed items.
-    /// `replace_with` does not need to be the same length as `range`.
-    ///
-    /// Note 1: The element range is removed even if the iterator is not
-    /// consumed until the end.
-    ///
-    /// Note 2: It is unspecified how many elements are removed from the vector,
-    /// if the `Splice` value is leaked.
-    ///
-    /// Note 3: The input iterator `replace_with` is only consumed
-    /// when the `Splice` value is dropped.
-    ///
-    /// Note 4: This is optimal if:
-    ///
-    /// * The tail (elements in the vector after `range`) is empty,
-    /// * or `replace_with` yields fewer elements than `range`’s length
-    /// * or the lower bound of its `size_hint()` is exact.
-    ///
-    /// Otherwise, a temporary vector is allocated and the tail is moved twice.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the vector.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(splice)]
-    /// let mut v = vec![1, 2, 3];
-    /// let new = [7, 8];
-    /// let u: Vec<_> = v.splice(..2, new.iter().cloned()).collect();
-    /// assert_eq!(v, &[7, 8, 3]);
-    /// assert_eq!(u, &[1, 2]);
-    /// ```
-    #[inline]
-    #[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-    pub fn splice<R, I>(&mut self, range: R, replace_with: I) -> Splice<I::IntoIter>
-        where R: RangeArgument<usize>, I: IntoIterator<Item=T>
-    {
-        Splice {
-            drain: self.drain(range),
-            replace_with: replace_with.into_iter(),
-        }
-    }
-
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for Vec<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.spec_extend(iter.into_iter())
-    }
-}
-
-macro_rules! __impl_slice_eq1 {
-    ($Lhs: ty, $Rhs: ty) => {
-        __impl_slice_eq1! { $Lhs, $Rhs, Sized }
-    };
-    ($Lhs: ty, $Rhs: ty, $Bound: ident) => {
-        #[stable(feature = "rust1", since = "1.0.0")]
-        impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
-            #[inline]
-            fn eq(&self, other: &$Rhs) -> bool { self[..] == other[..] }
-            #[inline]
-            fn ne(&self, other: &$Rhs) -> bool { self[..] != other[..] }
-        }
-    }
-}
-
-__impl_slice_eq1! { Vec<A>, Vec<B> }
-__impl_slice_eq1! { Vec<A>, &'b [B] }
-__impl_slice_eq1! { Vec<A>, &'b mut [B] }
-__impl_slice_eq1! { Cow<'a, [A]>, &'b [B], Clone }
-__impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B], Clone }
-__impl_slice_eq1! { Cow<'a, [A]>, Vec<B>, Clone }
-
-macro_rules! array_impls {
-    ($($N: expr)+) => {
-        $(
-            // NOTE: some less important impls are omitted to reduce code bloat
-            __impl_slice_eq1! { Vec<A>, [B; $N] }
-            __impl_slice_eq1! { Vec<A>, &'b [B; $N] }
-            // __impl_slice_eq1! { Vec<A>, &'b mut [B; $N] }
-            // __impl_slice_eq1! { Cow<'a, [A]>, [B; $N], Clone }
-            // __impl_slice_eq1! { Cow<'a, [A]>, &'b [B; $N], Clone }
-            // __impl_slice_eq1! { Cow<'a, [A]>, &'b mut [B; $N], Clone }
-        )+
-    }
-}
-
-array_impls! {
-     0  1  2  3  4  5  6  7  8  9
-    10 11 12 13 14 15 16 17 18 19
-    20 21 22 23 24 25 26 27 28 29
-    30 31 32
-}
-
-/// Implements comparison of vectors, lexicographically.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: PartialOrd> PartialOrd for Vec<T> {
-    #[inline]
-    fn partial_cmp(&self, other: &Vec<T>) -> Option<Ordering> {
-        PartialOrd::partial_cmp(&**self, &**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Eq> Eq for Vec<T> {}
-
-/// Implements ordering of vectors, lexicographically.
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Ord> Ord for Vec<T> {
-    #[inline]
-    fn cmp(&self, other: &Vec<T>) -> Ordering {
-        Ord::cmp(&**self, &**other)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for Vec<T> {
-    fn drop(&mut self) {
-        unsafe {
-            // use drop for [T]
-            ptr::drop_in_place(&mut self[..]);
-        }
-        // RawVec handles deallocation
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for Vec<T> {
-    /// Creates an empty `Vec<T>`.
-    fn default() -> Vec<T> {
-        Vec::new()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Debug> fmt::Debug for Vec<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        fmt::Debug::fmt(&**self, f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> AsRef<Vec<T>> for Vec<T> {
-    fn as_ref(&self) -> &Vec<T> {
-        self
-    }
-}
-
-#[stable(feature = "vec_as_mut", since = "1.5.0")]
-impl<T> AsMut<Vec<T>> for Vec<T> {
-    fn as_mut(&mut self) -> &mut Vec<T> {
-        self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> AsRef<[T]> for Vec<T> {
-    fn as_ref(&self) -> &[T] {
-        self
-    }
-}
-
-#[stable(feature = "vec_as_mut", since = "1.5.0")]
-impl<T> AsMut<[T]> for Vec<T> {
-    fn as_mut(&mut self) -> &mut [T] {
-        self
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T: Clone> From<&'a [T]> for Vec<T> {
-    #[cfg(not(test))]
-    fn from(s: &'a [T]) -> Vec<T> {
-        s.to_vec()
-    }
-    #[cfg(test)]
-    fn from(s: &'a [T]) -> Vec<T> {
-        ::slice::to_vec(s)
-    }
-}
-
-#[stable(feature = "vec_from_mut", since = "1.19.0")]
-impl<'a, T: Clone> From<&'a mut [T]> for Vec<T> {
-    #[cfg(not(test))]
-    fn from(s: &'a mut [T]) -> Vec<T> {
-        s.to_vec()
-    }
-    #[cfg(test)]
-    fn from(s: &'a mut [T]) -> Vec<T> {
-        ::slice::to_vec(s)
-    }
-}
-
-#[stable(feature = "vec_from_cow_slice", since = "1.14.0")]
-impl<'a, T> From<Cow<'a, [T]>> for Vec<T> where [T]: ToOwned<Owned=Vec<T>> {
-    fn from(s: Cow<'a, [T]>) -> Vec<T> {
-        s.into_owned()
-    }
-}
-
-// note: test pulls in libstd, which causes errors here
-#[cfg(not(test))]
-#[stable(feature = "vec_from_box", since = "1.18.0")]
-impl<T> From<Box<[T]>> for Vec<T> {
-    fn from(s: Box<[T]>) -> Vec<T> {
-        s.into_vec()
-    }
-}
-
-#[stable(feature = "box_from_vec", since = "1.18.0")]
-impl<T> Into<Box<[T]>> for Vec<T> {
-    fn into(self) -> Box<[T]> {
-        self.into_boxed_slice()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a> From<&'a str> for Vec<u8> {
-    fn from(s: &'a str) -> Vec<u8> {
-        From::from(s.as_bytes())
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Clone-on-write
-////////////////////////////////////////////////////////////////////////////////
-
-#[stable(feature = "cow_from_vec", since = "1.8.0")]
-impl<'a, T: Clone> From<&'a [T]> for Cow<'a, [T]> {
-    fn from(s: &'a [T]) -> Cow<'a, [T]> {
-        Cow::Borrowed(s)
-    }
-}
-
-#[stable(feature = "cow_from_vec", since = "1.8.0")]
-impl<'a, T: Clone> From<Vec<T>> for Cow<'a, [T]> {
-    fn from(v: Vec<T>) -> Cow<'a, [T]> {
-        Cow::Owned(v)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> FromIterator<T> for Cow<'a, [T]> where T: Clone {
-    fn from_iter<I: IntoIterator<Item = T>>(it: I) -> Cow<'a, [T]> {
-        Cow::Owned(FromIterator::from_iter(it))
-    }
-}
-
-////////////////////////////////////////////////////////////////////////////////
-// Iterators
-////////////////////////////////////////////////////////////////////////////////
-
-/// An iterator that moves out of a vector.
-///
-/// This `struct` is created by the `into_iter` method on [`Vec`][`Vec`] (provided
-/// by the [`IntoIterator`] trait).
-///
-/// [`Vec`]: struct.Vec.html
-/// [`IntoIterator`]: ../../std/iter/trait.IntoIterator.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<T> {
-    buf: Shared<T>,
-    cap: usize,
-    ptr: *const T,
-    end: *const T,
-}
-
-#[stable(feature = "vec_intoiter_debug", since = "1.13.0")]
-impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IntoIter")
-            .field(&self.as_slice())
-            .finish()
-    }
-}
-
-impl<T> IntoIter<T> {
-    /// Returns the remaining items of this iterator as a slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let vec = vec!['a', 'b', 'c'];
-    /// let mut into_iter = vec.into_iter();
-    /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    /// let _ = into_iter.next().unwrap();
-    /// assert_eq!(into_iter.as_slice(), &['b', 'c']);
-    /// ```
-    #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")]
-    pub fn as_slice(&self) -> &[T] {
-        unsafe {
-            slice::from_raw_parts(self.ptr, self.len())
-        }
-    }
-
-    /// Returns the remaining items of this iterator as a mutable slice.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// let vec = vec!['a', 'b', 'c'];
-    /// let mut into_iter = vec.into_iter();
-    /// assert_eq!(into_iter.as_slice(), &['a', 'b', 'c']);
-    /// into_iter.as_mut_slice()[2] = 'z';
-    /// assert_eq!(into_iter.next().unwrap(), 'a');
-    /// assert_eq!(into_iter.next().unwrap(), 'b');
-    /// assert_eq!(into_iter.next().unwrap(), 'z');
-    /// ```
-    #[stable(feature = "vec_into_iter_as_slice", since = "1.15.0")]
-    pub fn as_mut_slice(&mut self) -> &mut [T] {
-        unsafe {
-            slice::from_raw_parts_mut(self.ptr as *mut T, self.len())
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Send> Send for IntoIter<T> {}
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<T: Sync> Sync for IntoIter<T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        unsafe {
-            if self.ptr as *const _ == self.end {
-                None
-            } else {
-                if mem::size_of::<T>() == 0 {
-                    // purposefully don't use 'ptr.offset' because for
-                    // vectors with 0-size elements this would return the
-                    // same pointer.
-                    self.ptr = arith_offset(self.ptr as *const i8, 1) as *mut T;
-
-                    // Use a non-null pointer value
-                    // (self.ptr might be null because of wrapping)
-                    Some(ptr::read(1 as *mut T))
-                } else {
-                    let old = self.ptr;
-                    self.ptr = self.ptr.offset(1);
-
-                    Some(ptr::read(old))
-                }
-            }
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let exact = match self.ptr.offset_to(self.end) {
-            Some(x) => x as usize,
-            None => (self.end as usize).wrapping_sub(self.ptr as usize),
-        };
-        (exact, Some(exact))
-    }
-
-    #[inline]
-    fn count(self) -> usize {
-        self.len()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        unsafe {
-            if self.end == self.ptr {
-                None
-            } else {
-                if mem::size_of::<T>() == 0 {
-                    // See above for why 'ptr.offset' isn't used
-                    self.end = arith_offset(self.end as *const i8, -1) as *mut T;
-
-                    // Use a non-null pointer value
-                    // (self.end might be null because of wrapping)
-                    Some(ptr::read(1 as *mut T))
-                } else {
-                    self.end = self.end.offset(-1);
-
-                    Some(ptr::read(self.end))
-                }
-            }
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn is_empty(&self) -> bool {
-        self.ptr == self.end
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<T> FusedIterator for IntoIter<T> {}
-
-#[unstable(feature = "trusted_len", issue = "37572")]
-unsafe impl<T> TrustedLen for IntoIter<T> {}
-
-#[stable(feature = "vec_into_iter_clone", since = "1.8.0")]
-impl<T: Clone> Clone for IntoIter<T> {
-    fn clone(&self) -> IntoIter<T> {
-        self.as_slice().to_owned().into_iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for IntoIter<T> {
-    fn drop(&mut self) {
-        // destroy the remaining elements
-        for _x in self.by_ref() {}
-
-        // RawVec handles deallocation
-        let _ = unsafe { RawVec::from_raw_parts(self.buf.as_ptr(), self.cap) };
-    }
-}
-
-/// A draining iterator for `Vec<T>`.
-///
-/// This `struct` is created by the [`drain`] method on [`Vec`].
-///
-/// [`drain`]: struct.Vec.html#method.drain
-/// [`Vec`]: struct.Vec.html
-#[stable(feature = "drain", since = "1.6.0")]
-pub struct Drain<'a, T: 'a> {
-    /// Index of tail to preserve
-    tail_start: usize,
-    /// Length of tail
-    tail_len: usize,
-    /// Current remaining range to remove
-    iter: slice::Iter<'a, T>,
-    vec: Shared<Vec<T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Drain")
-         .field(&self.iter.as_slice())
-         .finish()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a, T: Send> Send for Drain<'a, T> {}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T> Iterator for Drain<'a, T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.iter.next().map(|elt| unsafe { ptr::read(elt as *const _) })
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T> DoubleEndedIterator for Drain<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.iter.next_back().map(|elt| unsafe { ptr::read(elt as *const _) })
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T> Drop for Drain<'a, T> {
-    fn drop(&mut self) {
-        // exhaust self first
-        while let Some(_) = self.next() {}
-
-        if self.tail_len > 0 {
-            unsafe {
-                let source_vec = self.vec.as_mut();
-                // memmove back untouched tail, update to new length
-                let start = source_vec.len();
-                let tail = self.tail_start;
-                let src = source_vec.as_ptr().offset(tail as isize);
-                let dst = source_vec.as_mut_ptr().offset(start as isize);
-                ptr::copy(src, dst, self.tail_len);
-                source_vec.set_len(start + self.tail_len);
-            }
-        }
-    }
-}
-
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T> ExactSizeIterator for Drain<'a, T> {
-    fn is_empty(&self) -> bool {
-        self.iter.is_empty()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Drain<'a, T> {}
-
-/// A place for insertion at the back of a `Vec`.
-///
-/// See [`Vec::place_back`](struct.Vec.html#method.place_back) for details.
-#[must_use = "places do nothing unless written to with `<-` syntax"]
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-#[derive(Debug)]
-pub struct PlaceBack<'a, T: 'a> {
-    vec: &'a mut Vec<T>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Placer<T> for PlaceBack<'a, T> {
-    type Place = PlaceBack<'a, T>;
-
-    fn make_place(self) -> Self {
-        // This will panic or abort if we would allocate > isize::MAX bytes
-        // or if the length increment would overflow for zero-sized types.
-        if self.vec.len == self.vec.buf.cap() {
-            self.vec.buf.double();
-        }
-        self
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for PlaceBack<'a, T> {
-    fn pointer(&mut self) -> *mut T {
-        unsafe { self.vec.as_mut_ptr().offset(self.vec.len as isize) }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for PlaceBack<'a, T> {
-    type Owner = &'a mut T;
-
-    unsafe fn finalize(mut self) -> &'a mut T {
-        let ptr = self.pointer();
-        self.vec.len += 1;
-        &mut *ptr
-    }
-}
-
-
-/// A splicing iterator for `Vec`.
-///
-/// This struct is created by the [`splice()`] method on [`Vec`]. See its
-/// documentation for more.
-///
-/// [`splice()`]: struct.Vec.html#method.splice
-/// [`Vec`]: struct.Vec.html
-#[derive(Debug)]
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-pub struct Splice<'a, I: Iterator + 'a> {
-    drain: Drain<'a, I::Item>,
-    replace_with: I,
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, I: Iterator> Iterator for Splice<'a, I> {
-    type Item = I::Item;
-
-    fn next(&mut self) -> Option<Self::Item> {
-        self.drain.next()
-    }
-
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.drain.size_hint()
-    }
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, I: Iterator> DoubleEndedIterator for Splice<'a, I> {
-    fn next_back(&mut self) -> Option<Self::Item> {
-        self.drain.next_back()
-    }
-}
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, I: Iterator> ExactSizeIterator for Splice<'a, I> {}
-
-
-#[unstable(feature = "splice", reason = "recently added", issue = "32310")]
-impl<'a, I: Iterator> Drop for Splice<'a, I> {
-    fn drop(&mut self) {
-        // exhaust drain first
-        while let Some(_) = self.drain.next() {}
-
-
-        unsafe {
-            if self.drain.tail_len == 0 {
-                self.drain.vec.as_mut().extend(self.replace_with.by_ref());
-                return
-            }
-
-            // First fill the range left by drain().
-            if !self.drain.fill(&mut self.replace_with) {
-                return
-            }
-
-            // There may be more elements. Use the lower bound as an estimate.
-            // FIXME: Is the upper bound a better guess? Or something else?
-            let (lower_bound, _upper_bound) = self.replace_with.size_hint();
-            if lower_bound > 0  {
-                self.drain.move_tail(lower_bound);
-                if !self.drain.fill(&mut self.replace_with) {
-                    return
-                }
-            }
-
-            // Collect any remaining elements.
-            // This is a zero-length vector which does not allocate if `lower_bound` was exact.
-            let mut collected = self.replace_with.by_ref().collect::<Vec<I::Item>>().into_iter();
-            // Now we have an exact count.
-            if collected.len() > 0 {
-                self.drain.move_tail(collected.len());
-                let filled = self.drain.fill(&mut collected);
-                debug_assert!(filled);
-                debug_assert_eq!(collected.len(), 0);
-            }
-        }
-        // Let `Drain::drop` move the tail back if necessary and restore `vec.len`.
-    }
-}
-
-/// Private helper methods for `Splice::drop`
-impl<'a, T> Drain<'a, T> {
-    /// The range from `self.vec.len` to `self.tail_start` contains elements
-    /// that have been moved out.
-    /// Fill that range as much as possible with new elements from the `replace_with` iterator.
-    /// Return whether we filled the entire range. (`replace_with.next()` didn’t return `None`.)
-    unsafe fn fill<I: Iterator<Item=T>>(&mut self, replace_with: &mut I) -> bool {
-        let vec = self.vec.as_mut();
-        let range_start = vec.len;
-        let range_end = self.tail_start;
-        let range_slice = slice::from_raw_parts_mut(
-            vec.as_mut_ptr().offset(range_start as isize),
-            range_end - range_start);
-
-        for place in range_slice {
-            if let Some(new_item) = replace_with.next() {
-                ptr::write(place, new_item);
-                vec.len += 1;
-            } else {
-                return false
-            }
-        }
-        true
-    }
-
-    /// Make room for inserting more elements before the tail.
-    unsafe fn move_tail(&mut self, extra_capacity: usize) {
-        let vec = self.vec.as_mut();
-        let used_capacity = self.tail_start + self.tail_len;
-        vec.buf.reserve(used_capacity, extra_capacity);
-
-        let new_tail_start = self.tail_start + extra_capacity;
-        let src = vec.as_ptr().offset(self.tail_start as isize);
-        let dst = vec.as_mut_ptr().offset(new_tail_start as isize);
-        ptr::copy(src, dst, self.tail_len);
-        self.tail_start = new_tail_start;
-    }
-}
diff --git a/src/libcollections/vec_deque.rs b/src/libcollections/vec_deque.rs
deleted file mode 100644
index e826c9432b5..00000000000
--- a/src/libcollections/vec_deque.rs
+++ /dev/null
@@ -1,2970 +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.
-
-//! A double-ended queue implemented with a growable ring buffer.
-//!
-//! This queue has `O(1)` amortized inserts and removals from both ends of the
-//! container. It also has `O(1)` indexing like a vector. The contained elements
-//! are not required to be copyable, and the queue will be sendable if the
-//! contained type is sendable.
-
-#![stable(feature = "rust1", since = "1.0.0")]
-
-use core::cmp::Ordering;
-use core::fmt;
-use core::iter::{repeat, FromIterator, FusedIterator};
-use core::mem;
-use core::ops::{Index, IndexMut, Place, Placer, InPlace};
-use core::ptr;
-use core::ptr::Shared;
-use core::slice;
-
-use core::hash::{Hash, Hasher};
-use core::cmp;
-
-use alloc::raw_vec::RawVec;
-
-use super::range::RangeArgument;
-use Bound::{Excluded, Included, Unbounded};
-use super::vec::Vec;
-
-const INITIAL_CAPACITY: usize = 7; // 2^3 - 1
-const MINIMUM_CAPACITY: usize = 1; // 2 - 1
-#[cfg(target_pointer_width = "32")]
-const MAXIMUM_ZST_CAPACITY: usize = 1 << (32 - 1); // Largest possible power of two
-#[cfg(target_pointer_width = "64")]
-const MAXIMUM_ZST_CAPACITY: usize = 1 << (64 - 1); // Largest possible power of two
-
-/// A double-ended queue implemented with a growable ring buffer.
-///
-/// The "default" usage of this type as a queue is to use [`push_back`] to add to
-/// the queue, and [`pop_front`] to remove from the queue. [`extend`] and [`append`]
-/// push onto the back in this manner, and iterating over `VecDeque` goes front
-/// to back.
-///
-/// [`push_back`]: #method.push_back
-/// [`pop_front`]: #method.pop_front
-/// [`extend`]: #method.extend
-/// [`append`]: #method.append
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct VecDeque<T> {
-    // tail and head are pointers into the buffer. Tail always points
-    // to the first element that could be read, Head always points
-    // to where data should be written.
-    // If tail == head the buffer is empty. The length of the ringbuffer
-    // is defined as the distance between the two.
-    tail: usize,
-    head: usize,
-    buf: RawVec<T>,
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: Clone> Clone for VecDeque<T> {
-    fn clone(&self) -> VecDeque<T> {
-        self.iter().cloned().collect()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for VecDeque<T> {
-    fn drop(&mut self) {
-        let (front, back) = self.as_mut_slices();
-        unsafe {
-            // use drop for [T]
-            ptr::drop_in_place(front);
-            ptr::drop_in_place(back);
-        }
-        // RawVec handles deallocation
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Default for VecDeque<T> {
-    /// Creates an empty `VecDeque<T>`.
-    #[inline]
-    fn default() -> VecDeque<T> {
-        VecDeque::new()
-    }
-}
-
-impl<T> VecDeque<T> {
-    /// Marginally more convenient
-    #[inline]
-    fn ptr(&self) -> *mut T {
-        self.buf.ptr()
-    }
-
-    /// Marginally more convenient
-    #[inline]
-    fn cap(&self) -> usize {
-        if mem::size_of::<T>() == 0 {
-            // For zero sized types, we are always at maximum capacity
-            MAXIMUM_ZST_CAPACITY
-        } else {
-            self.buf.cap()
-        }
-    }
-
-    /// Turn ptr into a slice
-    #[inline]
-    unsafe fn buffer_as_slice(&self) -> &[T] {
-        slice::from_raw_parts(self.ptr(), self.cap())
-    }
-
-    /// Turn ptr into a mut slice
-    #[inline]
-    unsafe fn buffer_as_mut_slice(&mut self) -> &mut [T] {
-        slice::from_raw_parts_mut(self.ptr(), self.cap())
-    }
-
-    /// Moves an element out of the buffer
-    #[inline]
-    unsafe fn buffer_read(&mut self, off: usize) -> T {
-        ptr::read(self.ptr().offset(off as isize))
-    }
-
-    /// Writes an element into the buffer, moving it.
-    #[inline]
-    unsafe fn buffer_write(&mut self, off: usize, value: T) {
-        ptr::write(self.ptr().offset(off as isize), value);
-    }
-
-    /// Returns `true` if and only if the buffer is at full capacity.
-    #[inline]
-    fn is_full(&self) -> bool {
-        self.cap() - self.len() == 1
-    }
-
-    /// Returns the index in the underlying buffer for a given logical element
-    /// index.
-    #[inline]
-    fn wrap_index(&self, idx: usize) -> usize {
-        wrap_index(idx, self.cap())
-    }
-
-    /// Returns the index in the underlying buffer for a given logical element
-    /// index + addend.
-    #[inline]
-    fn wrap_add(&self, idx: usize, addend: usize) -> usize {
-        wrap_index(idx.wrapping_add(addend), self.cap())
-    }
-
-    /// Returns the index in the underlying buffer for a given logical element
-    /// index - subtrahend.
-    #[inline]
-    fn wrap_sub(&self, idx: usize, subtrahend: usize) -> usize {
-        wrap_index(idx.wrapping_sub(subtrahend), self.cap())
-    }
-
-    /// Copies a contiguous block of memory len long from src to dst
-    #[inline]
-    unsafe fn copy(&self, dst: usize, src: usize, len: usize) {
-        debug_assert!(dst + len <= self.cap(),
-                      "cpy dst={} src={} len={} cap={}",
-                      dst,
-                      src,
-                      len,
-                      self.cap());
-        debug_assert!(src + len <= self.cap(),
-                      "cpy dst={} src={} len={} cap={}",
-                      dst,
-                      src,
-                      len,
-                      self.cap());
-        ptr::copy(self.ptr().offset(src as isize),
-                  self.ptr().offset(dst as isize),
-                  len);
-    }
-
-    /// Copies a contiguous block of memory len long from src to dst
-    #[inline]
-    unsafe fn copy_nonoverlapping(&self, dst: usize, src: usize, len: usize) {
-        debug_assert!(dst + len <= self.cap(),
-                      "cno dst={} src={} len={} cap={}",
-                      dst,
-                      src,
-                      len,
-                      self.cap());
-        debug_assert!(src + len <= self.cap(),
-                      "cno dst={} src={} len={} cap={}",
-                      dst,
-                      src,
-                      len,
-                      self.cap());
-        ptr::copy_nonoverlapping(self.ptr().offset(src as isize),
-                                 self.ptr().offset(dst as isize),
-                                 len);
-    }
-
-    /// Copies a potentially wrapping block of memory len long from src to dest.
-    /// (abs(dst - src) + len) must be no larger than cap() (There must be at
-    /// most one continuous overlapping region between src and dest).
-    unsafe fn wrap_copy(&self, dst: usize, src: usize, len: usize) {
-        #[allow(dead_code)]
-        fn diff(a: usize, b: usize) -> usize {
-            if a <= b { b - a } else { a - b }
-        }
-        debug_assert!(cmp::min(diff(dst, src), self.cap() - diff(dst, src)) + len <= self.cap(),
-                      "wrc dst={} src={} len={} cap={}",
-                      dst,
-                      src,
-                      len,
-                      self.cap());
-
-        if src == dst || len == 0 {
-            return;
-        }
-
-        let dst_after_src = self.wrap_sub(dst, src) < len;
-
-        let src_pre_wrap_len = self.cap() - src;
-        let dst_pre_wrap_len = self.cap() - dst;
-        let src_wraps = src_pre_wrap_len < len;
-        let dst_wraps = dst_pre_wrap_len < len;
-
-        match (dst_after_src, src_wraps, dst_wraps) {
-            (_, false, false) => {
-                // src doesn't wrap, dst doesn't wrap
-                //
-                //        S . . .
-                // 1 [_ _ A A B B C C _]
-                // 2 [_ _ A A A A B B _]
-                //            D . . .
-                //
-                self.copy(dst, src, len);
-            }
-            (false, false, true) => {
-                // dst before src, src doesn't wrap, dst wraps
-                //
-                //    S . . .
-                // 1 [A A B B _ _ _ C C]
-                // 2 [A A B B _ _ _ A A]
-                // 3 [B B B B _ _ _ A A]
-                //    . .           D .
-                //
-                self.copy(dst, src, dst_pre_wrap_len);
-                self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
-            }
-            (true, false, true) => {
-                // src before dst, src doesn't wrap, dst wraps
-                //
-                //              S . . .
-                // 1 [C C _ _ _ A A B B]
-                // 2 [B B _ _ _ A A B B]
-                // 3 [B B _ _ _ A A A A]
-                //    . .           D .
-                //
-                self.copy(0, src + dst_pre_wrap_len, len - dst_pre_wrap_len);
-                self.copy(dst, src, dst_pre_wrap_len);
-            }
-            (false, true, false) => {
-                // dst before src, src wraps, dst doesn't wrap
-                //
-                //    . .           S .
-                // 1 [C C _ _ _ A A B B]
-                // 2 [C C _ _ _ B B B B]
-                // 3 [C C _ _ _ B B C C]
-                //              D . . .
-                //
-                self.copy(dst, src, src_pre_wrap_len);
-                self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
-            }
-            (true, true, false) => {
-                // src before dst, src wraps, dst doesn't wrap
-                //
-                //    . .           S .
-                // 1 [A A B B _ _ _ C C]
-                // 2 [A A A A _ _ _ C C]
-                // 3 [C C A A _ _ _ C C]
-                //    D . . .
-                //
-                self.copy(dst + src_pre_wrap_len, 0, len - src_pre_wrap_len);
-                self.copy(dst, src, src_pre_wrap_len);
-            }
-            (false, true, true) => {
-                // dst before src, src wraps, dst wraps
-                //
-                //    . . .         S .
-                // 1 [A B C D _ E F G H]
-                // 2 [A B C D _ E G H H]
-                // 3 [A B C D _ E G H A]
-                // 4 [B C C D _ E G H A]
-                //    . .         D . .
-                //
-                debug_assert!(dst_pre_wrap_len > src_pre_wrap_len);
-                let delta = dst_pre_wrap_len - src_pre_wrap_len;
-                self.copy(dst, src, src_pre_wrap_len);
-                self.copy(dst + src_pre_wrap_len, 0, delta);
-                self.copy(0, delta, len - dst_pre_wrap_len);
-            }
-            (true, true, true) => {
-                // src before dst, src wraps, dst wraps
-                //
-                //    . .         S . .
-                // 1 [A B C D _ E F G H]
-                // 2 [A A B D _ E F G H]
-                // 3 [H A B D _ E F G H]
-                // 4 [H A B D _ E F F G]
-                //    . . .         D .
-                //
-                debug_assert!(src_pre_wrap_len > dst_pre_wrap_len);
-                let delta = src_pre_wrap_len - dst_pre_wrap_len;
-                self.copy(delta, 0, len - src_pre_wrap_len);
-                self.copy(0, self.cap() - delta, delta);
-                self.copy(dst, src, dst_pre_wrap_len);
-            }
-        }
-    }
-
-    /// Frobs the head and tail sections around to handle the fact that we
-    /// just reallocated. Unsafe because it trusts old_cap.
-    #[inline]
-    unsafe fn handle_cap_increase(&mut self, old_cap: usize) {
-        let new_cap = self.cap();
-
-        // Move the shortest contiguous section of the ring buffer
-        //    T             H
-        //   [o o o o o o o . ]
-        //    T             H
-        // A [o o o o o o o . . . . . . . . . ]
-        //        H T
-        //   [o o . o o o o o ]
-        //          T             H
-        // B [. . . o o o o o o o . . . . . . ]
-        //              H T
-        //   [o o o o o . o o ]
-        //              H                 T
-        // C [o o o o o . . . . . . . . . o o ]
-
-        if self.tail <= self.head {
-            // A
-            // Nop
-        } else if self.head < old_cap - self.tail {
-            // B
-            self.copy_nonoverlapping(old_cap, 0, self.head);
-            self.head += old_cap;
-            debug_assert!(self.head > self.tail);
-        } else {
-            // C
-            let new_tail = new_cap - (old_cap - self.tail);
-            self.copy_nonoverlapping(new_tail, self.tail, old_cap - self.tail);
-            self.tail = new_tail;
-            debug_assert!(self.head < self.tail);
-        }
-        debug_assert!(self.head < self.cap());
-        debug_assert!(self.tail < self.cap());
-        debug_assert!(self.cap().count_ones() == 1);
-    }
-}
-
-impl<T> VecDeque<T> {
-    /// Creates an empty `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let vector: VecDeque<u32> = VecDeque::new();
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn new() -> VecDeque<T> {
-        VecDeque::with_capacity(INITIAL_CAPACITY)
-    }
-
-    /// Creates an empty `VecDeque` with space for at least `n` elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let vector: VecDeque<u32> = VecDeque::with_capacity(10);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn with_capacity(n: usize) -> VecDeque<T> {
-        // +1 since the ringbuffer always leaves one space empty
-        let cap = cmp::max(n + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
-        assert!(cap > n, "capacity overflow");
-
-        VecDeque {
-            tail: 0,
-            head: 0,
-            buf: RawVec::with_capacity(cap),
-        }
-    }
-
-    /// Retrieves an element in the `VecDeque` by index.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(3);
-    /// buf.push_back(4);
-    /// buf.push_back(5);
-    /// assert_eq!(buf.get(1), Some(&4));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get(&self, index: usize) -> Option<&T> {
-        if index < self.len() {
-            let idx = self.wrap_add(self.tail, index);
-            unsafe { Some(&*self.ptr().offset(idx as isize)) }
-        } else {
-            None
-        }
-    }
-
-    /// Retrieves an element in the `VecDeque` mutably by index.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(3);
-    /// buf.push_back(4);
-    /// buf.push_back(5);
-    /// if let Some(elem) = buf.get_mut(1) {
-    ///     *elem = 7;
-    /// }
-    ///
-    /// assert_eq!(buf[1], 7);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn get_mut(&mut self, index: usize) -> Option<&mut T> {
-        if index < self.len() {
-            let idx = self.wrap_add(self.tail, index);
-            unsafe { Some(&mut *self.ptr().offset(idx as isize)) }
-        } else {
-            None
-        }
-    }
-
-    /// Swaps elements at indices `i` and `j`.
-    ///
-    /// `i` and `j` may be equal.
-    ///
-    /// Fails if there is no element with either index.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(3);
-    /// buf.push_back(4);
-    /// buf.push_back(5);
-    /// assert_eq!(buf, [3, 4, 5]);
-    /// buf.swap(0, 2);
-    /// assert_eq!(buf, [5, 4, 3]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn swap(&mut self, i: usize, j: usize) {
-        assert!(i < self.len());
-        assert!(j < self.len());
-        let ri = self.wrap_add(self.tail, i);
-        let rj = self.wrap_add(self.tail, j);
-        unsafe {
-            ptr::swap(self.ptr().offset(ri as isize),
-                      self.ptr().offset(rj as isize))
-        }
-    }
-
-    /// Returns the number of elements the `VecDeque` can hold without
-    /// reallocating.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let buf: VecDeque<i32> = VecDeque::with_capacity(10);
-    /// assert!(buf.capacity() >= 10);
-    /// ```
-    #[inline]
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn capacity(&self) -> usize {
-        self.cap() - 1
-    }
-
-    /// Reserves the minimum capacity for exactly `additional` more elements to be inserted in the
-    /// given `VecDeque`. Does nothing if the capacity is already sufficient.
-    ///
-    /// Note that the allocator may give the collection more space than it requests. Therefore
-    /// capacity can not be relied upon to be precisely minimal. Prefer [`reserve`] if future
-    /// insertions are expected.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf: VecDeque<i32> = vec![1].into_iter().collect();
-    /// buf.reserve_exact(10);
-    /// assert!(buf.capacity() >= 11);
-    /// ```
-    ///
-    /// [`reserve`]: #method.reserve
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve_exact(&mut self, additional: usize) {
-        self.reserve(additional);
-    }
-
-    /// Reserves capacity for at least `additional` more elements to be inserted in the given
-    /// `VecDeque`. The collection may reserve more space to avoid frequent reallocations.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new capacity overflows `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf: VecDeque<i32> = vec![1].into_iter().collect();
-    /// buf.reserve(10);
-    /// assert!(buf.capacity() >= 11);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn reserve(&mut self, additional: usize) {
-        let old_cap = self.cap();
-        let used_cap = self.len() + 1;
-        let new_cap = used_cap.checked_add(additional)
-            .and_then(|needed_cap| needed_cap.checked_next_power_of_two())
-            .expect("capacity overflow");
-
-        if new_cap > self.capacity() {
-            self.buf.reserve_exact(used_cap, new_cap - used_cap);
-            unsafe {
-                self.handle_cap_increase(old_cap);
-            }
-        }
-    }
-
-    /// Shrinks the capacity of the `VecDeque` as much as possible.
-    ///
-    /// It will drop down as close as possible to the length but the allocator may still inform the
-    /// `VecDeque` that there is space for a few more elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::with_capacity(15);
-    /// buf.extend(0..4);
-    /// assert_eq!(buf.capacity(), 15);
-    /// buf.shrink_to_fit();
-    /// assert!(buf.capacity() >= 4);
-    /// ```
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn shrink_to_fit(&mut self) {
-        // +1 since the ringbuffer always leaves one space empty
-        // len + 1 can't overflow for an existing, well-formed ringbuffer.
-        let target_cap = cmp::max(self.len() + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
-        if target_cap < self.cap() {
-            // There are three cases of interest:
-            //   All elements are out of desired bounds
-            //   Elements are contiguous, and head is out of desired bounds
-            //   Elements are discontiguous, and tail is out of desired bounds
-            //
-            // At all other times, element positions are unaffected.
-            //
-            // Indicates that elements at the head should be moved.
-            let head_outside = self.head == 0 || self.head >= target_cap;
-            // Move elements from out of desired bounds (positions after target_cap)
-            if self.tail >= target_cap && head_outside {
-                //                    T             H
-                //   [. . . . . . . . o o o o o o o . ]
-                //    T             H
-                //   [o o o o o o o . ]
-                unsafe {
-                    self.copy_nonoverlapping(0, self.tail, self.len());
-                }
-                self.head = self.len();
-                self.tail = 0;
-            } else if self.tail != 0 && self.tail < target_cap && head_outside {
-                //          T             H
-                //   [. . . o o o o o o o . . . . . . ]
-                //        H T
-                //   [o o . o o o o o ]
-                let len = self.wrap_sub(self.head, target_cap);
-                unsafe {
-                    self.copy_nonoverlapping(0, target_cap, len);
-                }
-                self.head = len;
-                debug_assert!(self.head < self.tail);
-            } else if self.tail >= target_cap {
-                //              H                 T
-                //   [o o o o o . . . . . . . . . o o ]
-                //              H T
-                //   [o o o o o . o o ]
-                debug_assert!(self.wrap_sub(self.head, 1) < target_cap);
-                let len = self.cap() - self.tail;
-                let new_tail = target_cap - len;
-                unsafe {
-                    self.copy_nonoverlapping(new_tail, self.tail, len);
-                }
-                self.tail = new_tail;
-                debug_assert!(self.head < self.tail);
-            }
-
-            self.buf.shrink_to_fit(target_cap);
-
-            debug_assert!(self.head < self.cap());
-            debug_assert!(self.tail < self.cap());
-            debug_assert!(self.cap().count_ones() == 1);
-        }
-    }
-
-    /// Shortens the `VecDeque`, dropping excess elements from the back.
-    ///
-    /// If `len` is greater than the `VecDeque`'s current length, this has no
-    /// effect.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(5);
-    /// buf.push_back(10);
-    /// buf.push_back(15);
-    /// assert_eq!(buf, [5, 10, 15]);
-    /// buf.truncate(1);
-    /// assert_eq!(buf, [5]);
-    /// ```
-    #[stable(feature = "deque_extras", since = "1.16.0")]
-    pub fn truncate(&mut self, len: usize) {
-        for _ in len..self.len() {
-            self.pop_back();
-        }
-    }
-
-    /// Returns a front-to-back iterator.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(5);
-    /// buf.push_back(3);
-    /// buf.push_back(4);
-    /// let b: &[_] = &[&5, &3, &4];
-    /// let c: Vec<&i32> = buf.iter().collect();
-    /// assert_eq!(&c[..], b);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter(&self) -> Iter<T> {
-        Iter {
-            tail: self.tail,
-            head: self.head,
-            ring: unsafe { self.buffer_as_slice() },
-        }
-    }
-
-    /// Returns a front-to-back iterator that returns mutable references.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(5);
-    /// buf.push_back(3);
-    /// buf.push_back(4);
-    /// for num in buf.iter_mut() {
-    ///     *num = *num - 2;
-    /// }
-    /// let b: &[_] = &[&mut 3, &mut 1, &mut 2];
-    /// assert_eq!(&buf.iter_mut().collect::<Vec<&mut i32>>()[..], b);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn iter_mut(&mut self) -> IterMut<T> {
-        IterMut {
-            tail: self.tail,
-            head: self.head,
-            ring: unsafe { self.buffer_as_mut_slice() },
-        }
-    }
-
-    /// Returns a pair of slices which contain, in order, the contents of the
-    /// `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut vector = VecDeque::new();
-    ///
-    /// vector.push_back(0);
-    /// vector.push_back(1);
-    /// vector.push_back(2);
-    ///
-    /// assert_eq!(vector.as_slices(), (&[0, 1, 2][..], &[][..]));
-    ///
-    /// vector.push_front(10);
-    /// vector.push_front(9);
-    ///
-    /// assert_eq!(vector.as_slices(), (&[9, 10][..], &[0, 1, 2][..]));
-    /// ```
-    #[inline]
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn as_slices(&self) -> (&[T], &[T]) {
-        unsafe {
-            let buf = self.buffer_as_slice();
-            RingSlices::ring_slices(buf, self.head, self.tail)
-        }
-    }
-
-    /// Returns a pair of slices which contain, in order, the contents of the
-    /// `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut vector = VecDeque::new();
-    ///
-    /// vector.push_back(0);
-    /// vector.push_back(1);
-    ///
-    /// vector.push_front(10);
-    /// vector.push_front(9);
-    ///
-    /// vector.as_mut_slices().0[0] = 42;
-    /// vector.as_mut_slices().1[0] = 24;
-    /// assert_eq!(vector.as_slices(), (&[42, 10][..], &[24, 1][..]));
-    /// ```
-    #[inline]
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn as_mut_slices(&mut self) -> (&mut [T], &mut [T]) {
-        unsafe {
-            let head = self.head;
-            let tail = self.tail;
-            let buf = self.buffer_as_mut_slice();
-            RingSlices::ring_slices(buf, head, tail)
-        }
-    }
-
-    /// Returns the number of elements in the `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut v = VecDeque::new();
-    /// assert_eq!(v.len(), 0);
-    /// v.push_back(1);
-    /// assert_eq!(v.len(), 1);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn len(&self) -> usize {
-        count(self.tail, self.head, self.cap())
-    }
-
-    /// Returns `true` if the `VecDeque` is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut v = VecDeque::new();
-    /// assert!(v.is_empty());
-    /// v.push_front(1);
-    /// assert!(!v.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_empty(&self) -> bool {
-        self.tail == self.head
-    }
-
-    /// Create a draining iterator that removes the specified range in the
-    /// `VecDeque` and yields the removed items.
-    ///
-    /// Note 1: The element range is removed even if the iterator is not
-    /// consumed until the end.
-    ///
-    /// Note 2: It is unspecified how many elements are removed from the deque,
-    /// if the `Drain` value is not dropped, but the borrow it holds expires
-    /// (eg. due to mem::forget).
-    ///
-    /// # Panics
-    ///
-    /// Panics if the starting point is greater than the end point or if
-    /// the end point is greater than the length of the vector.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut v: VecDeque<_> = vec![1, 2, 3].into_iter().collect();
-    /// let drained = v.drain(2..).collect::<VecDeque<_>>();
-    /// assert_eq!(drained, [3]);
-    /// assert_eq!(v, [1, 2]);
-    ///
-    /// // A full range clears all contents
-    /// v.drain(..);
-    /// assert!(v.is_empty());
-    /// ```
-    #[inline]
-    #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain<R>(&mut self, range: R) -> Drain<T>
-        where R: RangeArgument<usize>
-    {
-        // Memory safety
-        //
-        // When the Drain is first created, the source deque is shortened to
-        // make sure no uninitialized or moved-from elements are accessible at
-        // all if the Drain's destructor never gets to run.
-        //
-        // Drain will ptr::read out the values to remove.
-        // When finished, the remaining data will be copied back to cover the hole,
-        // and the head/tail values will be restored correctly.
-        //
-        let len = self.len();
-        let start = match range.start() {
-            Included(&n) => n,
-            Excluded(&n) => n + 1,
-            Unbounded    => 0,
-        };
-        let end = match range.end() {
-            Included(&n) => n + 1,
-            Excluded(&n) => n,
-            Unbounded    => len,
-        };
-        assert!(start <= end, "drain lower bound was too large");
-        assert!(end <= len, "drain upper bound was too large");
-
-        // The deque's elements are parted into three segments:
-        // * self.tail  -> drain_tail
-        // * drain_tail -> drain_head
-        // * drain_head -> self.head
-        //
-        // T = self.tail; H = self.head; t = drain_tail; h = drain_head
-        //
-        // We store drain_tail as self.head, and drain_head and self.head as
-        // after_tail and after_head respectively on the Drain. This also
-        // truncates the effective array such that if the Drain is leaked, we
-        // have forgotten about the potentially moved values after the start of
-        // the drain.
-        //
-        //        T   t   h   H
-        // [. . . o o x x o o . . .]
-        //
-        let drain_tail = self.wrap_add(self.tail, start);
-        let drain_head = self.wrap_add(self.tail, end);
-        let head = self.head;
-
-        // "forget" about the values after the start of the drain until after
-        // the drain is complete and the Drain destructor is run.
-        self.head = drain_tail;
-
-        Drain {
-            deque: unsafe { Shared::new(self as *mut _) },
-            after_tail: drain_head,
-            after_head: head,
-            iter: Iter {
-                tail: drain_tail,
-                head: drain_head,
-                ring: unsafe { self.buffer_as_mut_slice() },
-            },
-        }
-    }
-
-    /// Clears the buffer, removing all values.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut v = VecDeque::new();
-    /// v.push_back(1);
-    /// v.clear();
-    /// assert!(v.is_empty());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    #[inline]
-    pub fn clear(&mut self) {
-        self.drain(..);
-    }
-
-    /// Returns `true` if the `VecDeque` contains an element equal to the
-    /// given value.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut vector: VecDeque<u32> = VecDeque::new();
-    ///
-    /// vector.push_back(0);
-    /// vector.push_back(1);
-    ///
-    /// assert_eq!(vector.contains(&1), true);
-    /// assert_eq!(vector.contains(&10), false);
-    /// ```
-    #[stable(feature = "vec_deque_contains", since = "1.12.0")]
-    pub fn contains(&self, x: &T) -> bool
-        where T: PartialEq<T>
-    {
-        let (a, b) = self.as_slices();
-        a.contains(x) || b.contains(x)
-    }
-
-    /// Provides a reference to the front element, or `None` if the `VecDeque` is
-    /// empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// assert_eq!(d.front(), None);
-    ///
-    /// d.push_back(1);
-    /// d.push_back(2);
-    /// assert_eq!(d.front(), Some(&1));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn front(&self) -> Option<&T> {
-        if !self.is_empty() {
-            Some(&self[0])
-        } else {
-            None
-        }
-    }
-
-    /// Provides a mutable reference to the front element, or `None` if the
-    /// `VecDeque` is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// assert_eq!(d.front_mut(), None);
-    ///
-    /// d.push_back(1);
-    /// d.push_back(2);
-    /// match d.front_mut() {
-    ///     Some(x) => *x = 9,
-    ///     None => (),
-    /// }
-    /// assert_eq!(d.front(), Some(&9));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn front_mut(&mut self) -> Option<&mut T> {
-        if !self.is_empty() {
-            Some(&mut self[0])
-        } else {
-            None
-        }
-    }
-
-    /// Provides a reference to the back element, or `None` if the `VecDeque` is
-    /// empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// assert_eq!(d.back(), None);
-    ///
-    /// d.push_back(1);
-    /// d.push_back(2);
-    /// assert_eq!(d.back(), Some(&2));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn back(&self) -> Option<&T> {
-        if !self.is_empty() {
-            Some(&self[self.len() - 1])
-        } else {
-            None
-        }
-    }
-
-    /// Provides a mutable reference to the back element, or `None` if the
-    /// `VecDeque` is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// assert_eq!(d.back(), None);
-    ///
-    /// d.push_back(1);
-    /// d.push_back(2);
-    /// match d.back_mut() {
-    ///     Some(x) => *x = 9,
-    ///     None => (),
-    /// }
-    /// assert_eq!(d.back(), Some(&9));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn back_mut(&mut self) -> Option<&mut T> {
-        let len = self.len();
-        if !self.is_empty() {
-            Some(&mut self[len - 1])
-        } else {
-            None
-        }
-    }
-
-    /// Removes the first element and returns it, or `None` if the `VecDeque` is
-    /// empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// d.push_back(1);
-    /// d.push_back(2);
-    ///
-    /// assert_eq!(d.pop_front(), Some(1));
-    /// assert_eq!(d.pop_front(), Some(2));
-    /// assert_eq!(d.pop_front(), None);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop_front(&mut self) -> Option<T> {
-        if self.is_empty() {
-            None
-        } else {
-            let tail = self.tail;
-            self.tail = self.wrap_add(self.tail, 1);
-            unsafe { Some(self.buffer_read(tail)) }
-        }
-    }
-
-    /// Prepends an element to the `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut d = VecDeque::new();
-    /// d.push_front(1);
-    /// d.push_front(2);
-    /// assert_eq!(d.front(), Some(&2));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_front(&mut self, value: T) {
-        self.grow_if_necessary();
-
-        self.tail = self.wrap_sub(self.tail, 1);
-        let tail = self.tail;
-        unsafe {
-            self.buffer_write(tail, value);
-        }
-    }
-
-    /// Appends an element to the back of the `VecDeque`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(1);
-    /// buf.push_back(3);
-    /// assert_eq!(3, *buf.back().unwrap());
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn push_back(&mut self, value: T) {
-        self.grow_if_necessary();
-
-        let head = self.head;
-        self.head = self.wrap_add(self.head, 1);
-        unsafe { self.buffer_write(head, value) }
-    }
-
-    /// Removes the last element from the `VecDeque` and returns it, or `None` if
-    /// it is empty.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// assert_eq!(buf.pop_back(), None);
-    /// buf.push_back(1);
-    /// buf.push_back(3);
-    /// assert_eq!(buf.pop_back(), Some(3));
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn pop_back(&mut self) -> Option<T> {
-        if self.is_empty() {
-            None
-        } else {
-            self.head = self.wrap_sub(self.head, 1);
-            let head = self.head;
-            unsafe { Some(self.buffer_read(head)) }
-        }
-    }
-
-    #[inline]
-    fn is_contiguous(&self) -> bool {
-        self.tail <= self.head
-    }
-
-    /// Removes an element from anywhere in the `VecDeque` and returns it, replacing it with the
-    /// last element.
-    ///
-    /// This does not preserve ordering, but is O(1).
-    ///
-    /// Returns `None` if `index` is out of bounds.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// assert_eq!(buf.swap_remove_back(0), None);
-    /// buf.push_back(1);
-    /// buf.push_back(2);
-    /// buf.push_back(3);
-    /// assert_eq!(buf, [1, 2, 3]);
-    ///
-    /// assert_eq!(buf.swap_remove_back(0), Some(1));
-    /// assert_eq!(buf, [3, 2]);
-    /// ```
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn swap_remove_back(&mut self, index: usize) -> Option<T> {
-        let length = self.len();
-        if length > 0 && index < length - 1 {
-            self.swap(index, length - 1);
-        } else if index >= length {
-            return None;
-        }
-        self.pop_back()
-    }
-
-    /// Removes an element from anywhere in the `VecDeque` and returns it,
-    /// replacing it with the first element.
-    ///
-    /// This does not preserve ordering, but is O(1).
-    ///
-    /// Returns `None` if `index` is out of bounds.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// assert_eq!(buf.swap_remove_front(0), None);
-    /// buf.push_back(1);
-    /// buf.push_back(2);
-    /// buf.push_back(3);
-    /// assert_eq!(buf, [1, 2, 3]);
-    ///
-    /// assert_eq!(buf.swap_remove_front(2), Some(3));
-    /// assert_eq!(buf, [2, 1]);
-    /// ```
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn swap_remove_front(&mut self, index: usize) -> Option<T> {
-        let length = self.len();
-        if length > 0 && index < length && index != 0 {
-            self.swap(index, 0);
-        } else if index >= length {
-            return None;
-        }
-        self.pop_front()
-    }
-
-    /// Inserts an element at `index` within the `VecDeque`, shifting all elements with indices
-    /// greater than or equal to `index` towards the back.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `index` is greater than `VecDeque`'s length
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut vec_deque = VecDeque::new();
-    /// vec_deque.push_back('a');
-    /// vec_deque.push_back('b');
-    /// vec_deque.push_back('c');
-    /// assert_eq!(vec_deque, &['a', 'b', 'c']);
-    ///
-    /// vec_deque.insert(1, 'd');
-    /// assert_eq!(vec_deque, &['a', 'd', 'b', 'c']);
-    /// ```
-    #[stable(feature = "deque_extras_15", since = "1.5.0")]
-    pub fn insert(&mut self, index: usize, value: T) {
-        assert!(index <= self.len(), "index out of bounds");
-        self.grow_if_necessary();
-
-        // Move the least number of elements in the ring buffer and insert
-        // the given object
-        //
-        // At most len/2 - 1 elements will be moved. O(min(n, n-i))
-        //
-        // There are three main cases:
-        //  Elements are contiguous
-        //      - special case when tail is 0
-        //  Elements are discontiguous and the insert is in the tail section
-        //  Elements are discontiguous and the insert is in the head section
-        //
-        // For each of those there are two more cases:
-        //  Insert is closer to tail
-        //  Insert is closer to head
-        //
-        // Key: H - self.head
-        //      T - self.tail
-        //      o - Valid element
-        //      I - Insertion element
-        //      A - The element that should be after the insertion point
-        //      M - Indicates element was moved
-
-        let idx = self.wrap_add(self.tail, index);
-
-        let distance_to_tail = index;
-        let distance_to_head = self.len() - index;
-
-        let contiguous = self.is_contiguous();
-
-        match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
-            (true, true, _) if index == 0 => {
-                // push_front
-                //
-                //       T
-                //       I             H
-                //      [A o o o o o o . . . . . . . . .]
-                //
-                //                       H         T
-                //      [A o o o o o o o . . . . . I]
-                //
-
-                self.tail = self.wrap_sub(self.tail, 1);
-            }
-            (true, true, _) => {
-                unsafe {
-                    // contiguous, insert closer to tail:
-                    //
-                    //             T   I         H
-                    //      [. . . o o A o o o o . . . . . .]
-                    //
-                    //           T               H
-                    //      [. . o o I A o o o o . . . . . .]
-                    //           M M
-                    //
-                    // contiguous, insert closer to tail and tail is 0:
-                    //
-                    //
-                    //       T   I         H
-                    //      [o o A o o o o . . . . . . . . .]
-                    //
-                    //                       H             T
-                    //      [o I A o o o o o . . . . . . . o]
-                    //       M                             M
-
-                    let new_tail = self.wrap_sub(self.tail, 1);
-
-                    self.copy(new_tail, self.tail, 1);
-                    // Already moved the tail, so we only copy `index - 1` elements.
-                    self.copy(self.tail, self.tail + 1, index - 1);
-
-                    self.tail = new_tail;
-                }
-            }
-            (true, false, _) => {
-                unsafe {
-                    //  contiguous, insert closer to head:
-                    //
-                    //             T       I     H
-                    //      [. . . o o o o A o o . . . . . .]
-                    //
-                    //             T               H
-                    //      [. . . o o o o I A o o . . . . .]
-                    //                       M M M
-
-                    self.copy(idx + 1, idx, self.head - idx);
-                    self.head = self.wrap_add(self.head, 1);
-                }
-            }
-            (false, true, true) => {
-                unsafe {
-                    // discontiguous, insert closer to tail, tail section:
-                    //
-                    //                   H         T   I
-                    //      [o o o o o o . . . . . o o A o o]
-                    //
-                    //                   H       T
-                    //      [o o o o o o . . . . o o I A o o]
-                    //                           M M
-
-                    self.copy(self.tail - 1, self.tail, index);
-                    self.tail -= 1;
-                }
-            }
-            (false, false, true) => {
-                unsafe {
-                    // discontiguous, insert closer to head, tail section:
-                    //
-                    //           H             T         I
-                    //      [o o . . . . . . . o o o o o A o]
-                    //
-                    //             H           T
-                    //      [o o o . . . . . . o o o o o I A]
-                    //       M M M                         M
-
-                    // copy elements up to new head
-                    self.copy(1, 0, self.head);
-
-                    // copy last element into empty spot at bottom of buffer
-                    self.copy(0, self.cap() - 1, 1);
-
-                    // move elements from idx to end forward not including ^ element
-                    self.copy(idx + 1, idx, self.cap() - 1 - idx);
-
-                    self.head += 1;
-                }
-            }
-            (false, true, false) if idx == 0 => {
-                unsafe {
-                    // discontiguous, insert is closer to tail, head section,
-                    // and is at index zero in the internal buffer:
-                    //
-                    //       I                   H     T
-                    //      [A o o o o o o o o o . . . o o o]
-                    //
-                    //                           H   T
-                    //      [A o o o o o o o o o . . o o o I]
-                    //                               M M M
-
-                    // copy elements up to new tail
-                    self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
-
-                    // copy last element into empty spot at bottom of buffer
-                    self.copy(self.cap() - 1, 0, 1);
-
-                    self.tail -= 1;
-                }
-            }
-            (false, true, false) => {
-                unsafe {
-                    // discontiguous, insert closer to tail, head section:
-                    //
-                    //             I             H     T
-                    //      [o o o A o o o o o o . . . o o o]
-                    //
-                    //                           H   T
-                    //      [o o I A o o o o o o . . o o o o]
-                    //       M M                     M M M M
-
-                    // copy elements up to new tail
-                    self.copy(self.tail - 1, self.tail, self.cap() - self.tail);
-
-                    // copy last element into empty spot at bottom of buffer
-                    self.copy(self.cap() - 1, 0, 1);
-
-                    // move elements from idx-1 to end forward not including ^ element
-                    self.copy(0, 1, idx - 1);
-
-                    self.tail -= 1;
-                }
-            }
-            (false, false, false) => {
-                unsafe {
-                    // discontiguous, insert closer to head, head section:
-                    //
-                    //               I     H           T
-                    //      [o o o o A o o . . . . . . o o o]
-                    //
-                    //                     H           T
-                    //      [o o o o I A o o . . . . . o o o]
-                    //                 M M M
-
-                    self.copy(idx + 1, idx, self.head - idx);
-                    self.head += 1;
-                }
-            }
-        }
-
-        // tail might've been changed so we need to recalculate
-        let new_idx = self.wrap_add(self.tail, index);
-        unsafe {
-            self.buffer_write(new_idx, value);
-        }
-    }
-
-    /// Removes and returns the element at `index` from the `VecDeque`.
-    /// Whichever end is closer to the removal point will be moved to make
-    /// room, and all the affected elements will be moved to new positions.
-    /// Returns `None` if `index` is out of bounds.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(1);
-    /// buf.push_back(2);
-    /// buf.push_back(3);
-    /// assert_eq!(buf, [1, 2, 3]);
-    ///
-    /// assert_eq!(buf.remove(1), Some(2));
-    /// assert_eq!(buf, [1, 3]);
-    /// ```
-    #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn remove(&mut self, index: usize) -> Option<T> {
-        if self.is_empty() || self.len() <= index {
-            return None;
-        }
-
-        // There are three main cases:
-        //  Elements are contiguous
-        //  Elements are discontiguous and the removal is in the tail section
-        //  Elements are discontiguous and the removal is in the head section
-        //      - special case when elements are technically contiguous,
-        //        but self.head = 0
-        //
-        // For each of those there are two more cases:
-        //  Insert is closer to tail
-        //  Insert is closer to head
-        //
-        // Key: H - self.head
-        //      T - self.tail
-        //      o - Valid element
-        //      x - Element marked for removal
-        //      R - Indicates element that is being removed
-        //      M - Indicates element was moved
-
-        let idx = self.wrap_add(self.tail, index);
-
-        let elem = unsafe { Some(self.buffer_read(idx)) };
-
-        let distance_to_tail = index;
-        let distance_to_head = self.len() - index;
-
-        let contiguous = self.is_contiguous();
-
-        match (contiguous, distance_to_tail <= distance_to_head, idx >= self.tail) {
-            (true, true, _) => {
-                unsafe {
-                    // contiguous, remove closer to tail:
-                    //
-                    //             T   R         H
-                    //      [. . . o o x o o o o . . . . . .]
-                    //
-                    //               T           H
-                    //      [. . . . o o o o o o . . . . . .]
-                    //               M M
-
-                    self.copy(self.tail + 1, self.tail, index);
-                    self.tail += 1;
-                }
-            }
-            (true, false, _) => {
-                unsafe {
-                    // contiguous, remove closer to head:
-                    //
-                    //             T       R     H
-                    //      [. . . o o o o x o o . . . . . .]
-                    //
-                    //             T           H
-                    //      [. . . o o o o o o . . . . . . .]
-                    //                     M M
-
-                    self.copy(idx, idx + 1, self.head - idx - 1);
-                    self.head -= 1;
-                }
-            }
-            (false, true, true) => {
-                unsafe {
-                    // discontiguous, remove closer to tail, tail section:
-                    //
-                    //                   H         T   R
-                    //      [o o o o o o . . . . . o o x o o]
-                    //
-                    //                   H           T
-                    //      [o o o o o o . . . . . . o o o o]
-                    //                               M M
-
-                    self.copy(self.tail + 1, self.tail, index);
-                    self.tail = self.wrap_add(self.tail, 1);
-                }
-            }
-            (false, false, false) => {
-                unsafe {
-                    // discontiguous, remove closer to head, head section:
-                    //
-                    //               R     H           T
-                    //      [o o o o x o o . . . . . . o o o]
-                    //
-                    //                   H             T
-                    //      [o o o o o o . . . . . . . o o o]
-                    //               M M
-
-                    self.copy(idx, idx + 1, self.head - idx - 1);
-                    self.head -= 1;
-                }
-            }
-            (false, false, true) => {
-                unsafe {
-                    // discontiguous, remove closer to head, tail section:
-                    //
-                    //             H           T         R
-                    //      [o o o . . . . . . o o o o o x o]
-                    //
-                    //           H             T
-                    //      [o o . . . . . . . o o o o o o o]
-                    //       M M                         M M
-                    //
-                    // or quasi-discontiguous, remove next to head, tail section:
-                    //
-                    //       H                 T         R
-                    //      [. . . . . . . . . o o o o o x o]
-                    //
-                    //                         T           H
-                    //      [. . . . . . . . . o o o o o o .]
-                    //                                   M
-
-                    // draw in elements in the tail section
-                    self.copy(idx, idx + 1, self.cap() - idx - 1);
-
-                    // Prevents underflow.
-                    if self.head != 0 {
-                        // copy first element into empty spot
-                        self.copy(self.cap() - 1, 0, 1);
-
-                        // move elements in the head section backwards
-                        self.copy(0, 1, self.head - 1);
-                    }
-
-                    self.head = self.wrap_sub(self.head, 1);
-                }
-            }
-            (false, true, false) => {
-                unsafe {
-                    // discontiguous, remove closer to tail, head section:
-                    //
-                    //           R               H     T
-                    //      [o o x o o o o o o o . . . o o o]
-                    //
-                    //                           H       T
-                    //      [o o o o o o o o o o . . . . o o]
-                    //       M M M                       M M
-
-                    // draw in elements up to idx
-                    self.copy(1, 0, idx);
-
-                    // copy last element into empty spot
-                    self.copy(0, self.cap() - 1, 1);
-
-                    // move elements from tail to end forward, excluding the last one
-                    self.copy(self.tail + 1, self.tail, self.cap() - self.tail - 1);
-
-                    self.tail = self.wrap_add(self.tail, 1);
-                }
-            }
-        }
-
-        return elem;
-    }
-
-    /// Splits the collection into two at the given index.
-    ///
-    /// Returns a newly allocated `Self`. `self` contains elements `[0, at)`,
-    /// and the returned `Self` contains elements `[at, len)`.
-    ///
-    /// Note that the capacity of `self` does not change.
-    ///
-    /// Element at index 0 is the front of the queue.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `at > len`
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf: VecDeque<_> = vec![1,2,3].into_iter().collect();
-    /// let buf2 = buf.split_off(1);
-    /// assert_eq!(buf, [1]);
-    /// assert_eq!(buf2, [2, 3]);
-    /// ```
-    #[inline]
-    #[stable(feature = "split_off", since = "1.4.0")]
-    pub fn split_off(&mut self, at: usize) -> Self {
-        let len = self.len();
-        assert!(at <= len, "`at` out of bounds");
-
-        let other_len = len - at;
-        let mut other = VecDeque::with_capacity(other_len);
-
-        unsafe {
-            let (first_half, second_half) = self.as_slices();
-
-            let first_len = first_half.len();
-            let second_len = second_half.len();
-            if at < first_len {
-                // `at` lies in the first half.
-                let amount_in_first = first_len - at;
-
-                ptr::copy_nonoverlapping(first_half.as_ptr().offset(at as isize),
-                                         other.ptr(),
-                                         amount_in_first);
-
-                // just take all of the second half.
-                ptr::copy_nonoverlapping(second_half.as_ptr(),
-                                         other.ptr().offset(amount_in_first as isize),
-                                         second_len);
-            } else {
-                // `at` lies in the second half, need to factor in the elements we skipped
-                // in the first half.
-                let offset = at - first_len;
-                let amount_in_second = second_len - offset;
-                ptr::copy_nonoverlapping(second_half.as_ptr().offset(offset as isize),
-                                         other.ptr(),
-                                         amount_in_second);
-            }
-        }
-
-        // Cleanup where the ends of the buffers are
-        self.head = self.wrap_sub(self.head, other_len);
-        other.head = other.wrap_index(other_len);
-
-        other
-    }
-
-    /// Moves all the elements of `other` into `Self`, leaving `other` empty.
-    ///
-    /// # Panics
-    ///
-    /// Panics if the new number of elements in self overflows a `usize`.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf: VecDeque<_> = vec![1, 2].into_iter().collect();
-    /// let mut buf2: VecDeque<_> = vec![3, 4].into_iter().collect();
-    /// buf.append(&mut buf2);
-    /// assert_eq!(buf, [1, 2, 3, 4]);
-    /// assert_eq!(buf2, []);
-    /// ```
-    #[inline]
-    #[stable(feature = "append", since = "1.4.0")]
-    pub fn append(&mut self, other: &mut Self) {
-        // naive impl
-        self.extend(other.drain(..));
-    }
-
-    /// Retains only the elements specified by the predicate.
-    ///
-    /// In other words, remove all elements `e` such that `f(&e)` returns false.
-    /// This method operates in place and preserves the order of the retained
-    /// elements.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.extend(1..5);
-    /// buf.retain(|&x| x%2 == 0);
-    /// assert_eq!(buf, [2, 4]);
-    /// ```
-    #[stable(feature = "vec_deque_retain", since = "1.4.0")]
-    pub fn retain<F>(&mut self, mut f: F)
-        where F: FnMut(&T) -> bool
-    {
-        let len = self.len();
-        let mut del = 0;
-        for i in 0..len {
-            if !f(&self[i]) {
-                del += 1;
-            } else if del > 0 {
-                self.swap(i - del, i);
-            }
-        }
-        if del > 0 {
-            self.truncate(len - del);
-        }
-    }
-
-    // This may panic or abort
-    #[inline]
-    fn grow_if_necessary(&mut self) {
-        if self.is_full() {
-            let old_cap = self.cap();
-            self.buf.double();
-            unsafe {
-                self.handle_cap_increase(old_cap);
-            }
-            debug_assert!(!self.is_full());
-        }
-    }
-
-    /// Returns a place for insertion at the back of the `VecDeque`.
-    ///
-    /// Using this method with placement syntax is equivalent to [`push_back`](#method.push_back),
-    /// but may be more efficient.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collection_placement)]
-    /// #![feature(placement_in_syntax)]
-    ///
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.place_back() <- 3;
-    /// buf.place_back() <- 4;
-    /// assert_eq!(&buf, &[3, 4]);
-    /// ```
-    #[unstable(feature = "collection_placement",
-               reason = "placement protocol is subject to change",
-               issue = "30172")]
-    pub fn place_back(&mut self) -> PlaceBack<T> {
-        PlaceBack { vec_deque: self }
-    }
-
-    /// Returns a place for insertion at the front of the `VecDeque`.
-    ///
-    /// Using this method with placement syntax is equivalent to [`push_front`](#method.push_front),
-    /// but may be more efficient.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// #![feature(collection_placement)]
-    /// #![feature(placement_in_syntax)]
-    ///
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.place_front() <- 3;
-    /// buf.place_front() <- 4;
-    /// assert_eq!(&buf, &[4, 3]);
-    /// ```
-    #[unstable(feature = "collection_placement",
-               reason = "placement protocol is subject to change",
-               issue = "30172")]
-    pub fn place_front(&mut self) -> PlaceFront<T> {
-        PlaceFront { vec_deque: self }
-    }
-}
-
-impl<T: Clone> VecDeque<T> {
-    /// Modifies the `VecDeque` in-place so that `len()` is equal to new_len,
-    /// either by removing excess elements or by appending clones of `value` to the back.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::VecDeque;
-    ///
-    /// let mut buf = VecDeque::new();
-    /// buf.push_back(5);
-    /// buf.push_back(10);
-    /// buf.push_back(15);
-    /// assert_eq!(buf, [5, 10, 15]);
-    ///
-    /// buf.resize(2, 0);
-    /// assert_eq!(buf, [5, 10]);
-    ///
-    /// buf.resize(5, 20);
-    /// assert_eq!(buf, [5, 10, 20, 20, 20]);
-    /// ```
-    #[stable(feature = "deque_extras", since = "1.16.0")]
-    pub fn resize(&mut self, new_len: usize, value: T) {
-        let len = self.len();
-
-        if new_len > len {
-            self.extend(repeat(value).take(new_len - len))
-        } else {
-            self.truncate(new_len);
-        }
-    }
-}
-
-/// Returns the index in the underlying buffer for a given logical element index.
-#[inline]
-fn wrap_index(index: usize, size: usize) -> usize {
-    // size is always a power of 2
-    debug_assert!(size.is_power_of_two());
-    index & (size - 1)
-}
-
-/// Returns the two slices that cover the `VecDeque`'s valid range
-trait RingSlices: Sized {
-    fn slice(self, from: usize, to: usize) -> Self;
-    fn split_at(self, i: usize) -> (Self, Self);
-
-    fn ring_slices(buf: Self, head: usize, tail: usize) -> (Self, Self) {
-        let contiguous = tail <= head;
-        if contiguous {
-            let (empty, buf) = buf.split_at(0);
-            (buf.slice(tail, head), empty)
-        } else {
-            let (mid, right) = buf.split_at(tail);
-            let (left, _) = mid.split_at(head);
-            (right, left)
-        }
-    }
-}
-
-impl<'a, T> RingSlices for &'a [T] {
-    fn slice(self, from: usize, to: usize) -> Self {
-        &self[from..to]
-    }
-    fn split_at(self, i: usize) -> (Self, Self) {
-        (*self).split_at(i)
-    }
-}
-
-impl<'a, T> RingSlices for &'a mut [T] {
-    fn slice(self, from: usize, to: usize) -> Self {
-        &mut self[from..to]
-    }
-    fn split_at(self, i: usize) -> (Self, Self) {
-        (*self).split_at_mut(i)
-    }
-}
-
-/// Calculate the number of elements left to be read in the buffer
-#[inline]
-fn count(tail: usize, head: usize, size: usize) -> usize {
-    // size is always a power of 2
-    (head.wrapping_sub(tail)) & (size - 1)
-}
-
-/// An iterator over the elements of a `VecDeque`.
-///
-/// This `struct` is created by the [`iter`] method on [`VecDeque`]. See its
-/// documentation for more.
-///
-/// [`iter`]: struct.VecDeque.html#method.iter
-/// [`VecDeque`]: struct.VecDeque.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct Iter<'a, T: 'a> {
-    ring: &'a [T],
-    tail: usize,
-    head: usize,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Iter<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Iter")
-         .field(&self.ring)
-         .field(&self.tail)
-         .field(&self.head)
-         .finish()
-    }
-}
-
-// FIXME(#19839) Remove in favor of `#[derive(Clone)]`
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Clone for Iter<'a, T> {
-    fn clone(&self) -> Iter<'a, T> {
-        Iter {
-            ring: self.ring,
-            tail: self.tail,
-            head: self.head,
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for Iter<'a, T> {
-    type Item = &'a T;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a T> {
-        if self.tail == self.head {
-            return None;
-        }
-        let tail = self.tail;
-        self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
-        unsafe { Some(self.ring.get_unchecked(tail)) }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = count(self.tail, self.head, self.ring.len());
-        (len, Some(len))
-    }
-
-    fn fold<Acc, F>(self, mut accum: Acc, mut f: F) -> Acc
-        where F: FnMut(Acc, Self::Item) -> Acc
-    {
-        let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
-        accum = front.iter().fold(accum, &mut f);
-        back.iter().fold(accum, &mut f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for Iter<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a T> {
-        if self.tail == self.head {
-            return None;
-        }
-        self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
-        unsafe { Some(self.ring.get_unchecked(self.head)) }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for Iter<'a, T> {
-    fn is_empty(&self) -> bool {
-        self.head == self.tail
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for Iter<'a, T> {}
-
-
-/// A mutable iterator over the elements of a `VecDeque`.
-///
-/// This `struct` is created by the [`iter_mut`] method on [`VecDeque`]. See its
-/// documentation for more.
-///
-/// [`iter_mut`]: struct.VecDeque.html#method.iter_mut
-/// [`VecDeque`]: struct.VecDeque.html
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IterMut<'a, T: 'a> {
-    ring: &'a mut [T],
-    tail: usize,
-    head: usize,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for IterMut<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IterMut")
-         .field(&self.ring)
-         .field(&self.tail)
-         .field(&self.head)
-         .finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> Iterator for IterMut<'a, T> {
-    type Item = &'a mut T;
-
-    #[inline]
-    fn next(&mut self) -> Option<&'a mut T> {
-        if self.tail == self.head {
-            return None;
-        }
-        let tail = self.tail;
-        self.tail = wrap_index(self.tail.wrapping_add(1), self.ring.len());
-
-        unsafe {
-            let elem = self.ring.get_unchecked_mut(tail);
-            Some(&mut *(elem as *mut _))
-        }
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = count(self.tail, self.head, self.ring.len());
-        (len, Some(len))
-    }
-
-    fn fold<Acc, F>(self, mut accum: Acc, mut f: F) -> Acc
-        where F: FnMut(Acc, Self::Item) -> Acc
-    {
-        let (front, back) = RingSlices::ring_slices(self.ring, self.head, self.tail);
-        accum = front.iter_mut().fold(accum, &mut f);
-        back.iter_mut().fold(accum, &mut f)
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> DoubleEndedIterator for IterMut<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<&'a mut T> {
-        if self.tail == self.head {
-            return None;
-        }
-        self.head = wrap_index(self.head.wrapping_sub(1), self.ring.len());
-
-        unsafe {
-            let elem = self.ring.get_unchecked_mut(self.head);
-            Some(&mut *(elem as *mut _))
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> ExactSizeIterator for IterMut<'a, T> {
-    fn is_empty(&self) -> bool {
-        self.head == self.tail
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T> FusedIterator for IterMut<'a, T> {}
-
-/// An owning iterator over the elements of a `VecDeque`.
-///
-/// This `struct` is created by the [`into_iter`] method on [`VecDeque`][`VecDeque`]
-/// (provided by the `IntoIterator` trait). See its documentation for more.
-///
-/// [`into_iter`]: struct.VecDeque.html#method.into_iter
-/// [`VecDeque`]: struct.VecDeque.html
-#[derive(Clone)]
-#[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<T> {
-    inner: VecDeque<T>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<T: fmt::Debug> fmt::Debug for IntoIter<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("IntoIter")
-         .field(&self.inner)
-         .finish()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> Iterator for IntoIter<T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.inner.pop_front()
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        let len = self.inner.len();
-        (len, Some(len))
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> DoubleEndedIterator for IntoIter<T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.inner.pop_back()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> ExactSizeIterator for IntoIter<T> {
-    fn is_empty(&self) -> bool {
-        self.inner.is_empty()
-    }
-}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<T> FusedIterator for IntoIter<T> {}
-
-/// A draining iterator over the elements of a `VecDeque`.
-///
-/// This `struct` is created by the [`drain`] method on [`VecDeque`]. See its
-/// documentation for more.
-///
-/// [`drain`]: struct.VecDeque.html#method.drain
-/// [`VecDeque`]: struct.VecDeque.html
-#[stable(feature = "drain", since = "1.6.0")]
-pub struct Drain<'a, T: 'a> {
-    after_tail: usize,
-    after_head: usize,
-    iter: Iter<'a, T>,
-    deque: Shared<VecDeque<T>>,
-}
-
-#[stable(feature = "collection_debug", since = "1.17.0")]
-impl<'a, T: 'a + fmt::Debug> fmt::Debug for Drain<'a, T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_tuple("Drain")
-         .field(&self.after_tail)
-         .field(&self.after_head)
-         .field(&self.iter)
-         .finish()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a, T: Sync> Sync for Drain<'a, T> {}
-#[stable(feature = "drain", since = "1.6.0")]
-unsafe impl<'a, T: Send> Send for Drain<'a, T> {}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> Drop for Drain<'a, T> {
-    fn drop(&mut self) {
-        for _ in self.by_ref() {}
-
-        let source_deque = unsafe { self.deque.as_mut() };
-
-        // T = source_deque_tail; H = source_deque_head; t = drain_tail; h = drain_head
-        //
-        //        T   t   h   H
-        // [. . . o o x x o o . . .]
-        //
-        let orig_tail = source_deque.tail;
-        let drain_tail = source_deque.head;
-        let drain_head = self.after_tail;
-        let orig_head = self.after_head;
-
-        let tail_len = count(orig_tail, drain_tail, source_deque.cap());
-        let head_len = count(drain_head, orig_head, source_deque.cap());
-
-        // Restore the original head value
-        source_deque.head = orig_head;
-
-        match (tail_len, head_len) {
-            (0, 0) => {
-                source_deque.head = 0;
-                source_deque.tail = 0;
-            }
-            (0, _) => {
-                source_deque.tail = drain_head;
-            }
-            (_, 0) => {
-                source_deque.head = drain_tail;
-            }
-            _ => unsafe {
-                if tail_len <= head_len {
-                    source_deque.tail = source_deque.wrap_sub(drain_head, tail_len);
-                    source_deque.wrap_copy(source_deque.tail, orig_tail, tail_len);
-                } else {
-                    source_deque.head = source_deque.wrap_add(drain_tail, head_len);
-                    source_deque.wrap_copy(drain_tail, drain_head, head_len);
-                }
-            },
-        }
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> Iterator for Drain<'a, T> {
-    type Item = T;
-
-    #[inline]
-    fn next(&mut self) -> Option<T> {
-        self.iter.next().map(|elt| unsafe { ptr::read(elt) })
-    }
-
-    #[inline]
-    fn size_hint(&self) -> (usize, Option<usize>) {
-        self.iter.size_hint()
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> DoubleEndedIterator for Drain<'a, T> {
-    #[inline]
-    fn next_back(&mut self) -> Option<T> {
-        self.iter.next_back().map(|elt| unsafe { ptr::read(elt) })
-    }
-}
-
-#[stable(feature = "drain", since = "1.6.0")]
-impl<'a, T: 'a> ExactSizeIterator for Drain<'a, T> {}
-
-#[unstable(feature = "fused", issue = "35602")]
-impl<'a, T: 'a> FusedIterator for Drain<'a, T> {}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: PartialEq> PartialEq for VecDeque<A> {
-    fn eq(&self, other: &VecDeque<A>) -> bool {
-        if self.len() != other.len() {
-            return false;
-        }
-        let (sa, sb) = self.as_slices();
-        let (oa, ob) = other.as_slices();
-        if sa.len() == oa.len() {
-            sa == oa && sb == ob
-        } else if sa.len() < oa.len() {
-            // Always divisible in three sections, for example:
-            // self:  [a b c|d e f]
-            // other: [0 1 2 3|4 5]
-            // front = 3, mid = 1,
-            // [a b c] == [0 1 2] && [d] == [3] && [e f] == [4 5]
-            let front = sa.len();
-            let mid = oa.len() - front;
-
-            let (oa_front, oa_mid) = oa.split_at(front);
-            let (sb_mid, sb_back) = sb.split_at(mid);
-            debug_assert_eq!(sa.len(), oa_front.len());
-            debug_assert_eq!(sb_mid.len(), oa_mid.len());
-            debug_assert_eq!(sb_back.len(), ob.len());
-            sa == oa_front && sb_mid == oa_mid && sb_back == ob
-        } else {
-            let front = oa.len();
-            let mid = sa.len() - front;
-
-            let (sa_front, sa_mid) = sa.split_at(front);
-            let (ob_mid, ob_back) = ob.split_at(mid);
-            debug_assert_eq!(sa_front.len(), oa.len());
-            debug_assert_eq!(sa_mid.len(), ob_mid.len());
-            debug_assert_eq!(sb.len(), ob_back.len());
-            sa_front == oa && sa_mid == ob_mid && sb == ob_back
-        }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Eq> Eq for VecDeque<A> {}
-
-macro_rules! __impl_slice_eq1 {
-    ($Lhs: ty, $Rhs: ty) => {
-        __impl_slice_eq1! { $Lhs, $Rhs, Sized }
-    };
-    ($Lhs: ty, $Rhs: ty, $Bound: ident) => {
-        #[stable(feature = "vec-deque-partial-eq-slice", since = "1.17.0")]
-        impl<'a, 'b, A: $Bound, B> PartialEq<$Rhs> for $Lhs where A: PartialEq<B> {
-            fn eq(&self, other: &$Rhs) -> bool {
-                if self.len() != other.len() {
-                    return false;
-                }
-                let (sa, sb) = self.as_slices();
-                let (oa, ob) = other[..].split_at(sa.len());
-                sa == oa && sb == ob
-            }
-        }
-    }
-}
-
-__impl_slice_eq1! { VecDeque<A>, Vec<B> }
-__impl_slice_eq1! { VecDeque<A>, &'b [B] }
-__impl_slice_eq1! { VecDeque<A>, &'b mut [B] }
-
-macro_rules! array_impls {
-    ($($N: expr)+) => {
-        $(
-            __impl_slice_eq1! { VecDeque<A>, [B; $N] }
-            __impl_slice_eq1! { VecDeque<A>, &'b [B; $N] }
-            __impl_slice_eq1! { VecDeque<A>, &'b mut [B; $N] }
-        )+
-    }
-}
-
-array_impls! {
-     0  1  2  3  4  5  6  7  8  9
-    10 11 12 13 14 15 16 17 18 19
-    20 21 22 23 24 25 26 27 28 29
-    30 31 32
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: PartialOrd> PartialOrd for VecDeque<A> {
-    fn partial_cmp(&self, other: &VecDeque<A>) -> Option<Ordering> {
-        self.iter().partial_cmp(other.iter())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Ord> Ord for VecDeque<A> {
-    #[inline]
-    fn cmp(&self, other: &VecDeque<A>) -> Ordering {
-        self.iter().cmp(other.iter())
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A: Hash> Hash for VecDeque<A> {
-    fn hash<H: Hasher>(&self, state: &mut H) {
-        self.len().hash(state);
-        let (a, b) = self.as_slices();
-        Hash::hash_slice(a, state);
-        Hash::hash_slice(b, state);
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Index<usize> for VecDeque<A> {
-    type Output = A;
-
-    #[inline]
-    fn index(&self, index: usize) -> &A {
-        self.get(index).expect("Out of bounds access")
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> IndexMut<usize> for VecDeque<A> {
-    #[inline]
-    fn index_mut(&mut self, index: usize) -> &mut A {
-        self.get_mut(index).expect("Out of bounds access")
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> FromIterator<A> for VecDeque<A> {
-    fn from_iter<T: IntoIterator<Item = A>>(iter: T) -> VecDeque<A> {
-        let iterator = iter.into_iter();
-        let (lower, _) = iterator.size_hint();
-        let mut deq = VecDeque::with_capacity(lower);
-        deq.extend(iterator);
-        deq
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T> IntoIterator for VecDeque<T> {
-    type Item = T;
-    type IntoIter = IntoIter<T>;
-
-    /// Consumes the list into a front-to-back iterator yielding elements by
-    /// value.
-    fn into_iter(self) -> IntoIter<T> {
-        IntoIter { inner: self }
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a VecDeque<T> {
-    type Item = &'a T;
-    type IntoIter = Iter<'a, T>;
-
-    fn into_iter(self) -> Iter<'a, T> {
-        self.iter()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T> IntoIterator for &'a mut VecDeque<T> {
-    type Item = &'a mut T;
-    type IntoIter = IterMut<'a, T>;
-
-    fn into_iter(mut self) -> IterMut<'a, T> {
-        self.iter_mut()
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<A> Extend<A> for VecDeque<A> {
-    fn extend<T: IntoIterator<Item = A>>(&mut self, iter: T) {
-        for elt in iter {
-            self.push_back(elt);
-        }
-    }
-}
-
-#[stable(feature = "extend_ref", since = "1.2.0")]
-impl<'a, T: 'a + Copy> Extend<&'a T> for VecDeque<T> {
-    fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
-        self.extend(iter.into_iter().cloned());
-    }
-}
-
-#[stable(feature = "rust1", since = "1.0.0")]
-impl<T: fmt::Debug> fmt::Debug for VecDeque<T> {
-    fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
-        f.debug_list().entries(self).finish()
-    }
-}
-
-#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
-impl<T> From<Vec<T>> for VecDeque<T> {
-    fn from(mut other: Vec<T>) -> Self {
-        unsafe {
-            let other_buf = other.as_mut_ptr();
-            let mut buf = RawVec::from_raw_parts(other_buf, other.capacity());
-            let len = other.len();
-            mem::forget(other);
-
-            // We need to extend the buf if it's not a power of two, too small
-            // or doesn't have at least one free space
-            if !buf.cap().is_power_of_two() || (buf.cap() < (MINIMUM_CAPACITY + 1)) ||
-               (buf.cap() == len) {
-                let cap = cmp::max(buf.cap() + 1, MINIMUM_CAPACITY + 1).next_power_of_two();
-                buf.reserve_exact(len, cap - len);
-            }
-
-            VecDeque {
-                tail: 0,
-                head: len,
-                buf: buf,
-            }
-        }
-    }
-}
-
-#[stable(feature = "vecdeque_vec_conversions", since = "1.10.0")]
-impl<T> From<VecDeque<T>> for Vec<T> {
-    fn from(other: VecDeque<T>) -> Self {
-        unsafe {
-            let buf = other.buf.ptr();
-            let len = other.len();
-            let tail = other.tail;
-            let head = other.head;
-            let cap = other.cap();
-
-            // Need to move the ring to the front of the buffer, as vec will expect this.
-            if other.is_contiguous() {
-                ptr::copy(buf.offset(tail as isize), buf, len);
-            } else {
-                if (tail - head) >= cmp::min((cap - tail), head) {
-                    // There is enough free space in the centre for the shortest block so we can
-                    // do this in at most three copy moves.
-                    if (cap - tail) > head {
-                        // right hand block is the long one; move that enough for the left
-                        ptr::copy(buf.offset(tail as isize),
-                                  buf.offset((tail - head) as isize),
-                                  cap - tail);
-                        // copy left in the end
-                        ptr::copy(buf, buf.offset((cap - head) as isize), head);
-                        // shift the new thing to the start
-                        ptr::copy(buf.offset((tail - head) as isize), buf, len);
-                    } else {
-                        // left hand block is the long one, we can do it in two!
-                        ptr::copy(buf, buf.offset((cap - tail) as isize), head);
-                        ptr::copy(buf.offset(tail as isize), buf, cap - tail);
-                    }
-                } else {
-                    // Need to use N swaps to move the ring
-                    // We can use the space at the end of the ring as a temp store
-
-                    let mut left_edge: usize = 0;
-                    let mut right_edge: usize = tail;
-
-                    // The general problem looks like this
-                    // GHIJKLM...ABCDEF - before any swaps
-                    // ABCDEFM...GHIJKL - after 1 pass of swaps
-                    // ABCDEFGHIJM...KL - swap until the left edge reaches the temp store
-                    //                  - then restart the algorithm with a new (smaller) store
-                    // Sometimes the temp store is reached when the right edge is at the end
-                    // of the buffer - this means we've hit the right order with fewer swaps!
-                    // E.g
-                    // EF..ABCD
-                    // ABCDEF.. - after four only swaps we've finished
-
-                    while left_edge < len && right_edge != cap {
-                        let mut right_offset = 0;
-                        for i in left_edge..right_edge {
-                            right_offset = (i - left_edge) % (cap - right_edge);
-                            let src: isize = (right_edge + right_offset) as isize;
-                            ptr::swap(buf.offset(i as isize), buf.offset(src));
-                        }
-                        let n_ops = right_edge - left_edge;
-                        left_edge += n_ops;
-                        right_edge += right_offset + 1;
-
-                    }
-                }
-
-            }
-            let out = Vec::from_raw_parts(buf, len, cap);
-            mem::forget(other);
-            out
-        }
-    }
-}
-
-/// A place for insertion at the back of a `VecDeque`.
-///
-/// See [`VecDeque::place_back`](struct.VecDeque.html#method.place_back) for details.
-#[must_use = "places do nothing unless written to with `<-` syntax"]
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-#[derive(Debug)]
-pub struct PlaceBack<'a, T: 'a> {
-    vec_deque: &'a mut VecDeque<T>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Placer<T> for PlaceBack<'a, T> {
-    type Place = PlaceBack<'a, T>;
-
-    fn make_place(self) -> Self {
-        self.vec_deque.grow_if_necessary();
-        self
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for PlaceBack<'a, T> {
-    fn pointer(&mut self) -> *mut T {
-        unsafe { self.vec_deque.ptr().offset(self.vec_deque.head as isize) }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for PlaceBack<'a, T> {
-    type Owner = &'a mut T;
-
-    unsafe fn finalize(mut self) -> &'a mut T {
-        let head = self.vec_deque.head;
-        self.vec_deque.head = self.vec_deque.wrap_add(head, 1);
-        &mut *(self.vec_deque.ptr().offset(head as isize))
-    }
-}
-
-/// A place for insertion at the front of a `VecDeque`.
-///
-/// See [`VecDeque::place_front`](struct.VecDeque.html#method.place_front) for details.
-#[must_use = "places do nothing unless written to with `<-` syntax"]
-#[unstable(feature = "collection_placement",
-           reason = "struct name and placement protocol are subject to change",
-           issue = "30172")]
-#[derive(Debug)]
-pub struct PlaceFront<'a, T: 'a> {
-    vec_deque: &'a mut VecDeque<T>,
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Placer<T> for PlaceFront<'a, T> {
-    type Place = PlaceFront<'a, T>;
-
-    fn make_place(self) -> Self {
-        self.vec_deque.grow_if_necessary();
-        self
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> Place<T> for PlaceFront<'a, T> {
-    fn pointer(&mut self) -> *mut T {
-        let tail = self.vec_deque.wrap_sub(self.vec_deque.tail, 1);
-        unsafe { self.vec_deque.ptr().offset(tail as isize) }
-    }
-}
-
-#[unstable(feature = "collection_placement",
-           reason = "placement protocol is subject to change",
-           issue = "30172")]
-impl<'a, T> InPlace<T> for PlaceFront<'a, T> {
-    type Owner = &'a mut T;
-
-    unsafe fn finalize(mut self) -> &'a mut T {
-        self.vec_deque.tail = self.vec_deque.wrap_sub(self.vec_deque.tail, 1);
-        &mut *(self.vec_deque.ptr().offset(self.vec_deque.tail as isize))
-    }
-}
-
-#[cfg(test)]
-mod tests {
-    use test;
-
-    use super::VecDeque;
-
-    #[bench]
-    fn bench_push_back_100(b: &mut test::Bencher) {
-        let mut deq = VecDeque::with_capacity(101);
-        b.iter(|| {
-            for i in 0..100 {
-                deq.push_back(i);
-            }
-            deq.head = 0;
-            deq.tail = 0;
-        })
-    }
-
-    #[bench]
-    fn bench_push_front_100(b: &mut test::Bencher) {
-        let mut deq = VecDeque::with_capacity(101);
-        b.iter(|| {
-            for i in 0..100 {
-                deq.push_front(i);
-            }
-            deq.head = 0;
-            deq.tail = 0;
-        })
-    }
-
-    #[bench]
-    fn bench_pop_back_100(b: &mut test::Bencher) {
-        let mut deq = VecDeque::<i32>::with_capacity(101);
-
-        b.iter(|| {
-            deq.head = 100;
-            deq.tail = 0;
-            while !deq.is_empty() {
-                test::black_box(deq.pop_back());
-            }
-        })
-    }
-
-    #[bench]
-    fn bench_pop_front_100(b: &mut test::Bencher) {
-        let mut deq = VecDeque::<i32>::with_capacity(101);
-
-        b.iter(|| {
-            deq.head = 100;
-            deq.tail = 0;
-            while !deq.is_empty() {
-                test::black_box(deq.pop_front());
-            }
-        })
-    }
-
-    #[test]
-    fn test_swap_front_back_remove() {
-        fn test(back: bool) {
-            // This test checks that every single combination of tail position and length is tested.
-            // Capacity 15 should be large enough to cover every case.
-            let mut tester = VecDeque::with_capacity(15);
-            let usable_cap = tester.capacity();
-            let final_len = usable_cap / 2;
-
-            for len in 0..final_len {
-                let expected: VecDeque<_> = if back {
-                    (0..len).collect()
-                } else {
-                    (0..len).rev().collect()
-                };
-                for tail_pos in 0..usable_cap {
-                    tester.tail = tail_pos;
-                    tester.head = tail_pos;
-                    if back {
-                        for i in 0..len * 2 {
-                            tester.push_front(i);
-                        }
-                        for i in 0..len {
-                            assert_eq!(tester.swap_remove_back(i), Some(len * 2 - 1 - i));
-                        }
-                    } else {
-                        for i in 0..len * 2 {
-                            tester.push_back(i);
-                        }
-                        for i in 0..len {
-                            let idx = tester.len() - 1 - i;
-                            assert_eq!(tester.swap_remove_front(idx), Some(len * 2 - 1 - i));
-                        }
-                    }
-                    assert!(tester.tail < tester.cap());
-                    assert!(tester.head < tester.cap());
-                    assert_eq!(tester, expected);
-                }
-            }
-        }
-        test(true);
-        test(false);
-    }
-
-    #[test]
-    fn test_insert() {
-        // This test checks that every single combination of tail position, length, and
-        // insertion position is tested. Capacity 15 should be large enough to cover every case.
-
-        let mut tester = VecDeque::with_capacity(15);
-        // can't guarantee we got 15, so have to get what we got.
-        // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
-        // this test isn't covering what it wants to
-        let cap = tester.capacity();
-
-
-        // len is the length *after* insertion
-        for len in 1..cap {
-            // 0, 1, 2, .., len - 1
-            let expected = (0..).take(len).collect::<VecDeque<_>>();
-            for tail_pos in 0..cap {
-                for to_insert in 0..len {
-                    tester.tail = tail_pos;
-                    tester.head = tail_pos;
-                    for i in 0..len {
-                        if i != to_insert {
-                            tester.push_back(i);
-                        }
-                    }
-                    tester.insert(to_insert, to_insert);
-                    assert!(tester.tail < tester.cap());
-                    assert!(tester.head < tester.cap());
-                    assert_eq!(tester, expected);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_remove() {
-        // This test checks that every single combination of tail position, length, and
-        // removal position is tested. Capacity 15 should be large enough to cover every case.
-
-        let mut tester = VecDeque::with_capacity(15);
-        // can't guarantee we got 15, so have to get what we got.
-        // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
-        // this test isn't covering what it wants to
-        let cap = tester.capacity();
-
-        // len is the length *after* removal
-        for len in 0..cap - 1 {
-            // 0, 1, 2, .., len - 1
-            let expected = (0..).take(len).collect::<VecDeque<_>>();
-            for tail_pos in 0..cap {
-                for to_remove in 0..len + 1 {
-                    tester.tail = tail_pos;
-                    tester.head = tail_pos;
-                    for i in 0..len {
-                        if i == to_remove {
-                            tester.push_back(1234);
-                        }
-                        tester.push_back(i);
-                    }
-                    if to_remove == len {
-                        tester.push_back(1234);
-                    }
-                    tester.remove(to_remove);
-                    assert!(tester.tail < tester.cap());
-                    assert!(tester.head < tester.cap());
-                    assert_eq!(tester, expected);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_drain() {
-        let mut tester: VecDeque<usize> = VecDeque::with_capacity(7);
-
-        let cap = tester.capacity();
-        for len in 0..cap + 1 {
-            for tail in 0..cap + 1 {
-                for drain_start in 0..len + 1 {
-                    for drain_end in drain_start..len + 1 {
-                        tester.tail = tail;
-                        tester.head = tail;
-                        for i in 0..len {
-                            tester.push_back(i);
-                        }
-
-                        // Check that we drain the correct values
-                        let drained: VecDeque<_> = tester.drain(drain_start..drain_end).collect();
-                        let drained_expected: VecDeque<_> = (drain_start..drain_end).collect();
-                        assert_eq!(drained, drained_expected);
-
-                        // We shouldn't have changed the capacity or made the
-                        // head or tail out of bounds
-                        assert_eq!(tester.capacity(), cap);
-                        assert!(tester.tail < tester.cap());
-                        assert!(tester.head < tester.cap());
-
-                        // We should see the correct values in the VecDeque
-                        let expected: VecDeque<_> = (0..drain_start)
-                            .chain(drain_end..len)
-                            .collect();
-                        assert_eq!(expected, tester);
-                    }
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_shrink_to_fit() {
-        // This test checks that every single combination of head and tail position,
-        // is tested. Capacity 15 should be large enough to cover every case.
-
-        let mut tester = VecDeque::with_capacity(15);
-        // can't guarantee we got 15, so have to get what we got.
-        // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
-        // this test isn't covering what it wants to
-        let cap = tester.capacity();
-        tester.reserve(63);
-        let max_cap = tester.capacity();
-
-        for len in 0..cap + 1 {
-            // 0, 1, 2, .., len - 1
-            let expected = (0..).take(len).collect::<VecDeque<_>>();
-            for tail_pos in 0..max_cap + 1 {
-                tester.tail = tail_pos;
-                tester.head = tail_pos;
-                tester.reserve(63);
-                for i in 0..len {
-                    tester.push_back(i);
-                }
-                tester.shrink_to_fit();
-                assert!(tester.capacity() <= cap);
-                assert!(tester.tail < tester.cap());
-                assert!(tester.head < tester.cap());
-                assert_eq!(tester, expected);
-            }
-        }
-    }
-
-    #[test]
-    fn test_split_off() {
-        // This test checks that every single combination of tail position, length, and
-        // split position is tested. Capacity 15 should be large enough to cover every case.
-
-        let mut tester = VecDeque::with_capacity(15);
-        // can't guarantee we got 15, so have to get what we got.
-        // 15 would be great, but we will definitely get 2^k - 1, for k >= 4, or else
-        // this test isn't covering what it wants to
-        let cap = tester.capacity();
-
-        // len is the length *before* splitting
-        for len in 0..cap {
-            // index to split at
-            for at in 0..len + 1 {
-                // 0, 1, 2, .., at - 1 (may be empty)
-                let expected_self = (0..).take(at).collect::<VecDeque<_>>();
-                // at, at + 1, .., len - 1 (may be empty)
-                let expected_other = (at..).take(len - at).collect::<VecDeque<_>>();
-
-                for tail_pos in 0..cap {
-                    tester.tail = tail_pos;
-                    tester.head = tail_pos;
-                    for i in 0..len {
-                        tester.push_back(i);
-                    }
-                    let result = tester.split_off(at);
-                    assert!(tester.tail < tester.cap());
-                    assert!(tester.head < tester.cap());
-                    assert!(result.tail < result.cap());
-                    assert!(result.head < result.cap());
-                    assert_eq!(tester, expected_self);
-                    assert_eq!(result, expected_other);
-                }
-            }
-        }
-    }
-
-    #[test]
-    fn test_from_vec() {
-        use super::super::vec::Vec;
-        for cap in 0..35 {
-            for len in 0..cap + 1 {
-                let mut vec = Vec::with_capacity(cap);
-                vec.extend(0..len);
-
-                let vd = VecDeque::from(vec.clone());
-                assert!(vd.cap().is_power_of_two());
-                assert_eq!(vd.len(), vec.len());
-                assert!(vd.into_iter().eq(vec));
-            }
-        }
-    }
-
-    #[test]
-    fn test_vec_from_vecdeque() {
-        use super::super::vec::Vec;
-
-        fn create_vec_and_test_convert(cap: usize, offset: usize, len: usize) {
-            let mut vd = VecDeque::with_capacity(cap);
-            for _ in 0..offset {
-                vd.push_back(0);
-                vd.pop_front();
-            }
-            vd.extend(0..len);
-
-            let vec: Vec<_> = Vec::from(vd.clone());
-            assert_eq!(vec.len(), vd.len());
-            assert!(vec.into_iter().eq(vd));
-        }
-
-        for cap_pwr in 0..7 {
-            // Make capacity as a (2^x)-1, so that the ring size is 2^x
-            let cap = (2i32.pow(cap_pwr) - 1) as usize;
-
-            // In these cases there is enough free space to solve it with copies
-            for len in 0..((cap + 1) / 2) {
-                // Test contiguous cases
-                for offset in 0..(cap - len) {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-
-                // Test cases where block at end of buffer is bigger than block at start
-                for offset in (cap - len)..(cap - (len / 2)) {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-
-                // Test cases where block at start of buffer is bigger than block at end
-                for offset in (cap - (len / 2))..cap {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-            }
-
-            // Now there's not (necessarily) space to straighten the ring with simple copies,
-            // the ring will use swapping when:
-            // (cap + 1 - offset) > (cap + 1 - len) && (len - (cap + 1 - offset)) > (cap + 1 - len))
-            //  right block size  >   free space    &&      left block size       >    free space
-            for len in ((cap + 1) / 2)..cap {
-                // Test contiguous cases
-                for offset in 0..(cap - len) {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-
-                // Test cases where block at end of buffer is bigger than block at start
-                for offset in (cap - len)..(cap - (len / 2)) {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-
-                // Test cases where block at start of buffer is bigger than block at end
-                for offset in (cap - (len / 2))..cap {
-                    create_vec_and_test_convert(cap, offset, len)
-                }
-            }
-        }
-    }
-
-}