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()

src/ty/internal/func.rs

@@ -1,9 +1,11 @@
-use std::cell::{Cell, OnceCell};
+use std::cell::Cell;
 
 use derive_more::Constructor;
+use gc_arena::lock::GcRefLock;
 use hashbrown::HashMap;
 use inkwell::execution_engine::JitFunction;
 use itertools::Itertools;
+use gc_arena::{Collect, Gc, Mutation};
 
 use crate::bytecode::Func as BFunc;
 use crate::env::VmEnv;
@@ -13,7 +15,8 @@ use crate::jit::JITFunc;
 use crate::ty::internal::{Thunk, Value};
 use crate::vm::VM;
 
-#[derive(Debug, Clone)]
+#[derive(Debug, Clone, Collect)]
+#[collect(no_drop)]
 pub enum Param {
     Ident(usize),
     Formals {
@@ -43,21 +46,29 @@ impl From<ir::Param> for Param {
     }
 }
 
-#[derive(Debug, Clone, Constructor)]
-pub struct Func<'jit: 'vm, 'vm> {
-    pub func: &'vm BFunc,
-    pub env: &'vm VmEnv<'jit, 'vm>,
-    pub compiled: OnceCell<JitFunction<'jit, JITFunc<'jit, 'vm>>>,
+#[derive(Clone, Constructor)]
+pub struct Func<'gc> {
+    pub func: &'gc BFunc,
+    pub env: Gc<'gc, VmEnv<'gc>>,
+    pub compiled: GcRefLock<'gc, Option<JITFunc<'gc>>>,
     pub count: Cell<usize>,
 }
 
-impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
-    pub fn call(&self, vm: &'vm VM<'jit>, arg: Value<'jit, 'vm>) -> Result<Value<'jit, 'vm>> {
+unsafe impl<'gc> Collect for Func<'gc> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        self.env.trace(cc);
+        self.compiled.trace(cc);
+        self.count.trace(cc);
+    }
+}
+
+impl<'jit: 'vm, 'vm, 'gc> Func<'gc> {
+    pub fn call(&self, arg: Value<'gc>, vm: &VM, mc: &Mutation<'gc>) -> Result<Value<'gc>> {
         use Param::*;
 
         let mut env = self.env;
         env = match self.func.param.clone() {
-            Ident(ident) => env.enter_arg(ident, arg, &vm.bump),
+            Ident(ident) => env.enter_arg(ident, arg, mc),
             Formals {
                 formals,
                 ellipsis,
@@ -65,7 +76,7 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
             } => {
                 let arg = arg.unwrap_attr_set();
                 let mut new =
-                    HashMap::with_capacity_in(formals.len() + alias.iter().len(), &vm.bump);
+                    HashMap::with_capacity(formals.len() + alias.iter().len());
                 if !ellipsis
                     && arg
                         .as_inner()
@@ -80,7 +91,7 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
                     let arg = arg
                         .select(formal)
                         .or_else(|| {
-                            default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx)).into()))
+                            default.map(|idx| Value::Thunk(Thunk::new(vm.get_thunk(idx), mc).into()))
                         })
                         .unwrap();
                     new.insert(formal, arg);
@@ -88,23 +99,22 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
                 if let Some(alias) = alias {
                     new.insert(alias, Value::AttrSet(arg));
                 }
-                env.enter_let(vm.bump.alloc(new), &vm.bump)
+                env.enter_let(Gc::new(mc, new.into()), mc)
             }
         };
 
         let count = self.count.get();
         self.count.replace(count + 1);
         if count >= 1 {
-            let compiled = self.compiled.get_or_init(|| vm.compile_func(self.func));
-            let env = env as *const _;
-            let ret = unsafe { compiled.call(vm as *const VM, env) };
+            let compiled = self.compiled.borrow_mut(mc).get_or_insert_with(|| vm.compile_func(self.func));
+            let ret = unsafe { compiled.call(vm as *const VM, env.as_ref() as *const VmEnv) };
             return Ok(ret.into());
         }
-        vm.eval(self.func.opcodes.iter().copied(), vm.bump.alloc(env))
+        vm.eval(self.func.opcodes.iter().copied(), env)
     }
 }
 
