Use table entries (requires rust-lang#669)

Author: clarfonthey

src/map.rs

@@ -2812,9 +2812,8 @@ impl<K: Debug, V: Debug, S, A: Allocator> Debug for Entry<'_, K, V, S, A> {
 /// assert_eq!(map.len(), 2);
 /// ```
 pub struct OccupiedEntry<'a, K, V, S = DefaultHashBuilder, A: Allocator = Global> {
-    hash: u64,
-    elem: Bucket<(K, V)>,
-    table: &'a mut HashMap<K, V, S, A>,
+    inner: hash_table::OccupiedEntry<'a, (K, V), A>,
+    marker: PhantomData<&'a mut S>,
 }
 
 unsafe impl<K, V, S, A> Send for OccupiedEntry<'_, K, V, S, A>
@@ -3817,7 +3816,7 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn key(&self) -> &K {
-        unsafe { &self.elem.as_ref().0 }
+        &self.inner.get().0
     }
 
     /// Take the ownership of the key and value from the map.
@@ -3846,7 +3845,7 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn remove_entry(self) -> (K, V) {
-        unsafe { self.table.table.raw.remove(self.elem).0 }
+        self.inner.remove().0
     }
 
     /// Gets a reference to the value in the entry.
@@ -3867,7 +3866,7 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn get(&self) -> &V {
-        unsafe { &self.elem.as_ref().1 }
+        &self.inner.get().1
     }
 
     /// Gets a mutable reference to the value in the entry.
@@ -3899,7 +3898,7 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn get_mut(&mut self) -> &mut V {
-        unsafe { &mut self.elem.as_mut().1 }
+        &mut self.inner.get_mut().1
     }
 
     /// Converts the `OccupiedEntry` into a mutable reference to the value in the entry
@@ -3930,7 +3929,7 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn into_mut(self) -> &'a mut V {
-        unsafe { &mut self.elem.as_mut().1 }
+        &mut self.inner.into_mut().1
     }
 
     /// Sets the value of the entry, and returns the entry's old value.
@@ -4039,27 +4038,23 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
         unsafe {
             let mut spare_key = None;
 
-            self.table
-                .table
-                .raw
-                .replace_bucket_with(self.elem.clone(), |(key, value)| {
+            match self.inner
+                .replace_entry_with(|(key, value)| {
                     if let Some(new_value) = f(&key, value) {
                         Some((key, new_value))
                     } else {
                         spare_key = Some(key);
                         None
                     }
-                });
-
-            if let Some(key) = spare_key {
-                Entry::Vacant(VacantEntry {
-                    hash: self.hash,
-                    key,
-                    table: self.table,
-                })
-            } else {
-                Entry::Occupied(self)
-            }
+                }) {
+                    hash_table::Entry::Occupied(entry) => Entry::Occupied(OccupiedEntry {
+                        inner: entry
+                    }),
+                    hash_table::Entry::Vacant(entry) => Entry::Vacant(VacantEntry {
+                        inner: entry,
+                        key,
+                    })
+                }
         }
     }
 }