use crate::ast::{Expr, TypeAst};
use crate::engine::{Engine, RootSrc};
use crate::semantics::*;
use std::rc::Rc;
#[derive(Debug)]
pub struct Unsupported(pub String);
pub struct QReport {
pub ok: bool,
pub outputs: Vec<(String, String)>,
pub diagnostics: Vec<Diag>,
}
type RootSpec = (String, TypeAst, Rc<Expr>, Rc<Env>);
pub fn qevaluate(env: Rc<Env>) -> Result<QReport, Unsupported> {
let roots: Vec<RootSpec> = env
.outputs
.borrow()
.iter()
.map(|(n, t, e)| (n.clone(), t.clone(), e.clone(), env.clone()))
.collect();
let (report, _eng) = eval_rounds(&env, &roots, &[], &[], true)?;
Ok(report)
}
pub struct BoundSpec {
pub name: String,
pub raw: Value,
pub menv: Rc<Env>,
}
pub fn qevaluate_universe(
mods: &[Rc<Env>],
entry: &Rc<Env>,
binds: &[BoundSpec],
) -> Result<(QReport, Rc<Engine>), Unsupported> {
run_universe(mods, entry, binds, true)
}
pub(crate) fn run_universe(
mods: &[Rc<Env>],
entry: &Rc<Env>,
binds: &[BoundSpec],
serialize_outputs: bool,
) -> Result<(QReport, Rc<Engine>), Unsupported> {
let roots: Vec<RootSpec> = mods
.iter()
.flat_map(|m| {
m.outputs
.borrow()
.iter()
.map(|(n, t, e)| (n.clone(), t.clone(), e.clone(), m.clone()))
.collect::<Vec<_>>()
})
.collect();
eval_rounds(entry, &roots, binds, mods, serialize_outputs)
}
fn eval_rounds(
entry: &Rc<Env>,
roots: &[RootSpec],
binds: &[BoundSpec],
hook_mods: &[Rc<Env>],
serialize_outputs: bool,
) -> Result<(QReport, Rc<Engine>), Unsupported> {
let bind = |eng: &Rc<Engine>| {
for m in hook_mods {
eng.install_hooks(m, true);
}
for b in binds {
let decl = b.menv.inputs.borrow().get(&b.name).cloned();
let Some((ty_ast, _)) = decl else { continue };
let sc = Scope::new(&b.name, Some(b.menv.clone()));
match b.menv.resolve(&ty_ast, None) {
Ok(rt) => eng.bind_root(&b.name, RootSrc::Doc(b.raw.clone()), &rt, &sc),
Err(e) => entry.report(Diag::error(e, b.name.clone(), None)),
}
}
for (name, ty_ast, expr, menv) in roots {
if !eng.should_bind_root(name) {
continue;
}
let Ok(rt) = menv.resolve(ty_ast, None) else {
continue;
};
eng.bind_root(
name,
RootSrc::Expr(expr),
&rt,
&Scope::new(name, Some(menv.clone())),
);
}
};
let eng = Engine::evaluate_query(entry, &bind);
eng.validate_all("");
let diags = sort_diags(entry.diagnostics_vec()); entry.diag_set(diags.clone());
let ok = !diags.iter().any(|d| d.severity == "error");
let outputs = if ok && serialize_outputs {
roots
.iter()
.filter_map(|(n, _, _, _)| {
entry
.root(n)
.map(|v| (n.clone(), eng.serialize(&v, n, false)))
})
.collect()
} else {
vec![]
};
Ok((
QReport {
ok,
outputs,
diagnostics: diags,
},
eng,
))
}