use std::sync::Arc;
use dive_ir::ExprId;
use dive_ir::actions::ActionName;
use dive_value::Value;
use super::{Action, Acts, Enab, EnabledState, Flow, Gen, StateVals, Successor};
use crate::core::Core;
use crate::env::{Env, Ev, St, StateRef};
use crate::error::{EvalError, Result};
use crate::options::ActionComposition;
pub(crate) fn off_error(core: &Core, e: ExprId) -> EvalError {
EvalError::general(format!(
"The current version of TLC does not support action composition. An incomplete implementation can be enabled via the tlc2.tool.impl.Tool.cdot=true java property.\n{}",
core.loc(e)
))
}
fn distorted(core: &Core, e: ExprId) -> EvalError {
EvalError::unsupported(format!(
"action composition `A \\cdot B` with conjuncts after it or variables assigned before it (TLC's algorithm evaluates them against the intermediate state; `--action-composition=tlc` reproduces that) ({})",
core.loc(e)
))
}
fn copy_with(s0: &StateRef, s1: &StateVals) -> StateVals {
let current = match s0 {
StateRef::Vals(v) => Some(v),
_ => None,
};
s1.iter()
.enumerate()
.map(|(i, v)| {
v.as_ref()
.and_then(|_| current.and_then(|c| c.get(i).cloned().flatten()))
})
.collect()
}
impl Core {
fn bounded_composition(&self) -> bool {
self.host
.get()
.is_some_and(|host| host.requires_bounded_action_composition())
}
fn unproved_composition<T>(&self) -> Result<T> {
self.check_action_composition()?;
Err(EvalError::unsupported(
"unproved bounded action composition",
))
}
fn bounded_cdot_intermediates(
self: &Arc<Self>,
env: &Env,
s0: &StateRef,
a: ExprId,
b: ExprId,
) -> Result<Vec<StateVals>> {
if self.opts.action_composition != ActionComposition::Tla {
return self.unproved_composition();
}
let evaluator = crate::Evaluator {
core: self.clone(),
collected: None,
};
let mut inspected = env.clone();
if inspected.dynamic.cut == Some(0) && inspected.dynamic.subst.is_none() {
inspected.dynamic.cut = None;
}
let scope = crate::Scope {
env: inspected,
owner: self.ir.clone(),
names: self.names.clone(),
context: Arc::downgrade(self),
wrapper: None,
};
if evaluator
.canonical_producer_stability_budgeted(&[(a, scope.clone()), (b, scope)], &[], None)?
.is_none()
{
return self.unproved_composition();
}
let current = self.composition_current(s0)?;
if !matches!(¤t, StateRef::Vals(values) if values.len() == self.ir.vars().len() && values.iter().all(Option::is_some))
{
return self.unproved_composition();
}
if let Some(host) = self.host.get() {
host.check_bounded_action_composition()
.map_err(crate::host::host_error)?;
}
let empty = || vec![None; self.ir.vars().len()].into();
let intermediates = self.cdot_steps(env, ¤t, empty(), a, false)?;
if intermediates
.iter()
.any(|state| state.iter().any(Option::is_none))
{
return self.unproved_composition();
}
Ok(intermediates)
}
fn bounded_cdot_tail(
self: &Arc<Self>,
env: &Env,
intermediate: StateVals,
b: ExprId,
) -> Result<Vec<StateVals>> {
self.loop_work()?;
let empty = vec![None; self.ir.vars().len()].into();
let final_states = self.cdot_steps(env, &StateRef::Vals(intermediate), empty, b, true)?;
if final_states.len() > 1
|| final_states
.iter()
.any(|state| state.iter().any(Option::is_none))
{
return self.unproved_composition();
}
Ok(final_states)
}
fn composition_named(self: &Arc<Self>, state: &crate::NamedState) -> Result<StateVals> {
if !std::ptr::eq(state.context.as_ptr(), Arc::as_ptr(self)) {
return Err(EvalError::unsupported(
"foreign named action-composition state",
));
}
if state
.assignments()
.any(|(name, _)| self.root_var_named(name).is_none())
{
return Err(EvalError::unsupported(
"action composition with assigned hidden ENABLED variables",
));
}
Ok(self
.ir
.vars()
.iter()
.map(|decl| state.get(&self.ir.decl(*decl).name).cloned())
.collect())
}
fn composition_current(self: &Arc<Self>, state: &StateRef) -> Result<StateRef> {
match state {
StateRef::Named(state) => Ok(StateRef::Vals(self.composition_named(state)?)),
_ => Ok(state.clone()),
}
}
fn cdot_steps(
self: &Arc<Self>,
env: &Env,
s0: &StateRef,
t: StateVals,
a: ExprId,
bounded_tail: bool,
) -> Result<Vec<StateVals>> {
if !self.bounded_composition() {
self.check_action_composition()?;
}
let s0 = self.composition_current(s0)?;
let action = Action {
owner: self.ir.clone(),
names: self.names.clone(),
context: Arc::downgrade(self),
expr: a,
env: env.clone(),
name: ActionName::Unnamed,
params: Vec::new(),
label: String::new(),
id: usize::MAX,
};
let mut iss: Vec<StateVals> = Vec::new();
let mut collect = |s: &Successor<'_>| {
iss.push(StateVals::from(s.state));
Flow::Continue
};
let mut g = Gen {
core: self,
init: false,
diagnostic: false,
s0,
s1: t,
action: &action,
ordinal: 0,
emitted: 0,
intermediate: 0,
sink: &mut collect,
choices: None,
};
let result = g.step(a, &None, env);
if let Err(error) = result {
if bounded_tail && !iss.is_empty() && error.class() == crate::ErrorClass::Eval {
return self.unproved_composition();
}
return Err(error);
}
Ok(iss)
}
pub(crate) fn eval_cdot(
self: &Arc<Self>,
env: &mut Env,
st: &St,
a: ExprId,
b: ExprId,
e: ExprId,
) -> Result<Ev> {
if self.bounded_composition() {
let intermediates = self.bounded_cdot_intermediates(env, &st.s0, a, b)?;
let target = self.composition_current(&st.s1)?;
let StateRef::Vals(target) = target else {
return self.unproved_composition();
};
if target.len() != self.ir.vars().len() || target.iter().any(Option::is_none) {
return self.unproved_composition();
}
for intermediate in intermediates {
for successor in self.bounded_cdot_tail(env, intermediate, b)? {
self.loop_work()?;
let mut equal = true;
for (left, right) in successor.iter().zip(target.iter()) {
let (Some(left), Some(right)) = (left, right) else {
return self.unproved_composition();
};
if !self.equals(left, right)? {
equal = false;
break;
}
}
if equal {
return Ok(Ev::V(Value::TRUE));
}
}
}
return Ok(Ev::V(Value::FALSE));
}
if self.opts.action_composition == ActionComposition::Off {
return Err(off_error(self, e));
}
let empty: StateVals = vec![None; self.ir.vars().len()].into();
for t in self.cdot_steps(env, &st.s0, empty, a, false)? {
self.loop_work()?;
let st2 = St {
s0: StateRef::Vals(t),
s1: st.s1.clone(),
control: st.control,
};
match self.eval(&mut env.clone(), &st2, b)? {
Ev::V(Value::Bool(true)) => return Ok(Ev::V(Value::Bool(true))),
Ev::V(Value::Bool(false)) => {}
other => {
return Err(EvalError::general(format!(
"Attempted to evaluate an expression of form A \\cdot B, but B was {}.\n{}",
self.ev_string(&other),
self.loc(e)
)));
}
}
}
Ok(Ev::V(Value::Bool(false)))
}
}
impl Gen<'_, '_, '_> {
pub(super) fn cdot(
&mut self,
a: ExprId,
b: ExprId,
acts: &Acts,
env: &Env,
e: ExprId,
) -> Result<Flow> {
if self.core.bounded_composition() {
if acts.is_some() || self.s1.iter().any(Option::is_some) {
return self.core.unproved_composition();
}
let intermediates = self.core.bounded_cdot_intermediates(env, &self.s0, a, b)?;
for intermediate in intermediates {
for successor in self.core.bounded_cdot_tail(env, intermediate, b)? {
self.core.loop_work()?;
self.s1 = successor;
if self.emit() == Flow::Stop {
self.s1 = vec![None; self.core.ir.vars().len()].into();
return Ok(Flow::Stop);
}
}
}
self.s1 = vec![None; self.core.ir.vars().len()].into();
return Ok(Flow::Continue);
}
if self.choices.is_some() {
return Err(EvalError::unsupported(
"constructive generation of action composition",
));
}
let core = self.core;
let mode = core.opts.action_composition;
match mode {
ActionComposition::Off => return Err(off_error(core, e)),
ActionComposition::Tla if acts.is_some() || self.s1.iter().any(Option::is_some) => {
return Err(distorted(core, e));
}
_ => {}
}
core.check_action_composition()?;
let mut iss: Vec<StateVals> = Vec::new();
{
let mut collect = |s: &Successor<'_>| {
iss.push(StateVals::from(s.state));
Flow::Continue
};
let mut g = Gen {
core,
init: false,
diagnostic: false,
s0: self.s0.clone(),
s1: copy_with(&core.composition_current(&self.s0)?, &self.s1),
action: self.action,
ordinal: 0,
emitted: 0,
intermediate: 0,
sink: &mut collect,
choices: None,
};
g.step(a, acts, env)?;
}
if mode == ActionComposition::Tlc {
self.intermediate += iss.len() as u64;
}
let action = self.action;
for t in iss {
core.loop_work()?;
let mut g = Gen {
core,
init: false,
diagnostic: false,
s0: StateRef::Vals(t),
s1: self.s1.clone(),
action,
ordinal: self.ordinal,
emitted: 0,
intermediate: 0,
sink: &mut *self.sink,
choices: None,
};
let r = g.step(b, acts, env);
let n = g.emitted;
self.emitted += n;
self.ordinal += n;
if r? == Flow::Stop {
return Ok(Flow::Stop);
}
}
Ok(Flow::Continue)
}
}
impl Enab {
pub(super) fn cdot(
&self,
a: ExprId,
b: ExprId,
acts: &Acts,
env: &Env,
s1: &EnabledState,
e: ExprId,
) -> Result<Option<EnabledState>> {
let core = &self.core;
if core.bounded_composition() {
let mut continuation = acts.as_ref();
while let Some(item) = continuation {
if !matches!(item.kind, super::Kind::Changed) {
return core.unproved_composition();
}
continuation = item.next.as_ref();
}
if !s1.is_empty() {
return core.unproved_composition();
}
for intermediate in core.bounded_cdot_intermediates(env, &self.s0, a, b)? {
for successor in core.bounded_cdot_tail(env, intermediate, b)? {
core.loop_work()?;
let mut named = crate::NamedState::empty(core);
for (declaration, value) in core.ir.vars().iter().zip(successor.iter()) {
let Some(value) = value else {
return core.unproved_composition();
};
named = named.with(&core.ir.decl(*declaration).name, value.clone());
}
if let Some(successor) = self.cont(acts, named)? {
return Ok(Some(successor));
}
}
}
return Ok(None);
}
let root_s1 = core.composition_named(s1)?;
match core.opts.action_composition {
ActionComposition::Off => return Err(off_error(core, e)),
ActionComposition::Tla if acts.is_some() || !s1.is_empty() => {
return Err(distorted(core, e));
}
_ => {}
}
let t0 = copy_with(&core.composition_current(&self.s0)?, &root_s1);
for t in core.cdot_steps(env, &self.s0, t0, a, false)? {
core.loop_work()?;
let en = Enab {
core: core.clone(),
s0: StateRef::Vals(t),
};
if let Some(s2) = en.enabled(b, acts, env, s1.clone())? {
return Ok(Some(s2));
}
}
Ok(None)
}
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn copy_with_takes_current_values_of_assigned_variables() {
let s0 = StateRef::Vals(vec![Some(Value::Int(1)), Some(Value::Int(2))].into());
let s1: StateVals = vec![None, Some(Value::Int(9))].into();
assert_eq!(&*copy_with(&s0, &s1), &[None, Some(Value::Int(2))]);
assert_eq!(&*copy_with(&StateRef::Empty, &s1), &[None, None]);
}
}