Add allocator type to more collection types

Adds `A: AllocRef = Global` to `BinaryHeap`, `BTreeMap`, `BTreeSet`, `LinkedList`, `VecDeque`, `Rc`, `Arc`, `Vec`, `String`, `HashMap`, and `HashSet`

Author: TimDiekmann

src/liballoc/collections/binary_heap.rs

@@ -150,6 +150,7 @@ use core::mem::{self, size_of, swap, ManuallyDrop};
 use core::ops::{Deref, DerefMut};
 use core::ptr;
 
+use crate::alloc::{AllocRef, Global};
 use crate::slice;
 use crate::vec::{self, Vec};
 
@@ -245,8 +246,8 @@ use super::SpecExtend;
 /// [peek]: #method.peek
 /// [peek\_mut]: #method.peek_mut
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct BinaryHeap<T> {
-    data: Vec<T>,
+pub struct BinaryHeap<T, A: AllocRef = Global> {
+    data: Vec<T, A>,
 }
 
 /// Structure wrapping a mutable reference to the greatest item on a

src/liballoc/collections/btree/map.rs

@@ -12,6 +12,7 @@ use core::{fmt, ptr};
 use super::node::{self, marker, ForceResult::*, Handle, InsertResult::*, NodeRef};
 use super::search::{self, SearchResult::*};
 use super::unwrap_unchecked;
+use crate::alloc::{AllocRef, Global};
 
 use Entry::*;
 use UnderflowResult::*;
@@ -122,13 +123,14 @@ use UnderflowResult::*;
 /// *stat += random_stat_buff();
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct BTreeMap<K, V> {
+pub struct BTreeMap<K, V, A: AllocRef = Global> {
     root: Option<node::Root<K, V>>,
     length: usize,
+    alloc: PhantomData<A>,
 }
 
 #[stable(feature = "btree_drop", since = "1.7.0")]
-unsafe impl<#[may_dangle] K, #[may_dangle] V> Drop for BTreeMap<K, V> {
+unsafe impl<#[may_dangle] K, #[may_dangle] V, A: AllocRef> Drop for BTreeMap<K, V, A> {
     fn drop(&mut self) {
         unsafe {
             drop(ptr::read(self).into_iter());
@@ -148,7 +150,11 @@ impl<K: Clone, V: Clone> Clone for BTreeMap<K, V> {
         {
             match node.force() {
                 Leaf(leaf) => {
-                    let mut out_tree = BTreeMap { root: Some(node::Root::new_leaf()), length: 0 };
+                    let mut out_tree = BTreeMap {
+                        root: Some(node::Root::new_leaf()),
+                        length: 0,
+                        alloc: PhantomData,
+                    };
 
                     {
                         let root = out_tree.root.as_mut().unwrap();
@@ -210,7 +216,7 @@ impl<K: Clone, V: Clone> Clone for BTreeMap<K, V> {
         if self.is_empty() {
             // Ideally we'd call `BTreeMap::new` here, but that has the `K:
             // Ord` constraint, which this method lacks.
-            BTreeMap { root: None, length: 0 }
+            BTreeMap { root: None, length: 0, alloc: PhantomData }
         } else {
             clone_subtree(self.root.as_ref().unwrap().as_ref())
         }
@@ -558,7 +564,7 @@ impl<K: Ord, V> BTreeMap<K, V> {
     #[stable(feature = "rust1", since = "1.0.0")]
     #[rustc_const_unstable(feature = "const_btree_new", issue = "71835")]
     pub const fn new() -> BTreeMap<K, V> {
-        BTreeMap { root: None, length: 0 }
+        BTreeMap { root: None, length: 0, alloc: PhantomData }
     }
 
     /// Clears the map, removing all elements.
@@ -1535,7 +1541,7 @@ impl<K, V> ExactSizeIterator for IterMut<'_, K, V> {
 impl<K, V> FusedIterator for IterMut<'_, K, V> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> IntoIterator for BTreeMap<K, V> {
+impl<K, V, A: AllocRef> IntoIterator for BTreeMap<K, V, A> {
     type Item = (K, V);
     type IntoIter = IntoIter<K, V>;
 

src/liballoc/collections/btree/set.rs

@@ -2,14 +2,16 @@
 // to TreeMap
 
 use core::borrow::Borrow;
-use core::cmp::Ordering::{Equal, Greater, Less};
+use core::cmp::Ordering::{self, Equal, Greater, Less};
 use core::cmp::{max, min};
 use core::fmt::{self, Debug};
+use core::hash;
 use core::iter::{FromIterator, FusedIterator, Peekable};
 use core::ops::{BitAnd, BitOr, BitXor, RangeBounds, Sub};
 
 use super::map::{BTreeMap, Keys};
 use super::Recover;
+use crate::alloc::{AllocRef, Global};
 
 // FIXME(conventions): implement bounded iterators
 
@@ -56,10 +58,44 @@ use super::Recover;
 ///     println!("{}", book);
 /// }
 /// ```
-#[derive(Hash, PartialEq, Eq, Ord, PartialOrd)]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct BTreeSet<T> {
-    map: BTreeMap<T, ()>,
+pub struct BTreeSet<T, A: AllocRef = Global> {
+    map: BTreeMap<T, (), A>,
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: PartialEq> PartialEq for BTreeSet<T> {
+    #[inline]
+    fn eq(&self, other: &Self) -> bool {
+        self.map.eq(&other.map)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: Eq> Eq for BTreeSet<T> {}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: PartialOrd> PartialOrd for BTreeSet<T> {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.map.partial_cmp(&other.map)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: Ord> Ord for BTreeSet<T> {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.map.cmp(&other.map)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl<T: hash::Hash> hash::Hash for BTreeSet<T> {
+    #[inline]
+    fn hash<H: hash::Hasher>(&self, state: &mut H) {
+        self.map.hash(state)
+    }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]

src/liballoc/collections/linked_list.rs

@@ -21,6 +21,7 @@ use core::mem;
 use core::ptr::NonNull;
 
 use super::SpecExtend;
+use crate::alloc::{AllocRef, Global};
 use crate::boxed::Box;
 
 #[cfg(test)]
@@ -35,11 +36,12 @@ mod tests;
 /// array-based containers are generally faster,
 /// more memory efficient, and make better use of CPU cache.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct LinkedList<T> {
+pub struct LinkedList<T, A: AllocRef = Global> {
     head: Option<NonNull<Node<T>>>,
     tail: Option<NonNull<Node<T>>>,
     len: usize,
     marker: PhantomData<Box<Node<T>>>,
+    alloc: PhantomData<A>,
 }
 
 struct Node<T> {
@@ -134,7 +136,7 @@ impl<T> Node<T> {
 }
 
 // private methods
-impl<T> LinkedList<T> {
+impl<T, A: AllocRef> LinkedList<T, A> {
     /// Adds the given node to the front of the list.
     #[inline]
     fn push_front_node(&mut self, mut node: Box<Node<T>>) {
@@ -216,7 +218,10 @@ impl<T> LinkedList<T> {
             node
         })
     }
+}
 
+// private methods
+impl<T> LinkedList<T> {
     /// Unlinks the specified node from the current list.
     ///
     /// Warning: this will not check that the provided node belongs to the current list.
@@ -310,6 +315,7 @@ impl<T> LinkedList<T> {
                 tail: first_part_tail,
                 len: at,
                 marker: PhantomData,
+                alloc: PhantomData,
             };
 
             // Fix the head ptr of the second part
@@ -346,6 +352,7 @@ impl<T> LinkedList<T> {
                 tail: second_part_tail,
                 len: self.len - at,
                 marker: PhantomData,
+                alloc: PhantomData,
             };
 
             // Fix the tail ptr of the first part
@@ -382,7 +389,7 @@ impl<T> LinkedList<T> {
     #[rustc_const_stable(feature = "const_linked_list_new", since = "1.32.0")]
     #[stable(feature = "rust1", since = "1.0.0")]
     pub const fn new() -> Self {
-        LinkedList { head: None, tail: None, len: 0, marker: PhantomData }
+        LinkedList { head: None, tail: None, len: 0, marker: PhantomData, alloc: PhantomData }
     }
 
     /// Moves all elements from `other` to the end of the list.
@@ -964,11 +971,11 @@ impl<T> LinkedList<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for LinkedList<T> {
+unsafe impl<#[may_dangle] T, A: AllocRef> Drop for LinkedList<T, A> {
     fn drop(&mut self) {
-        struct DropGuard<'a, T>(&'a mut LinkedList<T>);
+        struct DropGuard<'a, T, A: AllocRef>(&'a mut LinkedList<T, A>);
 
-        impl<'a, T> Drop for DropGuard<'a, T> {
+        impl<'a, T, A: AllocRef> Drop for DropGuard<'a, T, A> {
             fn drop(&mut self) {
                 // Continue the same loop we do below. This only runs when a destructor has
                 // panicked. If another one panics this will abort.

src/liballoc/collections/vec_deque.rs

@@ -18,6 +18,7 @@ use core::ops::{Index, IndexMut, RangeBounds, Try};
 use core::ptr::{self, NonNull};
 use core::slice;
 
+use crate::alloc::{AllocRef, Global};
 use crate::collections::TryReserveError;
 use crate::raw_vec::RawVec;
 use crate::vec::Vec;
@@ -52,15 +53,15 @@ const MAXIMUM_ZST_CAPACITY: usize = 1 << (64 - 1); // Largest possible power of
 /// [`append`]: #method.append
 #[cfg_attr(not(test), rustc_diagnostic_item = "vecdeque_type")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct VecDeque<T> {
+pub struct VecDeque<T, A: AllocRef = Global> {
     // 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>,
+    buf: RawVec<T, A>,
 }
 
 /// PairSlices pairs up equal length slice parts of two deques
@@ -147,7 +148,7 @@ impl<T: Clone> Clone for VecDeque<T> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T> Drop for VecDeque<T> {
+unsafe impl<#[may_dangle] T, A: AllocRef> Drop for VecDeque<T, A> {
     fn drop(&mut self) {
         /// Runs the destructor for all items in the slice when it gets dropped (normally or
         /// during unwinding).
@@ -180,7 +181,7 @@ impl<T> Default for VecDeque<T> {
     }
 }
 
-impl<T> VecDeque<T> {
+impl<T, A: AllocRef> VecDeque<T, A> {
     /// Marginally more convenient
     #[inline]
     fn ptr(&self) -> *mut T {
@@ -956,7 +957,9 @@ impl<T> VecDeque<T> {
     pub fn iter_mut(&mut self) -> IterMut<'_, T> {
         IterMut { tail: self.tail, head: self.head, ring: unsafe { self.buffer_as_mut_slice() } }
     }
+}
 
+impl<T, A: AllocRef> VecDeque<T, A> {
     /// Returns a pair of slices which contain, in order, the contents of the
     /// `VecDeque`.
     ///
@@ -1057,7 +1060,9 @@ impl<T> VecDeque<T> {
     pub fn is_empty(&self) -> bool {
         self.tail == self.head
     }
+}
 
+impl<T> VecDeque<T> {
     /// Creates a draining iterator that removes the specified range in the
     /// `VecDeque` and yields the removed items.
     ///

src/liballoc/rc.rs

@@ -281,9 +281,10 @@ struct RcBox<T: ?Sized> {
 /// [get_mut]: #method.get_mut
 #[cfg_attr(not(test), rustc_diagnostic_item = "Rc")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Rc<T: ?Sized> {
+pub struct Rc<T: ?Sized, A: AllocRef = Global> {
     ptr: NonNull<RcBox<T>>,
     phantom: PhantomData<RcBox<T>>,
+    alloc: PhantomData<A>,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
@@ -299,7 +300,7 @@ impl<T: ?Sized + Unsize<U>, U: ?Sized> DispatchFromDyn<Rc<U>> for Rc<T> {}
 
 impl<T: ?Sized> Rc<T> {
     fn from_inner(ptr: NonNull<RcBox<T>>) -> Self {
-        Self { ptr, phantom: PhantomData }
+        Self { ptr, phantom: PhantomData, alloc: PhantomData }
     }
 
     unsafe fn from_ptr(ptr: *mut RcBox<T>) -> Self {
@@ -1114,7 +1115,7 @@ impl<T: ?Sized> Deref for Rc<T> {
 impl<T: ?Sized> Receiver for Rc<T> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-unsafe impl<#[may_dangle] T: ?Sized> Drop for Rc<T> {
+unsafe impl<#[may_dangle] T: ?Sized, A: AllocRef> Drop for Rc<T, A> {
     /// Drops the `Rc`.
     ///
     /// This will decrement the strong reference count. If the strong reference
@@ -2074,7 +2075,7 @@ trait RcBoxPtr<T: ?Sized> {
     }
 }
 
-impl<T: ?Sized> RcBoxPtr<T> for Rc<T> {
+impl<T: ?Sized, A: AllocRef> RcBoxPtr<T> for Rc<T, A> {
     #[inline(always)]
     fn inner(&self) -> &RcBox<T> {
         unsafe { self.ptr.as_ref() }

src/liballoc/string.rs

@@ -47,6 +47,7 @@
 #![stable(feature = "rust1", since = "1.0.0")]
 
 use core::char::{decode_utf16, REPLACEMENT_CHARACTER};
+use core::cmp::Ordering;
 use core::fmt;
 use core::hash;
 use core::iter::{FromIterator, FusedIterator};
@@ -55,6 +56,7 @@ use core::ops::{self, Add, AddAssign, Index, IndexMut, RangeBounds};
 use core::ptr;
 use core::str::{lossy, pattern::Pattern};
 
+use crate::alloc::{AllocRef, Global};
 use crate::borrow::{Cow, ToOwned};
 use crate::boxed::Box;
 use crate::collections::TryReserveError;
@@ -277,11 +279,10 @@ use crate::vec::Vec;
 /// [`&str`]: ../../std/primitive.str.html
 /// [`Deref`]: ../../std/ops/trait.Deref.html
 /// [`as_str()`]: struct.String.html#method.as_str
-#[derive(PartialOrd, Eq, Ord)]
 #[cfg_attr(not(test), rustc_diagnostic_item = "string_type")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct String {
-    vec: Vec<u8>,
+pub struct String<A: AllocRef = Global> {
+    vec: Vec<u8, A>,
 }
 
 /// A possible error value when converting a `String` from a UTF-8 byte vector.
@@ -1886,6 +1887,25 @@ impl PartialEq for String {
     }
 }
 
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Eq for String {}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl PartialOrd for String {
+    #[inline]
+    fn partial_cmp(&self, other: &Self) -> Option<Ordering> {
+        self.vec.partial_cmp(&other.vec)
+    }
+}
+
+#[stable(feature = "rust1", since = "1.0.0")]
+impl Ord for String {
+    #[inline]
+    fn cmp(&self, other: &Self) -> Ordering {
+        self.vec.cmp(&other.vec)
+    }
+}
+
 macro_rules! impl_eq {
     ($lhs:ty, $rhs: ty) => {
         #[stable(feature = "rust1", since = "1.0.0")]