add low-level HashTable API

Author: ibraheemdev

src/map.rs

@@ -7,22 +7,14 @@ use std::collections::hash_map::RandomState;
 use std::fmt;
 use std::hash::{BuildHasher, Hash};
 use std::marker::PhantomData;
-use std::mem::ManuallyDrop;
 
 /// A concurrent hash table.
 ///
 /// Most hash table operations require a [`Guard`](crate::Guard), which can be acquired through
 /// [`HashMap::guard`] or using the [`HashMap::pin`] API. See the [crate-level documentation](crate#usage)
 /// for details.
 pub struct HashMap<K, V, S = RandomState> {
-    raw: ManuallyDrop<raw::HashMap<K, V, S>>,
-}
-
-impl<K, V, S> Drop for HashMap<K, V, S> {
-    fn drop(&mut self) {
-        // Safety: We don't access `self` after taking the inner map.
-        raw::drop_map(unsafe { ManuallyDrop::take(&mut self.raw) });
-    }
+    raw: raw::HashMap<K, V, S>,
 }
 
 // Safety: `HashMap` acts as a single-threaded collection on a single thread.
@@ -139,12 +131,7 @@ impl<K, V, S> HashMapBuilder<K, V, S> {
     /// Construct a [`HashMap`] from the builder, using the configured options.
     pub fn build(self) -> HashMap<K, V, S> {
         HashMap {
-            raw: ManuallyDrop::new(raw::HashMap::new(
-                self.capacity,
-                self.hasher,
-                self.collector,
-                self.resize_mode,
-            )),
+            raw: raw::HashMap::new(self.capacity, self.hasher, self.collector, self.resize_mode),
         }
     }
 }
@@ -311,12 +298,12 @@ impl<K, V, S> HashMap<K, V, S> {
     /// ```
     pub fn with_capacity_and_hasher(capacity: usize, hash_builder: S) -> HashMap<K, V, S> {
         HashMap {
-            raw: ManuallyDrop::new(raw::HashMap::new(
+            raw: raw::HashMap::new(
                 capacity,
                 hash_builder,
                 Collector::default(),
                 ResizeMode::default(),
-            )),
+            ),
         }
     }
 
@@ -1133,13 +1120,8 @@ impl<K, V, S> IntoIterator for HashMap<K, V, S> {
     /// let v: Vec<(&str, i32)> = map.into_iter().collect();
     /// ```
     fn into_iter(self) -> Self::IntoIter {
-        let mut map = ManuallyDrop::new(self);
-
-        // Safety: We don't access `self` after taking the inner map.
-        let raw = unsafe { ManuallyDrop::take(&mut map.raw) };
-
         IntoIter {
-            raw: raw.into_iter(),
+            raw: self.raw.into_iter(),
         }
     }
 }

src/raw/alloc.rs

@@ -3,7 +3,8 @@ use std::marker::PhantomData;
 use std::sync::atomic::{AtomicPtr, AtomicU8, Ordering};
 use std::{alloc, mem, ptr};
 
-use super::{probe, State};
+use super::probe;
+use super::table::{meta, State};
 
 // A hash-table laid out in a single allocation.
 //
@@ -88,7 +89,7 @@ impl<T> Table<T> {
             // Initialize the meta table.
             ptr.add(mem::size_of::<TableLayout<T>>())
                 .cast::<u8>()
-                .write_bytes(super::meta::EMPTY, len);
+                .write_bytes(meta::EMPTY, len);
         }
 
         Table {