Use table entries (requires rust-lang#669)

Author: clarfonthey

src/map.rs

@@ -1215,18 +1215,17 @@ where
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn entry(&mut self, key: K) -> Entry<'_, K, V, S, A> {
         let hash = make_hash::<K, S>(&self.hash_builder, &key);
-        if let Some(elem) = self.table.raw.find(hash, equivalent_key(&key)) {
-            Entry::Occupied(OccupiedEntry {
-                hash,
-                elem,
-                table: self,
-            })
-        } else {
-            Entry::Vacant(VacantEntry {
-                hash,
+        let hasher = make_hasher(&self.hash_builder);
+        match self.table.entry(hash, equivalent_key(&key), hasher) {
+            hash_table::Entry::Occupied(inner) => Entry::Occupied(OccupiedEntry {
+                inner,
+                marker: PhantomData,
+            }),
+            hash_table::Entry::Vacant(inner) => Entry::Vacant(VacantEntry {
+                inner,
                 key,
-                table: self,
-            })
+                marker: PhantomData,
+            }),
         }
     }
 
@@ -1253,18 +1252,17 @@ where
         Q: Hash + Equivalent<K> + ?Sized,
     {
         let hash = make_hash::<Q, S>(&self.hash_builder, key);
-        if let Some(elem) = self.table.raw.find(hash, equivalent_key(key)) {
-            EntryRef::Occupied(OccupiedEntry {
-                hash,
-                elem,
-                table: self,
-            })
-        } else {
-            EntryRef::Vacant(VacantEntryRef {
-                hash,
+        let hasher = make_hasher(&self.hash_builder);
+        match self.table.entry(hash, equivalent_key(key), hasher) {
+            hash_table::Entry::Occupied(inner) => EntryRef::Occupied(OccupiedEntry {
+                inner,
+                marker: PhantomData,
+            }),
+            hash_table::Entry::Vacant(inner) => EntryRef::Vacant(VacantEntryRef {
+                inner,
                 key,
-                table: self,
-            })
+                marker: PhantomData,
+            }),
         }
     }
 
@@ -1826,13 +1824,10 @@ where
     /// ```
     #[cfg_attr(feature = "inline-more", inline)]
     pub fn insert(&mut self, k: K, v: V) -> Option<V> {
-        let hash = make_hash::<K, S>(&self.hash_builder, &k);
-        match self.find_or_find_insert_index(hash, &k) {
-            Ok(bucket) => Some(mem::replace(unsafe { &mut bucket.as_mut().1 }, v)),
-            Err(index) => {
-                unsafe {
-                    self.table.raw.insert_at_index(hash, index, (k, v));
-                }
+        match self.entry(k) {
+            Entry::Occupied(mut entry) => Some(entry.insert(v)),
+            Entry::Vacant(entry) => {
+                entry.insert(v);
                 None
             }
         }
@@ -1914,11 +1909,10 @@ where
     #[cfg_attr(feature = "inline-more", inline)]
     pub unsafe fn insert_unique_unchecked(&mut self, k: K, v: V) -> (&K, &mut V) {
         let hash = make_hash::<K, S>(&self.hash_builder, &k);
-        let bucket =
+        let entry =
             self.table
-                .raw
-                .insert(hash, (k, v), make_hasher::<_, V, S>(&self.hash_builder));
-        let (k_ref, v_ref) = unsafe { bucket.as_mut() };
+                .insert_unique(hash, (k, v), make_hasher::<_, V, S>(&self.hash_builder));
+        let (k_ref, v_ref) = entry.into_mut();
         (k_ref, v_ref)
     }
 
@@ -2812,9 +2806,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>
@@ -2874,9 +2867,9 @@ impl<K: Debug, V: Debug, S, A: Allocator> Debug for OccupiedEntry<'_, K, V, S, A
 /// assert!(map[&"b"] == 20 && map.len() == 2);
 /// ```
 pub struct VacantEntry<'a, K, V, S = DefaultHashBuilder, A: Allocator = Global> {
-    hash: u64,
+    inner: hash_table::VacantEntry<'a, (K, V), A>,
     key: K,
-    table: &'a mut HashMap<K, V, S, A>,
+    marker: PhantomData<&'a mut S>,
 }
 
 impl<K: Debug, V, S, A: Allocator> Debug for VacantEntry<'_, K, V, S, A> {
@@ -3018,9 +3011,9 @@ where
 /// assert!(map["b"] == 20 && map.len() == 2);
 /// ```
 pub struct VacantEntryRef<'map, 'key, K, Q: ?Sized, V, S, A: Allocator = Global> {
-    hash: u64,
+    inner: hash_table::VacantEntry<'map, (K, V), A>,
     key: &'key Q,
-    table: &'map mut HashMap<K, V, S, A>,
+    marker: PhantomData<&'map mut S>,
 }
 
 impl<K, Q, V, S, A> Debug for VacantEntryRef<'_, '_, K, Q, V, S, A>
@@ -3817,7 +3810,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 +3839,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 +3860,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 +3892,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 +3923,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.
@@ -4036,30 +4029,25 @@ impl<'a, K, V, S, A: Allocator> OccupiedEntry<'a, K, V, S, A> {
     where
         F: FnOnce(&K, V) -> Option<V>,
     {
-        unsafe {
-            let mut spare_key = None;
-
-            self.table
-                .table
-                .raw
-                .replace_bucket_with(self.elem.clone(), |(key, value)| {
-                    if let Some(new_value) = f(&key, value) {
-                        Some((key, new_value))
-                    } else {
-                        spare_key = Some(key);
-                        None
-                    }
-                });
+        let mut spare_key = None;
 
-            if let Some(key) = spare_key {
-                Entry::Vacant(VacantEntry {
-                    hash: self.hash,
-                    key,
-                    table: self.table,
-                })
+        match self.inner.replace_entry_with(|(key, value)| {
+            if let Some(new_value) = f(&key, value) {
+                Some((key, new_value))
             } else {
-                Entry::Occupied(self)
+                spare_key = Some(key);
+                None
             }
+        }) {
+            hash_table::Entry::Vacant(inner) => Entry::Vacant(VacantEntry {
+                inner,
+                key: unsafe { spare_key.unwrap_unchecked() },
+                marker: PhantomData,
+            }),
+            hash_table::Entry::Occupied(inner) => Entry::Occupied(OccupiedEntry {
+                inner,
+                marker: PhantomData,
+            }),
         }
     }
 }
@@ -4122,13 +4110,7 @@ impl<'a, K, V, S, A: Allocator> VacantEntry<'a, K, V, S, A> {
         K: Hash,
         S: BuildHasher,
     {
-        let table = &mut self.table.table.raw;
-        let entry = table.insert_entry(
-            self.hash,
-            (self.key, value),
-            make_hasher::<_, V, S>(&self.table.hash_builder),
-        );
-        &mut entry.1
+        &mut self.inner.insert((self.key, value)).into_mut().1
     }
 
     /// Sets the value of the entry with the [`VacantEntry`]'s key,
@@ -4153,15 +4135,9 @@ impl<'a, K, V, S, A: Allocator> VacantEntry<'a, K, V, S, A> {
         K: Hash,
         S: BuildHasher,
     {
-        let elem = self.table.table.raw.insert(
-            self.hash,
-            (self.key, value),
-            make_hasher::<_, V, S>(&self.table.hash_builder),
-        );
         OccupiedEntry {
-            hash: self.hash,
-            elem,
-            table: self.table,
+            inner: self.inner.insert((self.key, value)),
+            marker: PhantomData,
         }
     }
 }
@@ -4461,13 +4437,7 @@ impl<'map, 'key, K, Q: ?Sized, V, S, A: Allocator> VacantEntryRef<'map, 'key, K,
         &'key Q: Into<K>,
         S: BuildHasher,
     {
-        let table = &mut self.table.table.raw;
-        let entry = table.insert_entry(
-            self.hash,
-            (self.key.into(), value),
-            make_hasher::<_, V, S>(&self.table.hash_builder),
-        );
-        &mut entry.1
+        &mut self.inner.insert((self.key.into(), value)).into_mut().1
     }
 
     /// Sets the key and value of the entry and returns a mutable reference to
@@ -4506,17 +4476,11 @@ impl<'map, 'key, K, Q: ?Sized, V, S, A: Allocator> VacantEntryRef<'map, 'key, K,
         Q: Equivalent<K>,
         S: BuildHasher,
     {
-        let table = &mut self.table.table.raw;
         assert!(
             (self.key).equivalent(&key),
             "key used for Entry creation is not equivalent to the one used for insertion"
         );
-        let entry = table.insert_entry(
-            self.hash,
-            (key, value),
-            make_hasher::<_, V, S>(&self.table.hash_builder),
-        );
-        &mut entry.1
+        &mut self.inner.insert((key, value)).into_mut().1
     }
 
     /// Sets the value of the entry with the [`VacantEntryRef`]'s key,
@@ -4542,15 +4506,9 @@ impl<'map, 'key, K, Q: ?Sized, V, S, A: Allocator> VacantEntryRef<'map, 'key, K,
         &'key Q: Into<K>,
         S: BuildHasher,
     {
-        let elem = self.table.table.raw.insert(
-            self.hash,
-            (self.key.into(), value),
-            make_hasher::<_, V, S>(&self.table.hash_builder),
-        );
         OccupiedEntry {
-            hash: self.hash,
-            elem,
-            table: self.table,
+            inner: self.inner.insert((self.key.into(), value)),
+            marker: PhantomData,
         }
     }
 }

src/raw/mod.rs

@@ -1096,14 +1096,6 @@ impl<T, A: Allocator> RawTable<T, A> {
         }
     }
 
-    /// Inserts a new element into the table, and returns a mutable reference to it.
-    ///
-    /// This does not check if the given element already exists in the table.
-    #[cfg_attr(feature = "inline-more", inline)]
-    pub fn insert_entry(&mut self, hash: u64, value: T, hasher: impl Fn(&T) -> u64) -> &mut T {
-        unsafe { self.insert(hash, value, hasher).as_mut() }
-    }
-
     /// Inserts a new element into the table, without growing the table.
     ///
     /// There must be enough space in the table to insert the new element.

src/raw_entry.rs

@@ -1365,11 +1365,15 @@ impl<'a, K, V, S, A: Allocator> RawVacantEntryMut<'a, K, V, S, A> {
         K: Hash,
         S: BuildHasher,
     {
-        let &mut (ref mut k, ref mut v) = self.table.insert_entry(
-            hash,
-            (key, value),
-            make_hasher::<_, V, S>(self.hash_builder),
-        );
+        let &mut (ref mut k, ref mut v) = unsafe {
+            self.table
+                .insert(
+                    hash,
+                    (key, value),
+                    make_hasher::<_, V, S>(self.hash_builder),
+                )
+                .as_mut()
+        };
         (k, v)
     }
 
@@ -1420,9 +1424,11 @@ impl<'a, K, V, S, A: Allocator> RawVacantEntryMut<'a, K, V, S, A> {
     where
         H: Fn(&K) -> u64,
     {
-        let &mut (ref mut k, ref mut v) = self
-            .table
-            .insert_entry(hash, (key, value), |x| hasher(&x.0));
+        let &mut (ref mut k, ref mut v) = unsafe {
+            self.table
+                .insert(hash, (key, value), |x| hasher(&x.0))
+                .as_mut()
+        };
         (k, v)
     }