Implement ephemeron-based weak map

boa_gc/Cargo.toml

@@ -18,4 +18,5 @@ thinvec = ["thin-vec"]
 boa_profiler.workspace = true
 boa_macros.workspace = true
 
-thin-vec = { version = "0.2.12", optional = true }
+thin-vec = { version = "0.2.12", optional = true }
+hashbrown = { version = "0.14.0", features = ["raw"] }

boa_gc/src/internals/ephemeron_box.rs

@@ -125,11 +125,27 @@ impl<K: Trace + ?Sized, V: Trace> EphemeronBox<K, V> {
     }
 
     /// Returns a reference to the ephemeron's value or None.
-    pub(crate) fn value(&self) -> Option<&V> {
+    ///
+    /// # Safety
+    ///
+    /// The garbage collector must not run between the call to this function and the eventual
+    /// drop of the returned reference, since that could free the inner value.
+    pub(crate) unsafe fn value(&self) -> Option<&V> {
         // SAFETY: the garbage collector ensures `ptr` is valid as long as `data` is `Some`.
         unsafe { self.data.get().map(|ptr| &ptr.as_ref().value) }
     }
 
+    /// Returns a reference to the ephemeron's key or None.
+    ///
+    /// # Safety
+    ///
+    /// The garbage collector must not run between the call to this function and the eventual
+    /// drop of the returned reference, since that could free the inner value.
+    pub(crate) unsafe fn key(&self) -> Option<&GcBox<K>> {
+        // SAFETY: the garbage collector ensures `ptr` is valid as long as `data` is `Some`.
+        unsafe { self.data.get().map(|ptr| ptr.as_ref().key.as_ref()) }
+    }
+
     /// Marks this `EphemeronBox` as live.
     ///
     /// This doesn't mark the inner value of the ephemeron. [`ErasedEphemeronBox::trace`]

boa_gc/src/internals/weak_map_box.rs

@@ -1,9 +1,9 @@
-use crate::{GcRefCell, Trace, WeakGc};
-use std::{cell::Cell, collections::HashMap, ptr::NonNull};
+use crate::{pointers::RawWeakMap, GcRefCell, Trace, WeakGc};
+use std::{cell::Cell, ptr::NonNull};
 
 /// A box that is used to track [`WeakMap`][`crate::WeakMap`]s.
 pub(crate) struct WeakMapBox<K: Trace + Sized + 'static, V: Trace + Sized + 'static> {
-    pub(crate) map: WeakGc<GcRefCell<HashMap<WeakGc<K>, V>>>,
+    pub(crate) map: WeakGc<GcRefCell<RawWeakMap<K, V>>>,
     pub(crate) next: Cell<Option<NonNull<dyn ErasedWeakMapBox>>>,
 }
 
@@ -18,15 +18,16 @@ pub(crate) trait ErasedWeakMapBox {
     /// Returns `true` if the [`WeakMapBox`] is live.
     fn is_live(&self) -> bool;
 
-    /// Traces the weak reference inside of the [`WeakMapBox`] it the weak map is live.
+    /// Traces the weak reference inside of the [`WeakMapBox`] if the weak map is live.
     unsafe fn trace(&self);
 }
 
-impl<K: Trace, V: Trace> ErasedWeakMapBox for WeakMapBox<K, V> {
+impl<K: Trace, V: Trace + Clone> ErasedWeakMapBox for WeakMapBox<K, V> {
     fn clear_dead_entries(&self) {
         if let Some(map) = self.map.upgrade() {
-            let mut map = map.borrow_mut();
-            map.retain(|k, _| k.upgrade().is_some());
+            if let Ok(mut map) = map.try_borrow_mut() {
+                map.clear_expired()
+            }
         }
     }
 

boa_gc/src/lib.rs

@@ -78,9 +78,9 @@ pub(crate) mod internals;
 
 use boa_profiler::Profiler;
 use internals::{EphemeronBox, ErasedEphemeronBox, ErasedWeakMapBox, WeakMapBox};
+use pointers::RawWeakMap;
 use std::{
     cell::{Cell, RefCell},
-    collections::HashMap,
     mem,
     ptr::NonNull,
 };
@@ -219,11 +219,11 @@ impl Allocator {
         })
     }
 
-    fn alloc_weak_map<K: Trace, V: Trace>() -> WeakMap<K, V> {
+    fn alloc_weak_map<K: Trace, V: Trace + Clone>() -> WeakMap<K, V> {
         let _timer = Profiler::global().start_event("New WeakMap", "BoaAlloc");
 
         let weak_map = WeakMap {
-            inner: Gc::new(GcRefCell::new(HashMap::new())),
+            inner: Gc::new(GcRefCell::new(RawWeakMap::new())),
         };
         let weak = WeakGc::new(&weak_map.inner);
 

boa_gc/src/pointers/ephemeron.rs

@@ -84,7 +84,7 @@ impl<K: Trace + ?Sized, V: Trace> Ephemeron<K, V> {
         self.inner_ptr.get().as_ptr()
     }
 
-    fn inner(&self) -> &EphemeronBox<K, V> {
+    pub(crate) fn inner(&self) -> &EphemeronBox<K, V> {
         // SAFETY: Please see Gc::inner_ptr()
         unsafe { self.inner_ptr().as_ref() }
     }

boa_gc/src/pointers/mod.rs

@@ -10,3 +10,5 @@ pub use ephemeron::Ephemeron;
 pub use gc::Gc;
 pub use weak::WeakGc;
 pub use weak_map::WeakMap;
+
+pub(crate) use weak_map::RawWeakMap;