feat: generalize env

src/ty/internal/attrset.rs

@@ -6,12 +6,12 @@ use derive_more::Constructor;
 use itertools::Itertools;
 
 use crate::error::Result;
-use crate::vm::{LetEnv, VM};
+use crate::vm::{VmEnv, VM};
 
 use super::super::public as p;
 use super::Value;
 
-#[repr(C)]
+#[repr(transparent)]
 #[derive(Debug, Default, Constructor, Clone, PartialEq)]
 pub struct AttrSet<'jit: 'vm, 'vm> {
     data: HashMap<usize, Value<'jit, 'vm>>,
@@ -52,7 +52,7 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
         self.data.get(&sym).is_some()
     }
 
-    pub fn capture(&mut self, env: &Rc<LetEnv<'jit, 'vm>>) {
+    pub fn capture(&mut self, env: &Rc<VmEnv<'jit, 'vm>>) {
         self.data.iter().for_each(|(_, v)| if let Value::Thunk(ref thunk) = v.clone() {
             thunk.capture(env.clone());
         })
@@ -68,6 +68,10 @@ impl<'jit: 'vm, 'vm> AttrSet<'jit, 'vm> {
         &self.data
     }
 
+    pub fn into_inner(self: Rc<Self>) -> Rc<HashMap<usize, Value<'jit, 'vm>>> {
+        unsafe { std::mem::transmute(self) }
+    }
+
     pub fn from_inner(data: HashMap<usize, Value<'jit, 'vm>>) -> Self {
         Self { data }
     }

src/ty/internal/func.rs

@@ -10,8 +10,8 @@ use crate::bytecode::Func as BFunc;
 use crate::error::Result;
 use crate::ir;
 use crate::jit::JITFunc;
-use crate::ty::internal::{AttrSet, Thunk, Value};
-use crate::vm::{LetEnv, VM};
+use crate::ty::internal::{Thunk, Value};
+use crate::vm::{VmEnv, VM};
 
 #[derive(Debug, Clone)]
 pub enum Param {
@@ -46,7 +46,7 @@ impl From<ir::Param> for Param {
 #[derive(Debug, Clone, Constructor)]
 pub struct Func<'jit: 'vm, 'vm> {
     pub func: &'vm BFunc,
-    pub env: Rc<LetEnv<'jit, 'vm>>,
+    pub env: Rc<VmEnv<'jit, 'vm>>,
     pub compiled: OnceCell<JitFunction<'jit, JITFunc<'jit, 'vm>>>,
     pub count: Cell<usize>,
 }
@@ -86,7 +86,7 @@ impl<'vm, 'jit: 'vm> Func<'jit, 'vm> {
                 if let Some(alias) = alias {
                     new.insert(alias, Value::AttrSet(arg));
                 }
-                self.env.clone().enter_attrs(AttrSet::new(new).into())
+                self.env.clone().enter_attrs(new.into())
             }
         };
 

src/ty/internal/mod.rs

@@ -11,7 +11,7 @@ use super::public as p;
 
 use crate::bytecode::OpCodes;
 use crate::error::*;
-use crate::vm::{LetEnv, VM};
+use crate::vm::{VmEnv, VM};
 
 mod attrset;
 mod func;
@@ -477,7 +477,7 @@ pub struct Thunk<'jit, 'vm> {
 
 #[derive(Debug, IsVariant, Unwrap, Clone)]
 pub enum _Thunk<'jit, 'vm> {
-    Code(&'vm OpCodes, OnceCell<Rc<LetEnv<'jit, 'vm>>>),
+    Code(&'vm OpCodes, OnceCell<Rc<VmEnv<'jit, 'vm>>>),
     SuspendedFrom(*const Thunk<'jit, 'vm>),
     Value(Value<'jit, 'vm>),
 }
@@ -489,7 +489,7 @@ impl<'jit, 'vm> Thunk<'jit, 'vm> {
         }
     }
 
-    pub fn capture(&self, env: Rc<LetEnv<'jit, 'vm>>) {
+    pub fn capture(&self, env: Rc<VmEnv<'jit, 'vm>>) {
         if let _Thunk::Code(_, envcell) = &*self.thunk.borrow() {
             envcell.get_or_init(|| env);
         }