Auto merge of #42648 - murarth:merge-alloc-collections, r=alexcrichton

Merge crate `collections` into `alloc`

This is a necessary step in order to merge #42565

src/Cargo.lock

@@ -36,6 +36,7 @@ name = "alloc"
 version = "0.0.0"
 dependencies = [
  "core 0.0.0",
+ "std_unicode 0.0.0",
 ]
 
 [[package]]
@@ -250,15 +251,6 @@ dependencies = [
  "gcc 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",
 ]
 
-[[package]]
-name = "collections"
-version = "0.0.0"
-dependencies = [
- "alloc 0.0.0",
- "core 0.0.0",
- "std_unicode 0.0.0",
-]
-
 [[package]]
 name = "compiler_builtins"
 version = "0.0.0"
@@ -1594,7 +1586,6 @@ dependencies = [
  "alloc_jemalloc 0.0.0",
  "alloc_system 0.0.0",
  "build_helper 0.1.0",
- "collections 0.0.0",
  "compiler_builtins 0.0.0",
  "core 0.0.0",
  "gcc 0.3.50 (registry+https://github.com/rust-lang/crates.io-index)",

src/bootstrap/dist.rs

@@ -376,8 +376,8 @@ pub fn debugger_scripts(build: &Build,
         install(&build.src.join("src/etc/rust-windbg.cmd"), &sysroot.join("bin"),
             0o755);
 
+        cp_debugger_script("natvis/liballoc.natvis");
         cp_debugger_script("natvis/libcore.natvis");
-        cp_debugger_script("natvis/libcollections.natvis");
     } else {
         cp_debugger_script("debugger_pretty_printers_common.py");
 
@@ -550,7 +550,6 @@ pub fn rust_src(build: &Build) {
         "src/liballoc_jemalloc",
         "src/liballoc_system",
         "src/libbacktrace",
-        "src/libcollections",
         "src/libcompiler_builtins",
         "src/libcore",
         "src/liblibc",

src/bootstrap/doc.rs

@@ -246,7 +246,7 @@ pub fn std(build: &Build, stage: u32, target: &str) {
     // for which docs must be built.
     if !build.config.compiler_docs {
         cargo.arg("--no-deps");
-        for krate in &["alloc", "collections", "core", "std", "std_unicode"] {
+        for krate in &["alloc", "core", "std", "std_unicode"] {
             cargo.arg("-p").arg(krate);
             // Create all crate output directories first to make sure rustdoc uses
             // relative links.

src/doc/unstable-book/src/SUMMARY.md

@@ -110,7 +110,6 @@
     - [coerce_unsized](library-features/coerce-unsized.md)
     - [collection_placement](library-features/collection-placement.md)
     - [collections_range](library-features/collections-range.md)
-    - [collections](library-features/collections.md)
     - [command_envs](library-features/command-envs.md)
     - [compiler_builtins_lib](library-features/compiler-builtins-lib.md)
     - [compiler_fences](library-features/compiler-fences.md)

src/doc/unstable-book/src/library-features/collections.md

@@ -1,5 +0,0 @@
-# `collections`
-
-This feature is internal to the Rust compiler and is not intended for general use.
-
-------------------------

src/etc/natvis/liballoc.natvis

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="utf-8"?>
 <AutoVisualizer xmlns="http://schemas.microsoft.com/vstudio/debugger/natvis/2010">
-  <Type Name="collections::vec::Vec&lt;*&gt;">
+  <Type Name="alloc::vec::Vec&lt;*&gt;">
     <DisplayString>{{ size={len} }}</DisplayString>
     <Expand>
       <Item Name="[size]" ExcludeView="simple">len</Item>
@@ -11,7 +11,7 @@
       </ArrayItems>
     </Expand>
   </Type>
-  <Type Name="collections::vec_deque::VecDeque&lt;*&gt;">
+  <Type Name="alloc::vec_deque::VecDeque&lt;*&gt;">
     <DisplayString>{{ size={tail &lt;= head ? head - tail : buf.cap - tail + head} }}</DisplayString>
     <Expand>
       <Item Name="[size]" ExcludeView="simple">tail &lt;= head ? head - tail : buf.cap - tail + head</Item>
@@ -30,18 +30,18 @@
       </CustomListItems>
     </Expand>
   </Type>
-  <Type Name="collections::linked_list::LinkedList&lt;*&gt;">
+  <Type Name="alloc::linked_list::LinkedList&lt;*&gt;">
     <DisplayString>{{ size={len} }}</DisplayString>
     <Expand>
       <LinkedListItems>
         <Size>len</Size>
-        <HeadPointer>*(collections::linked_list::Node&lt;$T1&gt; **)&amp;head</HeadPointer>
-        <NextPointer>*(collections::linked_list::Node&lt;$T1&gt; **)&amp;next</NextPointer>
+        <HeadPointer>*(alloc::linked_list::Node&lt;$T1&gt; **)&amp;head</HeadPointer>
+        <NextPointer>*(alloc::linked_list::Node&lt;$T1&gt; **)&amp;next</NextPointer>
         <ValueNode>element</ValueNode>
       </LinkedListItems>
     </Expand>
   </Type>
-  <Type Name="collections::string::String">
+  <Type Name="alloc::string::String">
     <DisplayString>{*(char**)this,[vec.len]}</DisplayString>
     <StringView>*(char**)this,[vec.len]</StringView>
     <Expand>
@@ -53,4 +53,4 @@
       </ArrayItems>
     </Expand>
   </Type>
-</AutoVisualizer>
+</AutoVisualizer>

src/etc/rust-windbg.cmd

@@ -15,4 +15,4 @@ for /f "delims=" %%i in ('rustc --print=sysroot') do set rustc_sysroot=%%i
 
 set rust_etc=%rustc_sysroot%\lib\rustlib\etc
 
-windbg -c ".nvload %rust_etc%\libcore.natvis;.nvload %rust_etc%\libcollections.natvis;" %*
+windbg -c ".nvload %rust_etc%\liballoc.natvis; .nvload %rust_etc%\libcore.natvis;" %*

src/liballoc/Cargo.toml

@@ -9,3 +9,12 @@ path = "lib.rs"
 
 [dependencies]
 core = { path = "../libcore" }
+std_unicode = { path = "../libstd_unicode" }
+
+[[test]]
+name = "collectionstests"
+path = "../liballoc/tests/lib.rs"
+
+[[bench]]
+name = "collectionsbenches"
+path = "../liballoc/benches/lib.rs"

src/liballoc/arc.rs

@@ -1222,11 +1222,12 @@ mod tests {
     use std::sync::atomic;
     use std::sync::atomic::Ordering::{Acquire, SeqCst};
     use std::thread;
-    use std::vec::Vec;
-    use super::{Arc, Weak};
     use std::sync::Mutex;
     use std::convert::From;
 
+    use super::{Arc, Weak};
+    use vec::Vec;
+
     struct Canary(*mut atomic::AtomicUsize);
 
     impl Drop for Canary {

src/liballoc/boxed.rs

@@ -95,6 +95,7 @@ pub const HEAP: ExchangeHeapSingleton = ExchangeHeapSingleton { _force_singleton
 #[unstable(feature = "box_heap",
            reason = "may be renamed; uncertain about custom allocator design",
            issue = "27779")]
+#[allow(missing_debug_implementations)]
 #[derive(Copy, Clone)]
 pub struct ExchangeHeapSingleton {
     _force_singleton: (),
@@ -129,6 +130,7 @@ pub struct Box<T: ?Sized>(Unique<T>);
 #[unstable(feature = "placement_in",
            reason = "placement box design is still being worked out.",
            issue = "27779")]
+#[allow(missing_debug_implementations)]
 pub struct IntermediateBox<T: ?Sized> {
     ptr: *mut u8,
     size: usize,

src/liballoc/btree/node.rs

@@ -41,7 +41,6 @@
 // - 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;
@@ -49,6 +48,7 @@ use core::ptr::{self, Unique};
 use core::slice;
 
 use boxed::Box;
+use heap;
 
 const B: usize = 6;
 pub const MIN_LEN: usize = B - 1;

src/liballoc/lib.rs

@@ -1,4 +1,4 @@
-// Copyright 2014 The Rust Project Developers. See the COPYRIGHT
+// Copyright 2014-2017 The Rust Project Developers. See the COPYRIGHT
 // file at the top-level directory of this distribution and at
 // http://rust-lang.org/COPYRIGHT.
 //
@@ -8,18 +8,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! # The Rust core allocation library
+//! # The Rust core allocation and collections library
 //!
-//! This is the lowest level library through which allocation in Rust can be
-//! performed.
+//! This library provides smart pointers and collections for managing
+//! heap-allocated values.
 //!
 //! This library, like libcore, is not intended for general usage, but rather as
 //! a building block of other libraries. The types and interfaces in this
 //! library are reexported through the [standard library](../std/index.html),
 //! and should not be used through this library.
 //!
-//! Currently, there are four major definitions in this library.
-//!
 //! ## Boxed values
 //!
 //! The [`Box`](boxed/index.html) type is a smart pointer type. There can
@@ -51,6 +49,12 @@
 //! paired with synchronization primitives such as mutexes to allow mutation of
 //! shared resources.
 //!
+//! ## Collections
+//!
+//! Implementations of the most common general purpose data structures are
+//! defined in this library. They are reexported through the
+//! [standard collections library](../std/collections/index.html).
+//!
 //! ## Heap interfaces
 //!
 //! The [`heap`](heap/index.html) module defines the low-level interface to the
@@ -71,8 +75,20 @@
 #![no_std]
 #![needs_allocator]
 #![deny(warnings)]
+#![deny(missing_debug_implementations)]
 
+#![cfg_attr(test, allow(deprecated))] // rand
+#![cfg_attr(test, feature(placement_in))]
+#![cfg_attr(not(test), feature(char_escape_debug))]
+#![cfg_attr(not(test), feature(core_float))]
+#![cfg_attr(not(test), feature(exact_size_is_empty))]
+#![cfg_attr(not(test), feature(slice_rotate))]
+#![cfg_attr(not(test), feature(sort_unstable))]
+#![cfg_attr(not(test), feature(str_checked_slicing))]
+#![cfg_attr(test, feature(rand, test))]
 #![feature(allocator)]
+#![feature(allow_internal_unstable)]
+#![feature(box_patterns)]
 #![feature(box_syntax)]
 #![feature(cfg_target_has_atomic)]
 #![feature(coerce_unsized)]
@@ -80,16 +96,33 @@
 #![feature(core_intrinsics)]
 #![feature(custom_attribute)]
 #![feature(dropck_eyepatch)]
-#![cfg_attr(not(test), feature(exact_size_is_empty))]
+#![feature(exact_size_is_empty)]
+#![feature(fmt_internals)]
 #![feature(fundamental)]
+#![feature(fused)]
 #![feature(generic_param_attrs)]
+#![feature(i128_type)]
+#![feature(inclusive_range)]
 #![feature(lang_items)]
+#![feature(manually_drop)]
 #![feature(needs_allocator)]
+#![feature(nonzero)]
+#![feature(offset_to)]
 #![feature(optin_builtin_traits)]
+#![feature(pattern)]
 #![feature(placement_in_syntax)]
+#![feature(placement_new_protocol)]
 #![feature(shared)]
+#![feature(slice_get_slice)]
+#![feature(slice_patterns)]
+#![feature(slice_rsplit)]
+#![feature(specialization)]
 #![feature(staged_api)]
+#![feature(str_internals)]
+#![feature(str_mut_extras)]
+#![feature(trusted_len)]
 #![feature(unboxed_closures)]
+#![feature(unicode)]
 #![feature(unique)]
 #![feature(unsize)]
 
@@ -101,6 +134,10 @@
 #[cfg(test)]
 #[macro_use]
 extern crate std;
+#[cfg(test)]
+extern crate test;
+
+extern crate std_unicode;
 
 // Module with internal macros used by other modules (needs to be included before other modules).
 #[macro_use]
@@ -120,7 +157,7 @@ pub mod heap;
 pub mod boxed;
 #[cfg(test)]
 mod boxed {
-    pub use std::boxed::{Box, HEAP};
+    pub use std::boxed::{Box, IntermediateBox, HEAP};
 }
 #[cfg(test)]
 mod boxed_test;
@@ -128,8 +165,111 @@ mod boxed_test;
 pub mod arc;
 pub mod rc;
 pub mod raw_vec;
-#[unstable(feature = "str_box_extras", issue = "41119")]
-pub mod str;
 pub mod oom;
 
+// collections modules
+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);
+}
+
 pub use oom::oom;
+
+#[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;

src/liballoc/linked_list.rs

@@ -22,7 +22,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use alloc::boxed::{Box, IntermediateBox};
 use core::cmp::Ordering;
 use core::fmt;
 use core::hash::{Hasher, Hash};
@@ -32,6 +31,7 @@ use core::mem;
 use core::ops::{BoxPlace, InPlace, Place, Placer};
 use core::ptr::{self, Shared};
 
+use boxed::{Box, IntermediateBox};
 use super::SpecExtend;
 
 /// A doubly-linked list with owned nodes.

src/liballoc/macros.rs

@@ -8,6 +8,89 @@
 // 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)*)))
+}
+
 // Private macro to get the offset of a struct field in bytes from the address of the struct.
 macro_rules! offset_of {
     ($container:path, $field:ident) => {{

src/liballoc/range.rs

@@ -27,14 +27,14 @@ pub trait RangeArgument<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(collections)]
+    /// #![feature(alloc)]
     /// #![feature(collections_range)]
     ///
-    /// extern crate collections;
+    /// extern crate alloc;
     ///
     /// # fn main() {
-    /// use collections::range::RangeArgument;
-    /// use collections::Bound::*;
+    /// use alloc::range::RangeArgument;
+    /// use alloc::Bound::*;
     ///
     /// assert_eq!((..10).start(), Unbounded);
     /// assert_eq!((3..10).start(), Included(&3));
@@ -49,14 +49,14 @@ pub trait RangeArgument<T: ?Sized> {
     /// # Examples
     ///
     /// ```
-    /// #![feature(collections)]
+    /// #![feature(alloc)]
     /// #![feature(collections_range)]
     ///
-    /// extern crate collections;
+    /// extern crate alloc;
     ///
     /// # fn main() {
-    /// use collections::range::RangeArgument;
-    /// use collections::Bound::*;
+    /// use alloc::range::RangeArgument;
+    /// use alloc::Bound::*;
     ///
     /// assert_eq!((3..).end(), Unbounded);
     /// assert_eq!((3..10).end(), Excluded(&10));

src/liballoc/raw_vec.rs

@@ -44,6 +44,7 @@ use core::cmp;
 /// `shrink_to_fit`, and `from_box` will actually set RawVec's private capacity
 /// field. This allows zero-sized types to not be special-cased by consumers of
 /// this type.
+#[allow(missing_debug_implementations)]
 pub struct RawVec<T> {
     ptr: Unique<T>,
     cap: usize,

src/liballoc/slice.rs

@@ -97,7 +97,6 @@
 // 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;
@@ -105,6 +104,7 @@ use core::ptr;
 use core::slice as core_slice;
 
 use borrow::{Borrow, BorrowMut, ToOwned};
+use boxed::Box;
 use vec::Vec;
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -141,7 +141,7 @@ pub use self::hack::to_vec;
 // `core::slice::SliceExt` - we need to supply these functions for the
 // `test_permutations` test
 mod hack {
-    use alloc::boxed::Box;
+    use boxed::Box;
     use core::mem;
 
     #[cfg(test)]

src/liballoc/string.rs

@@ -56,8 +56,6 @@
 
 #![stable(feature = "rust1", since = "1.0.0")]
 
-use alloc::str as alloc_str;
-
 use core::fmt;
 use core::hash;
 use core::iter::{FromIterator, FusedIterator};
@@ -70,7 +68,7 @@ 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 str::{self, from_boxed_utf8_unchecked, FromStr, Utf8Error, Chars};
 use vec::Vec;
 use boxed::Box;
 
@@ -1464,7 +1462,7 @@ impl String {
     #[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) }
+        unsafe { from_boxed_utf8_unchecked(slice) }
     }
 }
 

src/liballoc/tests/lib.rs

@@ -10,11 +10,11 @@
 
 #![deny(warnings)]
 
+#![feature(alloc)]
 #![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)]
@@ -31,7 +31,7 @@
 #![feature(unicode)]
 #![feature(utf8_error_error_len)]
 
-extern crate collections;
+extern crate alloc;
 extern crate test;
 extern crate std_unicode;
 extern crate core;

src/liballoc/vec.rs

@@ -66,10 +66,6 @@
 
 #![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};
@@ -84,6 +80,10 @@ use core::ptr;
 use core::ptr::Shared;
 use core::slice;
 
+use borrow::ToOwned;
+use borrow::Cow;
+use boxed::Box;
+use raw_vec::RawVec;
 use super::range::RangeArgument;
 use Bound::{Excluded, Included, Unbounded};
 

src/liballoc/vec_deque.rs

@@ -29,7 +29,7 @@ use core::slice;
 use core::hash::{Hash, Hasher};
 use core::cmp;
 
-use alloc::raw_vec::RawVec;
+use raw_vec::RawVec;
 
 use super::range::RangeArgument;
 use Bound::{Excluded, Included, Unbounded};

src/libcollections/Cargo.toml

@@ -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"

src/libcollections/lib.rs

@@ -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);
-}

src/libcollections/macros.rs

@@ -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)*)))
-}

src/libcore/str/mod.rs

@@ -2015,7 +2015,7 @@ mod traits {
            issue = "32110")]
 pub trait StrExt {
     // NB there are no docs here are they're all located on the StrExt trait in
-    // libcollections, not here.
+    // liballoc, not here.
 
     #[stable(feature = "core", since = "1.6.0")]
     fn contains<'a, P: Pattern<'a>>(&'a self, pat: P) -> bool;

src/librustc_data_structures/fnv.rs

@@ -26,7 +26,7 @@ pub fn FnvHashSet<V: Hash + Eq>() -> FnvHashSet<V> {
 }
 
 /// A speedy hash algorithm for node ids and def ids. The hashmap in
-/// libcollections by default uses SipHash which isn't quite as speedy as we
+/// liballoc by default uses SipHash which isn't quite as speedy as we
 /// want. In the compiler we're not really worried about DOS attempts, so we
 /// just default to a non-cryptographic hash.
 ///

src/librustc_data_structures/fx.rs

@@ -26,7 +26,7 @@ pub fn FxHashSet<V: Hash + Eq>() -> FxHashSet<V> {
     HashSet::default()
 }
 
-/// A speedy hash algorithm for use within rustc. The hashmap in libcollections
+/// A speedy hash algorithm for use within rustc. The hashmap in liballoc
 /// by default uses SipHash which isn't quite as speedy as we want. In the
 /// compiler we're not really worried about DOS attempts, so we use a fast
 /// non-cryptographic hash.

src/librustc_resolve/diagnostics.rs

@@ -188,16 +188,16 @@ already been imported.
 Erroneous code example:
 
 ```compile_fail,E0254
-extern crate collections;
+extern crate alloc;
 
 mod foo {
-    pub trait collections {
+    pub trait alloc {
         fn do_something();
     }
 }
 
-use foo::collections; // error: an extern crate named `collections` has already
-                      //        been imported in this module
+use foo::alloc; // error: an extern crate named `alloc` has already
+                //        been imported in this module
 
 fn main() {}
 ```
@@ -206,15 +206,15 @@ To fix issue issue, you have to rename at least one of the two imports.
 Example:
 
 ```ignore
-extern crate collections as libcollections; // ok!
+extern crate alloc as liballoc; // ok!
 
 mod foo {
-    pub trait collections {
+    pub trait alloc {
         fn do_something();
     }
 }
 
-use foo::collections;
+use foo::alloc;
 
 fn main() {}
 ```
@@ -1425,7 +1425,7 @@ Erroneous code example:
 
 ```compile_fail,E0469
 #[macro_use(drink, be_merry)] // error: imported macro not found
-extern crate collections;
+extern crate alloc;
 
 fn main() {
     // ...
@@ -1467,7 +1467,7 @@ Erroneous code example:
 
 ```compile_fail,E0470
 #[macro_reexport(drink, be_merry)]
-extern crate collections;
+extern crate alloc;
 
 fn main() {
     // ...

src/librustc_typeck/diagnostics.rs

@@ -2265,8 +2265,8 @@ If `ForeignTrait` is a trait defined in some external crate `foo`, then the
 following trait `impl` is an error:
 
 ```compile_fail,E0210
-extern crate collections;
-use collections::range::RangeArgument;
+extern crate alloc;
+use alloc::range::RangeArgument;
 
 impl<T> RangeArgument<T> for T { } // error
 

src/libserialize/collection_impls.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-//! Implementations of serialization for structures found in libcollections
+//! Implementations of serialization for structures found in liballoc
 
 use std::hash::{Hash, BuildHasher};
 

src/libserialize/lib.rs

@@ -28,15 +28,12 @@ Core encoding and decoding interfaces.
 #![deny(warnings)]
 
 #![feature(box_syntax)]
-#![feature(collections)]
 #![feature(core_intrinsics)]
 #![feature(i128_type)]
 #![feature(specialization)]
 #![cfg_attr(stage0, feature(staged_api))]
 #![cfg_attr(test, feature(test))]
 
-extern crate collections;
-
 pub use self::serialize::{Decoder, Encoder, Decodable, Encodable};
 
 pub use self::serialize::{SpecializationError, SpecializedEncoder, SpecializedDecoder};

src/libstd/Cargo.toml

@@ -15,7 +15,6 @@ alloc_jemalloc = { path = "../liballoc_jemalloc", optional = true }
 alloc_system = { path = "../liballoc_system" }
 panic_unwind = { path = "../libpanic_unwind", optional = true }
 panic_abort = { path = "../libpanic_abort" }
-collections = { path = "../libcollections" }
 core = { path = "../libcore" }
 libc = { path = "../rustc/libc_shim" }
 rand = { path = "../librand" }

src/libstd/collections/mod.rs

@@ -420,15 +420,15 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::Bound;
+pub use alloc::Bound;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::{BinaryHeap, BTreeMap, BTreeSet};
+pub use alloc::{BinaryHeap, BTreeMap, BTreeSet};
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::{LinkedList, VecDeque};
+pub use alloc::{LinkedList, VecDeque};
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::{binary_heap, btree_map, btree_set};
+pub use alloc::{binary_heap, btree_map, btree_set};
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::{linked_list, vec_deque};
+pub use alloc::{linked_list, vec_deque};
 
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use self::hash_map::HashMap;
@@ -436,7 +436,7 @@ pub use self::hash_map::HashMap;
 pub use self::hash_set::HashSet;
 
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::range;
+pub use alloc::range;
 
 mod hash;
 

src/libstd/lib.rs

@@ -254,7 +254,6 @@
 #![feature(cfg_target_vendor)]
 #![feature(char_escape_debug)]
 #![feature(char_internals)]
-#![feature(collections)]
 #![feature(collections_range)]
 #![feature(compiler_builtins_lib)]
 #![feature(const_fn)]
@@ -337,11 +336,9 @@ use prelude::v1::*;
                  debug_assert_ne, unreachable, unimplemented, write, writeln, try)]
 extern crate core as __core;
 
+#[allow(deprecated)] extern crate rand as core_rand;
 #[macro_use]
 #[macro_reexport(vec, format)]
-extern crate collections as core_collections;
-
-#[allow(deprecated)] extern crate rand as core_rand;
 extern crate alloc;
 extern crate std_unicode;
 extern crate libc;
@@ -430,17 +427,17 @@ pub use alloc::boxed;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use alloc::rc;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::borrow;
+pub use alloc::borrow;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::fmt;
+pub use alloc::fmt;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::slice;
+pub use alloc::slice;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::str;
+pub use alloc::str;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::string;
+pub use alloc::string;
 #[stable(feature = "rust1", since = "1.0.0")]
-pub use core_collections::vec;
+pub use alloc::vec;
 #[stable(feature = "rust1", since = "1.0.0")]
 pub use std_unicode::char;
 #[unstable(feature = "i128", issue = "35118")]

src/libstd_unicode/lib.rs

@@ -52,7 +52,7 @@ pub mod str {
     pub use u_str::Utf16Encoder;
 }
 
-// For use in libcollections, not re-exported in libstd.
+// For use in liballoc, not re-exported in libstd.
 pub mod derived_property {
     pub use tables::derived_property::{Case_Ignorable, Cased};
 }

src/libstd_unicode/u_str.rs

@@ -32,7 +32,7 @@ pub struct SplitWhitespace<'a> {
 }
 
 /// Methods for Unicode string slices
-#[allow(missing_docs)] // docs in libcollections
+#[allow(missing_docs)] // docs in liballoc
 pub trait UnicodeStr {
     fn split_whitespace<'a>(&'a self) -> SplitWhitespace<'a>;
     fn is_whitespace(&self) -> bool;

src/test/compile-fail/E0254.rs

@@ -8,18 +8,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
+#![feature(alloc)]
 
-extern crate collections;
-//~^ NOTE previous import of `collections` here
+extern crate alloc;
+//~^ NOTE previous import of `alloc` here
 
 mod foo {
-    pub trait collections {
+    pub trait alloc {
         fn do_something();
     }
 }
 
-use foo::collections;
+use foo::alloc;
 //~^ ERROR E0254
 //~| NOTE already imported
 

src/test/compile-fail/E0259.rs

@@ -8,13 +8,13 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections, libc)]
+#![feature(alloc, libc)]
 
-extern crate collections;
-//~^ NOTE previous import of `collections` here
+extern crate alloc;
+//~^ NOTE previous import of `alloc` here
 
-extern crate libc as collections;
+extern crate libc as alloc;
 //~^ ERROR E0259
-//~| NOTE `collections` already imported
+//~| NOTE `alloc` already imported
 
 fn main() {}

src/test/compile-fail/E0260.rs

@@ -8,14 +8,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
+#![feature(alloc)]
 
-extern crate collections;
-//~^ NOTE previous import of `collections` here
+extern crate alloc;
+//~^ NOTE previous import of `alloc` here
 
-mod collections {
-//~^ ERROR `collections` has already been imported in this module [E0260]
-//~| NOTE `collections` already imported
+mod alloc {
+//~^ ERROR `alloc` has already been imported in this module [E0260]
+//~| NOTE `alloc` already imported
     pub trait MyTrait {
         fn do_something();
     }

src/test/compile-fail/lint-unused-extern-crate.rs

@@ -13,13 +13,13 @@
 #![deny(unused_extern_crates)]
 #![allow(unused_variables)]
 #![allow(deprecated)]
+#![feature(alloc)]
 #![feature(libc)]
-#![feature(collections)]
 #![feature(rand)]
 
 extern crate libc; //~ ERROR: unused extern crate
 
-extern crate collections as collecs; // no error, it is used
+extern crate alloc as collecs; // no error, it is used
 
 extern crate rand; // no error, the use marks it as used
                    // even if imported objects aren't used

src/test/compile-fail/resolve_self_super_hint.rs

@@ -8,25 +8,25 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
+#![feature(alloc)]
 
 mod a {
-    extern crate collections;
-    use collections::HashMap;
-    //~^ ERROR unresolved import `collections::HashMap` [E0432]
-    //~| Did you mean `self::collections`?
+    extern crate alloc;
+    use alloc::HashMap;
+    //~^ ERROR unresolved import `alloc::HashMap` [E0432]
+    //~| Did you mean `self::alloc`?
     mod b {
-        use collections::HashMap;
-        //~^ ERROR unresolved import `collections::HashMap` [E0432]
-        //~| Did you mean `a::collections`?
+        use alloc::HashMap;
+        //~^ ERROR unresolved import `alloc::HashMap` [E0432]
+        //~| Did you mean `a::alloc`?
         mod c {
-            use collections::HashMap;
-            //~^ ERROR unresolved import `collections::HashMap` [E0432]
-            //~| Did you mean `a::collections`?
+            use alloc::HashMap;
+            //~^ ERROR unresolved import `alloc::HashMap` [E0432]
+            //~| Did you mean `a::alloc`?
             mod d {
-                use collections::HashMap;
-                //~^ ERROR unresolved import `collections::HashMap` [E0432]
-                //~| Did you mean `a::collections`?
+                use alloc::HashMap;
+                //~^ ERROR unresolved import `alloc::HashMap` [E0432]
+                //~| Did you mean `a::alloc`?
             }
         }
     }

src/test/run-pass-fulldeps/issue-2804.rs

@@ -8,10 +8,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
 #![feature(rustc_private)]
 
-extern crate collections;
 extern crate serialize;
 
 use std::collections::HashMap;

src/test/run-pass-fulldeps/regions-mock-tcx.rs

@@ -15,10 +15,9 @@
 // - Multiple lifetime parameters
 // - Arenas
 
-#![feature(rustc_private, libc, collections)]
+#![feature(rustc_private, libc)]
 
 extern crate arena;
-extern crate collections;
 extern crate libc;
 
 use TypeStructure::{TypeInt, TypeFunction};

src/test/run-pass/drop-with-type-ascription-2.rs

@@ -9,8 +9,6 @@
 // except according to those terms.
 
 
-#![feature(collections)]
-
 fn main() {
     let args = vec!["foobie", "asdf::asdf"];
     let arr: Vec<&str> = args[1].split("::").collect();

src/test/run-pass/for-loop-no-std.rs

@@ -8,12 +8,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(lang_items, start, collections)]
+#![feature(lang_items, start, alloc)]
 #![no_std]
 
 extern crate std as other;
 
-#[macro_use] extern crate collections;
+#[macro_use] extern crate alloc;
 
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {

src/test/run-pass/foreach-external-iterators-hashmap-break-restart.rs

@@ -9,10 +9,6 @@
 // except according to those terms.
 
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 // This is a fancy one: it uses an external iterator established

src/test/run-pass/foreach-external-iterators-hashmap.rs

@@ -9,10 +9,6 @@
 // except according to those terms.
 
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 pub fn main() {

src/test/run-pass/format-no-std.rs

@@ -10,14 +10,14 @@
 
 // ignore-emscripten missing rust_begin_unwind
 
-#![feature(lang_items, start, collections)]
+#![feature(lang_items, start, alloc)]
 #![no_std]
 
 extern crate std as other;
 
-#[macro_use] extern crate collections;
+#[macro_use] extern crate alloc;
 
-use collections::string::ToString;
+use alloc::string::ToString;
 
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {

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

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashSet;
 
 #[derive(Copy, Clone, PartialEq, Eq, Hash)]

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

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 pub fn main() {

src/test/run-pass/issue-19811-escape-unicode.rs

@@ -9,8 +9,6 @@
 // except according to those terms.
 
 
-#![feature(collections)]
-
 fn main() {
     let mut escaped = String::from("");
     for c in '\u{10401}'.escape_unicode() {

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

@@ -10,9 +10,6 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(collections)]
-
-extern crate collections;
 use std::collections::VecDeque;
 
 pub fn main() {

src/test/run-pass/issue-2804-2.rs

@@ -11,10 +11,6 @@
 // Minimized version of issue-2804.rs. Both check that callee IDs don't
 // clobber the previous node ID in a macro expr
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 fn add_interfaces(managed_ip: String, device: HashMap<String, isize>)  {

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

@@ -10,10 +10,7 @@
 
 // pretty-expanded FIXME #23616
 
-#![allow(unknown_features)]
-#![feature(box_syntax, collections)]
-
-extern crate collections;
+#![feature(box_syntax)]
 
 use std::collections::HashMap;
 

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

@@ -8,10 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 fn check_strs(actual: &str, expected: &str) -> bool {

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

@@ -9,10 +9,7 @@
 // except according to those terms.
 
 
-#![allow(unknown_features)]
-#![feature(box_syntax, collections)]
-
-extern crate collections;
+#![feature(box_syntax)]
 
 use std::collections::HashMap;
 

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

@@ -13,10 +13,6 @@
 
 // pretty-expanded FIXME #23616
 
-#![feature(collections)]
-
-extern crate collections;
-
 use std::collections::HashMap;
 
 struct A(isize, isize);

src/test/run-pass/istr.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
 use std::string::String;
 
 fn test_stack_assign() {

src/test/run-pass/new-unicode-escapes.rs

@@ -9,8 +9,6 @@
 // except according to those terms.
 
 
-#![feature(collections)]
-
 pub fn main() {
     let s = "\u{2603}";
     assert_eq!(s, "☃");

src/test/run-pass/option-ext.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
 pub fn main() {
     let thing = "{{ f }}";
     let f = thing.find("{{");

src/test/run-pass/overloaded-autoderef.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 #![allow(unknown_features)]
-#![feature(box_syntax, collections, core)]
+#![feature(box_syntax, core)]
 
 use std::cell::RefCell;
 use std::rc::Rc;

src/test/run-pass/overloaded-deref.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
 use std::cell::RefCell;
 use std::rc::Rc;
 use std::string::String;

src/test/run-pass/sync-send-iterators-in-libcollections.rs

@@ -9,21 +9,16 @@
 // except according to those terms.
 
 #![allow(warnings)]
-#![feature(collections)]
 #![feature(drain, collections_bound, btree_range, vecmap)]
 
-extern crate collections;
-
-use collections::BinaryHeap;
-use collections::{BTreeMap, BTreeSet};
-use collections::LinkedList;
-use collections::String;
-use collections::Vec;
-use collections::VecDeque;
+use std::collections::BinaryHeap;
+use std::collections::{BTreeMap, BTreeSet};
+use std::collections::LinkedList;
+use std::collections::VecDeque;
 use std::collections::HashMap;
 use std::collections::HashSet;
 
-use collections::Bound::Included;
+use std::collections::Bound::Included;
 use std::mem;
 
 fn is_sync<T>(_: T) where T: Sync {}

src/test/run-pass/utf8_chars.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 //
 
-#![feature(collections, core, str_char)]
+#![feature(core, str_char)]
 
 use std::str;
 

src/test/run-pass/vec-macro-no-std.rs

@@ -8,7 +8,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(lang_items, start, libc, collections)]
+#![feature(lang_items, start, libc, alloc)]
 #![no_std]
 
 extern crate std as other;
@@ -16,9 +16,9 @@ extern crate std as other;
 extern crate libc;
 
 #[macro_use]
-extern crate collections;
+extern crate alloc;
 
-use collections::vec::Vec;
+use alloc::vec::Vec;
 
 // Issue #16806
 

src/test/run-pass/while-prelude-drop.rs

@@ -8,8 +8,6 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(collections)]
-
 use std::string::String;
 
 #[derive(PartialEq)]

src/tools/linkchecker/main.rs

@@ -118,15 +118,15 @@ fn check(cache: &mut Cache,
         return None;
     }
     // FIXME(#32553)
-    if file.ends_with("collections/string/struct.String.html") {
+    if file.ends_with("string/struct.String.html") {
         return None;
     }
     // FIXME(#32130)
     if file.ends_with("btree_set/struct.BTreeSet.html") ||
-       file.ends_with("collections/struct.BTreeSet.html") ||
-       file.ends_with("collections/btree_map/struct.BTreeMap.html") ||
-       file.ends_with("collections/hash_map/struct.HashMap.html") ||
-       file.ends_with("collections/hash_set/struct.HashSet.html") {
+       file.ends_with("struct.BTreeSet.html") ||
+       file.ends_with("btree_map/struct.BTreeMap.html") ||
+       file.ends_with("hash_map/struct.HashMap.html") ||
+       file.ends_with("hash_set/struct.HashSet.html") {
         return None;
     }