use dive_core::plan::Code;
use dive_core::{Error, ErrorKind, Handle, Machine, Sink};
use crate::{Explorer, state_identity};
#[derive(Clone, Copy, Debug, PartialEq, Eq)]
pub enum Site {
Init,
Next(usize),
Constraint(usize),
ActionConstraint(usize),
Invariant(usize),
ImpliedInit(usize),
ImpliedAction(usize),
Incomplete,
Fingerprint,
View,
}
#[derive(Clone, Debug, PartialEq, Eq)]
pub struct Failure {
pub site: Site,
pub message: String,
pub initial: bool,
pub parent: Option<Vec<Handle>>,
pub state: Option<Vec<Handle>>,
pub action: Option<usize>,
pub init_action: Option<usize>,
pub in_model: bool,
pub emitted: u64,
}
impl Failure {
#[must_use]
pub fn site_resumes(&self) -> bool {
matches!(self.site, Site::Invariant(_)) && !self.initial && self.in_model
}
}
#[derive(Clone, Debug, Default, PartialEq, Eq)]
pub struct Replayed {
pub distinct: u64,
pub queued: u64,
pub error: Option<Failure>,
}
fn persist(m: &mut Machine, hs: &[Handle]) -> Result<Vec<Handle>, Error> {
let mut out = Vec::with_capacity(hs.len());
for &h in hs {
out.push(if h.is_empty() { h } else { m.heap.intern(h)? });
}
Ok(out)
}
impl Explorer<'_> {
pub(crate) fn fail_check(&mut self, m: &mut Machine, site: Site, e: Error) -> Error {
if e.kind() != ErrorKind::Eval {
return e;
}
match self.failure_at(m, site, e.message().to_owned()) {
Ok(f) => {
self.failure = Some(f);
Error::stop()
}
Err(e) => e,
}
}
pub(crate) fn failure_at(
&mut self,
m: &mut Machine,
site: Site,
message: String,
) -> Result<Failure, Error> {
let state = Some(persist(m, &m.s1.clone())?);
let parent = if self.initial {
None
} else {
Some(m.s0.clone())
};
Ok(Failure {
site,
message,
initial: self.initial,
parent,
state,
action: self.action,
init_action: self.init_action,
in_model: self.in_model,
emitted: 0,
})
}
pub(crate) fn generator_failure(&self, m: &Machine, message: String) -> Failure {
Failure {
site: self.action.map_or(Site::Init, Site::Next),
message,
initial: self.initial,
parent: (!self.initial).then(|| m.s0.clone()),
state: None,
action: self.action,
init_action: self.init_action,
in_model: false,
emitted: self.emitted - self.action_start,
}
}
}
struct Collect {
states: Vec<(Vec<Handle>, bool)>,
}
impl Sink for Collect {
fn emit(&mut self, m: &mut Machine, _code: &Code) -> Result<(), Error> {
let complete = m.assigned == m.s1.len();
let values = persist(m, &m.s1.clone())?;
self.states.push((values, complete));
Ok(())
}
}
pub(crate) fn replay_after(
m: &mut Machine,
ex: &mut Explorer<'_>,
ordinal: u64,
) -> Result<Replayed, Error> {
m.without_debugger(|m| replay_after_unobserved(m, ex, ordinal))
}
fn replay_after_unobserved(
m: &mut Machine,
ex: &mut Explorer<'_>,
ordinal: u64,
) -> Result<Replayed, Error> {
let plan = ex.plan;
let code = &plan.code;
let s0 = m.s0.clone();
let mut out = Replayed::default();
let mut added = ex.seen.empty_like();
let mut emission = 0u64;
for (index, a) in plan.next.iter().enumerate() {
ex.action = Some(index);
let mut sink = Collect { states: Vec::new() };
let old = m.enter(a.frame);
for &(slot, v) in &a.preset {
if let Some(x) = m.frame.get_mut(m.base + slot as usize) {
*x = v;
}
}
let ran = m.run_action(code, a.g, &mut sink);
m.leave(old);
if let Err(e) = ran {
if e.kind() != ErrorKind::Eval {
return Err(e);
}
out.error = Some(Failure {
site: Site::Next(index),
message: e.message().to_owned(),
initial: false,
parent: Some(s0),
state: None,
action: Some(index),
init_action: None,
in_model: false,
emitted: sink.states.len() as u64,
});
return Ok(out);
}
for (values, complete) in sink.states {
let o = emission;
emission += 1;
if o < ordinal {
continue;
}
if !complete {
return Ok(out);
}
m.s0.copy_from_slice(&s0);
m.s1.copy_from_slice(&values);
if o == ordinal {
if !replay_implied(m, ex, &mut out)? {
return Ok(out);
}
continue;
}
ex.changed = crate::changed_vars(m);
let inside = match ex.in_model_of(m) {
Ok(b) => b,
Err((site, e)) => {
if e.kind() != ErrorKind::Eval {
return Err(e);
}
ex.in_model = true;
out.error = Some(ex.failure_at(m, site, e.message().to_owned())?);
return Ok(out);
}
};
let mut new = true;
if inside {
let mut identity = Vec::new();
let key =
match state_identity(m, plan, ex.seen.exact.as_ref().map(|_| &mut identity)) {
Ok(k) => ex.seen.key(k),
Err(e) if e.kind() == ErrorKind::Eval && plan.view.is_some() => {
out.error =
Some(ex.failure_at(m, Site::View, e.message().to_owned())?);
return Ok(out);
}
Err(e) => return Err(e),
};
new = !ex.seen_contains(key, &identity, &m.heap, ("ReplayMembership", Some(o)))?
&& (ex.disk.is_some()
|| !added.contains_row(key, &identity, &m.heap, ex.poll)?);
if new {
if ex.disk.is_some() {
ex.seen_insert(key, &identity, &m.heap, ("ReplayInsertion", Some(o)))?;
} else {
added.insert_row(key, &identity, &m.heap, u64::MAX, ex.poll)?;
}
out.distinct += 1;
}
}
if new && !replay_invariants(m, ex, inside, &mut out)? {
return Ok(out);
}
if !replay_implied(m, ex, &mut out)? {
return Ok(out);
}
if inside && new {
out.queued += 1;
}
}
}
Ok(out)
}
fn replay_invariants(
m: &mut Machine,
ex: &mut Explorer<'_>,
inside: bool,
out: &mut Replayed,
) -> Result<bool, Error> {
let plan = ex.plan;
for (i, c) in plan.invariants.iter().enumerate() {
match ex.check(m, &plan.code, c) {
Ok(true) => {}
Ok(false) => return Ok(false),
Err(e) => {
if e.kind() != ErrorKind::Eval {
return Err(e);
}
ex.in_model = inside;
out.error = Some(ex.failure_at(m, Site::Invariant(i), e.message().to_owned())?);
return Ok(false);
}
}
}
Ok(true)
}
fn replay_implied(
m: &mut Machine,
ex: &mut Explorer<'_>,
out: &mut Replayed,
) -> Result<bool, Error> {
let plan = ex.plan;
for (i, c) in plan.implied_actions.iter().enumerate() {
match crate::check_step(m, &plan.code, c) {
Ok(true) => {}
Ok(false) => return Ok(false),
Err(e) => {
if e.kind() != ErrorKind::Eval {
return Err(e);
}
out.error =
Some(ex.failure_at(m, Site::ImpliedAction(i), e.message().to_owned())?);
return Ok(false);
}
}
}
Ok(true)
}