-impl PartialEq for Func<'_, '_> {
+impl PartialEq for Func<'_, '_, '_> {
     fn eq(&self, _: &Self) -> bool {
         false
     }

src/ty/internal/list.rs

@@ -2,6 +2,7 @@ use hashbrown::HashSet;
 
 use derive_more::Constructor;
 use rpds::Vector;
+use gc_arena::{Collect, Mutation};
 
 use crate::error::Result;
 use crate::ty::public as p;
@@ -9,38 +10,46 @@ use crate::vm::VM;
 
 use super::Value;
 
-#[derive(Debug, Constructor, Clone, PartialEq)]
-pub struct List<'jit: 'vm, 'vm> {
-    data: Vector<Value<'jit, 'vm>>,
+#[derive(Constructor, Clone, PartialEq)]
+pub struct List<'gc> {
+    data: Vector<Value<'gc>>
 }
 
-impl<'jit: 'vm, 'vm> List<'jit, 'vm> {
+unsafe impl Collect for List<'_> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        for v in self.data.iter() {
+            v.trace(cc);
+        }
+    }
+}
+
+impl<'gc> List<'gc> {
     pub fn empty() -> Self {
         List {
             data: Vector::new(),
         }
     }
 
-    pub fn push(&mut self, elem: Value<'jit, 'vm>) {
+    pub fn push(&mut self, elem: Value<'gc>) {
         self.data.push_back_mut(elem);
     }
 
-    pub fn concat(&mut self, other: &List<'jit, 'vm>) {
+    pub fn concat(&mut self, other: &List<'gc>) {
         for elem in other.data.iter() {
             self.data.push_back_mut(elem.clone());
         }
     }
 
-    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 vec: Vec<_> = self.data.iter().cloned().collect();
         for v in vec.iter_mut() {
-            v.force_deep(vm)?;
+            v.force_deep(vm, mc)?;
         }
         self.data = vec.into_iter().collect();
         Ok(())
     }
 
-    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::List(p::List::new(
             self.data
                 .iter()

src/ty/internal/mod.rs

@@ -1,10 +1,13 @@
-use hashbrown::HashSet;
-use std::cell::OnceCell;
-use std::cell::RefCell;
+use std::cell::Cell;
 use std::hash::Hash;
-use std::rc::{Rc, Weak};
+use std::mem::MaybeUninit;
+use std::ops::Deref;
 
 use derive_more::{IsVariant, Unwrap};
+use gc_arena::Mutation;
+use gc_arena::lock::RefLock;
+use gc_arena::{Collect, Gc, lock::GcRefLock};
+use hashbrown::HashSet;
 
 use super::common::*;
 use super::public as p;
@@ -25,38 +28,125 @@ pub use func::*;
 pub use list::List;
 pub use primop::*;
 
-#[derive(Debug, IsVariant, Unwrap, Clone)]
-pub enum Value<'jit: 'vm, 'vm> {
-    Const(Const),
-    Thunk(Rc<Thunk<'jit, 'vm>>),
-    AttrSet(Rc<AttrSet<'jit, 'vm>>),
-    List(Rc<List<'jit, 'vm>>),
-    Catchable(Catchable),
-    PrimOp(Rc<PrimOp<'jit, 'vm>>),
-    PartialPrimOp(Rc<PartialPrimOp<'jit, 'vm>>),
-    Func(Rc<Func<'jit, 'vm>>),
-    Builtins(Weak<AttrSet<'jit, 'vm>>),
+#[derive(Collect)]
+#[collect(unsafe_drop)]
+pub struct CoW<'gc, T: Clone + Collect> {
+    inner: Gc<'gc, CoWInner<T>>,
 }
 
-impl Hash for Value<'_, '_> {
+struct CoWInner<T: Clone + Collect> {
+    ref_count: Cell<usize>,
+    data: MaybeUninit<T>,
+}
+
+unsafe impl<T: Clone + Collect> Collect for CoWInner<T> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        unsafe { self.data.assume_init_ref() }.trace(cc);
+    }
+}
+
+impl<'gc, T: Clone + Collect> CoW<'gc, T> {
+    pub fn new(data: T, mc: &Mutation<'gc>) -> Self {
+        Self {
+            inner: Gc::new(mc, CoWInner::new(data)),
+        }
+    }
+
+    pub fn new_cyclic(datafn: impl FnOnce(Self) -> T, mc: &Mutation<'gc>) -> Self {
+        let inner = Gc::new(
+            mc,
+            CoWInner {
+                ref_count: Cell::new(1),
+                data: MaybeUninit::uninit(),
+            },
+        );
+        let data = datafn(CoW { inner });
+        unsafe { std::mem::transmute::<_, &mut MaybeUninit<_>>(&inner.data) }.write(data);
+        Self { inner }
+    }
+
+    pub fn make_mut(&mut self, mc: &Mutation<'gc>) -> &mut T {
+        if self.inner.ref_count.get() == 1 {
+            unsafe { std::mem::transmute(self.inner.data.assume_init_ref()) }
+        } else {
+            unsafe {
+                *self = CoW::new(self.inner.data.assume_init_ref().clone(), mc);
+                std::mem::transmute(self.inner.data.assume_init_ref())
+            }
+        }
+    }
+
+    pub fn as_ptr(&self) -> *const T {
+        self.as_ref() as *const T
+    }
+}
+
+impl<'gc, T: Clone + Collect> AsRef<T> for CoW<'gc, T> {
+    fn as_ref(&self) -> &T {
+        unsafe { self.inner.data.assume_init_ref() }
+    }
+}
+
+impl<'gc, T: Clone + Collect> Deref for CoW<'gc, T> {
+    type Target = T;
+    fn deref(&self) -> &Self::Target {
+        self.as_ref()
+    }
+}
+
+impl<'gc, T: Clone + Collect> Clone for CoW<'gc, T> {
+    fn clone(&self) -> Self {
+        self.inner.ref_count.set(self.inner.ref_count.get() + 1);
+        Self { inner: self.inner }
+    }
+}
+
+impl<'gc, T: Clone + Collect> Drop for CoW<'gc, T> {
+    fn drop(&mut self) {
+        self.inner.ref_count.set(self.inner.ref_count.get() - 1);
+    }
+}
+
+impl<T: Clone + Collect> CoWInner<T> {
+    fn new(data: T) -> Self {
+        Self {
+            ref_count: Cell::new(1),
+            data: MaybeUninit::new(data),
+        }
+    }
+}
+
+#[derive(IsVariant, Unwrap, Clone, Collect)]
+#[collect(no_drop)]
+pub enum Value<'gc> {
+    Const(Const),
+    Thunk(Thunk<'gc>),
+    AttrSet(CoW<'gc, AttrSet<'gc>>),
+    List(CoW<'gc, List<'gc>>),
+    Catchable(Catchable),
+    PrimOp(Gc<'gc, PrimOp<'gc>>),
+    PartialPrimOp(CoW<'gc, PartialPrimOp<'gc>>),
+    Func(Gc<'gc, Func<'gc>>),
+}
+
+impl Hash for Value<'_> {
     fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
         use Value::*;
         std::mem::discriminant(self).hash(state);
         match self {
             Const(x) => x.hash(state),
-            Thunk(x) => (x.as_ref() as *const self::Thunk).hash(state),
-            AttrSet(x) => (x.as_ref() as *const self::AttrSet).hash(state),
-            List(x) => (x.as_ref() as *const self::List).hash(state),
+            Thunk(x) => (x as *const self::Thunk).hash(state),
+            AttrSet(x) => x.as_ptr().hash(state),
+            List(x) => x.as_ptr().hash(state),
             Catchable(x) => x.hash(state),
             PrimOp(x) => (x.as_ref() as *const self::PrimOp).hash(state),
             PartialPrimOp(x) => (x.as_ref() as *const self::PartialPrimOp).hash(state),
             Func(x) => (x.as_ref() as *const self::Func).hash(state),
-            Builtins(x) => (x.as_ptr()).hash(state),
         }
     }
 }
 
