Add a core method to support set's replace_full

This may improve performance slightly, because it will perform a hash
lookup only once, although `RawTable` does force an early reserve to
accomplish that. This is the same trade-off that `insert` makes.

This also lets us remove the saved key from `map::OccupiedEntry`, which
may benefit all other `entry` use cases where that was unused.

Author: cuviper

src/map.rs

@@ -462,7 +462,7 @@ impl<K, V, S> IndexMap<K, V, S>
 where
     S: BuildHasher,
 {
-    fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> HashValue {
+    pub(crate) fn hash<Q: ?Sized + Hash>(&self, key: &Q) -> HashValue {
         let mut h = self.hash_builder.build_hasher();
         key.hash(&mut h);
         HashValue(h.finish() as usize)

src/map/core.rs

@@ -332,6 +332,33 @@ impl<K, V> IndexMapCore<K, V> {
         }
     }
 
+    /// Same as `insert_full`, except it also replaces the key
+    pub(crate) fn replace_full(
+        &mut self,
+        hash: HashValue,
+        key: K,
+        value: V,
+    ) -> (usize, Option<(K, V)>)
+    where
+        K: Eq,
+    {
+        match self.find_or_insert(hash, &key) {
+            Ok(i) => {
+                let entry = &mut self.entries[i];
+                let kv = (
+                    mem::replace(&mut entry.key, key),
+                    mem::replace(&mut entry.value, value),
+                );
+                (i, Some(kv))
+            }
+            Err(i) => {
+                debug_assert_eq!(i, self.entries.len());
+                self.push_entry(hash, key, value);
+                (i, None)
+            }
+        }
+    }
+
     /// Remove an entry by shifting all entries that follow it
     pub(crate) fn shift_remove_full<Q>(&mut self, hash: HashValue, key: &Q) -> Option<(usize, K, V)>
     where

src/map/core/entry.rs

@@ -9,7 +9,7 @@ impl<K, V> IndexMapCore<K, V> {
         K: Eq,
     {
         match self.raw_entry(hash, |k| *k == key) {
-            Ok(raw) => Entry::Occupied(OccupiedEntry { raw, key }),
+            Ok(raw) => Entry::Occupied(OccupiedEntry { raw }),
             Err(map) => Entry::Vacant(VacantEntry { map, hash, key }),
         }
     }
@@ -124,7 +124,6 @@ impl<K: fmt::Debug, V: fmt::Debug> fmt::Debug for Entry<'_, K, V> {
 /// It is part of the [`Entry`] enum.
 pub struct OccupiedEntry<'a, K, V> {
     raw: RawTableEntry<'a, K, V>,
-    key: K,
 }
 
 impl<'a, K, V> OccupiedEntry<'a, K, V> {
@@ -162,12 +161,6 @@ impl<'a, K, V> OccupiedEntry<'a, K, V> {
         &mut self.raw.into_bucket().value
     }
 
-    /// Put the new key in the occupied entry's key slot
-    pub(crate) fn replace_key(mut self) -> K {
-        let old_key = &mut self.raw.bucket_mut().key;
-        mem::replace(old_key, self.key)
-    }
-
     /// Sets the value of the entry to `value`, and returns the entry's old value.
     pub fn insert(&mut self, value: V) -> V {
         mem::replace(self.get_mut(), value)

src/set.rs

@@ -368,15 +368,10 @@ where
     ///
     /// Computes in **O(1)** time (average).
     pub fn replace_full(&mut self, value: T) -> (usize, Option<T>) {
-        use super::map::Entry::*;
-
-        match self.map.entry(value) {
-            Vacant(e) => {
-                let index = e.index();
-                e.insert(());
-                (index, None)
-            }
-            Occupied(e) => (e.index(), Some(e.replace_key())),
+        let hash = self.map.hash(&value);
+        match self.map.core.replace_full(hash, value, ()) {
+            (i, Some((replaced, ()))) => (i, Some(replaced)),
+            (i, None) => (i, None),
         }
     }
 

src/set/tests.rs

@@ -233,6 +233,18 @@ fn replace_order() {
     }
 }
 
+#[test]
+fn replace_change() {
+    // Check pointers to make sure it really changes
+    let mut set = indexset!(vec![42]);
+    let old_ptr = set[0].as_ptr();
+    let new = set[0].clone();
+    let new_ptr = new.as_ptr();
+    assert_ne!(old_ptr, new_ptr);
+    let replaced = set.replace(new).unwrap();
+    assert_eq!(replaced.as_ptr(), old_ptr);
+}
+
 #[test]
 fn grow() {
     let insert = [0, 4, 2, 12, 8, 7, 11];