Migrate off of RawTable APIs

Summary:
The `RawTable` APIs are removed in latest `hashbrown` upgrade (coming in D68793000). rust-lang/hashbrown#546

The PR notes that users should migrate to the `HashTable` APIs instead.

- `HashTable`: https://docs.rs/hashbrown/latest/hashbrown/struct.HashTable.html
- `RawTable`: https://docs.rs/hashbrown/0.14.5/hashbrown/raw/struct.RawTable.html

Reviewed By: dtolnay

Differential Revision: D69195912

fbshipit-source-id: b5c4d0cc33a977d9ceb247ffedcf49d7be0b01ec

Author: capickett

allocative/allocative/src/impls/hashbrown.rs

@@ -11,7 +11,6 @@
 
 use std::mem;
 
-use hashbrown::raw::RawTable;
 use hashbrown::HashTable;
 
 use crate::Allocative;
@@ -20,28 +19,6 @@ use crate::Visitor;
 
 const CAPACITY_NAME: Key = Key::new("capacity");
 
-impl<T: Allocative> Allocative for RawTable<T> {
-    fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
-        use crate::impls::common::DATA_NAME;
-        use crate::impls::hashbrown_util;
-
-        let mut visitor = visitor.enter_self_sized::<Self>();
-        {
-            let mut visitor = visitor.enter_unique(DATA_NAME, mem::size_of::<*const T>());
-            {
-                let mut visitor = visitor.enter(
-                    CAPACITY_NAME,
-                    hashbrown_util::raw_table_alloc_size_for_len::<T>(self.capacity()),
-                );
-                unsafe { visitor.visit_iter(self.iter().map(|e| e.as_ref())) };
-                visitor.exit();
-            }
-            visitor.exit();
-        }
-        visitor.exit();
-    }
-}
-
 impl<T: Allocative> Allocative for HashTable<T> {
     fn visit<'a, 'b: 'a>(&self, visitor: &'a mut Visitor<'b>) {
         use crate::impls::common::DATA_NAME;
@@ -70,7 +47,6 @@ mod tests {
     use std::hash::Hash;
     use std::hash::Hasher;
 
-    use hashbrown::raw::RawTable;
     use hashbrown::HashTable;
 
     use crate::golden::golden_test;
@@ -81,16 +57,6 @@ mod tests {
         hasher.finish()
     }
 
-    #[test]
-    fn test_raw_table() {
-        let mut table = RawTable::with_capacity(100);
-        for i in 0..100 {
-            table.insert(hash(&i.to_string()), i.to_string(), hash);
-        }
-
-        golden_test!(&table);
-    }
-
     #[test]
     fn test_hash_table() {
         let mut table = HashTable::with_capacity(100);

app/buck2_interpreter_for_build/src/attrs/coerce/arc_str_interner.rs

@@ -11,18 +11,18 @@ use std::cell::RefCell;
 
 use buck2_util::arc_str::ArcStr;
 use dupe::Dupe;
-use hashbrown::raw::RawTable;
+use hashbrown::HashTable;
 
 use crate::attrs::coerce::str_hash::str_hash;
 
 pub(crate) struct ArcStrInterner {
-    cache: RefCell<RawTable<(u64, ArcStr)>>,
+    cache: RefCell<HashTable<(u64, ArcStr)>>,
 }
 
 impl ArcStrInterner {
     pub(crate) fn new() -> ArcStrInterner {
         ArcStrInterner {
-            cache: RefCell::new(RawTable::new()),
+            cache: RefCell::new(HashTable::new()),
         }
     }
 
@@ -34,12 +34,12 @@ impl ArcStrInterner {
         let hash = str_hash(s);
         let mut cache = self.cache.borrow_mut();
 
-        if let Some((_h, v)) = cache.get(hash, |(_h, v)| s == v.as_str()) {
+        if let Some((_h, v)) = cache.find(hash, |(_h, v)| s == v.as_str()) {
             return v.dupe();
         }
 
         let value = ArcStr::from(s);
-        cache.insert(hash, (hash, value.dupe()), |(h, _v)| *h);
+        cache.insert_unique(hash, (hash, value.dupe()), |(h, _v)| *h);
         value
     }
 }

app/buck2_interpreter_for_build/src/attrs/coerce/interner.rs

@@ -18,24 +18,21 @@ use buck2_util::arc_str::ArcSlice;
 use buck2_util::arc_str::ArcStr;
 use buck2_util::hash::BuckHasher;
 use dupe::Dupe;
-use hashbrown::raw::RawTable;
+use hashbrown::HashTable;
 
 /// An interner specific to our AttrCoercionContext used for interning different kinds of attributes.
 /// Things specific about this interner:
 /// - Requires interned values to be Dupe, so that you can intern both Arc<...> and specific Arc types like ArcStr.
 /// - Interner is not static, so it's not required to take up memory for the entire duration of the program.
 pub(crate) struct AttrCoercionInterner<T: Dupe + Hash + Eq, H = BuckHasher> {
-    /// We use `RawTable` where because `HashMap` API
-    /// requires either computing hash twice (for get, then for insert) or
-    /// allocating a key to perform a query using `entry` API.
-    cache: RefCell<RawTable<(u64, T)>>,
+    cache: RefCell<HashTable<(u64, T)>>,
     _marker: marker::PhantomData<H>,
 }
 
 impl<T: Dupe + Hash + Eq, H: Hasher + Default> AttrCoercionInterner<T, H> {
     pub(crate) fn new() -> Self {
         Self {
-            cache: RefCell::new(RawTable::new()),
+            cache: RefCell::new(HashTable::new()),
             _marker: marker::PhantomData,
         }
     }
@@ -49,12 +46,12 @@ impl<T: Dupe + Hash + Eq, H: Hasher + Default> AttrCoercionInterner<T, H> {
         let hash = compute_hash(&internable, H::default());
         let mut cache = self.cache.borrow_mut();
 
-        if let Some((_h, v)) = cache.get(hash, |(_h, v)| internable.equivalent(v)) {
+        if let Some((_h, v)) = cache.find(hash, |(_h, v)| internable.equivalent(v)) {
             return v.dupe();
         }
 
         let value: T = internable.into();
-        cache.insert(hash, (hash, value.dupe()), |(h, _v)| *h);
+        cache.insert_unique(hash, (hash, value.dupe()), |(h, _v)| *h);
         value
     }
 }

app/buck2_interpreter_for_build/src/interpreter/buckconfig.rs

@@ -17,7 +17,7 @@ use buck2_common::legacy_configs::dice::OpaqueLegacyBuckConfigOnDice;
 use buck2_common::legacy_configs::key::BuckconfigKeyRef;
 use buck2_core::soft_error;
 use dice::DiceComputations;
-use hashbrown::raw::RawTable;
+use hashbrown::HashTable;
 use starlark::collections::Hashed;
 use starlark::environment::Module;
 use starlark::values::FrozenStringValue;
@@ -46,8 +46,8 @@ struct BuckConfigsInner<'a> {
     /// Hash map by `(section, key)` pair, so we do one table lookup per request.
     /// So we hash the `key` even if the section does not exist,
     /// but this is practically not an issue, because keys usually come with cached hash.
-    current_cell_cache: RawTable<BuckConfigEntry>,
-    root_cell_cache: RawTable<BuckConfigEntry>,
+    current_cell_cache: HashTable<BuckConfigEntry>,
+    root_cell_cache: HashTable<BuckConfigEntry>,
 }
 
 /// Version of cell buckconfig optimized for fast query from `read_config` Starlark function.
@@ -89,8 +89,8 @@ impl<'a> LegacyBuckConfigsForStarlark<'a> {
             module,
             inner: RefCell::new(BuckConfigsInner {
                 configs_view,
-                current_cell_cache: RawTable::new(),
-                root_cell_cache: RawTable::new(),
+                current_cell_cache: HashTable::new(),
+                root_cell_cache: HashTable::new(),
             }),
         }
     }
@@ -115,7 +115,7 @@ impl<'a> LegacyBuckConfigsForStarlark<'a> {
         } else {
             current_cell_cache
         };
-        if let Some(e) = cache.get(hash, |e| {
+        if let Some(e) = cache.find(hash, |e| {
             e.section.key() == section.key() && e.key.as_str() == *key.key()
         }) {
             return Ok(e.value);
@@ -134,7 +134,7 @@ impl<'a> LegacyBuckConfigsForStarlark<'a> {
         }
         .map(|v| self.module.frozen_heap().alloc_str(&v));
 
-        cache.insert(
+        cache.insert_unique(
             hash,
             BuckConfigEntry {
                 section: Hashed::new_unchecked(section.hash(), (*section.key()).to_owned()),

starlark-rust/starlark/src/values/trace.rs

@@ -35,7 +35,6 @@ use std::sync::Arc;
 use std::sync::Mutex;
 
 use either::Either;
-use hashbrown::raw::RawTable;
 use hashbrown::HashTable;
 use starlark_map::small_set::SmallSet;
 use starlark_map::Hashed;
@@ -81,14 +80,6 @@ unsafe impl<'v, T: Trace<'v>> Trace<'v> for [T] {
     }
 }
 
-unsafe impl<'v, T: Trace<'v>> Trace<'v> for RawTable<T> {
-    fn trace(&mut self, tracer: &Tracer<'v>) {
-        unsafe {
-            self.iter().for_each(|e| e.as_mut().trace(tracer));
-        }
-    }
-}
-
 unsafe impl<'v, T: Trace<'v>> Trace<'v> for HashTable<T> {
     fn trace(&mut self, tracer: &Tracer<'v>) {
         self.iter_mut().for_each(|e| e.trace(tracer));

starlark-rust/starlark/src/values/types/string/intern/interner.rs

@@ -17,7 +17,7 @@
 
 //! Generic interner for starlark strings.
 
-use hashbrown::raw::RawTable;
+use hashbrown::HashTable;
 
 use crate as starlark;
 use crate::collections::Hashed;
@@ -28,7 +28,7 @@ use crate::values::Trace;
 /// `[FrozenStringValue]` interner.
 #[derive(Default)]
 pub(crate) struct FrozenStringValueInterner {
-    map: RawTable<FrozenStringValue>,
+    map: HashTable<FrozenStringValue>,
 }
 
 impl FrozenStringValueInterner {
@@ -39,14 +39,15 @@ impl FrozenStringValueInterner {
     ) -> FrozenStringValue {
         match self
             .map
-            .get(s.hash().promote(), |x| s == x.get_hashed_str())
+            .find(s.hash().promote(), |x| s == x.get_hashed_str())
         {
             Some(frozen_string) => *frozen_string,
             None => {
                 let frozen_string = alloc();
-                self.map.insert(s.hash().promote(), frozen_string, |x| {
-                    x.get_hash().promote()
-                });
+                self.map
+                    .insert_unique(s.hash().promote(), frozen_string, |x| {
+                        x.get_hash().promote()
+                    });
                 frozen_string
             }
         }
@@ -55,7 +56,7 @@ impl FrozenStringValueInterner {
 
 #[derive(Default, Trace)]
 pub(crate) struct StringValueInterner<'v> {
-    map: RawTable<StringValue<'v>>,
+    map: HashTable<StringValue<'v>>,
 }
 
 impl<'v> StringValueInterner<'v> {
@@ -66,13 +67,13 @@ impl<'v> StringValueInterner<'v> {
     ) -> StringValue<'v> {
         match self
             .map
-            .get(s.hash().promote(), |x| s == x.get_hashed_str())
+            .find(s.hash().promote(), |x| s == x.get_hashed_str())
         {
             Some(string_value) => *string_value,
             None => {
                 let string_value = alloc();
                 self.map
-                    .insert(s.hash().promote(), string_value, |x| x.get_hash().promote());
+                    .insert_unique(s.hash().promote(), string_value, |x| x.get_hash().promote());
                 string_value
             }
         }