-impl<'jit: 'vm, 'vm> Value<'jit, 'vm> {
+impl<'gc> Value<'gc> {
     fn eq_impl(&self, other: &Self) -> bool {
         use Value::*;
         match (self, other) {
@@ -68,49 +158,46 @@ impl<'jit: 'vm, 'vm> Value<'jit, 'vm> {
     }
 }
 
-impl<'jit: 'vm, 'vm> PartialEq for Value<'jit, 'vm> {
+impl<'jit: 'vm, 'vm, 'gc> PartialEq for Value<'gc> {
     fn eq(&self, other: &Self) -> bool {
         use Value::*;
         match (self, other) {
             (Const(a), Const(b)) => a.eq(b),
-            (AttrSet(a), AttrSet(b)) => {
-                (a.as_ref() as *const self::AttrSet).eq(&(b.as_ref() as *const _))
-            }
-            (List(a), List(b)) => (a.as_ref() as *const self::List).eq(&(b.as_ref() as *const _)),
-            (Builtins(a), Builtins(b)) => a.ptr_eq(b),
+            (AttrSet(a), AttrSet(b)) => a.as_ptr().eq(&b.as_ptr()),
+            (List(a), List(b)) => a.as_ptr().eq(&b.as_ptr()),
             _ => false,
         }
     }
 }
 
