diff --git a/library/std/src/collections/hash/map.rs b/library/std/src/collections/hash/map.rs
index 251d62bd2033a..ad6328f76ed6d 100644
--- a/library/std/src/collections/hash/map.rs
+++ b/library/std/src/collections/hash/map.rs
@@ -4,6 +4,7 @@ mod tests;
 use hashbrown::hash_map as base;
 
 use self::Entry::*;
+use crate::alloc::{Allocator, Global};
 use crate::borrow::Borrow;
 use crate::collections::{TryReserveError, TryReserveErrorKind};
 use crate::error::Error;
@@ -243,8 +244,13 @@ use crate::ops::Index;
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashMap")]
 #[stable(feature = "rust1", since = "1.0.0")]
 #[rustc_insignificant_dtor]
-pub struct HashMap<K, V, S = RandomState> {
-    base: base::HashMap<K, V, S>,
+pub struct HashMap<
+    K,
+    V,
+    S = RandomState,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::HashMap<K, V, S, A>,
 }
 
 impl<K, V> HashMap<K, V, RandomState> {
@@ -286,6 +292,46 @@ impl<K, V> HashMap<K, V, RandomState> {
     }
 }
 
+impl<K, V, A: Allocator> HashMap<K, V, RandomState, A> {
+    /// Creates an empty `HashMap` using the given allocator.
+    ///
+    /// The hash map is initially created with a capacity of 0, so it will not allocate until it
+    /// is first inserted into.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// let mut map: HashMap<&str, i32> = HashMap::new();
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn new_in(alloc: A) -> Self {
+        HashMap::with_hasher_in(Default::default(), alloc)
+    }
+
+    /// Creates an empty `HashMap` with at least the specified capacity using
+    /// the given allocator.
+    ///
+    /// The hash map will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash map will not allocate.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashMap;
+    /// let mut map: HashMap<&str, i32> = HashMap::with_capacity(10);
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> Self {
+        HashMap::with_capacity_and_hasher_in(capacity, Default::default(), alloc)
+    }
+}
+
 impl<K, V, S> HashMap<K, V, S> {
     /// Creates an empty `HashMap` which will use the given hash builder to hash
     /// keys.
@@ -347,6 +393,47 @@ impl<K, V, S> HashMap<K, V, S> {
     pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashMap<K, V, S> {
         HashMap { base: base::HashMap::with_capacity_and_hasher(capacity, hasher) }
     }
+}
+
+impl<K, V, S, A: Allocator> HashMap<K, V, S, A> {
+    /// Creates an empty `HashMap` which will use the given hash builder and
+    /// allocator.
+    ///
+    /// The created map has the default initial capacity.
+    ///
+    /// Warning: `hash_builder` is normally randomly generated, and
+    /// is designed to allow HashMaps to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashMap` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_hasher_in(hash_builder: S, alloc: A) -> Self {
+        HashMap { base: base::HashMap::with_hasher_in(hash_builder, alloc) }
+    }
+
+    /// Creates an empty `HashMap` with at least the specified capacity, using
+    /// `hasher` to hash the keys and `alloc` to allocate memory.
+    ///
+    /// The hash map will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash map will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow HashMaps to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hasher` passed should implement the [`BuildHasher`] trait for
+    /// the `HashMap` to be useful, see its documentation for details.
+    ///
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_and_hasher_in(capacity: usize, hash_builder: S, alloc: A) -> Self {
+        HashMap { base: base::HashMap::with_capacity_and_hasher_in(capacity, hash_builder, alloc) }
+    }
 
     /// Returns the number of elements the map can hold without reallocating.
     ///
@@ -424,7 +511,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-    pub fn into_keys(self) -> IntoKeys<K, V> {
+    pub fn into_keys(self) -> IntoKeys<K, V, A> {
         IntoKeys { inner: self.into_iter() }
     }
 
@@ -519,7 +606,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-    pub fn into_values(self) -> IntoValues<K, V> {
+    pub fn into_values(self) -> IntoValues<K, V, A> {
         IntoValues { inner: self.into_iter() }
     }
 
@@ -648,7 +735,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain(&mut self) -> Drain<'_, K, V> {
+    pub fn drain(&mut self) -> Drain<'_, K, V, A> {
         Drain { base: self.base.drain() }
     }
 
@@ -688,7 +775,7 @@ impl<K, V, S> HashMap<K, V, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "hash_extract_if", since = "1.88.0")]
-    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F>
+    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, K, V, F, A>
     where
         F: FnMut(&K, &mut V) -> bool,
     {
@@ -762,10 +849,11 @@ impl<K, V, S> HashMap<K, V, S> {
     }
 }
 
-impl<K, V, S> HashMap<K, V, S>
+impl<K, V, S, A> HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     /// Reserves capacity for at least `additional` more elements to be inserted
     /// in the `HashMap`. The collection may reserve more space to speculatively
@@ -884,7 +972,7 @@ where
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn entry(&mut self, key: K) -> Entry<'_, K, V> {
+    pub fn entry(&mut self, key: K) -> Entry<'_, K, V, A> {
         map_entry(self.base.rustc_entry(key))
     }
 
@@ -1232,7 +1320,7 @@ where
     /// assert_eq!(err.value, "b");
     /// ```
     #[unstable(feature = "map_try_insert", issue = "82766")]
