Fix for 61780

src/lib.rs

@@ -9,8 +9,8 @@
 extern crate rand;
 
 mod bench;
-mod table;
 mod map;
+mod table;
 
 pub use map::*;
 pub use table::{make_hash, SafeHash};

src/map.rs

@@ -11,19 +11,19 @@
 use self::Entry::*;
 use self::VacantEntryState::*;
 
-use std::cell::Cell;
+use rand::{self, Rng};
 use std::borrow::Borrow;
+use std::cell::Cell;
 use std::cmp::max;
 use std::fmt::{self, Debug};
 #[allow(deprecated)]
 use std::hash::{BuildHasher, Hash, Hasher, SipHasher13};
 use std::iter::{FromIterator, FusedIterator};
 use std::mem::{self, replace};
 use std::ops::{Deref, Index};
-use rand::{self, Rng};
 
-use super::table::{self, Bucket, EmptyBucket, FullBucket, FullBucketMut, RawTable, SafeHash};
 use super::table::BucketState::{Empty, Full};
+use super::table::{self, Bucket, EmptyBucket, FullBucket, FullBucketMut, RawTable, SafeHash};
 
 const MIN_NONZERO_RAW_CAPACITY: usize = 32; // must be a power of two
 
@@ -812,7 +812,8 @@ where
     pub fn reserve(&mut self, additional: usize) {
         let remaining = self.capacity() - self.len(); // this can't overflow
         if remaining < additional {
-            let min_cap = self.len()
+            let min_cap = self
+                .len()
                 .checked_add(additional)
                 .expect("reserve overflow");
             let raw_cap = self.resize_policy.raw_capacity(min_cap);
@@ -2663,11 +2664,11 @@ fn assert_covariance() {
 
 #[cfg(test)]
 mod test_map {
-    use super::HashMap;
     use super::Entry::{Occupied, Vacant};
+    use super::HashMap;
     use super::RandomState;
-    use std::cell::RefCell;
     use rand::{thread_rng, Rng};
+    use std::cell::RefCell;
 
     #[test]
     fn test_zero_capacities() {
@@ -3595,7 +3596,6 @@ mod test_map {
         panic!("Adaptive early resize failed");
     }
 
-
     #[test]
     fn test_remove_at_index() {
         let mut m = HashMap::new();

src/table.rs

@@ -9,7 +9,7 @@
 // except according to those terms.
 
 use std::alloc::{handle_alloc_error, Alloc, Global, Layout, LayoutErr};
-use std::collections::CollectionAllocErr;
+use std::collections::TryReserveError;
 use std::hash::{BuildHasher, Hash, Hasher};
 use std::marker;
 use std::mem;
@@ -679,7 +679,7 @@ impl<K, V> RawTable<K, V> {
     unsafe fn new_uninitialized_internal(
         capacity: usize,
         fallibility: Fallibility,
-    ) -> Result<RawTable<K, V>, CollectionAllocErr> {
+    ) -> Result<RawTable<K, V>, TryReserveError> {
         if capacity == 0 {
             return Ok(RawTable {
                 size: 0,
@@ -694,10 +694,16 @@ impl<K, V> RawTable<K, V> {
         // we just allocate a single array, and then have the subarrays
         // point into it.
         let (layout, _) = calculate_layout::<K, V>(capacity)?;
-        let buffer = Global.alloc(layout).map_err(|e| match fallibility {
-            Infallible => handle_alloc_error(layout),
-            Fallible => e,
-        })?;
+        let buffer = Global
+            .alloc(layout)
+            .map_err(|e| match fallibility {
+                Infallible => handle_alloc_error(layout),
+                Fallible => e,
+            })
+            .map_err(|_alloc_err| TryReserveError::AllocError {
+                layout: layout,
+                non_exhaustive: (),
+            })?;
 
         Ok(RawTable {
             capacity_mask: capacity.wrapping_sub(1),
@@ -711,8 +717,8 @@ impl<K, V> RawTable<K, V> {
     /// at the very least, set every hash to EMPTY_BUCKET.
     unsafe fn new_uninitialized(capacity: usize) -> RawTable<K, V> {
         match Self::new_uninitialized_internal(capacity, Infallible) {
-            Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
-            Err(CollectionAllocErr::AllocErr) => unreachable!(),
+            Err(TryReserveError::CapacityOverflow) => panic!("capacity overflow"),
+            Err(TryReserveError::AllocError { .. }) => unreachable!(),
             Ok(table) => table,
         }
     }
@@ -733,7 +739,7 @@ impl<K, V> RawTable<K, V> {
     fn new_internal(
         capacity: usize,
         fallibility: Fallibility,
-    ) -> Result<RawTable<K, V>, CollectionAllocErr> {
+    ) -> Result<RawTable<K, V>, TryReserveError> {
         unsafe {
             let ret = RawTable::new_uninitialized_internal(capacity, fallibility)?;
             if capacity > 0 {
@@ -744,18 +750,18 @@ impl<K, V> RawTable<K, V> {
     }
 
     /// Tries to create a new raw table from a given capacity. If it cannot allocate,
-    /// it returns with AllocErr.
+    /// it returns with AllocError.
     #[allow(unused)]
-    pub fn try_new(capacity: usize) -> Result<RawTable<K, V>, CollectionAllocErr> {
+    pub fn try_new(capacity: usize) -> Result<RawTable<K, V>, TryReserveError> {
         Self::new_internal(capacity, Fallible)
     }
 
     /// Creates a new raw table from a given capacity. All buckets are
     /// initially empty.
     pub fn new(capacity: usize) -> RawTable<K, V> {
         match Self::new_internal(capacity, Infallible) {
-            Err(CollectionAllocErr::CapacityOverflow) => panic!("capacity overflow"),
-            Err(CollectionAllocErr::AllocErr) => unreachable!(),
+            Err(TryReserveError::CapacityOverflow) => panic!("capacity overflow"),
+            Err(TryReserveError::AllocError { .. }) => unreachable!(),
             Ok(table) => table,
         }
     }