use std::collections::{HashMap, HashSet};
use std::sync::Arc;
use dive_eval::Evaluator;
use dive_ir::{DefId, DefKind, Ir, LocalRef, SlotKind, StdOp, Symbol};
use dive_value::Value;
use crate::level::parent_of;
#[derive(Clone, Debug)]
pub(crate) enum Look {
Def(DefId),
Value(Value),
Java(StdOp, DefId),
Literal(dive_ir::ExprId),
}
pub(crate) struct Tables {
pub(crate) ir: Arc<Ir>,
ev: Evaluator,
pub(crate) controlled: bool,
pub(crate) fallible_errors: bool,
root_vars: HashSet<String>,
pub(crate) consts: Vec<Option<Look>>,
pub(crate) tool_obj: HashMap<DefId, Look>,
pub(crate) body_obj: HashMap<DefId, Look>,
}
impl Tables {
pub(crate) fn new(ir: Arc<Ir>) -> Result<Self, crate::BindError> {
let n = ir.consts().len();
let ev = Evaluator::new(
dive_eval::Model::new(ir.clone()),
dive_eval::Options::default(),
)
.map_err(|e| crate::BindError::unsupported(e.to_string()))?;
let root_vars = ir.vars().iter().map(|&d| ir.decl(d).name.clone()).collect();
Ok(Self {
ir,
ev,
controlled: false,
fallible_errors: false,
root_vars,
consts: vec![None; n],
tool_obj: HashMap::new(),
body_obj: HashMap::new(),
})
}
pub(crate) fn set_evaluator(&mut self, ev: Evaluator, controlled: bool) {
self.ev = ev;
self.controlled = controlled;
}
pub(crate) fn eval_error(
&self,
error: dive_eval::EvalError,
to_binding: impl FnOnce(dive_eval::EvalError) -> crate::BindError,
) -> crate::control::StepError {
crate::control::eval_error(self.controlled, self.fallible_errors, error, to_binding)
}
pub(crate) fn is_exception(&self, error: &dive_eval::EvalError) -> bool {
((self.controlled || self.fallible_errors)
&& error.class() == dive_eval::ErrorClass::Interrupted)
|| (self.fallible_errors
&& matches!(
error.class(),
dive_eval::ErrorClass::ResourceLimit | dive_eval::ErrorClass::Bug
))
}
pub(crate) fn ev(&self) -> &Evaluator {
&self.ev
}
pub(crate) fn is_root_var_name(&self, name: &str) -> bool {
self.root_vars.contains(name)
}
pub(crate) fn lookup_def(&self, d: DefId) -> Look {
if let Some(l) = self.tool_obj.get(&d) {
return l.clone();
}
if let Some(l) = self.body_obj.get(&d) {
return l.clone();
}
if let Some(op) = self.ir.def(d).std {
return Look::Java(op, d);
}
let mut body = self.ir.def(d).body;
loop {
match self.ir.expr(body) {
dive_ir::Expr::Num(_) | dive_ir::Expr::Str(_) => return Look::Literal(body),
dive_ir::Expr::Subst { body: b, .. } => body = *b,
_ => break,
}
}
Look::Def(d)
}
pub(crate) fn const_look(&self, c: dive_ir::ConstId) -> Option<Look> {
self.consts.get(c.index()).cloned().flatten()
}
pub(crate) fn slot_info(&self, frame: DefId, r: LocalRef) -> Option<(String, SlotKind)> {
let ir = &*self.ir;
let mut target = frame;
if let dive_ir::DefScope::LetValue { parent, .. } = ir.def(target).scope {
target = parent;
}
for _ in 0..r.up {
target = parent_of(ir.def(target).scope)?;
if let dive_ir::DefScope::LetValue { parent, .. } = ir.def(target).scope {
target = parent;
}
}
let slot = ir.def(target).frame.get(r.slot.index())?;
Some((slot.name.clone(), slot.kind.clone()))
}
pub(crate) fn op_defs(&self, module: dive_ir::ModuleId) -> Vec<(String, DefId)> {
let ir = &*self.ir;
ir.module(module)
.context
.iter()
.filter_map(|(n, s)| match s {
Symbol::Def(d)
if matches!(ir.def(*d).kind, DefKind::Operator | DefKind::Function) =>
{
Some((n.clone(), *d))
}
_ => None,
})
.collect()
}
}