-    pub fn try_insert(&mut self, key: K, value: V) -> Result<&mut V, OccupiedError<'_, K, V>> {
+    pub fn try_insert(&mut self, key: K, value: V) -> Result<&mut V, OccupiedError<'_, K, V, A>> {
         match self.entry(key) {
             Occupied(entry) => Err(OccupiedError { entry, value }),
             Vacant(entry) => Ok(entry.insert(value)),
@@ -1298,11 +1386,12 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Clone for HashMap<K, V, S>
+impl<K, V, S, A> Clone for HashMap<K, V, S, A>
 where
     K: Clone,
     V: Clone,
     S: Clone,
+    A: Allocator + Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -1316,13 +1405,14 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> PartialEq for HashMap<K, V, S>
+impl<K, V, S, A> PartialEq for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     V: PartialEq,
     S: BuildHasher,
+    A: Allocator,
 {
-    fn eq(&self, other: &HashMap<K, V, S>) -> bool {
+    fn eq(&self, other: &HashMap<K, V, S, A>) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -1332,19 +1422,21 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Eq for HashMap<K, V, S>
+impl<K, V, S, A> Eq for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     V: Eq,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Debug for HashMap<K, V, S>
+impl<K, V, S, A> Debug for HashMap<K, V, S, A>
 where
     K: Debug,
     V: Debug,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_map().entries(self.iter()).finish()
@@ -1364,11 +1456,12 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, Q: ?Sized, V, S> Index<&Q> for HashMap<K, V, S>
+impl<K, Q: ?Sized, V, S, A> Index<&Q> for HashMap<K, V, S, A>
 where
     K: Eq + Hash + Borrow<Q>,
     Q: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Output = V;
 
@@ -1523,11 +1616,15 @@ impl<K, V> Default for IterMut<'_, K, V> {
 /// let iter = map.into_iter();
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<K, V> {
-    base: base::IntoIter<K, V>,
+pub struct IntoIter<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::IntoIter<K, V, A>,
 }
 
-impl<K, V> IntoIter<K, V> {
+impl<K, V, A: Allocator> IntoIter<K, V, A> {
     /// Returns an iterator of references over the remaining items.
     #[inline]
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
@@ -1656,11 +1753,16 @@ impl<K, V: Debug> fmt::Debug for Values<'_, K, V> {
 /// ```
 #[stable(feature = "drain", since = "1.6.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "hashmap_drain_ty")]
-pub struct Drain<'a, K: 'a, V: 'a> {
-    base: base::Drain<'a, K, V>,
+pub struct Drain<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::Drain<'a, K, V, A>,
 }
 
-impl<'a, K, V> Drain<'a, K, V> {
+impl<'a, K, V, A: Allocator> Drain<'a, K, V, A> {
     /// Returns an iterator of references over the remaining items.
     #[inline]
     pub(super) fn iter(&self) -> Iter<'_, K, V> {
@@ -1687,8 +1789,14 @@ impl<'a, K, V> Drain<'a, K, V> {
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` to remove and discard elements"]
-pub struct ExtractIf<'a, K, V, F> {
-    base: base::ExtractIf<'a, K, V, F>,
+pub struct ExtractIf<
+    'a,
+    K,
+    V,
+    F,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::ExtractIf<'a, K, V, F, A>,
 }
 
 /// A mutable iterator over the values of a `HashMap`.
@@ -1740,8 +1848,12 @@ impl<K, V> Default for ValuesMut<'_, K, V> {
 /// let iter_keys = map.into_keys();
 /// ```
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoKeys<K, V> {
-    inner: IntoIter<K, V>,
+pub struct IntoKeys<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    inner: IntoIter<K, V, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1770,8 +1882,12 @@ impl<K, V> Default for IntoKeys<K, V> {
 /// let iter_keys = map.into_values();
 /// ```
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-pub struct IntoValues<K, V> {
-    inner: IntoIter<K, V>,
+pub struct IntoValues<
+    K,
+    V,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    inner: IntoIter<K, V, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1789,14 +1905,19 @@ impl<K, V> Default for IntoValues<K, V> {
 /// [`entry`]: HashMap::entry
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashMapEntry")]
-pub enum Entry<'a, K: 'a, V: 'a> {
+pub enum Entry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// An occupied entry.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V>),
+    Occupied(#[stable(feature = "rust1", since = "1.0.0")] OccupiedEntry<'a, K, V, A>),
 
     /// A vacant entry.
     #[stable(feature = "rust1", since = "1.0.0")]
-    Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V>),
+    Vacant(#[stable(feature = "rust1", since = "1.0.0")] VacantEntry<'a, K, V, A>),
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
@@ -1812,12 +1933,17 @@ impl<K: Debug, V: Debug> Debug for Entry<'_, K, V> {
 /// A view into an occupied entry in a `HashMap`.
 /// It is part of the [`Entry`] enum.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct OccupiedEntry<'a, K: 'a, V: 'a> {
-    base: base::RustcOccupiedEntry<'a, K, V>,
+pub struct OccupiedEntry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::RustcOccupiedEntry<'a, K, V, A>,
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
-impl<K: Debug, V: Debug> Debug for OccupiedEntry<'_, K, V> {
+impl<K: Debug, V: Debug, A: Allocator> Debug for OccupiedEntry<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedEntry")
             .field("key", self.key())
@@ -1829,12 +1955,17 @@ impl<K: Debug, V: Debug> Debug for OccupiedEntry<'_, K, V> {
 /// A view into a vacant entry in a `HashMap`.
 /// It is part of the [`Entry`] enum.
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct VacantEntry<'a, K: 'a, V: 'a> {
-    base: base::RustcVacantEntry<'a, K, V>,
+pub struct VacantEntry<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::RustcVacantEntry<'a, K, V, A>,
 }
 
 #[stable(feature = "debug_hash_map", since = "1.12.0")]
-impl<K: Debug, V> Debug for VacantEntry<'_, K, V> {
+impl<K: Debug, V, A: Allocator> Debug for VacantEntry<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("VacantEntry").field(self.key()).finish()
     }
@@ -1844,15 +1975,20 @@ impl<K: Debug, V> Debug for VacantEntry<'_, K, V> {
 ///
 /// Contains the occupied entry, and the value that was not inserted.
 #[unstable(feature = "map_try_insert", issue = "82766")]
-pub struct OccupiedError<'a, K: 'a, V: 'a> {
+pub struct OccupiedError<
+    'a,
+    K: 'a,
+    V: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// The entry in the map that was already occupied.
-    pub entry: OccupiedEntry<'a, K, V>,
+    pub entry: OccupiedEntry<'a, K, V, A>,
     /// The value which was not inserted, because the entry was already occupied.
     pub value: V,
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<K: Debug, V: Debug> Debug for OccupiedError<'_, K, V> {
+impl<K: Debug, V: Debug, A: Allocator> Debug for OccupiedError<'_, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedError")
             .field("key", self.entry.key())
@@ -1863,7 +1999,7 @@ impl<K: Debug, V: Debug> Debug for OccupiedError<'_, K, V> {
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<'a, K: Debug, V: Debug> fmt::Display for OccupiedError<'a, K, V> {
+impl<'a, K: Debug, V: Debug, A: Allocator> fmt::Display for OccupiedError<'a, K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         write!(
             f,
@@ -1876,10 +2012,10 @@ impl<'a, K: Debug, V: Debug> fmt::Display for OccupiedError<'a, K, V> {
 }
 
 #[unstable(feature = "map_try_insert", issue = "82766")]
-impl<'a, K: Debug, V: Debug> Error for OccupiedError<'a, K, V> {}
+impl<'a, K: Debug, V: Debug, A: Allocator> Error for OccupiedError<'a, K, V, A> {}
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
+impl<'a, K, V, S, A: Allocator> IntoIterator for &'a HashMap<K, V, S, A> {
     type Item = (&'a K, &'a V);
     type IntoIter = Iter<'a, K, V>;
 
@@ -1891,7 +2027,7 @@ impl<'a, K, V, S> IntoIterator for &'a HashMap<K, V, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
+impl<'a, K, V, S, A: Allocator> IntoIterator for &'a mut HashMap<K, V, S, A> {
     type Item = (&'a K, &'a mut V);
     type IntoIter = IterMut<'a, K, V>;
 
@@ -1903,9 +2039,9 @@ impl<'a, K, V, S> IntoIterator for &'a mut HashMap<K, V, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> IntoIterator for HashMap<K, V, S> {
+impl<K, V, S, A: Allocator> IntoIterator for HashMap<K, V, S, A> {
     type Item = (K, V);
-    type IntoIter = IntoIter<K, V>;
+    type IntoIter = IntoIter<K, V, A>;
 
     /// Creates a consuming iterator, that is, one that moves each key-value
     /// pair out of the map in arbitrary order. The map cannot be used after
@@ -1927,7 +2063,7 @@ impl<K, V, S> IntoIterator for HashMap<K, V, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    fn into_iter(self) -> IntoIter<K, V> {
+    fn into_iter(self) -> IntoIter<K, V, A> {
         IntoIter { base: self.base.into_iter() }
     }
 }
@@ -2015,7 +2151,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> Iterator for IntoIter<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoIter<K, V, A> {
     type Item = (K, V);
 
     #[inline]
@@ -2040,17 +2176,17 @@ impl<K, V> Iterator for IntoIter<K, V> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V> ExactSizeIterator for IntoIter<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoIter<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K, V> FusedIterator for IntoIter<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoIter<K, V, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: Debug, V: Debug> fmt::Debug for IntoIter<K, V> {
+impl<K: Debug, V: Debug, A: Allocator> fmt::Debug for IntoIter<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.iter()).finish()
     }
@@ -2169,7 +2305,7 @@ impl<K, V: fmt::Debug> fmt::Debug for ValuesMut<'_, K, V> {
 }
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> Iterator for IntoKeys<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoKeys<K, V, A> {
     type Item = K;
 
     #[inline]
@@ -2194,24 +2330,24 @@ impl<K, V> Iterator for IntoKeys<K, V> {
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> ExactSizeIterator for IntoKeys<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoKeys<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> FusedIterator for IntoKeys<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoKeys<K, V, A> {}
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K: Debug, V> fmt::Debug for IntoKeys<K, V> {
+impl<K: Debug, V, A: Allocator> fmt::Debug for IntoKeys<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.inner.iter().map(|(k, _)| k)).finish()
     }
 }
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> Iterator for IntoValues<K, V> {
+impl<K, V, A: Allocator> Iterator for IntoValues<K, V, A> {
     type Item = V;
 
     #[inline]
@@ -2236,24 +2372,24 @@ impl<K, V> Iterator for IntoValues<K, V> {
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> ExactSizeIterator for IntoValues<K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for IntoValues<K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.inner.len()
     }
 }
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V> FusedIterator for IntoValues<K, V> {}
+impl<K, V, A: Allocator> FusedIterator for IntoValues<K, V, A> {}
 
 #[stable(feature = "map_into_keys_values", since = "1.54.0")]
-impl<K, V: Debug> fmt::Debug for IntoValues<K, V> {
+impl<K, V: Debug, A: Allocator> fmt::Debug for IntoValues<K, V, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.inner.iter().map(|(_, v)| v)).finish()
     }
 }
 
 #[stable(feature = "drain", since = "1.6.0")]
-impl<'a, K, V> Iterator for Drain<'a, K, V> {
+impl<'a, K, V, A: Allocator> Iterator for Drain<'a, K, V, A> {
     type Item = (K, V);
 
     #[inline]
@@ -2274,17 +2410,17 @@ impl<'a, K, V> Iterator for Drain<'a, K, V> {
     }
 }
 #[stable(feature = "drain", since = "1.6.0")]
-impl<K, V> ExactSizeIterator for Drain<'_, K, V> {
+impl<K, V, A: Allocator> ExactSizeIterator for Drain<'_, K, V, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K, V> FusedIterator for Drain<'_, K, V> {}
+impl<K, V, A: Allocator> FusedIterator for Drain<'_, K, V, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K, V> fmt::Debug for Drain<'_, K, V>
+impl<K, V, A: Allocator> fmt::Debug for Drain<'_, K, V, A>
 where
     K: fmt::Debug,
     V: fmt::Debug,
@@ -2295,7 +2431,7 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> Iterator for ExtractIf<'_, K, V, F>
+impl<K, V, F, A: Allocator> Iterator for ExtractIf<'_, K, V, F, A>
 where
     F: FnMut(&K, &mut V) -> bool,
 {
@@ -2312,10 +2448,13 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> FusedIterator for ExtractIf<'_, K, V, F> where F: FnMut(&K, &mut V) -> bool {}
+impl<K, V, F, A: Allocator> FusedIterator for ExtractIf<'_, K, V, F, A> where
+    F: FnMut(&K, &mut V) -> bool
+{
+}
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, V, F> fmt::Debug for ExtractIf<'_, K, V, F>
+impl<K, V, F, A: Allocator> fmt::Debug for ExtractIf<'_, K, V, F, A>
 where
     K: fmt::Debug,
     V: fmt::Debug,
@@ -2325,7 +2464,7 @@ where
     }
 }
 
-impl<'a, K, V> Entry<'a, K, V> {
+impl<'a, K, V, A: Allocator> Entry<'a, K, V, A> {
     /// Ensures a value is in the entry by inserting the default if empty, and returns
     /// a mutable reference to the value in the entry.
     ///
@@ -2473,7 +2612,7 @@ impl<'a, K, V> Entry<'a, K, V> {
     /// ```
     #[inline]
     #[stable(feature = "entry_insert", since = "1.83.0")]
-    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
         match self {
             Occupied(mut entry) => {
                 entry.insert(value);
@@ -2510,7 +2649,7 @@ impl<'a, K, V: Default> Entry<'a, K, V> {
     }
 }
 
-impl<'a, K, V> OccupiedEntry<'a, K, V> {
+impl<'a, K, V, A: Allocator> OccupiedEntry<'a, K, V, A> {
     /// Gets a reference to the key in the entry.
     ///
     /// # Examples
@@ -2682,7 +2821,7 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
     }
 }
 
-impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
+impl<'a, K: 'a, V: 'a, A: Allocator> VacantEntry<'a, K, V, A> {
     /// Gets a reference to the key that would be used when inserting a value
     /// through the `VacantEntry`.
     ///
@@ -2760,7 +2899,7 @@ impl<'a, K: 'a, V: 'a> VacantEntry<'a, K, V> {
     /// ```
     #[inline]
     #[stable(feature = "entry_insert", since = "1.83.0")]
-    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V> {
+    pub fn insert_entry(self, value: V) -> OccupiedEntry<'a, K, V, A> {
         let base = self.base.insert_entry(value);
         OccupiedEntry { base }
     }
@@ -2786,10 +2925,11 @@ where
 /// Inserts all new key-values from the iterator and replaces values with existing
 /// keys with new values returned from the iterator.
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K, V, S> Extend<(K, V)> for HashMap<K, V, S>
+impl<K, V, S, A> Extend<(K, V)> for HashMap<K, V, S, A>
 where
     K: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (K, V)>>(&mut self, iter: T) {
@@ -2808,11 +2948,12 @@ where
 }
 
 #[stable(feature = "hash_extend_copy", since = "1.4.0")]
-impl<'a, K, V, S> Extend<(&'a K, &'a V)> for HashMap<K, V, S>
+impl<'a, K, V, S, A> Extend<(&'a K, &'a V)> for HashMap<K, V, S, A>
 where
     K: Eq + Hash + Copy,
     V: Copy,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<T: IntoIterator<Item = (&'a K, &'a V)>>(&mut self, iter: T) {
@@ -2831,7 +2972,9 @@ where
 }
 
 #[inline]
-fn map_entry<'a, K: 'a, V: 'a>(raw: base::RustcEntry<'a, K, V>) -> Entry<'a, K, V> {
+fn map_entry<'a, K: 'a, V: 'a, A: Allocator>(
+    raw: base::RustcEntry<'a, K, V, A>,
+) -> Entry<'a, K, V, A> {
     match raw {
         base::RustcEntry::Occupied(base) => Entry::Occupied(OccupiedEntry { base }),
         base::RustcEntry::Vacant(base) => Entry::Vacant(VacantEntry { base }),
diff --git a/library/std/src/collections/hash/set.rs b/library/std/src/collections/hash/set.rs
index 6795da80aacb6..02a4a0d9c8156 100644
--- a/library/std/src/collections/hash/set.rs
+++ b/library/std/src/collections/hash/set.rs
@@ -4,6 +4,7 @@ mod tests;
 use hashbrown::hash_set as base;
 
 use super::map::map_try_reserve_error;
+use crate::alloc::{Allocator, Global};
 use crate::borrow::Borrow;
 use crate::collections::TryReserveError;
 use crate::fmt;
@@ -122,8 +123,12 @@ use crate::ops::{BitAnd, BitOr, BitXor, Sub};
 /// ```
 #[cfg_attr(not(test), rustc_diagnostic_item = "HashSet")]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct HashSet<T, S = RandomState> {
-    base: base::HashSet<T, S>,
+pub struct HashSet<
+    T,
+    S = RandomState,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::HashSet<T, S, A>,
 }
 
 impl<T> HashSet<T, RandomState> {
@@ -166,7 +171,141 @@ impl<T> HashSet<T, RandomState> {
     }
 }
 
+impl<T, A: Allocator> HashSet<T, RandomState, A> {
+    /// Creates an empty `HashSet` in the provided allocator.
+    ///
+    /// The hash set is initially created with a capacity of 0, so it will not allocate until it
+    /// is first inserted into.
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn new_in(alloc: A) -> HashSet<T, RandomState, A> {
+        HashSet::with_hasher_in(Default::default(), alloc)
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// let set: HashSet<i32> = HashSet::with_capacity(10);
+    /// assert!(set.capacity() >= 10);
+    /// ```
+    #[inline]
+    #[must_use]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_in(capacity: usize, alloc: A) -> HashSet<T, RandomState, A> {
+        HashSet::with_capacity_and_hasher_in(capacity, Default::default(), alloc)
+    }
+}
+
 impl<T, S> HashSet<T, S> {
+    /// Creates a new empty hash set which will use the given hasher to hash
+    /// keys.
+    ///
+    /// The hash set is also created with the default initial capacity.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_hasher(s);
+    /// set.insert(2);
+    /// ```
+    #[inline]
+    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
+    #[rustc_const_stable(feature = "const_collections_with_hasher", since = "1.85.0")]
+    pub const fn with_hasher(hasher: S) -> HashSet<T, S> {
+        HashSet { base: base::HashSet::with_hasher(hasher) }
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity, using
+    /// `hasher` to hash the keys.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    ///
+    /// # Examples
+    ///
+    /// ```
+    /// use std::collections::HashSet;
+    /// use std::hash::RandomState;
+    ///
+    /// let s = RandomState::new();
+    /// let mut set = HashSet::with_capacity_and_hasher(10, s);
+    /// set.insert(1);
+    /// ```
+    #[inline]
+    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
+    pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S> {
+        HashSet { base: base::HashSet::with_capacity_and_hasher(capacity, hasher) }
+    }
+}
+
+impl<T, S, A: Allocator> HashSet<T, S, A> {
+    /// Creates a new empty hash set which will use the given hasher to hash
+    /// keys and will allocate memory using the provided allocator.
+    ///
+    /// The hash set is also created with the default initial capacity.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_hasher_in(hasher: S, alloc: A) -> HashSet<T, S, A> {
+        HashSet { base: base::HashSet::with_hasher_in(hasher, alloc) }
+    }
+
+    /// Creates an empty `HashSet` with at least the specified capacity, using
+    /// `hasher` to hash the keys and `alloc` to allocate memory.
+    ///
+    /// The hash set will be able to hold at least `capacity` elements without
+    /// reallocating. This method is allowed to allocate for more elements than
+    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
+    ///
+    /// Warning: `hasher` is normally randomly generated, and
+    /// is designed to allow `HashSet`s to be resistant to attacks that
+    /// cause many collisions and very poor performance. Setting it
+    /// manually using this function can expose a DoS attack vector.
+    ///
+    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
+    /// the `HashSet` to be useful, see its documentation for details.
+    #[inline]
+    #[unstable(feature = "allocator_api", issue = "32838")]
+    pub fn with_capacity_and_hasher_in(capacity: usize, hasher: S, alloc: A) -> HashSet<T, S, A> {
+        HashSet { base: base::HashSet::with_capacity_and_hasher_in(capacity, hasher, alloc) }
+    }
+
     /// Returns the number of elements the set can hold without reallocating.
     ///
     /// # Examples
@@ -272,7 +411,7 @@ impl<T, S> HashSet<T, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "drain", since = "1.6.0")]
-    pub fn drain(&mut self) -> Drain<'_, T> {
+    pub fn drain(&mut self) -> Drain<'_, T, A> {
         Drain { base: self.base.drain() }
     }
 
@@ -309,7 +448,7 @@ impl<T, S> HashSet<T, S> {
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "hash_extract_if", since = "1.88.0")]
-    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F>
+    pub fn extract_if<F>(&mut self, pred: F) -> ExtractIf<'_, T, F, A>
     where
         F: FnMut(&T) -> bool,
     {
@@ -362,67 +501,6 @@ impl<T, S> HashSet<T, S> {
         self.base.clear()
     }
 
-    /// Creates a new empty hash set which will use the given hasher to hash
-    /// keys.
-    ///
-    /// The hash set is also created with the default initial capacity.
-    ///
-    /// Warning: `hasher` is normally randomly generated, and
-    /// is designed to allow `HashSet`s to be resistant to attacks that
-    /// cause many collisions and very poor performance. Setting it
-    /// manually using this function can expose a DoS attack vector.
-    ///
-    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
-    /// the `HashSet` to be useful, see its documentation for details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    /// use std::hash::RandomState;
-    ///
-    /// let s = RandomState::new();
-    /// let mut set = HashSet::with_hasher(s);
-    /// set.insert(2);
-    /// ```
-    #[inline]
-    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-    #[rustc_const_stable(feature = "const_collections_with_hasher", since = "1.85.0")]
-    pub const fn with_hasher(hasher: S) -> HashSet<T, S> {
-        HashSet { base: base::HashSet::with_hasher(hasher) }
-    }
-
-    /// Creates an empty `HashSet` with at least the specified capacity, using
-    /// `hasher` to hash the keys.
-    ///
-    /// The hash set will be able to hold at least `capacity` elements without
-    /// reallocating. This method is allowed to allocate for more elements than
-    /// `capacity`. If `capacity` is zero, the hash set will not allocate.
-    ///
-    /// Warning: `hasher` is normally randomly generated, and
-    /// is designed to allow `HashSet`s to be resistant to attacks that
-    /// cause many collisions and very poor performance. Setting it
-    /// manually using this function can expose a DoS attack vector.
-    ///
-    /// The `hash_builder` passed should implement the [`BuildHasher`] trait for
-    /// the `HashSet` to be useful, see its documentation for details.
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// use std::collections::HashSet;
-    /// use std::hash::RandomState;
-    ///
-    /// let s = RandomState::new();
-    /// let mut set = HashSet::with_capacity_and_hasher(10, s);
-    /// set.insert(1);
-    /// ```
-    #[inline]
-    #[stable(feature = "hashmap_build_hasher", since = "1.7.0")]
-    pub fn with_capacity_and_hasher(capacity: usize, hasher: S) -> HashSet<T, S> {
-        HashSet { base: base::HashSet::with_capacity_and_hasher(capacity, hasher) }
-    }
-
     /// Returns a reference to the set's [`BuildHasher`].
     ///
     /// # Examples
@@ -442,10 +520,11 @@ impl<T, S> HashSet<T, S> {
     }
 }
 
-impl<T, S> HashSet<T, S>
+impl<T, S, A> HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     /// Reserves capacity for at least `additional` more elements to be inserted
     /// in the `HashSet`. The collection may reserve more space to speculatively
@@ -569,7 +648,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn difference<'a>(&'a self, other: &'a HashSet<T, S>) -> Difference<'a, T, S> {
+    pub fn difference<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Difference<'a, T, S, A> {
         Difference { iter: self.iter(), other }
     }
 
@@ -599,8 +678,8 @@ where
     #[stable(feature = "rust1", since = "1.0.0")]
     pub fn symmetric_difference<'a>(
         &'a self,
-        other: &'a HashSet<T, S>,
-    ) -> SymmetricDifference<'a, T, S> {
+        other: &'a HashSet<T, S, A>,
+    ) -> SymmetricDifference<'a, T, S, A> {
         SymmetricDifference { iter: self.difference(other).chain(other.difference(self)) }
     }
 
@@ -631,7 +710,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S>) -> Intersection<'a, T, S> {
+    pub fn intersection<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Intersection<'a, T, S, A> {
         if self.len() <= other.len() {
             Intersection { iter: self.iter(), other }
         } else {
@@ -660,7 +739,7 @@ where
     #[inline]
     #[rustc_lint_query_instability]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn union<'a>(&'a self, other: &'a HashSet<T, S>) -> Union<'a, T, S> {
+    pub fn union<'a>(&'a self, other: &'a HashSet<T, S, A>) -> Union<'a, T, S, A> {
         if self.len() >= other.len() {
             Union { iter: self.iter().chain(other.difference(self)) }
         } else {
@@ -812,7 +891,7 @@ where
     /// ```
     #[inline]
     #[unstable(feature = "hash_set_entry", issue = "60896")]
-    pub fn entry(&mut self, value: T) -> Entry<'_, T, S> {
+    pub fn entry(&mut self, value: T) -> Entry<'_, T, S, A> {
         map_entry(self.base.entry(value))
     }
 
@@ -834,7 +913,7 @@ where
     /// assert_eq!(a.is_disjoint(&b), false);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_disjoint(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_disjoint(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() <= other.len() {
             self.iter().all(|v| !other.contains(v))
         } else {
@@ -860,7 +939,7 @@ where
     /// assert_eq!(set.is_subset(&sup), false);
     /// ```
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_subset(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_subset(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() <= other.len() { self.iter().all(|v| other.contains(v)) } else { false }
     }
 
@@ -886,7 +965,7 @@ where
     /// ```
     #[inline]
     #[stable(feature = "rust1", since = "1.0.0")]
-    pub fn is_superset(&self, other: &HashSet<T, S>) -> bool {
+    pub fn is_superset(&self, other: &HashSet<T, S, A>) -> bool {
         other.is_subset(self)
     }
 
@@ -995,7 +1074,7 @@ where
 }
 
 #[inline]
-fn map_entry<'a, K: 'a, V: 'a>(raw: base::Entry<'a, K, V>) -> Entry<'a, K, V> {
+fn map_entry<'a, K: 'a, V: 'a, A: Allocator>(raw: base::Entry<'a, K, V, A>) -> Entry<'a, K, V, A> {
     match raw {
         base::Entry::Occupied(base) => Entry::Occupied(OccupiedEntry { base }),
         base::Entry::Vacant(base) => Entry::Vacant(VacantEntry { base }),
@@ -1003,10 +1082,11 @@ fn map_entry<'a, K: 'a, V: 'a>(raw: base::Entry<'a, K, V>) -> Entry<'a, K, V> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for HashSet<T, S>
+impl<T, S, A> Clone for HashSet<T, S, A>
 where
     T: Clone,
     S: Clone,
+    A: Allocator + Clone,
 {
     #[inline]
     fn clone(&self) -> Self {
@@ -1024,12 +1104,13 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> PartialEq for HashSet<T, S>
+impl<T, S, A> PartialEq for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
-    fn eq(&self, other: &HashSet<T, S>) -> bool {
+    fn eq(&self, other: &HashSet<T, S, A>) -> bool {
         if self.len() != other.len() {
             return false;
         }
@@ -1039,17 +1120,19 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Eq for HashSet<T, S>
+impl<T, S, A> Eq for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> fmt::Debug for HashSet<T, S>
+impl<T, S, A> fmt::Debug for HashSet<T, S, A>
 where
     T: fmt::Debug,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_set().entries(self.iter()).finish()
@@ -1107,10 +1190,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Extend<T> for HashSet<T, S>
+impl<T, S, A> Extend<T> for HashSet<T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<I: IntoIterator<Item = T>>(&mut self, iter: I) {
@@ -1129,10 +1213,11 @@ where
 }
 
 #[stable(feature = "hash_extend_copy", since = "1.4.0")]
-impl<'a, T, S> Extend<&'a T> for HashSet<T, S>
+impl<'a, T, S, A> Extend<&'a T> for HashSet<T, S, A>
 where
     T: 'a + Eq + Hash + Copy,
     S: BuildHasher,
+    A: Allocator,
 {
     #[inline]
     fn extend<I: IntoIterator<Item = &'a T>>(&mut self, iter: I) {
@@ -1341,8 +1426,11 @@ impl<K> Default for Iter<'_, K> {
 /// let mut iter = a.into_iter();
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct IntoIter<K> {
-    base: base::IntoIter<K>,
+pub struct IntoIter<
+    K,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::IntoIter<K, A>,
 }
 
 #[stable(feature = "default_iters_hash", since = "1.83.0")]
@@ -1371,8 +1459,12 @@ impl<K> Default for IntoIter<K> {
 /// ```
 #[stable(feature = "rust1", since = "1.0.0")]
 #[cfg_attr(not(test), rustc_diagnostic_item = "hashset_drain_ty")]
-pub struct Drain<'a, K: 'a> {
-    base: base::Drain<'a, K>,
+pub struct Drain<
+    'a,
+    K: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::Drain<'a, K, A>,
 }
 
 /// A draining, filtering iterator over the items of a `HashSet`.
@@ -1393,8 +1485,13 @@ pub struct Drain<'a, K: 'a> {
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
 #[must_use = "iterators are lazy and do nothing unless consumed; \
     use `retain` to remove and discard elements"]
-pub struct ExtractIf<'a, K, F> {
-    base: base::ExtractIf<'a, K, F>,
+pub struct ExtractIf<
+    'a,
+    K,
+    F,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::ExtractIf<'a, K, F, A>,
 }
 
 /// A lazy iterator producing elements in the intersection of `HashSet`s.
@@ -1417,11 +1514,16 @@ pub struct ExtractIf<'a, K, F> {
 #[must_use = "this returns the intersection as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Intersection<'a, T: 'a, S: 'a> {
+pub struct Intersection<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, S>,
+    other: &'a HashSet<T, S, A>,
 }
 
 /// A lazy iterator producing elements in the difference of `HashSet`s.
@@ -1444,11 +1546,16 @@ pub struct Intersection<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the difference as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Difference<'a, T: 'a, S: 'a> {
+pub struct Difference<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     // iterator of the first set
     iter: Iter<'a, T>,
     // the second set
-    other: &'a HashSet<T, S>,
+    other: &'a HashSet<T, S, A>,
 }
 
 /// A lazy iterator producing elements in the symmetric difference of `HashSet`s.
@@ -1471,8 +1578,13 @@ pub struct Difference<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the difference as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct SymmetricDifference<'a, T: 'a, S: 'a> {
-    iter: Chain<Difference<'a, T, S>, Difference<'a, T, S>>,
+pub struct SymmetricDifference<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    iter: Chain<Difference<'a, T, S, A>, Difference<'a, T, S, A>>,
 }
 
 /// A lazy iterator producing elements in the union of `HashSet`s.
@@ -1495,12 +1607,17 @@ pub struct SymmetricDifference<'a, T: 'a, S: 'a> {
 #[must_use = "this returns the union as an iterator, \
               without modifying either input set"]
 #[stable(feature = "rust1", since = "1.0.0")]
-pub struct Union<'a, T: 'a, S: 'a> {
-    iter: Chain<Iter<'a, T>, Difference<'a, T, S>>,
+pub struct Union<
+    'a,
+    T: 'a,
+    S: 'a,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    iter: Chain<Iter<'a, T>, Difference<'a, T, S, A>>,
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
+impl<'a, T, S, A: Allocator> IntoIterator for &'a HashSet<T, S, A> {
     type Item = &'a T;
     type IntoIter = Iter<'a, T>;
 
@@ -1512,9 +1629,9 @@ impl<'a, T, S> IntoIterator for &'a HashSet<T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> IntoIterator for HashSet<T, S> {
+impl<T, S, A: Allocator> IntoIterator for HashSet<T, S, A> {
     type Item = T;
-    type IntoIter = IntoIter<T>;
+    type IntoIter = IntoIter<T, A>;
 
     /// Creates a consuming iterator, that is, one that moves each value out
     /// of the set in arbitrary order. The set cannot be used after calling
@@ -1538,7 +1655,7 @@ impl<T, S> IntoIterator for HashSet<T, S> {
     /// ```
     #[inline]
     #[rustc_lint_query_instability]
-    fn into_iter(self) -> IntoIter<T> {
+    fn into_iter(self) -> IntoIter<T, A> {
         IntoIter { base: self.base.into_iter() }
     }
 }
@@ -1593,7 +1710,7 @@ impl<K: fmt::Debug> fmt::Debug for Iter<'_, K> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> Iterator for IntoIter<K> {
+impl<K, A: Allocator> Iterator for IntoIter<K, A> {
     type Item = K;
 
     #[inline]
@@ -1618,24 +1735,24 @@ impl<K> Iterator for IntoIter<K> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> ExactSizeIterator for IntoIter<K> {
+impl<K, A: Allocator> ExactSizeIterator for IntoIter<K, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K> FusedIterator for IntoIter<K> {}
+impl<K, A: Allocator> FusedIterator for IntoIter<K, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: fmt::Debug> fmt::Debug for IntoIter<K> {
+impl<K: fmt::Debug, A: Allocator> fmt::Debug for IntoIter<K, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.base, f)
     }
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, K> Iterator for Drain<'a, K> {
+impl<'a, K, A: Allocator> Iterator for Drain<'a, K, A> {
     type Item = K;
 
     #[inline]
@@ -1656,24 +1773,24 @@ impl<'a, K> Iterator for Drain<'a, K> {
     }
 }
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<K> ExactSizeIterator for Drain<'_, K> {
+impl<K, A: Allocator> ExactSizeIterator for Drain<'_, K, A> {
     #[inline]
     fn len(&self) -> usize {
         self.base.len()
     }
 }
 #[stable(feature = "fused", since = "1.26.0")]
-impl<K> FusedIterator for Drain<'_, K> {}
+impl<K, A: Allocator> FusedIterator for Drain<'_, K, A> {}
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<K: fmt::Debug> fmt::Debug for Drain<'_, K> {
+impl<K: fmt::Debug, A: Allocator> fmt::Debug for Drain<'_, K, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         fmt::Debug::fmt(&self.base, f)
     }
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> Iterator for ExtractIf<'_, K, F>
+impl<K, F, A: Allocator> Iterator for ExtractIf<'_, K, F, A>
 where
     F: FnMut(&K) -> bool,
 {
@@ -1690,10 +1807,10 @@ where
 }
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> FusedIterator for ExtractIf<'_, K, F> where F: FnMut(&K) -> bool {}
+impl<K, F, A: Allocator> FusedIterator for ExtractIf<'_, K, F, A> where F: FnMut(&K) -> bool {}
 
 #[stable(feature = "hash_extract_if", since = "1.88.0")]
-impl<K, F> fmt::Debug for ExtractIf<'_, K, F>
+impl<K, F, A: Allocator> fmt::Debug for ExtractIf<'_, K, F, A>
 where
     K: fmt::Debug,
 {
@@ -1703,7 +1820,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Intersection<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Intersection<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Intersection { iter: self.iter.clone(), ..*self }
@@ -1711,10 +1828,11 @@ impl<T, S> Clone for Intersection<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Intersection<'a, T, S>
+impl<'a, T, S, A> Iterator for Intersection<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1745,10 +1863,11 @@ where
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Intersection<'_, T, S>
+impl<T, S, A> fmt::Debug for Intersection<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1756,15 +1875,16 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Intersection<'_, T, S>
+impl<T, S, A> FusedIterator for Intersection<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Difference<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Difference<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Difference { iter: self.iter.clone(), ..*self }
@@ -1772,10 +1892,11 @@ impl<T, S> Clone for Difference<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Difference<'a, T, S>
+impl<'a, T, S, A> Iterator for Difference<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1806,18 +1927,20 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Difference<'_, T, S>
+impl<T, S, A> FusedIterator for Difference<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Difference<'_, T, S>
+impl<T, S, A> fmt::Debug for Difference<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1825,7 +1948,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for SymmetricDifference<'_, T, S> {
+impl<T, S, A: Allocator> Clone for SymmetricDifference<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         SymmetricDifference { iter: self.iter.clone() }
@@ -1833,10 +1956,11 @@ impl<T, S> Clone for SymmetricDifference<'_, T, S> {
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for SymmetricDifference<'a, T, S>
+impl<'a, T, S, A> Iterator for SymmetricDifference<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1859,18 +1983,20 @@ where
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for SymmetricDifference<'_, T, S>
+impl<T, S, A> FusedIterator for SymmetricDifference<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for SymmetricDifference<'_, T, S>
+impl<T, S, A> fmt::Debug for SymmetricDifference<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1878,7 +2004,7 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<T, S> Clone for Union<'_, T, S> {
+impl<T, S, A: Allocator> Clone for Union<'_, T, S, A> {
     #[inline]
     fn clone(&self) -> Self {
         Union { iter: self.iter.clone() }
@@ -1886,7 +2012,7 @@ impl<T, S> Clone for Union<'_, T, S> {
 }
 
 #[stable(feature = "fused", since = "1.26.0")]
-impl<T, S> FusedIterator for Union<'_, T, S>
+impl<T, S, A: Allocator> FusedIterator for Union<'_, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
@@ -1894,10 +2020,11 @@ where
 }
 
 #[stable(feature = "std_debug", since = "1.16.0")]
-impl<T, S> fmt::Debug for Union<'_, T, S>
+impl<T, S, A: Allocator> fmt::Debug for Union<'_, T, S, A>
 where
     T: fmt::Debug + Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_list().entries(self.clone()).finish()
@@ -1905,10 +2032,11 @@ where
 }
 
 #[stable(feature = "rust1", since = "1.0.0")]
-impl<'a, T, S> Iterator for Union<'a, T, S>
+impl<'a, T, S, A> Iterator for Union<'a, T, S, A>
 where
     T: Eq + Hash,
     S: BuildHasher,
+    A: Allocator,
 {
     type Item = &'a T;
 
@@ -1973,7 +2101,12 @@ where
 /// assert_eq!(vec, ["a", "b", "c", "d", "e"]);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub enum Entry<'a, T, S> {
+pub enum Entry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
     /// An occupied entry.
     ///
     /// # Examples
@@ -1990,7 +2123,7 @@ pub enum Entry<'a, T, S> {
     ///     Entry::Occupied(_) => { }
     /// }
     /// ```
-    Occupied(OccupiedEntry<'a, T, S>),
+    Occupied(OccupiedEntry<'a, T, S, A>),
 
     /// A vacant entry.
     ///
@@ -2008,11 +2141,11 @@ pub enum Entry<'a, T, S> {
     ///     Entry::Vacant(_) => { }
     /// }
     /// ```
-    Vacant(VacantEntry<'a, T, S>),
+    Vacant(VacantEntry<'a, T, S, A>),
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for Entry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for Entry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         match *self {
             Entry::Vacant(ref v) => f.debug_tuple("Entry").field(v).finish(),
@@ -2060,12 +2193,17 @@ impl<T: fmt::Debug, S> fmt::Debug for Entry<'_, T, S> {
 /// assert_eq!(set.len(), 2);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub struct OccupiedEntry<'a, T, S> {
-    base: base::OccupiedEntry<'a, T, S>,
+pub struct OccupiedEntry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::OccupiedEntry<'a, T, S, A>,
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for OccupiedEntry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for OccupiedEntry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_struct("OccupiedEntry").field("value", self.get()).finish()
     }
@@ -2100,18 +2238,23 @@ impl<T: fmt::Debug, S> fmt::Debug for OccupiedEntry<'_, T, S> {
 /// assert!(set.contains("b") && set.len() == 2);
 /// ```
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-pub struct VacantEntry<'a, T, S> {
-    base: base::VacantEntry<'a, T, S>,
+pub struct VacantEntry<
+    'a,
+    T,
+    S,
+    #[unstable(feature = "allocator_api", issue = "32838")] A: Allocator = Global,
+> {
+    base: base::VacantEntry<'a, T, S, A>,
 }
 
 #[unstable(feature = "hash_set_entry", issue = "60896")]
-impl<T: fmt::Debug, S> fmt::Debug for VacantEntry<'_, T, S> {
+impl<T: fmt::Debug, S, A: Allocator> fmt::Debug for VacantEntry<'_, T, S, A> {
     fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
         f.debug_tuple("VacantEntry").field(self.get()).finish()
     }
 }
 
-impl<'a, T, S> Entry<'a, T, S> {
+impl<'a, T, S, A: Allocator> Entry<'a, T, S, A> {
     /// Sets the value of the entry, and returns an OccupiedEntry.
     ///
     /// # Examples
@@ -2128,7 +2271,7 @@ impl<'a, T, S> Entry<'a, T, S> {
     /// ```
     #[inline]
     #[unstable(feature = "hash_set_entry", issue = "60896")]
-    pub fn insert(self) -> OccupiedEntry<'a, T, S>
+    pub fn insert(self) -> OccupiedEntry<'a, T, S, A>
     where
         T: Hash,
         S: BuildHasher,
@@ -2198,7 +2341,7 @@ impl<'a, T, S> Entry<'a, T, S> {
     }
 }
 
-impl<T, S> OccupiedEntry<'_, T, S> {
+impl<T, S, A: Allocator> OccupiedEntry<'_, T, S, A> {
     /// Gets a reference to the value in the entry.
     ///
     /// # Examples
@@ -2255,7 +2398,7 @@ impl<T, S> OccupiedEntry<'_, T, S> {
     }
 }
 
-impl<'a, T, S> VacantEntry<'a, T, S> {
+impl<'a, T, S, A: Allocator> VacantEntry<'a, T, S, A> {
     /// Gets a reference to the value that would be used when inserting
     /// through the `VacantEntry`.
     ///
@@ -2325,7 +2468,7 @@ impl<'a, T, S> VacantEntry<'a, T, S> {
     }
 
     #[inline]
-    fn insert_entry(self) -> OccupiedEntry<'a, T, S>
+    fn insert_entry(self) -> OccupiedEntry<'a, T, S, A>
     where
         T: Hash,
         S: BuildHasher,
diff --git a/tests/ui/generics/wrong-number-of-args.rs b/tests/ui/generics/wrong-number-of-args.rs
index 6524bd538b6bf..8bc384a3d817d 100644
--- a/tests/ui/generics/wrong-number-of-args.rs
+++ b/tests/ui/generics/wrong-number-of-args.rs
@@ -321,10 +321,6 @@ mod stdlib {
         //~| ERROR struct takes at least 2
         //~| HELP add missing
 
-        type D = HashMap<usize, String, char, f64>;
-        //~^ ERROR struct takes at most 3
-        //~| HELP remove the
-
         type E = HashMap<>;
         //~^ ERROR struct takes at least 2 generic arguments but 0 generic arguments
         //~| HELP add missing
diff --git a/tests/ui/generics/wrong-number-of-args.stderr b/tests/ui/generics/wrong-number-of-args.stderr
index bac0d26b622dc..bedeeb812fc99 100644
--- a/tests/ui/generics/wrong-number-of-args.stderr
+++ b/tests/ui/generics/wrong-number-of-args.stderr
@@ -926,16 +926,8 @@ help: add missing generic arguments
 LL |         type C = HashMap<'static, K, V>;
    |                                 ++++++
 
-error[E0107]: struct takes at most 3 generic arguments but 4 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:324:18
-   |
-LL |         type D = HashMap<usize, String, char, f64>;
-   |                  ^^^^^^^                    ----- help: remove the unnecessary generic argument
-   |                  |
-   |                  expected at most 3 generic arguments
-
 error[E0107]: struct takes at least 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:328:18
+  --> $DIR/wrong-number-of-args.rs:324:18
    |
 LL |         type E = HashMap<>;
    |                  ^^^^^^^ expected at least 2 generic arguments
@@ -946,7 +938,7 @@ LL |         type E = HashMap<K, V>;
    |                          ++++
 
 error[E0107]: missing generics for enum `Result`
-  --> $DIR/wrong-number-of-args.rs:334:18
+  --> $DIR/wrong-number-of-args.rs:330:18
    |
 LL |         type A = Result;
    |                  ^^^^^^ expected 2 generic arguments
@@ -957,7 +949,7 @@ LL |         type A = Result<T, E>;
    |                        ++++++
 
 error[E0107]: enum takes 2 generic arguments but 1 generic argument was supplied
-  --> $DIR/wrong-number-of-args.rs:338:18
+  --> $DIR/wrong-number-of-args.rs:334:18
    |
 LL |         type B = Result<String>;
    |                  ^^^^^^ ------ supplied 1 generic argument
@@ -970,7 +962,7 @@ LL |         type B = Result<String, E>;
    |                               +++
 
 error[E0107]: enum takes 0 lifetime arguments but 1 lifetime argument was supplied
-  --> $DIR/wrong-number-of-args.rs:342:18
+  --> $DIR/wrong-number-of-args.rs:338:18
    |
 LL |         type C = Result<'static>;
    |                  ^^^^^^--------- help: remove the unnecessary generics
@@ -978,7 +970,7 @@ LL |         type C = Result<'static>;
    |                  expected 0 lifetime arguments
 
 error[E0107]: enum takes 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:342:18
+  --> $DIR/wrong-number-of-args.rs:338:18
    |
 LL |         type C = Result<'static>;
    |                  ^^^^^^ expected 2 generic arguments
@@ -989,7 +981,7 @@ LL |         type C = Result<'static, T, E>;
    |                                ++++++
 
 error[E0107]: enum takes 2 generic arguments but 3 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:348:18
+  --> $DIR/wrong-number-of-args.rs:344:18
    |
 LL |         type D = Result<usize, String, char>;
    |                  ^^^^^^              ------ help: remove the unnecessary generic argument
@@ -997,7 +989,7 @@ LL |         type D = Result<usize, String, char>;
    |                  expected 2 generic arguments
 
 error[E0107]: enum takes 2 generic arguments but 0 generic arguments were supplied
-  --> $DIR/wrong-number-of-args.rs:352:18
+  --> $DIR/wrong-number-of-args.rs:348:18
    |
 LL |         type E = Result<>;
    |                  ^^^^^^ expected 2 generic arguments
@@ -1007,7 +999,7 @@ help: add missing generic arguments
 LL |         type E = Result<T, E>;
    |                         ++++
 
-error: aborting due to 71 previous errors
+error: aborting due to 70 previous errors
 
 Some errors have detailed explanations: E0106, E0107.
 For more information about an error, try `rustc --explain E0106`.
diff --git a/tests/ui/inference/issue-71732.stderr b/tests/ui/inference/issue-71732.stderr
index af8b310fd1d9c..e791316948560 100644
--- a/tests/ui/inference/issue-71732.stderr
+++ b/tests/ui/inference/issue-71732.stderr
@@ -10,7 +10,7 @@ LL |         .get(&"key".into())
            - impl Borrow<str> for String;
            - impl<T> Borrow<T> for T
              where T: ?Sized;
-note: required by a bound in `HashMap::<K, V, S>::get`
+note: required by a bound in `HashMap::<K, V, S, A>::get`
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 help: consider specifying the generic argument
    |
diff --git a/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr b/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
index 6272455cc57ee..af0f67b7c1c07 100644
--- a/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
+++ b/tests/ui/moves/suggest-clone-when-some-obligation-is-unmet.stderr
@@ -6,7 +6,7 @@ LL |     let mut copy: Vec<U> = map.clone().into_values().collect();
    |                            |
    |                            move occurs because value has type `HashMap<T, U, Hash128_1>`, which does not implement the `Copy` trait
    |
-note: `HashMap::<K, V, S>::into_values` takes ownership of the receiver `self`, which moves value
+note: `HashMap::<K, V, S, A>::into_values` takes ownership of the receiver `self`, which moves value
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 note: if `Hash128_1` implemented `Clone`, you could clone the value
   --> $DIR/suggest-clone-when-some-obligation-is-unmet.rs:8:1
diff --git a/tests/ui/privacy/suggest-box-new.rs b/tests/ui/privacy/suggest-box-new.rs
index ff585387020e4..87ee13d15edb9 100644
--- a/tests/ui/privacy/suggest-box-new.rs
+++ b/tests/ui/privacy/suggest-box-new.rs
@@ -14,7 +14,7 @@ fn main() {
     let _ = std::collections::HashMap();
     //~^ ERROR expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
     let _ = std::collections::HashMap {};
-    //~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+    //~^ ERROR cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
     let _ = Box {}; //~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
 
     // test that we properly instantiate the parameter of `Box::<T>::new` with an inference variable
diff --git a/tests/ui/privacy/suggest-box-new.stderr b/tests/ui/privacy/suggest-box-new.stderr
index e3a7e5f620176..7367672351d6c 100644
--- a/tests/ui/privacy/suggest-box-new.stderr
+++ b/tests/ui/privacy/suggest-box-new.stderr
@@ -5,6 +5,7 @@ LL |     let _ = std::collections::HashMap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+  ::: $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    |
    = note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL |     let _ = std::collections::HashMap::new();
    |                                      +++++
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    |
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
   --> $DIR/suggest-box-new.rs:16:13
    |
 LL |     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/suggestions/multi-suggestion.ascii.stderr b/tests/ui/suggestions/multi-suggestion.ascii.stderr
index c2ae19b1ae9aa..2da0f9bd12c22 100644
--- a/tests/ui/suggestions/multi-suggestion.ascii.stderr
+++ b/tests/ui/suggestions/multi-suggestion.ascii.stderr
@@ -5,6 +5,7 @@ LL |     let _ = std::collections::HashMap();
    |             ^^^^^^^^^^^^^^^^^^^^^^^^^^^
    |
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+  ::: $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    |
    = note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL |     let _ = std::collections::HashMap::new();
    |                                      +++++
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL |     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    |
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
   --> $DIR/multi-suggestion.rs:19:13
    |
 LL |     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    |
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
    |
+   = and 4 other candidates
 help: consider using the `Default` trait
    |
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/suggestions/multi-suggestion.rs b/tests/ui/suggestions/multi-suggestion.rs
index 99d2407aa212a..6d822a8e5aff5 100644
--- a/tests/ui/suggestions/multi-suggestion.rs
+++ b/tests/ui/suggestions/multi-suggestion.rs
@@ -17,6 +17,6 @@ fn main() {
     let _ = std::collections::HashMap();
     //[ascii]~^ ERROR expected function, tuple struct or tuple variant, found struct `std::collections::HashMap`
     let _ = std::collections::HashMap {};
-    //[ascii]~^ ERROR cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+    //[ascii]~^ ERROR cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
     let _ = Box {}; //[ascii]~ ERROR cannot construct `Box<_, _>` with struct literal syntax due to private fields
 }
diff --git a/tests/ui/suggestions/multi-suggestion.unicode.stderr b/tests/ui/suggestions/multi-suggestion.unicode.stderr
index fc187cac91d12..69529b67b7757 100644
--- a/tests/ui/suggestions/multi-suggestion.unicode.stderr
+++ b/tests/ui/suggestions/multi-suggestion.unicode.stderr
@@ -5,6 +5,7 @@ LL │     let _ = std::collections::HashMap();
    │             ━━━━━━━━━━━━━━━━━━━━━━━━━━━
    ╰╴
    ╭▸ $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
+   ⸬  $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
    │
    ╰ note: `std::collections::HashMap` defined here
 help: you might have meant to use an associated function to build this type
@@ -12,14 +13,15 @@ help: you might have meant to use an associated function to build this type
 LL │     let _ = std::collections::HashMap::new();
    ├╴                                     +++++
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    ├╴
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    ├╴
 LL -     let _ = std::collections::HashMap();
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
-   ╰╴
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
+   │
+   ╰ and 4 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL │     let _ = <std::collections::HashMap as std::default::Default>::default();
@@ -73,7 +75,7 @@ LL -         })),
 LL +         wtf: Some(<Box as std::default::Default>::default()),
    ╰╴
 
-error: cannot construct `HashMap<_, _, _>` with struct literal syntax due to private fields
+error: cannot construct `HashMap<_, _, _, _>` with struct literal syntax due to private fields
    ╭▸ $DIR/multi-suggestion.rs:19:13
    │
 LL │     let _ = std::collections::HashMap {};
@@ -86,14 +88,15 @@ LL -     let _ = std::collections::HashMap {};
 LL +     let _ = std::collections::HashMap::new();
    ├╴
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity(_);
+LL +     let _ = std::collections::HashMap::new_in(_);
    ├╴
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_hasher(_);
+LL +     let _ = std::collections::HashMap::with_capacity(_);
    ├╴
 LL -     let _ = std::collections::HashMap {};
-LL +     let _ = std::collections::HashMap::with_capacity_and_hasher(_, _);
-   ╰╴
+LL +     let _ = std::collections::HashMap::with_capacity_in(_, _);
+   │
+   ╰ and 4 other candidates
 help: consider using the `Default` trait
    ╭╴
 LL -     let _ = std::collections::HashMap {};
diff --git a/tests/ui/traits/issue-77982.stderr b/tests/ui/traits/issue-77982.stderr
index edc7f56ea467b..4bc24e81215a0 100644
--- a/tests/ui/traits/issue-77982.stderr
+++ b/tests/ui/traits/issue-77982.stderr
@@ -10,7 +10,7 @@ LL |     opts.get(opt.as_ref());
            - impl Borrow<str> for String;
            - impl<T> Borrow<T> for T
              where T: ?Sized;
-note: required by a bound in `HashMap::<K, V, S>::get`
+note: required by a bound in `HashMap::<K, V, S, A>::get`
   --> $SRC_DIR/std/src/collections/hash/map.rs:LL:COL
 help: consider specifying the generic argument
    |