feat: JIT (WIP)

src/vm/mod.rs

@@ -1,37 +1,35 @@
 use hashbrown::{HashMap, HashSet};
-use std::cell::RefCell;
-use std::pin::Pin;
+use std::cell::{Cell, OnceCell, RefCell};
 
 use crate::builtins::env;
 use crate::bytecode::{BinOp, Func as F, OpCode, OpCodes, Program, UnOp};
 use crate::error::*;
 use crate::ty::internal::*;
+use crate::ty::common::Const;
 use crate::ty::public::{self as p, Symbol};
-
 use crate::stack::Stack;
+use crate::jit::JITContext;
 
 use derive_more::Constructor;
 use ecow::EcoString;
 pub use env::Env;
-pub use jit::JITContext;
 
 mod env;
-mod jit;
 
 #[cfg(test)]
 mod test;
 
-pub const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();
+const STACK_SIZE: usize = 8 * 1024 / size_of::<Value>();
 
-pub fn run(prog: Program, jit: Pin<Box<JITContext<'_>>>) -> Result<p::Value> {
-    let vm = VM::new(
-        prog.thunks,
-        prog.funcs,
-        RefCell::new(prog.symbols),
-        RefCell::new(prog.symmap),
-        prog.consts,
+pub fn run(prog: Program, jit: JITContext<'_>) -> Result<p::Value> {
+    let vm = VM {
+        thunks: prog.thunks,
+        funcs: prog.funcs,
+        symbols: RefCell::new(prog.symbols),
+        symmap: RefCell::new(prog.symmap),
+        consts: prog.consts,
         jit,
-    );
+    };
     let env = env(&vm);
     let mut seen = HashSet::new();
     let value = vm
@@ -47,7 +45,7 @@ pub struct VM<'jit> {
     symbols: RefCell<Vec<EcoString>>,
     symmap: RefCell<HashMap<EcoString, usize>>,
     consts: Box<[Const]>,
-    jit: Pin<Box<JITContext<'jit>>>,
+    jit: JITContext<'jit>,
 }
 
 impl<'vm, 'jit: 'vm> VM<'jit> {
@@ -137,7 +135,7 @@ impl<'vm, 'jit: 'vm> VM<'jit> {
             }
             OpCode::Func { idx } => {
                 let func = self.get_func(idx);
-                stack.push(Value::Func(Func::new(func, env.clone(), None).into()))?;
+                stack.push(Value::Func(Func::new(func, env.clone(), OnceCell::new(), Cell::new(0)).into()))?;
             }
             OpCode::UnOp { op } => {
                 use UnOp::*;