feat: gc-arena (WIP, does not compile)

src/ty/internal/attrset.rs

@@ -1,9 +1,9 @@
 use std::rc::Rc;
 
 use hashbrown::{HashMap, HashSet};
-
 use derive_more::Constructor;
 use itertools::Itertools;
+use gc_arena::{Collect, Gc, Mutation};
 
 use crate::env::VmEnv;
 use crate::error::Result;
@@ -13,82 +13,87 @@ use super::super::public as p;
 use super::Value;
 
 #[repr(transparent)]
-#[derive(Debug, Default, Constructor, Clone, PartialEq)]
-pub struct AttrSet<'jit: 'vm, 'vm> {
-    data: HashMap<usize, Value<'jit, 'vm>>,
+#[derive(Constructor, Clone, PartialEq)]
+pub struct AttrSet<'gc> {
+    data: HashMap<usize, Value<'gc>>,
 }
 
-impl<'jit, 'vm> From<HashMap<usize, Value<'jit, 'vm>>> for AttrSet<'jit, 'vm> {
-    fn from(data: HashMap<usize, Value<'jit, 'vm>>) -> Self {
+unsafe impl<'jit: 'vm, 'vm, 'gc> Collect for AttrSet<'gc> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        for (_, v) in self.data.iter() {
+            v.trace(cc);
+        }
+    }
+}
+
+impl<'gc> From<HashMap<usize, Value<'gc>>> for AttrSet<'gc> {
+    fn from(data: HashMap<usize, Value<'gc>>) -> Self {
         Self { data }
     }
 }
 
-impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
+impl<'jit: 'vm, 'vm, 'gc> AttrSet<'gc> {
     pub fn with_capacity(cap: usize) -> Self {
         AttrSet {
             data: HashMap::with_capacity(cap),
         }
     }
 
-    pub fn push_attr_force(&mut self, sym: usize, val: Value<'jit, 'vm>) {
+    pub fn push_attr_force(&mut self, sym: usize, val: Value<'gc>) {
         self.data.insert(sym, val);
     }
 
-    pub fn push_attr(&mut self, sym: usize, val: Value<'jit, 'vm>) {
+    pub fn push_attr(&mut self, sym: usize, val: Value<'gc>) {
         if self.data.get(&sym).is_some() {
             todo!()
         }
         self.data.insert(sym, val);
     }
 
-    pub fn select(&self, sym: usize) -> Option<Value<'jit, 'vm>> {
-        self.data.get(&sym).map(|val| match val {
-            Value::Builtins(x) => Value::AttrSet(x.upgrade().unwrap()),
-            val => val.clone(),
-        })
+    pub fn select(&self, sym: usize) -> Option<Value<'gc>> {
+        self.data.get(&sym).cloned()
     }
 
     pub fn has_attr(&self, sym: usize) -> bool {
         self.data.get(&sym).is_some()
     }
 
-    pub fn capture(&mut self, env: &'vm VmEnv<'jit, 'vm>) {
+    pub fn capture(&mut self, env: Gc<'gc, VmEnv<'gc>>, mc: &Mutation<'gc>) {
         self.data.iter().for_each(|(_, v)| {
             if let Value::Thunk(ref thunk) = v.clone() {
-                thunk.capture(env);
+                thunk.capture(env, mc);
             }
         })
     }
 
-    pub fn update(&mut self, other: &AttrSet<'jit, 'vm>) {
+    pub fn update(&mut self, other: &AttrSet<'gc>) {
         for (k, v) in other.data.iter() {
             self.push_attr_force(*k, v.clone())
         }
     }
 
-    pub fn as_inner(&self) -> &HashMap<usize, Value<'jit, 'vm>> {
+    pub fn as_inner(&self) -> &HashMap<usize, Value<'gc>> {
         &self.data
     }
 
-    pub fn into_inner(self: Rc<Self>) -> Rc<HashMap<usize, Value<'jit, 'vm>>> {
+    pub fn into_inner(self: Rc<Self>) -> Rc<HashMap<usize, Value<'gc>>> {
         unsafe { std::mem::transmute(self) }
     }
 
-    pub fn from_inner(data: HashMap<usize, Value<'jit, 'vm>>) -> Self {
+    pub fn from_inner(data: HashMap<usize, Value<'gc>>) -> Self {
         Self { data }
     }
 
-    pub fn force_deep(&mut self, vm: &'vm VM<'jit>) -> Result<()> {
+    pub fn force_deep(&mut self, vm: &VM, mc: &Mutation<'gc>) -> Result<()> {
         let mut map: Vec<_> = self.data.iter().map(|(k, v)| (*k, v.clone())).collect();
         for (_, v) in map.iter_mut() {
-            v.force_deep(vm)?;
+            v.force_deep(vm, mc)?;
         }
         self.data = map.into_iter().collect();
         Ok(())
     }
 
-    pub fn eq_impl(&self, other: &AttrSet<'jit, 'vm>) -> bool {
+    pub fn eq_impl(&self, other: &AttrSet<'gc>) -> bool {
         self.data.iter().len() == other.data.iter().len()
             && std::iter::zip(
                 self.data.iter().sorted_by_key(|(k, _)| **k),
@@ -97,7 +102,7 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
             .all(|((_, v1), (_, v2))| v1.eq_impl(v2))
     }
 
-    pub fn to_public(&self, vm: &'vm VM, seen: &mut HashSet<Value<'jit, 'vm>>) -> p::Value {
+        pub fn to_public(&self, vm: &VM<'gc>, seen: &mut HashSet<Value<'gc>>) -> p::Value {
         p::Value::AttrSet(p::AttrSet::new(
             self.data
                 .iter()