feat: bumpalo

src/ty/internal/attrset.rs

@@ -52,10 +52,10 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
         self.data.get(&sym).is_some()
     }
 
-    pub fn capture(&mut self, env: &Rc<VmEnv<'jit, 'vm>>) {
+    pub fn capture(&mut self, env: &'vm VmEnv<'jit, 'vm>) {
         self.data.iter().for_each(|(_, v)| {
             if let Value::Thunk(ref thunk) = v.clone() {
-                thunk.capture(Rc::clone(env));
+                thunk.capture(env);
             }
         })
     }

src/ty/internal/func.rs

@@ -1,5 +1,4 @@
 use std::cell::{Cell, OnceCell};
-use std::rc::Rc;
 
 use derive_more::Constructor;
 use hashbrown::HashMap;
@@ -46,7 +45,7 @@ impl From<ir::Param> for Param {
 #[derive(Debug, Clone, Constructor)]
 pub struct Func<'jit: 'vm, 'vm> {
     pub func: &'vm BFunc,
-    pub env: Rc<VmEnv<'jit, 'vm>>,
+    pub env: &'vm VmEnv<'jit, 'vm>,
     pub compiled: OnceCell<JitFunction<'jit, JITFunc<'jit, 'vm>>>,
     pub count: Cell<usize>,
 }
@@ -55,16 +54,16 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
     pub fn call(&self, vm: &'vm VM<'jit>, arg: Value<'jit, 'vm>) -> Result<Value<'jit, 'vm>> {
         use Param::*;
 
-        let mut env = self.env.clone();
-        match self.func.param.clone() {
-            Ident(ident) => env.enter_arg(ident, arg),
+        let mut env = self.env;
+        env = match self.func.param.clone() {
+            Ident(ident) => env.enter_arg(ident, arg, &vm.bump),
             Formals {
                 formals,
                 ellipsis,
                 alias,
             } => {
                 let arg = arg.unwrap_attr_set();
-                let mut new = HashMap::with_capacity(formals.len() + alias.iter().len());
+                let mut new = HashMap::with_capacity_in(formals.len() + alias.iter().len(), &vm.bump);
                 if !ellipsis
                     && arg
                         .as_inner()
@@ -87,7 +86,7 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
                 if let Some(alias) = alias {
                     new.insert(alias, Value::AttrSet(arg));
                 }
-                env.enter_let(new.into())
+                env.enter_let(vm.bump.alloc(new), &vm.bump)
             }
         };
 
@@ -95,14 +94,11 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
         self.count.replace(count + 1);
         if count >= 1 {
             let compiled = self.compiled.get_or_init(|| vm.compile_func(self.func));
-            let env = Rc::into_raw(env);
+            let env = env as *const _;
             let ret = unsafe { compiled.call(vm as *const VM, env) };
-            unsafe {
-                Rc::decrement_strong_count(env);
-            }
             return Ok(ret.into());
         }
-        vm.eval(self.func.opcodes.iter().copied(), env)
+        vm.eval(self.func.opcodes.iter().copied(), vm.bump.alloc(env))
     }
 }
 

src/ty/internal/mod.rs

@@ -467,17 +467,11 @@ pub struct Thunk<'jit, 'vm> {
 
 #[derive(Debug, IsVariant, Unwrap, Clone)]
 pub enum _Thunk<'jit, 'vm> {
-    Code(&'vm OpCodes, OnceCell<EnvRef<'jit, 'vm>>),
+    Code(&'vm OpCodes, OnceCell<&'vm VmEnv<'jit, 'vm>>),
     SuspendedFrom(*const Thunk<'jit, 'vm>),
     Value(Value<'jit, 'vm>),
 }
 
-#[derive(Debug, IsVariant, Unwrap, Clone)]
-pub enum EnvRef<'jit, 'vm> {
-    Strong(Rc<VmEnv<'jit, 'vm>>),
-    Weak(Weak<VmEnv<'jit, 'vm>>),
-}
-
 impl<'jit, 'vm> Thunk<'jit, 'vm> {
     pub fn new(opcodes: &'vm OpCodes) -> Self {
         Thunk {
@@ -485,15 +479,9 @@ impl<'jit, 'vm> Thunk<'jit, 'vm> {
         }
     }
 
-    pub fn capture(&self, env: Rc<VmEnv<'jit, 'vm>>) {
+    pub fn capture(&self, env: &'vm VmEnv<'jit, 'vm>) {
         if let _Thunk::Code(_, envcell) = &*self.thunk.borrow() {
-            envcell.get_or_init(|| EnvRef::Strong(env));
-        }
-    }
-
-    pub fn capture_weak(&self, env: Weak<VmEnv<'jit, 'vm>>) {
-        if let _Thunk::Code(_, envcell) = &*self.thunk.borrow() {
-            envcell.get_or_init(|| EnvRef::Weak(env));
+            envcell.get_or_init(|| env);
         }
     }
 
@@ -519,10 +507,7 @@ impl<'jit, 'vm> Thunk<'jit, 'vm> {
             _Thunk::SuspendedFrom(self as *const Thunk),
         )
         .unwrap_code();
-        let env = match env.get().unwrap() {
-            EnvRef::Strong(env) => env.clone(),
-            EnvRef::Weak(env) => env.upgrade().unwrap(),
-        };
+        let env = env.get().unwrap();
         let value = vm.eval(opcodes.iter().copied(), env)?;
         let _ = std::mem::replace(&mut *self.thunk.borrow_mut(), _Thunk::Value(value));
         Ok(match unsafe { &*(&*self.thunk.borrow() as *const _) } {