feat(env): Rc

src/vm/mod.rs

@@ -1,7 +1,6 @@
 use std::cell::RefCell;
 use std::collections::{HashMap, HashSet};
 use std::pin::Pin;
-use std::rc::Rc;
 
 use crate::builtins::env;
 use crate::bytecode::{BinOp, Func as F, OpCode, OpCodes, Program, UnOp};
@@ -80,12 +79,12 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
     pub fn eval(
         &'vm self,
         opcodes: impl Iterator<Item = OpCode>,
-        env: Rc<Env<'vm>>,
+        mut env: Env<'vm>,
     ) -> Result<Value<'vm>> {
         let mut stack = Stack::<_, STACK_SIZE>::new();
         let mut iter = opcodes.into_iter();
         while let Some(opcode) = iter.next() {
-            let jmp = self.single_op(opcode, &mut stack, &env)?;
+            let jmp = self.single_op(opcode, &mut stack, &mut env)?;
             for _ in 0..jmp {
                 iter.next().unwrap();
             }
@@ -101,7 +100,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
         &'vm self,
         opcode: OpCode,
         stack: &'s mut Stack<Value<'vm>, CAP>,
-        env: &Rc<Env<'vm>>,
+        env: &mut Env<'vm>,
     ) -> Result<usize> {
         match opcode {
             OpCode::Illegal => panic!("illegal opcode"),
@@ -187,7 +186,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                 stack.push(Value::AttrSet(AttrSet::empty().into()))?;
             }
             OpCode::FinalizeRec => {
-                env.enter(
+                let env = env.clone().enter(
                     stack
                         .tos()?
                         .clone()
@@ -196,7 +195,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                         .iter()
                         .map(|(k, v)| (k.clone(), v.clone())),
                 );
-                stack.tos_mut()?.as_mut().unwrap_attr_set().capture(env);
+                stack.tos_mut()?.as_mut().unwrap_attr_set().capture(&env);
             }
             OpCode::PushStaticAttr { name } => {
                 let val = stack.pop();
@@ -252,13 +251,11 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                 })?)?;
             }
             OpCode::EnterEnv => match stack.pop() {
-                Value::AttrSet(attrs) => env.enter_with(attrs),
+                Value::AttrSet(attrs) => *env = env.clone().enter_with(attrs),
 
                 _ => unreachable!(),
             },
-            OpCode::LeaveEnv => {
-                env.leave();
-            }
+            OpCode::LeaveEnv => *env = env.clone().leave(),
             OpCode::Assert => {
                 if !stack.pop().unwrap_const().unwrap_bool() {
                     todo!()