feat: gc-arena

finally...

src/ty/internal/attrset.rs

@@ -7,7 +7,6 @@ use hashbrown::{HashMap, HashSet};
 use itertools::Itertools;
 
 use crate::env::VmEnv;
-use crate::error::Result;
 use crate::vm::VM;
 
 use super::super::public as p;
@@ -85,16 +84,6 @@ impl<'jit: 'vm, 'vm, 'gc> AttrSet<'gc> {
         Self { data }
     }
 
-    pub fn force_deep(&mut self, vm: &VM, mc: &Mutation<'gc>) -> Result<()> {
-        todo!()
-        /* let mut map: Vec<_> = self.data.iter().map(|(k, v)| (*k, v.clone())).collect();
-        for (_, v) in map.iter_mut() {
-            v.force_deep(vm, mc)?;
-        }
-        self.data = map.into_iter().collect();
-        Ok(()) */
-    }
-
     pub fn eq_impl(&self, other: &AttrSet<'gc>) -> bool {
         self.data.iter().len() == other.data.iter().len()
             && std::iter::zip(

src/ty/internal/func.rs

@@ -1,7 +1,7 @@
 use std::cell::Cell;
 
 use gc_arena::lock::{GcRefLock, RefLock};
-use gc_arena::{Arena, Collect, Gc, Mutation, Rootable};
+use gc_arena::{Collect, Gc, Mutation};
 use hashbrown::HashMap;
 use itertools::Itertools;
 
@@ -11,7 +11,7 @@ use crate::error::Result;
 use crate::ir;
 use crate::jit::JITFunc;
 use crate::ty::internal::{Thunk, Value};
-use crate::vm::{GcRoot, VM, eval};
+use crate::vm::VM;
 
 #[derive(Debug, Clone, Collect)]
 #[collect(no_drop)]
@@ -44,7 +44,6 @@ impl From<ir::Param> for Param {
     }
 }
 
-#[derive(Clone)]
 pub struct Func<'gc> {
     pub func: &'gc BFunc,
     pub env: Gc<'gc, VmEnv<'gc>>,
@@ -70,15 +69,13 @@ impl<'gc> Func<'gc> {
         }
     }
 
-    pub fn call(
+    pub fn call_compile(
         &self,
         arg: Value<'gc>,
         vm: &'gc VM<'gc>,
         mc: &Mutation<'gc>,
-        arena: &Arena<impl for<'a> Rootable<'a, Root = GcRoot<'a>>>,
     ) -> Result<Value<'gc>> {
-        todo!()
-        /* use Param::*;
+        use Param::*;
 
         let mut env = self.env;
         env = match self.func.param.clone() {
@@ -117,17 +114,13 @@ impl<'gc> Func<'gc> {
             }
         };
 
-        let count = self.count.get();
-        self.count.replace(count + 1);
-        if count >= 1 {
-            let compiled = &mut *self.compiled.borrow_mut(mc);
-            let compiled = compiled.get_or_insert_with(|| vm.compile_func(self.func));
-            let ret = unsafe { compiled.call(env.as_ref() as *const VmEnv, mc as *const _) };
-            return Ok(ret.into());
-        }
-        eval(self.func.opcodes.iter().copied(), arena, |val, _| {
-            Ok(val)
-        }) */
+        let compiled = self
+            .compiled
+            .borrow_mut(mc)
+            .get_or_insert_with(|| vm.compile_func(self.func))
+            .clone();
+        let ret = unsafe { compiled.call(env.as_ref() as *const VmEnv, mc as *const _) };
+        Ok(ret.into())
     }
 }
 

src/ty/internal/list.rs

@@ -1,12 +1,11 @@
 use hashbrown::HashSet;
 
 use derive_more::Constructor;
-use gc_arena::{Arena, Collect, Rootable};
+use gc_arena::Collect;
 use rpds::Vector;
 
-use crate::error::Result;
 use crate::ty::public as p;
-use crate::vm::{GcRoot, VM};
+use crate::vm::VM;
 
 use super::Value;
 

src/ty/internal/mod.rs

@@ -604,13 +604,13 @@ impl<'gc> Thunk<'gc> {
         }
     }
 
-    pub fn suspend(&self, mc: &Mutation<'gc>) -> (&'gc OpCodes, Gc<'gc, VmEnv<'gc>>) {
+    pub fn suspend(&self, mc: &Mutation<'gc>) -> Result<(&'gc OpCodes, Gc<'gc, VmEnv<'gc>>)> {
         let _Thunk::Code(opcodes, env) =
             std::mem::replace(&mut *self.thunk.borrow_mut(mc), _Thunk::Suspended)
         else {
-            unreachable!()
+            return Err(Error::EvalError("infinite recursion occured".into()))
         };
-        (opcodes, env.unwrap())
+        Ok((opcodes, env.unwrap()))
     }
 
     pub fn insert_value(&self, value: Value<'gc>, mc: &Mutation<'gc>) {