imxyy1soope1/nixjit
1
0
Fork 0
Code Issues Pull Requests Actions Projects 1 Releases Activity

feat: at least it compiles, right?

Browse Source
This commit is contained in:
imxyy_soope_
2025-06-12 20:12:31 +08:00
parent 7293cb9f75
commit 49255948ff
22 changed files with 383 additions and 251 deletions
Download Patch File Download Diff File Expand all files Collapse all files

133
src/eval/mod.rs
View File

@@ -7,26 +7,34 @@ use crate::env::VmEnv;
use crate::error::{Error, Result};
use crate::ir::{self, DynamicAttrPair};
use crate::ty::common::Const;
use crate::ty::internal::{AttrSet, List, Thunk, ThunkRef, Value};
use crate::ty::internal::{AttrSet, EnvRef, List, ThunkRef, Value};
use crate::ty::public::Symbol;
pub mod jit;
pub trait Evaluate {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value>;
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value>;
}
impl Evaluate for ir::Attrs {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let mut attrs = AttrSet::new(
self.stcs
.into_iter()
.map(|(k, v)| Ok((k, v.eval(engine, env)?)))
.map(|(k, v)| {
Ok((k, {
let mut val = v.eval(engine, env)?;
if let Value::Thunk(thunk) = &mut val {
thunk.capture(EnvRef::Strong(env.clone()));
}
val
}))
})
.collect::<Result<_>>()?,
);
for DynamicAttrPair(k, v) in self.dyns {
let mut k = k.eval(engine, env)?;
k.coerce_to_string();
k.force(engine)?.coerce_to_string();
attrs.push_attr(k.unwrap_string(), v.eval(engine, env)?);
}
Value::AttrSet(attrs.into()).ok()
@@ -34,11 +42,17 @@ impl Evaluate for ir::Attrs {
}
impl Evaluate for ir::List {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
Value::List(List::from(
self.items
.into_iter()
.map(|val| val.eval(engine, env))
.map(|val| {
let mut val = val.eval(engine, env)?;
if let Value::Thunk(thunk) = &mut val {
thunk.capture(EnvRef::Strong(env.clone()));
}
val.ok()
})
.collect::<Result<EcoVec<_>>>()?,
))
.ok()
@@ -46,7 +60,7 @@ impl Evaluate for ir::List {
}
impl Evaluate for ir::HasAttr {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
use ir::Attr::*;
let mut val = self.lhs.eval(engine, env)?;
val.has_attr(self.rhs.into_iter().map(|attr| {
@@ -55,7 +69,7 @@ impl Evaluate for ir::HasAttr {
Strs(expr) => expr.eval(engine, env)?.unwrap_string(),
Dynamic(expr) => {
let mut val = expr.eval(engine, env)?;
val.coerce_to_string();
val.force(engine)?.coerce_to_string();
val.unwrap_string()
}
})
@@ -65,10 +79,12 @@ impl Evaluate for ir::HasAttr {
}
impl Evaluate for ir::BinOp {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
use ir::BinOpKind::*;
let mut lhs = self.lhs.eval(engine, env)?;
let mut rhs = self.rhs.eval(engine, env)?;
lhs.force(engine)?;
rhs.force(engine)?;
match self.kind {
Add => lhs.add(rhs),
Sub => {
@@ -115,9 +131,10 @@ impl Evaluate for ir::BinOp {
}
impl Evaluate for ir::UnOp {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
use ir::UnOpKind::*;
let mut rhs = self.rhs.eval(engine, env)?;
rhs.force(engine)?;
match self.kind {
Neg => rhs.neg(),
Not => rhs.not(),
@@ -127,43 +144,45 @@ impl Evaluate for ir::UnOp {
}
impl Evaluate for ir::Select {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
use ir::Attr::*;
let mut val = self.expr.eval(engine, env)?;
if let Some(default) = self.default {
val.select_with_default(
let default = default.eval(engine, env)?;
val.force(engine)?.select_with_default(
self.attrpath.into_iter().map(|attr| {
Ok(match attr {
Str(ident) => ident,
Strs(expr) => expr.eval(engine, env)?.unwrap_string(),
Dynamic(expr) => {
let mut val = expr.eval(engine, env)?;
val.coerce_to_string();
val.force(engine)?.coerce_to_string();
val.unwrap_string()
}
})
}),
default.eval(engine, env)?,
default,
)?;
} else {
val.select(self.attrpath.into_iter().map(|attr| {
Ok(match attr {
Str(ident) => ident,
Strs(expr) => expr.eval(engine, env)?.unwrap_string(),
Dynamic(expr) => {
let mut val = expr.eval(engine, env)?;
val.coerce_to_string();
val.unwrap_string()
}
})
}))?;
val.force(engine)?
.select(self.attrpath.into_iter().map(|attr| {
Ok(match attr {
Str(ident) => ident,
Strs(expr) => expr.eval(engine, env)?.unwrap_string(),
Dynamic(expr) => {
let mut val = expr.eval(engine, env)?;
val.force(engine)?.coerce_to_string();
val.unwrap_string()
}
})
}))?;
}
val.ok()
}
}
impl Evaluate for ir::If {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
// TODO: Error Handling
let cond = self.cond.eval(engine, env)?.unwrap_bool();
if cond {
@@ -175,14 +194,19 @@ impl Evaluate for ir::If {
}
impl Evaluate for ir::LoadFunc {
fn eval(self, _: &Engine, _: &VmEnv) -> Result<Value> {
Value::Func(Rc::new(ThunkRef::new(self.idx).into())).ok()
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
Value::Func(ThunkRef {
idx: engine.func_offset + self.idx,
env: Some(EnvRef::Strong(env.clone())).into(),
})
.ok()
}
}
impl Evaluate for ir::Call {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let mut func = self.func.eval(engine, env)?;
func.force(engine)?;
// FIXME: Modify Value::call
for arg in self.args {
func.call(arg.eval(engine, env)?, engine)?;
@@ -192,34 +216,44 @@ impl Evaluate for ir::Call {
}
impl Evaluate for ir::Let {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
let bindings = self.bindings.into_iter().map(|(_, v)| Ok(v.eval(engine, env)?)).collect::<Result<Vec<_>>>()?;
self.expr.eval(engine, &env.enter_let(bindings))
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let bindings = self
.bindings
.into_iter()
.map(|(_, v)| v.eval(engine, env))
.collect::<Result<Vec<_>>>()?;
env.enter_let(bindings);
let val = self.expr.eval(engine, env)?;
env.pop_let();
Ok(val)
}
}
impl Evaluate for ir::With {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let namespace = self.namespace.eval(engine, env)?;
// TODO: Error Handling
self.expr.eval(engine, &env.enter_with(namespace.unwrap_attr_set().into_inner()))
self.expr.eval(
engine,
&mut env.enter_with(namespace.unwrap_attr_set().into_inner()),
)
}
}
impl Evaluate for ir::Assert {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
todo!()
}
}
impl Evaluate for ir::ConcatStrings {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let mut parts = self
.parts
.into_iter()
.map(|part| {
let mut part = part.eval(engine, env)?;
part.coerce_to_string();
part.force(engine)?.coerce_to_string();
part.ok()
})
.collect::<Result<Vec<_>>>()?
@@ -235,13 +269,13 @@ impl Evaluate for ir::ConcatStrings {
}
impl Evaluate for ir::String {
fn eval(self, _: &Engine, _: &VmEnv) -> Result<Value> {
fn eval(self, _: &mut Engine, _: &mut VmEnv) -> Result<Value> {
Value::String(self.val).ok()
}
}
impl Evaluate for ir::Const {
fn eval(self, _: &Engine, _: &VmEnv) -> Result<Value> {
fn eval(self, _: &mut Engine, _: &mut VmEnv) -> Result<Value> {
match self.val {
Const::Null => Value::Null,
Const::Int(x) => Value::Int(x),
@@ -253,33 +287,36 @@ impl Evaluate for ir::Const {
}
impl Evaluate for ir::Var {
fn eval(self, _: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, _: &mut Engine, env: &mut VmEnv) -> Result<Value> {
env.lookup_with(&self.sym)
.cloned()
.ok_or_else(|| Error::EvalError(format!("{} not found", Symbol::from(self.sym))))
}
}
impl Evaluate for ir::Arg {
fn eval(self, _: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, _: &mut Engine, env: &mut VmEnv) -> Result<Value> {
env.lookup_arg(self.level).clone().ok()
}
}
impl Evaluate for ir::LetVar {
fn eval(self, _: &Engine, env: &VmEnv) -> Result<Value> {
env.lookup_let(self.level, self.idx).clone().ok()
fn eval(self, _: &mut Engine, env: &mut VmEnv) -> Result<Value> {
let mut ret = env.lookup_let(self.level, self.idx);
if let Value::Thunk(thunk) = &mut ret {
thunk.upgrade();
}
ret.ok()
}
}
impl Evaluate for ir::Thunk {
fn eval(self, _: &Engine, _: &VmEnv) -> Result<Value> {
Value::Thunk(Rc::new(Thunk::new(self.idx).into())).ok()
fn eval(self, _: &mut Engine, _: &mut VmEnv) -> Result<Value> {
Value::Thunk(ThunkRef::new(self.idx)).ok()
}
}
impl Evaluate for ir::Path {
fn eval(self, engine: &Engine, env: &VmEnv) -> Result<Value> {
fn eval(self, engine: &mut Engine, env: &mut VmEnv) -> Result<Value> {
todo!()
}
}