feat(env): Rc

src/vm/env.rs

@@ -1,28 +1,13 @@
-use std::cell::RefCell;
 use std::rc::Rc;
 
 use rpds::HashTrieMap;
 
 use crate::ty::internal::{AttrSet, Value};
 
-#[derive(Debug, Default)]
+#[derive(Debug, Default, Clone)]
 pub struct Env<'vm> {
-    last: RefCell<Option<Rc<Env<'vm>>>>,
-    map: RefCell<HashTrieMap<usize, Value<'vm>>>,
-}
-
-impl Clone for Env<'_> {
-    fn clone(&self) -> Self {
-        Env {
-            last: RefCell::new(
-                self.last
-                    .borrow()
-                    .clone()
-                    .map(|e| Rc::new(e.as_ref().clone())),
-            ),
-            map: RefCell::new(self.map.borrow().clone()),
-        }
-    }
+    last: Option<Rc<Env<'vm>>>,
+    map: HashTrieMap<usize, Value<'vm>>,
 }
 
 impl<'vm> Env<'vm> {
@@ -31,28 +16,30 @@ impl<'vm> Env<'vm> {
     }
 
     pub fn lookup(&self, symbol: usize) -> Option<Value<'vm>> {
-        self.map.borrow().get(&symbol).cloned()
+        self.map.get(&symbol).cloned()
     }
 
-    pub fn insert(&self, symbol: usize, value: Value<'vm>) {
-        self.map.borrow_mut().insert_mut(symbol, value);
+    pub fn insert(&mut self, symbol: usize, value: Value<'vm>) {
+        self.map.insert_mut(symbol, value);
     }
 
-    pub fn enter(&self, new: impl Iterator<Item = (usize, Value<'vm>)>) {
-        let mut map = self.map.borrow().clone();
+    pub fn enter(self, new: impl Iterator<Item = (usize, Value<'vm>)>) -> Self {
+        let mut map = self.map.clone();
         for (k, v) in new {
             map.insert_mut(k, v);
         }
-        let last = Env {
-            last: self.last.clone(),
-            map: self.map.clone(),
-        };
-        *self.last.borrow_mut() = Some(Rc::new(last));
-        *self.map.borrow_mut() = map;
+        let last = Some(
+            Env {
+                last: self.last,
+                map: self.map,
+            }
+            .into(),
+        );
+        Env { last, map }
     }
 
-    pub fn enter_with(&self, new: Rc<AttrSet<'vm>>) {
-        let mut map = self.map.borrow().clone();
+    pub fn enter_with(self, new: Rc<AttrSet<'vm>>) -> Self {
+        let mut map = self.map.clone();
         for (k, v) in new.as_inner().iter() {
             let v = if let Value::Builtins = v {
                 Value::AttrSet(new.clone())
@@ -61,18 +48,17 @@ impl<'vm> Env<'vm> {
             };
             map.insert_mut(k.clone(), v);
         }
-        let last = Env {
-            last: self.last.clone(),
-            map: self.map.clone(),
-        };
-        *self.last.borrow_mut() = Some(Rc::new(last));
-        *self.map.borrow_mut() = map;
+        let last = Some(
+            Env {
+                last: self.last.clone(),
+                map: self.map.clone(),
+            }
+            .into(),
+        );
+        Env { last, map }
     }
 
-    pub fn leave(&self) {
-        let last = (*self.last.borrow_mut()).take().unwrap();
-        let _ = std::mem::replace(&mut *self.last.borrow_mut(), last.last.borrow().clone());
-        let map = last.map.borrow().clone();
-        *self.map.borrow_mut() = map;
+    pub fn leave(self) -> Self {
+        self.last.unwrap().as_ref().clone()
     }
 }

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