feat(jit): fib!

src/vm/env.rs

@@ -4,14 +4,20 @@ use std::rc::Rc;
 use crate::ty::internal::{AttrSet, Value};
 
 #[derive(Debug, Default, Clone)]
-pub struct Env<'jit, 'vm> {
-    pub map: Rc<HashMap<usize, Value<'jit, 'vm>>>,
-    pub last: Option<Rc<Env<'jit, 'vm>>>,
+pub struct LetEnv<'jit, 'vm> {
+    map: Rc<HashMap<usize, Value<'jit, 'vm>>>,
+    last: Option<Rc<LetEnv<'jit, 'vm>>>,
 }
 
-impl<'jit, 'vm> Env<'jit, 'vm> {
-    pub fn empty() -> Self {
-        Env::default()
+#[derive(Debug, Default, Clone)]
+pub struct WithEnv<'jit, 'vm> {
+    map: Rc<AttrSet<'jit, 'vm>>,
+    last: Option<Rc<WithEnv<'jit, 'vm>>>,
+}
+
+impl<'jit, 'vm> LetEnv<'jit, 'vm> {
+    pub fn new(map: Rc<HashMap<usize, Value<'jit, 'vm>>>) -> Self {
+        Self { map, last: None }
     }
 
     pub fn lookup(&self, symbol: usize) -> Option<Value<'jit, 'vm>> {
@@ -21,46 +27,63 @@ impl<'jit, 'vm> Env<'jit, 'vm> {
         self.last.as_ref().map(|env| env.lookup(symbol)).flatten()
     }
 
-    pub fn insert(&mut self, symbol: usize, value: Value<'jit, 'vm>) {
-        Rc::make_mut(&mut self.map).insert(symbol, value);
-    }
-
-    pub fn enter(self, new: impl Iterator<Item = (usize, Value<'jit, 'vm>)>) -> Self {
+    pub fn enter_let(self, new: impl Iterator<Item = (usize, Value<'jit, 'vm>)>) -> Self {
         let map = Rc::new(new.collect());
-        let last = Some(
-            Env {
-                last: self.last,
-                map: self.map,
-            }
-            .into(),
-        );
-        Env { last, map }
+        let last = Some(self.into());
+        LetEnv { last, map }
     }
 
     pub fn enter_with(self, new: Rc<AttrSet<'jit, 'vm>>) -> Self {
-        let map = Rc::new(
-            new.as_inner()
-                .iter()
-                .map(|(&k, v)| {
-                    (
-                        k,
-                        if let Value::Builtins(weak) = v {
-                            Value::AttrSet(weak.upgrade().unwrap())
-                        } else {
-                            v.clone()
-                        },
-                    )
-                })
-                .collect(),
-        );
-        let last = Some(
-            Env {
-                last: self.last.clone(),
-                map: self.map.clone(),
-            }
-            .into(),
-        );
-        Env { last, map }
+        let map = new
+            .as_inner()
+            .iter()
+            .map(|(&k, v)| {
+                (
+                    k,
+                    if let Value::Builtins(weak) = v {
+                        Value::AttrSet(weak.upgrade().unwrap())
+                    } else {
+                        v.clone()
+                    },
+                )
+            })
+            .collect::<HashMap<_, _>>()
+            .into();
+        let last = Some(self.into());
+        LetEnv { last, map }
+    }
+
+    pub fn leave(self) -> Self {
+        self.last.unwrap().as_ref().clone()
+    }
+}
+
+impl<'jit, 'vm> WithEnv<'jit, 'vm> {
+    pub fn lookup(&self, symbol: usize) -> Option<Value<'jit, 'vm>> {
+        if let Some(val) = self.map.select(symbol) {
+            return Some(val);
+        }
+        self.last.as_ref().map(|env| env.lookup(symbol)).flatten()
+    }
+
+    pub fn enter_with(self, new: Rc<AttrSet<'jit, 'vm>>) -> Self {
+        let map = Rc::new(new
+            .as_inner()
+            .iter()
+            .map(|(&k, v)| {
+                (
+                    k,
+                    if let Value::Builtins(weak) = v {
+                        Value::AttrSet(weak.upgrade().unwrap())
+                    } else {
+                        v.clone()
+                    },
+                )
+            })
+            .collect::<HashMap<_, _>>()
+            .into());
+        let last = Some(self.into());
+        WithEnv { last, map }
     }
 
     pub fn leave(self) -> Self {

src/vm/mod.rs

@@ -13,7 +13,7 @@ use crate::ty::public::{self as p, Symbol};
 
 use derive_more::Constructor;
 use ecow::EcoString;
-pub use env::Env;
+pub use env::LetEnv;
 
 mod env;
 
@@ -82,7 +82,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
     pub fn eval(
         &'vm self,
         opcodes: impl Iterator<Item = OpCode>,
-        mut env: Env<'jit, 'vm>,
+        mut env: LetEnv<'jit, 'vm>,
     ) -> Result<Value<'jit, 'vm>> {
         let mut stack = Stack::<_, STACK_SIZE>::new();
         let mut iter = opcodes.into_iter();
@@ -103,7 +103,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
         &'vm self,
         opcode: OpCode,
         stack: &'s mut Stack<Value<'jit, 'vm>, CAP>,
-        env: &mut Env<'jit, 'vm>,
+        env: &mut LetEnv<'jit, 'vm>,
     ) -> Result<usize> {
         match opcode {
             OpCode::Illegal => panic!("illegal opcode"),
@@ -121,11 +121,6 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                 stack.tos_mut()?.force(self)?;
             }
             OpCode::Jmp { step } => return Ok(step),
-            OpCode::JmpIfTrue { step } => {
-                if let Value::Const(Const::Bool(true)) = stack.pop() {
-                    return Ok(step);
-                }
-            }
             OpCode::JmpIfFalse { step } => {
                 if let Value::Const(Const::Bool(false)) = stack.pop() {
                     return Ok(step);
@@ -193,7 +188,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
                 stack.push(Value::AttrSet(AttrSet::with_capacity(cap).into()))?;
             }
             OpCode::FinalizeRec => {
-                let env = env.clone().enter(
+                let env = env.clone().enter_let(
                     stack
                         .tos()?
                         .clone()