-impl Eq for Value<'_, '_> {}
+impl Eq for Value<'_> {}
 
-#[derive(Debug, IsVariant, Unwrap, Clone, PartialEq)]
-pub enum ValueAsRef<'v, 'vm: 'v, 'jit: 'vm> {
+#[derive(IsVariant, Unwrap, Clone)]
+pub enum ValueAsRef<'v, 'gc> {
     Const(&'v Const),
-    Thunk(&'v Thunk<'jit, 'vm>),
-    AttrSet(&'v AttrSet<'jit, 'vm>),
-    List(&'v List<'jit, 'vm>),
+    Thunk(&'v Thunk<'gc>),
+    AttrSet(&'v AttrSet<'gc>),
+    List(&'v List<'gc>),
     Catchable(&'v Catchable),
-    PrimOp(&'v PrimOp<'jit, 'vm>),
-    PartialPrimOp(&'v PartialPrimOp<'jit, 'vm>),
-    Func(&'v Func<'jit, 'vm>),
+    PrimOp(&'v PrimOp<'gc>),
+    PartialPrimOp(&'v PartialPrimOp<'gc>),
+    Func(&'v Func<'gc>),
 }
 
-#[derive(Debug, IsVariant, Unwrap, PartialEq)]
-pub enum ValueAsMut<'v, 'vm: 'v, 'jit: 'vm> {
+#[derive(IsVariant, Unwrap)]
+pub enum ValueAsMut<'v, 'gc> {
     Const(&'v mut Const),
-    Thunk(&'v Thunk<'jit, 'vm>),
-    AttrSet(&'v mut AttrSet<'jit, 'vm>),
-    List(&'v mut List<'jit, 'vm>),
+    Thunk(&'v Thunk<'gc>),
+    AttrSet(&'v mut AttrSet<'gc>),
+    List(&'v mut List<'gc>),
     Catchable(&'v mut Catchable),
-    PrimOp(&'v mut PrimOp<'jit, 'vm>),
-    PartialPrimOp(&'v mut PartialPrimOp<'jit, 'vm>),
-    Func(&'v Func<'jit, 'vm>),
+    PrimOp(&'v PrimOp<'gc>),
+    PartialPrimOp(&'v mut PartialPrimOp<'gc>),
+    Func(&'v Func<'gc>),
 }
 
-impl<'v, 'vm: 'v, 'jit: 'vm> Value<'jit, 'vm> {
-    pub fn as_ref(&'v self) -> ValueAsRef<'v, 'vm, 'jit> {
+impl<'gc, 'v> Value<'gc> {
+    pub fn as_ref(&'v self) -> ValueAsRef<'v, 'gc> {
         use Value::*;
         use ValueAsRef as R;
         match self {
@@ -122,29 +209,27 @@ impl<'v, 'vm: 'v, 'jit: 'vm> Value<'jit, 'vm> {
             PrimOp(x) => R::PrimOp(x),
             PartialPrimOp(x) => R::PartialPrimOp(x),
             Func(x) => R::Func(x),
-            Builtins(_) => unreachable!(),
         }
     }
 
-    pub fn as_mut(&'v mut self) -> ValueAsMut<'v, 'vm, 'jit> {
+    pub fn as_mut(&'v mut self, mc: &Mutation<'gc>) -> ValueAsMut<'v, 'gc> {
         use Value::*;
         use ValueAsMut as M;
         match self {
             Const(x) => M::Const(x),
             Thunk(x) => M::Thunk(x),
-            AttrSet(x) => M::AttrSet(Rc::make_mut(x)),
-            List(x) => M::List(Rc::make_mut(x)),
+            AttrSet(x) => M::AttrSet(x.make_mut(mc)),
+            List(x) => M::List(x.make_mut(mc)),
             Catchable(x) => M::Catchable(x),
-            PrimOp(x) => M::PrimOp(Rc::make_mut(x)),
-            PartialPrimOp(x) => M::PartialPrimOp(Rc::make_mut(x)),
+            PrimOp(x) => M::PrimOp(x),
+            PartialPrimOp(x) => M::PartialPrimOp(x.make_mut(mc)),
             Func(x) => M::Func(x),
-            Builtins(_) => unreachable!(),
         }
     }
 }
 
 use Value::Const as VmConst;
-impl<'jit, 'vm> Value<'jit, 'vm> {
+impl<'gc> Value<'gc> {
     pub fn ok(self) -> Result<Self> {
         Ok(self)
     }
@@ -164,7 +249,6 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
             PrimOp(_) => "lambda",
             PartialPrimOp(_) => "lambda",
             Func(_) => "lambda",
-            Builtins(_) => "set",
         }
     }
 
@@ -176,16 +260,16 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
         }
     }
 
-    pub fn call(&mut self, vm: &'vm VM<'jit>, arg: Self) -> Result<()> {
+    pub fn call(&mut self, arg: Self, vm: &VM, mc: &Mutation<'gc>) -> Result<()> {
         use Value::*;
         if matches!(arg, Value::Catchable(_)) {
             *self = arg;
             return Ok(());
         }
         *self = match self {
-            PrimOp(func) => func.call(vm, arg),
-            PartialPrimOp(func) => func.call(vm, arg),
-            Value::Func(func) => func.call(vm, arg),
+            PrimOp(func) => func.call(arg, vm, mc),
+            PartialPrimOp(func) => func.call(arg, vm, mc),
+            Value::Func(func) => func.call(arg, vm, mc),
             Catchable(_) => return Ok(()),
             _ => todo!(),
         }?;
@@ -316,9 +400,9 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
         self
     }
 
-    pub fn push(&mut self, elem: Self) -> &mut Self {
+    pub fn push(&mut self, elem: Self, mc: &Mutation<'gc>) -> &mut Self {
         if let Value::List(list) = self {
-            Rc::make_mut(list).push(elem);
+            list.make_mut(mc).push(elem);
         } else if let Value::Catchable(_) = self {
         } else if let Value::Catchable(_) = elem {
             *self = elem;
@@ -328,23 +412,23 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
         self
     }
 
-    pub fn concat(&mut self, other: Self) {
+    pub fn concat(&mut self, other: Self, mc: &Mutation<'gc>) {
         if let x @ Value::Catchable(_) = other {
             *self = x;
             return;
         }
         match (self, other) {
             (Value::List(a), Value::List(b)) => {
-                Rc::make_mut(a).concat(b.as_ref());
+                a.make_mut(mc).concat(b.as_ref());
             }
             (Value::Catchable(_), _) => (),
             _ => todo!(),
         }
     }
 
-    pub fn push_attr(&mut self, sym: usize, val: Self) -> &mut Self {
+    pub fn push_attr(&mut self, sym: usize, val: Self, mc: &Mutation<'gc>) -> &mut Self {
         if let Value::AttrSet(attrs) = self {
-            Rc::make_mut(attrs).push_attr(sym, val)
+            attrs.make_mut(mc).push_attr(sym, val);
         } else if let Value::Catchable(_) = self {
         } else if let Value::Catchable(_) = val {
             *self = val
@@ -354,21 +438,21 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
         self
     }
 
-    pub fn update(&mut self, other: Self) {
+    pub fn update(&mut self, other: Self, mc: &Mutation<'gc>) {
         if let x @ Value::Catchable(_) = other {
             *self = x;
             return;
         }
         match (self, other) {
             (Value::AttrSet(a), Value::AttrSet(b)) => {
-                Rc::make_mut(a).update(b.as_ref());
+                a.make_mut(mc).update(b.as_ref());
             }
             (Value::Catchable(_), _) => (),
             _ => todo!(),
         }
     }
 
-    pub fn select(&mut self, sym: usize, vm: &'vm VM<'jit>) -> Result<&mut Self> {
+    pub fn select(&mut self, sym: usize, vm: &VM<'gc>) -> Result<&mut Self> {
         let val = match self {
             Value::AttrSet(attrs) => attrs
                 .select(sym)
@@ -418,106 +502,127 @@ impl<'jit, 'vm> Value<'jit, 'vm> {
         self
     }
 
-    pub fn force(&mut self, vm: &'vm VM<'jit>) -> Result<&mut Self> {
+    pub fn force(&mut self, vm: &VM<'gc>, mc: &Mutation<'gc>) -> Result<&mut Self> {
         if let Value::Thunk(thunk) = self {
-            let value = thunk.force(vm)?.clone();
+            let value = thunk.force(vm, mc)?.clone();
             *self = value
         }
         Ok(self)
     }
 
-    pub fn force_deep(&mut self, vm: &'vm VM<'jit>) -> Result<&mut Self> {
+    pub fn force_deep(&mut self, vm: &VM<'gc>, mc: &Mutation<'gc>) -> Result<&mut Self> {
         match self {
             Value::Thunk(thunk) => {
-                let mut value = thunk.force(vm)?.clone();
-                let _ = value.force_deep(vm)?;
+                let mut value = thunk.force(vm, mc)?.clone();
+                let _ = value.force_deep(vm, mc)?;
                 *self = value;
             }
-            Value::List(list) => Rc::make_mut(list).force_deep(vm)?,
-            Value::AttrSet(attrs) => Rc::make_mut(attrs).force_deep(vm)?,
+            Value::List(list) => list.make_mut(mc).force_deep(vm, mc)?,
+            Value::AttrSet(attrs) => attrs.make_mut(mc).force_deep(vm, mc)?,
             _ => (),
         }
         Ok(self)
     }
 
-    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 {
         use self::Value::*;
         use p::Value;
         if seen.contains(self) {
             return Value::Repeated;
         }
-        seen.insert(self.clone());
         match self {
-            AttrSet(attrs) => attrs.to_public(vm, seen),
-            List(list) => list.to_public(vm, seen),
+            AttrSet(attrs) => {
+                seen.insert(self.clone());
+                attrs.to_public(vm, seen)
+            }
+            List(list) => {
+                seen.insert(self.clone());
+                list.to_public(vm, seen)
+            }
             Catchable(catchable) => Value::Catchable(catchable.clone()),
             Const(cnst) => Value::Const(cnst.clone()),
             Thunk(_) => Value::Thunk,
             PrimOp(primop) => Value::PrimOp(primop.name),
             PartialPrimOp(primop) => Value::PartialPrimOp(primop.name),
             Func(_) => Value::Func,
-            Builtins(x) => x.upgrade().unwrap().to_public(vm, seen),
         }
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct Thunk<'jit, 'vm> {
-    pub thunk: RefCell<_Thunk<'jit, 'vm>>,
+#[repr(transparent)]
+#[derive(Clone, Collect)]
+#[collect(no_drop)]
+pub struct Thunk<'gc> {
+    pub thunk: GcRefLock<'gc, _Thunk<'gc>>,
 }
 
-#[derive(Debug, IsVariant, Unwrap, Clone)]
-pub enum _Thunk<'jit, 'vm> {
-    Code(&'vm OpCodes, OnceCell<&'vm VmEnv<'jit, 'vm>>),
-    SuspendedFrom(*const Thunk<'jit, 'vm>),
-    Value(Value<'jit, 'vm>),
+#[derive(IsVariant, Unwrap)]
+pub enum _Thunk<'gc> {
+    Code(
+        &'gc OpCodes,
+        GcRefLock<'gc, Option<Gc<'gc, VmEnv<'gc>>>>,
+    ),
+    Suspended,
+    Value(Value<'gc>),
 }
 
-impl<'jit, 'vm> Thunk<'jit, 'vm> {
-    pub fn new(opcodes: &'vm OpCodes) -> Self {
+unsafe impl<'gc> Collect for _Thunk<'gc> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        use _Thunk::*;
+        match self {
+            Code(_, env) => env.trace(cc),
+            Value(val) => val.trace(cc),
+            _ => (),
+        }
+    }
+}
+
+impl<'gc> Thunk<'gc> {
+    pub fn new(opcodes: &'gc OpCodes, mc: &Mutation<'gc>) -> Self {
         Thunk {
-            thunk: RefCell::new(_Thunk::Code(opcodes, OnceCell::new())),
+            thunk: Gc::new(
+                mc,
+                RefLock::new(_Thunk::Code(opcodes, Gc::new(mc, RefLock::new(None)))),
+            ),
         }
     }
 
-    pub fn capture(&self, env: &'vm VmEnv<'jit, 'vm>) {
+    pub fn capture(&self, env: Gc<'gc, VmEnv<'gc>>, mc: &Mutation<'gc>) {
         if let _Thunk::Code(_, envcell) = &*self.thunk.borrow() {
-            envcell.get_or_init(|| env);
+            envcell.borrow_mut(mc).insert(env);
         }
     }
 
-    pub fn force(&self, vm: &'vm VM<'jit>) -> Result<&Value<'jit, 'vm>> {
+    pub fn force(&self, vm: &VM<'gc>, mc: &Mutation<'gc>) -> Result<Value<'gc>> {
         use _Thunk::*;
         match &*self.thunk.borrow() {
             Value(_) => {
                 return Ok(match unsafe { &*(&*self.thunk.borrow() as *const _) } {
-                    Value(value) => value,
+                    Value(value) => value.clone(),
                     _ => unreachable!(),
                 });
             }
-            SuspendedFrom(from) => {
-                return Err(Error::EvalError(format!(
-                    "thunk {:p} already suspended from {from:p} (infinite recursion encountered)",
-                    self as *const Thunk
-                )));
+            Suspended => {
+                return Err(Error::EvalError("infinite recursion encountered".into()));
             }
             Code(..) => (),
         }
-        let (opcodes, env) = std::mem::replace(
-            &mut *self.thunk.borrow_mut(),
-            _Thunk::SuspendedFrom(self as *const Thunk),
-        )
-        .unwrap_code();
-        let env = env.get().unwrap();
+        let (opcodes, env) =
+            std::mem::replace(&mut *self.thunk.borrow_mut(mc), _Thunk::Suspended).unwrap_code();
+        let env = env.as_ref().borrow().unwrap();
         let value = vm.eval(opcodes.iter().copied(), env)?;
-        let _ = std::mem::replace(&mut *self.thunk.borrow_mut(), _Thunk::Value(value));
+        let _ = std::mem::replace(&mut *self.thunk.borrow_mut(mc), _Thunk::Value(value));
         Ok(match unsafe { &*(&*self.thunk.borrow() as *const _) } {
-            Value(value) => value,
+            Value(value) => value.clone(),
             _ => unreachable!(),
         })
     }
 
-    pub fn value(&'vm self) -> Option<Value<'jit, 'vm>> {
+    pub fn value(&self) -> Option<Value<'gc>> {
         match &*self.thunk.borrow() {
             _Thunk::Value(value) => Some(value.clone()),
             _ => None,
@@ -525,7 +630,7 @@ impl<'jit, 'vm> Thunk<'jit, 'vm> {
     }
 }
 
-impl PartialEq for Thunk<'_, '_> {
+impl PartialEq for Thunk<'_> {
     fn eq(&self, _: &Self) -> bool {
         false
     }

src/ty/internal/primop.rs

@@ -1,74 +1,84 @@
-use std::rc::Rc;
-
 use derive_more::Constructor;
+use gc_arena::Mutation;
+use gc_arena::Collect;
 
 use crate::error::Result;
 use crate::vm::VM;
 
 use super::Value;
+use super::CoW;
 
-#[derive(Debug, Clone, Constructor)]
-pub struct PrimOp<'jit: 'vm, 'vm> {
+#[derive(Debug, Clone, Constructor, Collect)]
+#[collect(require_static)]
+pub struct PrimOp<'gc> {
     pub name: &'static str,
     arity: usize,
-    func: fn(&'vm VM<'jit>, Vec<Value<'jit, 'vm>>) -> Result<Value<'jit, 'vm>>,
+    func: fn(Vec<Value<'gc>>, &VM, &Mutation<'gc>) -> Result<Value<'gc>>,
 }
 
-impl PartialEq for PrimOp<'_, '_> {
+impl PartialEq for PrimOp<'_> {
     fn eq(&self, _: &Self) -> bool {
         false
     }
 }
 
-impl<'jit, 'vm> PrimOp<'jit, 'vm> {
-    pub fn call(&self, vm: &'vm VM<'jit>, arg: Value<'jit, 'vm>) -> Result<Value<'jit, 'vm>> {
+impl<'gc> PrimOp<'gc> {
+    pub fn call(&self, arg: Value<'gc>, vm: &VM, mc: &Mutation<'gc>) -> Result<Value<'gc>> {
         let mut args = Vec::with_capacity(self.arity);
         args.push(arg);
         if self.arity > 1 {
             Value::PartialPrimOp(
-                PartialPrimOp {
+                CoW::new(PartialPrimOp {
                     name: self.name,
                     arity: self.arity - 1,
                     args,
                     func: self.func,
-                }
-                .into(),
+                }, mc)
             )
             .ok()
         } else {
-            (self.func)(vm, args)
+            (self.func)(args, vm, mc)
         }
     }
 }
 
-#[derive(Debug, Clone)]
-pub struct PartialPrimOp<'jit: 'vm, 'vm> {
+#[derive(Clone)]
+pub struct PartialPrimOp<'gc> {
     pub name: &'static str,
     arity: usize,
-    args: Vec<Value<'jit, 'vm>>,
-    func: fn(&'vm VM<'jit>, Vec<Value<'jit, 'vm>>) -> Result<Value<'jit, 'vm>>,
+    args: Vec<Value<'gc>>,
+    func: fn(Vec<Value<'gc>>, &VM, &Mutation<'gc>) -> Result<Value<'gc>>,
 }
 
-impl PartialEq for PartialPrimOp<'_, '_> {
+unsafe impl<'jit: 'vm, 'vm, 'gc> Collect for PartialPrimOp<'gc> {
+    fn trace(&self, cc: &gc_arena::Collection) {
+        for v in self.args.iter() {
+            v.trace(cc);
+        }
+    }
+}
+
+impl PartialEq for PartialPrimOp<'_> {
     fn eq(&self, _: &Self) -> bool {
         false
     }
 }
 
-impl<'jit: 'vm, 'vm> PartialPrimOp<'jit, 'vm> {
+impl<'gc> PartialPrimOp<'gc> {
     pub fn call(
-        self: &mut Rc<Self>,
-        vm: &'vm VM<'jit>,
-        arg: Value<'jit, 'vm>,
-    ) -> Result<Value<'jit, 'vm>> {
-        let self_mut = Rc::make_mut(self);
+        self: &mut CoW<'gc, Self>,
+        arg: Value<'gc>,
+        vm: &VM,
+        mc: &Mutation<'gc>
+    ) -> Result<Value<'gc>> {
+        let func = self.func;
+        let self_mut = self.make_mut(mc);
         self_mut.args.push(arg);
         self_mut.arity -= 1;
         if self_mut.arity > 0 {
             Value::PartialPrimOp(self.clone()).ok()
         } else {
-            let args = std::mem::take(&mut self_mut.args);
-            (self.func)(vm, args)
+            func(std::mem::take(&mut self_mut.args), vm, mc)
         }
     }
 }