1049 lines
36 KiB
Rust
1049 lines
36 KiB
Rust
use alloc::{format, string::String, vec, vec::Vec};
|
|
|
|
use crate::{
|
|
ExprId, SourceForm, SourceId, Span,
|
|
ast::{Ast, BinaryOp, CompareOp, Expr, Field, Literal},
|
|
diagnostic::{Diagnostic, DiagnosticKind, Result},
|
|
module::{EmptyLoader, LoadedSource, Module, SourceLoader},
|
|
parse_source_with_source_id,
|
|
runtime::{
|
|
AbstractValue, Binding, ConcreteValue, Constraint, Data, DataField, Env, EnvId, ExprRef,
|
|
FunctionParam, FunctionValue, LiteralValue, ModuleId, ObjectField, ObjectValue,
|
|
PrimitiveType, RuntimeValue, Thunk, ThunkId, ThunkKind, ThunkState,
|
|
},
|
|
};
|
|
|
|
pub struct Engine<L = EmptyLoader> {
|
|
loader: L,
|
|
modules: Vec<Module>,
|
|
thunks: Vec<Thunk>,
|
|
envs: Vec<Env>,
|
|
}
|
|
|
|
impl Engine<EmptyLoader> {
|
|
pub fn from_parse(ast: Ast, root: ExprId) -> Self {
|
|
let mut this = Self::new(EmptyLoader);
|
|
this.register_parsed(
|
|
String::from("<memory>"),
|
|
String::from("<memory>"),
|
|
SourceId(0),
|
|
ast,
|
|
root,
|
|
SourceForm::Expr,
|
|
);
|
|
this
|
|
}
|
|
}
|
|
|
|
impl<L: SourceLoader> Engine<L> {
|
|
pub fn new(loader: L) -> Self {
|
|
Self {
|
|
loader,
|
|
modules: Vec::new(),
|
|
thunks: Vec::new(),
|
|
envs: Vec::new(),
|
|
}
|
|
}
|
|
|
|
pub fn add_root_source(
|
|
&mut self,
|
|
key: impl Into<String>,
|
|
name: impl Into<String>,
|
|
source: &str,
|
|
) -> Result<ModuleId> {
|
|
self.add_source(key.into(), name.into(), source)
|
|
}
|
|
|
|
pub fn eval_module(&mut self, module: ModuleId) -> Result<RuntimeValue> {
|
|
let thunk = self.modules[module.0 as usize].root_thunk;
|
|
self.force(thunk)
|
|
}
|
|
|
|
pub fn eval_root(&mut self) -> Result<RuntimeValue> {
|
|
self.eval_module(ModuleId(0))
|
|
}
|
|
|
|
pub fn materialize(&mut self, value: &RuntimeValue) -> Result<Data> {
|
|
match value {
|
|
RuntimeValue::Concrete(value) => match value {
|
|
ConcreteValue::String(value) => Ok(Data::String(value.clone())),
|
|
ConcreteValue::Int(value) => Ok(Data::Int(*value)),
|
|
ConcreteValue::Float(value) => Ok(Data::Float(*value)),
|
|
ConcreteValue::Bool(value) => Ok(Data::Bool(*value)),
|
|
ConcreteValue::Array(items) => {
|
|
let mut data = Vec::new();
|
|
for item in items {
|
|
let value = self.force(*item)?;
|
|
data.push(self.materialize(&value)?);
|
|
}
|
|
Ok(Data::Array(data))
|
|
}
|
|
ConcreteValue::Object(object) => {
|
|
let mut fields = Vec::new();
|
|
for field in &object.fields {
|
|
let value = self.force(field.value)?;
|
|
fields.push(DataField {
|
|
name: field.name.clone(),
|
|
value: self.materialize(&value)?,
|
|
});
|
|
}
|
|
Ok(Data::Object(fields))
|
|
}
|
|
ConcreteValue::Function(_) => Err(Diagnostic::new(
|
|
DiagnosticKind::Materialize,
|
|
Span::default(),
|
|
"cannot materialize function value",
|
|
)),
|
|
},
|
|
RuntimeValue::Abstract(abstract_value) => {
|
|
let Some(default) = abstract_value.default else {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Materialize,
|
|
Span::default(),
|
|
"cannot materialize unresolved abstract value without default",
|
|
));
|
|
};
|
|
let value = self.force(default)?;
|
|
self.ensure_satisfies(&value, &abstract_value.constraints, Span::default())?;
|
|
self.materialize(&value)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn add_source(&mut self, key: String, name: String, source: &str) -> Result<ModuleId> {
|
|
if let Some(id) = self.find_module(&key) {
|
|
return Ok(id);
|
|
}
|
|
let source_id = SourceId(self.modules.len() as u32);
|
|
let parsed = parse_source_with_source_id(source_id, source)?;
|
|
Ok(self.register_parsed(
|
|
key,
|
|
name,
|
|
source_id,
|
|
parsed.ast,
|
|
parsed.root,
|
|
parsed.source_form,
|
|
))
|
|
}
|
|
|
|
fn register_parsed(
|
|
&mut self,
|
|
key: String,
|
|
name: String,
|
|
source: SourceId,
|
|
ast: Ast,
|
|
root: ExprId,
|
|
source_form: SourceForm,
|
|
) -> ModuleId {
|
|
let module = ModuleId(self.modules.len() as u32);
|
|
let root_env = self.new_env(None);
|
|
let root_thunk = if source_form == SourceForm::Fields {
|
|
if let Expr::Object(fields) = ast.get(root).expr.clone() {
|
|
let object = self
|
|
.build_object(module, &fields, root_env)
|
|
.expect("module object construction should not fail for parsed fields");
|
|
for field in &object.fields {
|
|
self.bind(root_env, field.name.clone(), field.value);
|
|
}
|
|
self.add_value_thunk(RuntimeValue::Concrete(ConcreteValue::Object(object)))
|
|
} else {
|
|
self.add_expr_thunk(ExprRef { module, expr: root }, root_env)
|
|
}
|
|
} else {
|
|
self.add_expr_thunk(ExprRef { module, expr: root }, root_env)
|
|
};
|
|
self.modules.push(Module {
|
|
key,
|
|
name,
|
|
source,
|
|
ast,
|
|
root,
|
|
source_form,
|
|
root_env,
|
|
root_thunk,
|
|
});
|
|
module
|
|
}
|
|
|
|
fn find_module(&self, key: &str) -> Option<ModuleId> {
|
|
self.modules
|
|
.iter()
|
|
.position(|module| module.key == key)
|
|
.map(|index| ModuleId(index as u32))
|
|
}
|
|
|
|
fn load_import(&mut self, current: ModuleId, specifier: &str) -> Result<ModuleId> {
|
|
let current_key = self.modules[current.0 as usize].key.clone();
|
|
let LoadedSource { key, name, source } = self.loader.load(Some(¤t_key), specifier)?;
|
|
self.add_source(key, name, &source)
|
|
}
|
|
|
|
fn eval_expr(&mut self, reference: ExprRef, env: EnvId) -> Result<RuntimeValue> {
|
|
let span = self.expr_span(reference);
|
|
let expr = self.expr(reference).clone();
|
|
match expr {
|
|
Expr::Literal(literal) => Ok(RuntimeValue::Concrete(literal_to_concrete(literal))),
|
|
Expr::Ident(name) => self.eval_ident(&name, env, span),
|
|
Expr::Object(fields) => self
|
|
.build_object(reference.module, &fields, env)
|
|
.map(|object| RuntimeValue::Concrete(ConcreteValue::Object(object))),
|
|
Expr::Array(items) => {
|
|
let thunks = items
|
|
.into_iter()
|
|
.map(|item| {
|
|
self.add_expr_thunk(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: item,
|
|
},
|
|
env,
|
|
)
|
|
})
|
|
.collect();
|
|
Ok(RuntimeValue::Concrete(ConcreteValue::Array(thunks)))
|
|
}
|
|
Expr::Let { bindings, body } => {
|
|
let let_env = self.new_env(Some(env));
|
|
for binding in bindings {
|
|
let name = field_name(&binding)?;
|
|
let thunk = self.add_expr_thunk(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: binding.value,
|
|
},
|
|
let_env,
|
|
);
|
|
self.bind(let_env, name, thunk);
|
|
}
|
|
self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: body,
|
|
},
|
|
let_env,
|
|
)
|
|
}
|
|
Expr::Import(specifier) => {
|
|
let module = self.load_import(reference.module, &specifier)?;
|
|
self.eval_module(module)
|
|
}
|
|
Expr::Path { base, field } => {
|
|
let base = self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: base,
|
|
},
|
|
env,
|
|
)?;
|
|
let RuntimeValue::Concrete(ConcreteValue::Object(object)) = base else {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::TypeMismatch,
|
|
span,
|
|
"path base is not an object",
|
|
));
|
|
};
|
|
let Some(thunk) = object
|
|
.fields
|
|
.iter()
|
|
.find(|item| item.name == field)
|
|
.map(|item| item.value)
|
|
else {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::UnresolvedIdentifier,
|
|
span,
|
|
format!("unknown field `{field}`"),
|
|
));
|
|
};
|
|
self.force(thunk)
|
|
}
|
|
Expr::Call { callee, args } => self.eval_call(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: callee,
|
|
},
|
|
args,
|
|
reference.module,
|
|
env,
|
|
span,
|
|
),
|
|
Expr::Function { params, body } => {
|
|
let params = params
|
|
.into_iter()
|
|
.map(|param| FunctionParam {
|
|
name: param.name,
|
|
constraint: param.constraint.map(|expr| ExprRef {
|
|
module: reference.module,
|
|
expr,
|
|
}),
|
|
})
|
|
.collect();
|
|
Ok(RuntimeValue::Concrete(ConcreteValue::Function(
|
|
FunctionValue {
|
|
params,
|
|
body: ExprRef {
|
|
module: reference.module,
|
|
expr: body,
|
|
},
|
|
env,
|
|
},
|
|
)))
|
|
}
|
|
Expr::Match { scrutinee, arms } => {
|
|
let value = self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: scrutinee,
|
|
},
|
|
env,
|
|
)?;
|
|
for arm in arms {
|
|
let pattern = ExprRef {
|
|
module: reference.module,
|
|
expr: arm.pattern,
|
|
};
|
|
if self.matches_pattern(&value, pattern, env)? {
|
|
return self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: arm.body,
|
|
},
|
|
env,
|
|
);
|
|
}
|
|
}
|
|
Err(Diagnostic::new(
|
|
DiagnosticKind::MatchFailure,
|
|
span,
|
|
"no match arm matched",
|
|
))
|
|
}
|
|
Expr::Binary { op, lhs, rhs } => {
|
|
let lhs = self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: lhs,
|
|
},
|
|
env,
|
|
)?;
|
|
let rhs = self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: rhs,
|
|
},
|
|
env,
|
|
)?;
|
|
match op {
|
|
BinaryOp::And => self.compose_and(lhs, rhs, span),
|
|
BinaryOp::Patch => self.patch(lhs, rhs),
|
|
}
|
|
}
|
|
Expr::Default { base, fallback } => {
|
|
let base = self.eval_expr(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: base,
|
|
},
|
|
env,
|
|
)?;
|
|
match base {
|
|
RuntimeValue::Abstract(mut abstract_value) => {
|
|
abstract_value.default = Some(self.add_expr_thunk(
|
|
ExprRef {
|
|
module: reference.module,
|
|
expr: fallback,
|
|
},
|
|
env,
|
|
));
|
|
Ok(RuntimeValue::Abstract(abstract_value))
|
|
}
|
|
concrete @ RuntimeValue::Concrete(_) => Ok(concrete),
|
|
}
|
|
}
|
|
Expr::CompareConstraint { op, value } => {
|
|
let value_ref = ExprRef {
|
|
module: reference.module,
|
|
expr: value,
|
|
};
|
|
let value = self.eval_expr(value_ref, env)?;
|
|
let value = literal_value_from_runtime(&value).ok_or_else(|| {
|
|
Diagnostic::new(
|
|
DiagnosticKind::TypeMismatch,
|
|
span,
|
|
"comparison constraint operand must be a literal",
|
|
)
|
|
})?;
|
|
Ok(RuntimeValue::Abstract(AbstractValue {
|
|
constraints: vec![Constraint::Compare(op, value)],
|
|
default: None,
|
|
}))
|
|
}
|
|
Expr::RegexConstraint(pattern) => Ok(RuntimeValue::Abstract(AbstractValue {
|
|
constraints: vec![Constraint::Regex(pattern)],
|
|
default: None,
|
|
})),
|
|
Expr::Wildcard => Err(Diagnostic::new(
|
|
DiagnosticKind::UnsupportedFeature,
|
|
span,
|
|
"wildcard is only valid as a match pattern",
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn eval_ident(&mut self, name: &str, env: EnvId, span: Span) -> Result<RuntimeValue> {
|
|
if let Some(primitive) = primitive_type(name) {
|
|
return Ok(RuntimeValue::Abstract(AbstractValue {
|
|
constraints: vec![Constraint::Type(primitive)],
|
|
default: None,
|
|
}));
|
|
}
|
|
if let Some(thunk) = self.lookup(env, name) {
|
|
return self.force(thunk);
|
|
}
|
|
if name.chars().next().is_some_and(char::is_uppercase) {
|
|
return Ok(RuntimeValue::Abstract(AbstractValue {
|
|
constraints: vec![Constraint::BuiltinPredicate(String::from(name))],
|
|
default: None,
|
|
}));
|
|
}
|
|
Err(Diagnostic::new(
|
|
DiagnosticKind::UnresolvedIdentifier,
|
|
span,
|
|
format!("unknown identifier `{name}`"),
|
|
))
|
|
}
|
|
|
|
fn build_object(
|
|
&mut self,
|
|
module: ModuleId,
|
|
fields: &[Field],
|
|
env: EnvId,
|
|
) -> Result<ObjectValue> {
|
|
let mut object = ObjectValue { fields: Vec::new() };
|
|
for field in fields {
|
|
self.insert_field(
|
|
&mut object,
|
|
module,
|
|
&field.path,
|
|
field.value,
|
|
env,
|
|
field.span,
|
|
)?;
|
|
}
|
|
Ok(object)
|
|
}
|
|
|
|
fn insert_field(
|
|
&mut self,
|
|
object: &mut ObjectValue,
|
|
module: ModuleId,
|
|
path: &[String],
|
|
expr: ExprId,
|
|
env: EnvId,
|
|
span: Span,
|
|
) -> Result<()> {
|
|
if path.is_empty() {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Syntax,
|
|
span,
|
|
"empty field path",
|
|
));
|
|
}
|
|
if path.len() == 1 {
|
|
let value = self.add_expr_thunk(ExprRef { module, expr }, env);
|
|
if object.fields.iter().any(|field| field.name == path[0]) {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Conflict,
|
|
span,
|
|
format!("duplicate field `{}`", path[0]),
|
|
));
|
|
}
|
|
object.fields.push(ObjectField {
|
|
name: path[0].clone(),
|
|
value,
|
|
});
|
|
return Ok(());
|
|
}
|
|
|
|
let name = &path[0];
|
|
if let Some(index) = object.fields.iter().position(|field| field.name == *name) {
|
|
let existing = self.force(object.fields[index].value)?;
|
|
let RuntimeValue::Concrete(ConcreteValue::Object(mut nested)) = existing else {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Conflict,
|
|
span,
|
|
format!("field `{name}` is already defined as a non-object"),
|
|
));
|
|
};
|
|
self.insert_field(&mut nested, module, &path[1..], expr, env, span)?;
|
|
object.fields[index].value =
|
|
self.add_value_thunk(RuntimeValue::Concrete(ConcreteValue::Object(nested)));
|
|
return Ok(());
|
|
}
|
|
|
|
let mut nested = ObjectValue { fields: Vec::new() };
|
|
self.insert_field(&mut nested, module, &path[1..], expr, env, span)?;
|
|
object.fields.push(ObjectField {
|
|
name: name.clone(),
|
|
value: self.add_value_thunk(RuntimeValue::Concrete(ConcreteValue::Object(nested))),
|
|
});
|
|
Ok(())
|
|
}
|
|
|
|
fn eval_call(
|
|
&mut self,
|
|
callee: ExprRef,
|
|
args: Vec<ExprId>,
|
|
caller_module: ModuleId,
|
|
caller_env: EnvId,
|
|
span: Span,
|
|
) -> Result<RuntimeValue> {
|
|
let callee = self.eval_expr(callee, caller_env)?;
|
|
let RuntimeValue::Concrete(ConcreteValue::Function(function)) = callee else {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::TypeMismatch,
|
|
span,
|
|
"callee is not a function",
|
|
));
|
|
};
|
|
if args.len() != function.params.len() {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::TypeMismatch,
|
|
span,
|
|
"function call argument count mismatch",
|
|
));
|
|
}
|
|
let call_env = self.new_env(Some(function.env));
|
|
for (param, arg) in function.params.iter().zip(args) {
|
|
let arg_ref = ExprRef {
|
|
module: caller_module,
|
|
expr: arg,
|
|
};
|
|
let arg_thunk = if let Some(constraint) = param.constraint {
|
|
self.add_constrained_thunk(constraint, function.env, arg_ref, caller_env)
|
|
} else {
|
|
self.add_expr_thunk(arg_ref, caller_env)
|
|
};
|
|
self.bind(call_env, param.name.clone(), arg_thunk);
|
|
}
|
|
self.eval_expr(function.body, call_env)
|
|
}
|
|
|
|
fn matches_pattern(
|
|
&mut self,
|
|
value: &RuntimeValue,
|
|
pattern: ExprRef,
|
|
env: EnvId,
|
|
) -> Result<bool> {
|
|
match self.expr(pattern).clone() {
|
|
Expr::Wildcard => Ok(true),
|
|
Expr::CompareConstraint { .. } | Expr::RegexConstraint(_) | Expr::Ident(_) => {
|
|
let constraint = self.eval_expr(pattern, env)?;
|
|
match constraint {
|
|
RuntimeValue::Abstract(abstract_value) => self
|
|
.ensure_satisfies(
|
|
value,
|
|
&abstract_value.constraints,
|
|
self.expr_span(pattern),
|
|
)
|
|
.map(|_| true)
|
|
.or_else(|diag| match diag.kind {
|
|
DiagnosticKind::ConstraintViolation
|
|
| DiagnosticKind::UnsupportedFeature => Ok(false),
|
|
_ => Err(diag),
|
|
}),
|
|
other => Ok(&other == value),
|
|
}
|
|
}
|
|
_ => {
|
|
let pattern_value = self.eval_expr(pattern, env)?;
|
|
Ok(&pattern_value == value)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compose_and(
|
|
&mut self,
|
|
lhs: RuntimeValue,
|
|
rhs: RuntimeValue,
|
|
span: Span,
|
|
) -> Result<RuntimeValue> {
|
|
match (lhs, rhs) {
|
|
(RuntimeValue::Abstract(mut lhs), RuntimeValue::Abstract(rhs)) => {
|
|
lhs.constraints.extend(rhs.constraints);
|
|
lhs.default = merge_default(lhs.default, rhs.default, span)?;
|
|
Ok(RuntimeValue::Abstract(lhs))
|
|
}
|
|
(RuntimeValue::Abstract(abstract_value), concrete @ RuntimeValue::Concrete(_))
|
|
| (concrete @ RuntimeValue::Concrete(_), RuntimeValue::Abstract(abstract_value)) => {
|
|
self.ensure_satisfies(&concrete, &abstract_value.constraints, span)?;
|
|
Ok(concrete)
|
|
}
|
|
(
|
|
RuntimeValue::Concrete(ConcreteValue::Object(lhs)),
|
|
RuntimeValue::Concrete(ConcreteValue::Object(rhs)),
|
|
) => self.compose_objects(lhs, rhs, span),
|
|
(RuntimeValue::Concrete(lhs), RuntimeValue::Concrete(rhs)) => {
|
|
if concrete_scalar_eq(&lhs, &rhs) {
|
|
Ok(RuntimeValue::Concrete(lhs))
|
|
} else {
|
|
Err(Diagnostic::new(
|
|
DiagnosticKind::Conflict,
|
|
span,
|
|
"concrete values conflict",
|
|
))
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
fn compose_objects(
|
|
&mut self,
|
|
mut lhs: ObjectValue,
|
|
rhs: ObjectValue,
|
|
span: Span,
|
|
) -> Result<RuntimeValue> {
|
|
for rhs_field in rhs.fields {
|
|
if let Some(index) = lhs
|
|
.fields
|
|
.iter()
|
|
.position(|lhs_field| lhs_field.name == rhs_field.name)
|
|
{
|
|
let lhs_value = self.force(lhs.fields[index].value)?;
|
|
let rhs_value = self.force(rhs_field.value)?;
|
|
let value = self.compose_and(lhs_value, rhs_value, span)?;
|
|
lhs.fields[index].value = self.add_value_thunk(value);
|
|
} else {
|
|
lhs.fields.push(rhs_field);
|
|
}
|
|
}
|
|
Ok(RuntimeValue::Concrete(ConcreteValue::Object(lhs)))
|
|
}
|
|
|
|
fn patch(&mut self, lhs: RuntimeValue, rhs: RuntimeValue) -> Result<RuntimeValue> {
|
|
match (lhs, rhs) {
|
|
(
|
|
RuntimeValue::Concrete(ConcreteValue::Object(lhs)),
|
|
RuntimeValue::Concrete(ConcreteValue::Object(rhs)),
|
|
) => self.patch_objects(lhs, rhs),
|
|
(_, rhs) => Ok(rhs),
|
|
}
|
|
}
|
|
|
|
fn patch_objects(&mut self, mut lhs: ObjectValue, rhs: ObjectValue) -> Result<RuntimeValue> {
|
|
for rhs_field in rhs.fields {
|
|
if let Some(index) = lhs
|
|
.fields
|
|
.iter()
|
|
.position(|lhs_field| lhs_field.name == rhs_field.name)
|
|
{
|
|
let lhs_value = self.force(lhs.fields[index].value)?;
|
|
let rhs_value = self.force(rhs_field.value)?;
|
|
let value = self.patch(lhs_value, rhs_value)?;
|
|
lhs.fields[index].value = self.add_value_thunk(value);
|
|
} else {
|
|
lhs.fields.push(rhs_field);
|
|
}
|
|
}
|
|
Ok(RuntimeValue::Concrete(ConcreteValue::Object(lhs)))
|
|
}
|
|
|
|
fn ensure_satisfies(
|
|
&mut self,
|
|
value: &RuntimeValue,
|
|
constraints: &[Constraint],
|
|
span: Span,
|
|
) -> Result<()> {
|
|
for constraint in constraints {
|
|
self.satisfies(value, constraint, span)?;
|
|
}
|
|
Ok(())
|
|
}
|
|
|
|
fn satisfies(
|
|
&mut self,
|
|
value: &RuntimeValue,
|
|
constraint: &Constraint,
|
|
span: Span,
|
|
) -> Result<()> {
|
|
match constraint {
|
|
Constraint::Type(primitive) => {
|
|
if value_matches_primitive(value, *primitive) {
|
|
Ok(())
|
|
} else {
|
|
Err(Diagnostic::new(
|
|
DiagnosticKind::ConstraintViolation,
|
|
span,
|
|
"value does not satisfy primitive type constraint",
|
|
))
|
|
}
|
|
}
|
|
Constraint::Compare(op, expected) => compare_value(value, *op, expected)
|
|
.then_some(())
|
|
.ok_or_else(|| {
|
|
Diagnostic::new(
|
|
DiagnosticKind::ConstraintViolation,
|
|
span,
|
|
"value does not satisfy comparison constraint",
|
|
)
|
|
}),
|
|
Constraint::Regex(_) => Err(Diagnostic::new(
|
|
DiagnosticKind::UnsupportedFeature,
|
|
span,
|
|
"regex constraints require a future regex feature",
|
|
)),
|
|
Constraint::BuiltinPredicate(name) => Err(Diagnostic::new(
|
|
DiagnosticKind::UnsupportedFeature,
|
|
span,
|
|
format!("builtin predicate `{name}` is not implemented"),
|
|
)),
|
|
}
|
|
}
|
|
|
|
fn force(&mut self, id: ThunkId) -> Result<RuntimeValue> {
|
|
let index = id.0 as usize;
|
|
match self.thunks[index].state.clone() {
|
|
ThunkState::Evaluated(value) => return Ok(value),
|
|
ThunkState::Evaluating => {
|
|
self.thunks[index].state = ThunkState::Error;
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Cycle,
|
|
Span::default(),
|
|
"cyclic thunk dependency",
|
|
));
|
|
}
|
|
ThunkState::Error => {
|
|
return Err(Diagnostic::new(
|
|
DiagnosticKind::Cycle,
|
|
Span::default(),
|
|
"thunk previously failed",
|
|
));
|
|
}
|
|
ThunkState::Unevaluated => {}
|
|
}
|
|
|
|
self.thunks[index].state = ThunkState::Evaluating;
|
|
let kind = self.thunks[index].kind.clone();
|
|
let result = match kind {
|
|
ThunkKind::Expr { expr, env } => self.eval_expr(expr, env),
|
|
ThunkKind::Constrained {
|
|
constraint,
|
|
constraint_env,
|
|
value,
|
|
value_env,
|
|
} => {
|
|
let span = self.expr_span(value);
|
|
let constraint = self.eval_expr(constraint, constraint_env)?;
|
|
let value = self.eval_expr(value, value_env)?;
|
|
self.compose_and(constraint, value, span)
|
|
}
|
|
ThunkKind::Value(value) => Ok(value),
|
|
};
|
|
match result {
|
|
Ok(value) => {
|
|
self.thunks[index].state = ThunkState::Evaluated(value.clone());
|
|
Ok(value)
|
|
}
|
|
Err(error) => {
|
|
self.thunks[index].state = ThunkState::Error;
|
|
Err(error)
|
|
}
|
|
}
|
|
}
|
|
|
|
fn add_expr_thunk(&mut self, expr: ExprRef, env: EnvId) -> ThunkId {
|
|
self.add_thunk(ThunkKind::Expr { expr, env })
|
|
}
|
|
|
|
fn add_constrained_thunk(
|
|
&mut self,
|
|
constraint: ExprRef,
|
|
constraint_env: EnvId,
|
|
value: ExprRef,
|
|
value_env: EnvId,
|
|
) -> ThunkId {
|
|
self.add_thunk(ThunkKind::Constrained {
|
|
constraint,
|
|
constraint_env,
|
|
value,
|
|
value_env,
|
|
})
|
|
}
|
|
|
|
fn add_value_thunk(&mut self, value: RuntimeValue) -> ThunkId {
|
|
self.add_thunk(ThunkKind::Value(value))
|
|
}
|
|
|
|
fn add_thunk(&mut self, kind: ThunkKind) -> ThunkId {
|
|
let id = ThunkId(self.thunks.len() as u32);
|
|
self.thunks.push(Thunk {
|
|
kind,
|
|
state: ThunkState::Unevaluated,
|
|
});
|
|
id
|
|
}
|
|
|
|
fn new_env(&mut self, parent: Option<EnvId>) -> EnvId {
|
|
let id = EnvId(self.envs.len() as u32);
|
|
self.envs.push(Env {
|
|
parent,
|
|
bindings: Vec::new(),
|
|
});
|
|
id
|
|
}
|
|
|
|
fn bind(&mut self, env: EnvId, name: String, value: ThunkId) {
|
|
self.envs[env.0 as usize]
|
|
.bindings
|
|
.push(Binding { name, value });
|
|
}
|
|
|
|
fn lookup(&self, env: EnvId, name: &str) -> Option<ThunkId> {
|
|
let mut current = Some(env);
|
|
while let Some(env) = current {
|
|
let frame = &self.envs[env.0 as usize];
|
|
if let Some(binding) = frame
|
|
.bindings
|
|
.iter()
|
|
.rev()
|
|
.find(|binding| binding.name == name)
|
|
{
|
|
return Some(binding.value);
|
|
}
|
|
current = frame.parent;
|
|
}
|
|
None
|
|
}
|
|
|
|
fn expr(&self, reference: ExprRef) -> &Expr {
|
|
&self.modules[reference.module.0 as usize]
|
|
.ast
|
|
.get(reference.expr)
|
|
.expr
|
|
}
|
|
|
|
fn expr_span(&self, reference: ExprRef) -> Span {
|
|
self.modules[reference.module.0 as usize]
|
|
.ast
|
|
.span(reference.expr)
|
|
}
|
|
}
|
|
|
|
fn field_name(field: &Field) -> Result<String> {
|
|
if field.path.len() == 1 {
|
|
Ok(field.path[0].clone())
|
|
} else {
|
|
Err(Diagnostic::new(
|
|
DiagnosticKind::UnsupportedFeature,
|
|
field.span,
|
|
"nested let binding names are not supported",
|
|
))
|
|
}
|
|
}
|
|
|
|
fn primitive_type(name: &str) -> Option<PrimitiveType> {
|
|
match name {
|
|
"String" => Some(PrimitiveType::String),
|
|
"Int" => Some(PrimitiveType::Int),
|
|
"Float" => Some(PrimitiveType::Float),
|
|
"Bool" => Some(PrimitiveType::Bool),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn literal_to_concrete(literal: Literal) -> ConcreteValue {
|
|
match literal {
|
|
Literal::String(value) => ConcreteValue::String(value),
|
|
Literal::Int(value) => ConcreteValue::Int(value),
|
|
Literal::Float(value) => ConcreteValue::Float(value),
|
|
Literal::Bool(value) => ConcreteValue::Bool(value),
|
|
}
|
|
}
|
|
|
|
fn literal_value_from_runtime(value: &RuntimeValue) -> Option<LiteralValue> {
|
|
match value {
|
|
RuntimeValue::Concrete(ConcreteValue::String(value)) => {
|
|
Some(LiteralValue::String(value.clone()))
|
|
}
|
|
RuntimeValue::Concrete(ConcreteValue::Int(value)) => Some(LiteralValue::Int(*value)),
|
|
RuntimeValue::Concrete(ConcreteValue::Float(value)) => Some(LiteralValue::Float(*value)),
|
|
RuntimeValue::Concrete(ConcreteValue::Bool(value)) => Some(LiteralValue::Bool(*value)),
|
|
_ => None,
|
|
}
|
|
}
|
|
|
|
fn value_matches_primitive(value: &RuntimeValue, primitive: PrimitiveType) -> bool {
|
|
matches!(
|
|
(value, primitive),
|
|
(
|
|
RuntimeValue::Concrete(ConcreteValue::String(_)),
|
|
PrimitiveType::String
|
|
) | (
|
|
RuntimeValue::Concrete(ConcreteValue::Int(_)),
|
|
PrimitiveType::Int
|
|
) | (
|
|
RuntimeValue::Concrete(ConcreteValue::Float(_)),
|
|
PrimitiveType::Float
|
|
) | (
|
|
RuntimeValue::Concrete(ConcreteValue::Bool(_)),
|
|
PrimitiveType::Bool
|
|
)
|
|
)
|
|
}
|
|
|
|
fn compare_value(value: &RuntimeValue, op: CompareOp, expected: &LiteralValue) -> bool {
|
|
match (value, expected) {
|
|
(RuntimeValue::Concrete(ConcreteValue::Int(actual)), LiteralValue::Int(expected)) => {
|
|
compare_f64(*actual as f64, op, *expected as f64)
|
|
}
|
|
(RuntimeValue::Concrete(ConcreteValue::Float(actual)), LiteralValue::Float(expected)) => {
|
|
compare_f64(*actual, op, *expected)
|
|
}
|
|
(RuntimeValue::Concrete(ConcreteValue::Int(actual)), LiteralValue::Float(expected)) => {
|
|
compare_f64(*actual as f64, op, *expected)
|
|
}
|
|
(RuntimeValue::Concrete(ConcreteValue::Float(actual)), LiteralValue::Int(expected)) => {
|
|
compare_f64(*actual, op, *expected as f64)
|
|
}
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn compare_f64(actual: f64, op: CompareOp, expected: f64) -> bool {
|
|
match op {
|
|
CompareOp::Gt => actual > expected,
|
|
CompareOp::Gte => actual >= expected,
|
|
CompareOp::Lt => actual < expected,
|
|
CompareOp::Lte => actual <= expected,
|
|
CompareOp::Eq => actual == expected,
|
|
}
|
|
}
|
|
|
|
fn concrete_scalar_eq(lhs: &ConcreteValue, rhs: &ConcreteValue) -> bool {
|
|
match (lhs, rhs) {
|
|
(ConcreteValue::String(lhs), ConcreteValue::String(rhs)) => lhs == rhs,
|
|
(ConcreteValue::Int(lhs), ConcreteValue::Int(rhs)) => lhs == rhs,
|
|
(ConcreteValue::Float(lhs), ConcreteValue::Float(rhs)) => lhs == rhs,
|
|
(ConcreteValue::Bool(lhs), ConcreteValue::Bool(rhs)) => lhs == rhs,
|
|
_ => false,
|
|
}
|
|
}
|
|
|
|
fn merge_default(
|
|
lhs: Option<ThunkId>,
|
|
rhs: Option<ThunkId>,
|
|
span: Span,
|
|
) -> Result<Option<ThunkId>> {
|
|
match (lhs, rhs) {
|
|
(None, None) => Ok(None),
|
|
(Some(value), None) | (None, Some(value)) => Ok(Some(value)),
|
|
(Some(lhs), Some(rhs)) if lhs == rhs => Ok(Some(lhs)),
|
|
(Some(_), Some(_)) => Err(Diagnostic::new(
|
|
DiagnosticKind::DefaultConflict,
|
|
span,
|
|
"conflicting defaults",
|
|
)),
|
|
}
|
|
}
|
|
|
|
#[cfg(test)]
|
|
mod tests {
|
|
use super::*;
|
|
use crate::{LoadedSource, parse_source};
|
|
|
|
fn eval_data(source: &str) -> Data {
|
|
let parsed = parse_source(source).unwrap();
|
|
let mut engine = Engine::from_parse(parsed.ast, parsed.root);
|
|
let value = engine.eval_root().unwrap();
|
|
engine.materialize(&value).unwrap()
|
|
}
|
|
|
|
#[test]
|
|
fn materializes_default() {
|
|
let data = eval_data("port = Int & >= 1 default 8080;");
|
|
assert!(matches!(data, Data::Object(_)));
|
|
}
|
|
|
|
#[test]
|
|
fn composes_schema_and_value() {
|
|
let data = eval_data(
|
|
r#"
|
|
let
|
|
MyConfig = { port = Int & > 443 default 8080; };
|
|
in
|
|
MyConfig & { port = 8000; }
|
|
"#,
|
|
);
|
|
let Data::Object(fields) = data else { panic!() };
|
|
assert_eq!(fields[0].name, "port");
|
|
assert_eq!(fields[0].value, Data::Int(8000));
|
|
}
|
|
|
|
#[test]
|
|
fn detects_constraint_violation() {
|
|
let parsed = parse_source("{ port = Int & > 443; } & { port = 80; }").unwrap();
|
|
let mut engine = Engine::from_parse(parsed.ast, parsed.root);
|
|
assert!(engine.eval_root().is_err());
|
|
}
|
|
|
|
#[derive(Default)]
|
|
struct MapLoader {
|
|
sources: Vec<(String, String)>,
|
|
}
|
|
|
|
impl SourceLoader for MapLoader {
|
|
fn load(&mut self, _current_key: Option<&str>, specifier: &str) -> Result<LoadedSource> {
|
|
let source = self
|
|
.sources
|
|
.iter()
|
|
.find(|(key, _)| key == specifier)
|
|
.map(|(_, source)| source.clone())
|
|
.ok_or_else(|| {
|
|
Diagnostic::new(DiagnosticKind::Import, Span::default(), "missing source")
|
|
})?;
|
|
Ok(LoadedSource {
|
|
key: specifier.into(),
|
|
name: specifier.into(),
|
|
source,
|
|
})
|
|
}
|
|
}
|
|
|
|
#[test]
|
|
fn imports_module_on_demand() {
|
|
let mut engine = Engine::new(MapLoader {
|
|
sources: vec![(
|
|
String::from("dep"),
|
|
String::from("schema = { port = Int default 8080; }"),
|
|
)],
|
|
});
|
|
let module = engine
|
|
.add_root_source(
|
|
"main",
|
|
"main",
|
|
r#"(import "dep").schema & { port = 9000; }"#,
|
|
)
|
|
.unwrap();
|
|
let value = engine.eval_module(module).unwrap();
|
|
let data = engine.materialize(&value).unwrap();
|
|
let Data::Object(fields) = data else { panic!() };
|
|
assert_eq!(fields[0].value, Data::Int(9000));
|
|
}
|
|
|
|
#[test]
|
|
fn top_level_fields_are_recursive_module_scope() {
|
|
let mut engine = Engine::new(EmptyLoader);
|
|
let module = engine
|
|
.add_root_source(
|
|
"main",
|
|
"main",
|
|
"schema = { port = Int default 8080; }; result = schema;",
|
|
)
|
|
.unwrap();
|
|
let value = engine.eval_module(module).unwrap();
|
|
let data = engine.materialize(&value).unwrap();
|
|
let Data::Object(fields) = data else { panic!() };
|
|
assert_eq!(fields[1].name, "result");
|
|
assert!(matches!(fields[1].value, Data::Object(_)));
|
|
}
|
|
}
|