feat: bumpalo

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