Fixup insertion slot separately

Author: Zoxc

src/raw/mod.rs

@@ -1601,51 +1601,50 @@ impl<A: Allocator + Clone> RawTableInner<A> {
         }
     }
 
+    /// Fixes up an insertion slot due to false positives for groups smaller than the group width.
+    #[inline]
+    unsafe fn fix_insert_slot(&self, index: usize) -> usize {
+        // In tables smaller than the group width, trailing control
+        // bytes outside the range of the table are filled with
+        // EMPTY entries. These will unfortunately trigger a
+        // match, but once masked may point to a full bucket that
+        // is already occupied. We detect this situation here and
+        // perform a second scan starting at the beginning of the
+        // table. This second scan is guaranteed to find an empty
+        // slot (due to the load factor) before hitting the trailing
+        // control bytes (containing EMPTY).
+        if unlikely(self.is_bucket_full(index)) {
+            debug_assert!(self.bucket_mask < Group::WIDTH);
+            // SAFETY:
+            //
+            // * We are in range and `ptr = self.ctrl(0)` are valid for reads
+            //   and properly aligned, because the table is already allocated
+            //   (see `TableLayout::calculate_layout_for` and `ptr::read`);
+            //
+            // * For tables larger than the group width, we will never end up in the given
+            //   branch, since `(probe_seq.pos + bit) & self.bucket_mask` cannot return a
+            //   full bucket index. For tables smaller than the group width, calling the
+            //   `lowest_set_bit_nonzero` function (when `nightly` feature enabled) is also
+            //   safe, as the trailing control bytes outside the range of the table are filled
+            //   with EMPTY bytes, so this second scan either finds an empty slot (due to the
+            //   load factor) or hits the trailing control bytes (containing EMPTY). See
+            //   `intrinsics::cttz_nonzero` for more information.
+            Group::load_aligned(self.ctrl(0))
+                .match_empty_or_deleted()
+                .lowest_set_bit_nonzero()
+        } else {
+            index
+        }
+    }
+
     /// Finds the position to insert something in a group.
+    /// This may have false positives and must be fixed up with `fix_insert_slot` before it's used.
     #[inline]
     fn find_insert_slot_in_group(&self, group: &Group, probe_seq: &ProbeSeq) -> Option<usize> {
         let bit = group.match_empty_or_deleted().lowest_set_bit();
 
         if likely(bit.is_some()) {
-            let mut index = (probe_seq.pos + bit.unwrap()) & self.bucket_mask;
-
-            // In tables smaller than the group width, trailing control
-            // bytes outside the range of the table are filled with
-            // EMPTY entries. These will unfortunately trigger a
-            // match, but once masked may point to a full bucket that
-            // is already occupied. We detect this situation here and
-            // perform a second scan starting at the beginning of the
-            // table. This second scan is guaranteed to find an empty
-            // slot (due to the load factor) before hitting the trailing
-            // control bytes (containing EMPTY).
-            //
-            // SAFETY: The `index` is guaranteed to be in range `0..self.bucket_mask`
-            // due to masking with `self.bucket_mask`
-            unsafe {
-                if unlikely(self.is_bucket_full(index)) {
-                    debug_assert!(self.bucket_mask < Group::WIDTH);
-                    debug_assert_ne!(probe_seq.pos, 0);
-                    // SAFETY:
-                    //
-                    // * We are in range and `ptr = self.ctrl(0)` are valid for reads
-                    //   and properly aligned, because the table is already allocated
-                    //   (see `TableLayout::calculate_layout_for` and `ptr::read`);
-                    //
-                    // * For tables larger than the group width, we will never end up in the given
-                    //   branch, since `(probe_seq.pos + bit) & self.bucket_mask` cannot return a
-                    //   full bucket index. For tables smaller than the group width, calling the
-                    //   `lowest_set_bit_nonzero` function (when `nightly` feature enabled) is also
-                    //   safe, as the trailing control bytes outside the range of the table are filled
-                    //   with EMPTY bytes, so this second scan either finds an empty slot (due to the
-                    //   load factor) or hits the trailing control bytes (containing EMPTY). See
-                    //   `intrinsics::cttz_nonzero` for more information.
-                    index = Group::load_aligned(self.ctrl(0))
-                        .match_empty_or_deleted()
-                        .lowest_set_bit_nonzero();
-                }
-            }
-
-            Some(index)
+            Some((probe_seq.pos + bit.unwrap()) & self.bucket_mask)
         } else {
             None
         }
@@ -1690,10 +1689,8 @@ impl<A: Allocator + Clone> RawTableInner<A> {
                 // We must have found a insert slot by now, since the current group contains at
                 // least one. For tables smaller than the group width, there will still be an
                 // empty element in the current (and only) group due to the load factor.
-                debug_assert!(insert_slot.is_some());
-                match insert_slot {
-                    Some(insert_slot) => return (insert_slot, false),
-                    None => unsafe { hint::unreachable_unchecked() },
+                unsafe {
+                    return (self.fix_insert_slot(insert_slot.unwrap_unchecked()), false);
                 }
             }
 
@@ -1756,7 +1753,7 @@ impl<A: Allocator + Clone> RawTableInner<A> {
                 let index = self.find_insert_slot_in_group(&group, &probe_seq);
 
                 if likely(index.is_some()) {
-                    return index.unwrap();
+                    return self.fix_insert_slot(index.unwrap_unchecked());
                 }
             }
             probe_seq.move_next(self.bucket_mask);