feat: lots of optimization

* allocate vm stack on the stack
* use Rc instead of Arc
* optimize recursive attribute set

src/ty/internal/mod.rs

@@ -1,5 +1,5 @@
 use std::cell::RefCell;
-use std::sync::Arc;
+use std::rc::Rc;
 
 use derive_more::{IsVariant, Unwrap};
 
@@ -32,7 +32,7 @@ pub trait ToPublic {
 #[derive(Debug, Clone)]
 pub struct Thunk<'vm> {
     pub thunk: RefCell<_Thunk<'vm>>,
-    pub env: RefCell<Option<Arc<Env<'vm>>>>,
+    pub env: RefCell<Option<Rc<Env<'vm>>>>,
 }
 
 #[derive(Debug, IsVariant, Unwrap, Clone)]
@@ -54,7 +54,7 @@ impl<'vm> Thunk<'vm> {
         self.thunk.borrow().clone().unwrap_code()
     }
 
-    pub fn capture(&self, env: Arc<Env<'vm>>) {
+    pub fn capture(&self, env: Rc<Env<'vm>>) {
         *self.env.borrow_mut() = Some(env);
     }
 
@@ -137,7 +137,7 @@ pub enum ValueAsMut<'v, 'vm: 'v> {
 }
 
 impl<'v, 'vm: 'v> Value<'vm> {
-    pub fn as_ref(&'vm self) -> ValueAsRef<'v, 'vm> {
+    pub fn as_ref(&'v self) -> ValueAsRef<'v, 'vm> {
         use Value::*;
         use ValueAsRef as R;
         match self {
@@ -154,7 +154,7 @@ impl<'v, 'vm: 'v> Value<'vm> {
         }
     }
 
-    pub fn as_mut(&'vm mut self) -> ValueAsMut<'v, 'vm> {
+    pub fn as_mut(&'v mut self) -> ValueAsMut<'v, 'vm> {
         use Value::*;
         use ValueAsMut as M;
         match self {
@@ -379,13 +379,13 @@ impl<'vm> Value<'vm> {
         }
     }
 
-    pub fn select(&mut self, sym: Symbol) -> Result<&mut Self> {
+    pub fn select(&mut self, sym: &Symbol) -> Result<&mut Self> {
         let val = match self {
             Value::AttrSet(attrs) => attrs
-                .select(sym.clone())
+                .select(sym)
                 .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
             Value::RecAttrSet(attrs) => attrs
-                .select(sym.clone())
+                .select(sym)
                 .ok_or_else(|| Error::EvalError(format!("{sym:?} not found"))),
             Value::Catchable(_) => return Ok(self),
             _ => Err(Error::EvalError(format!(
@@ -397,10 +397,10 @@ impl<'vm> Value<'vm> {
         Ok(self)
     }
 
-    pub fn select_with_default(&mut self, sym: Symbol, default: Value<'vm>) -> Result<&mut Self> {
+    pub fn select_with_default(&mut self, sym: &Symbol, default: Value<'vm>) -> Result<&mut Self> {
         let val = match self {
-            Value::AttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
-            Value::RecAttrSet(attrs) => attrs.select(sym.clone()).unwrap_or(default),
+            Value::AttrSet(attrs) => attrs.select(sym).unwrap_or(default),
+            Value::RecAttrSet(attrs) => attrs.select(sym).unwrap_or(default),
             Value::Catchable(_) => return Ok(self),
             _ => {
                 return Err(Error::EvalError(format!(
@@ -413,7 +413,7 @@ impl<'vm> Value<'vm> {
         Ok(self)
     }
 
-    pub fn has_attr(&mut self, sym: Symbol) -> &mut Self {
+    pub fn has_attr(&mut self, sym: &Symbol) -> &mut Self {
         if let Value::AttrSet(attrs) = self {
             let val = VmConst(Const::Bool(attrs.has_attr(sym)));
             *self = val;
@@ -440,6 +440,9 @@ impl<'vm> Value<'vm> {
         if let Value::Thunk(thunk) = self {
             let value = thunk.force(vm)?;
             *self = value
+        } else if let Value::ThunkRef(thunk) = self {
+            let value = thunk.force(vm)?;
+            *self = value
         }
         Ok(self)
     }
@@ -451,6 +454,11 @@ impl<'vm> Value<'vm> {
                 let _ = value.force_deep(vm)?;
                 *self = value;
             }
+            Value::ThunkRef(thunk) => {
+                let mut value = thunk.force(vm)?;
+                let _ = value.force_deep(vm)?;
+                *self = value;
+            }
             Value::List(list) => list.force_deep(vm)?,
             Value::AttrSet(attrs) => attrs.force_deep(vm)?,
             Value::RecAttrSet(attrs) => attrs.force_deep(vm)?,