swaitsandClaude Opus 4.7
3fc0d7c57d
`default(...)` is now a transition with the same semantics as any
event-driven transition. It fires immediately after the declaring
state's entries finish and its durings start, applying the standard
exit-to-LCA / enter-to-target algorithm. Three behavioral changes
follow from this unification:
* Optional. A state with children is no longer required to declare a
`default(...)`. When omitted, the state itself is the resting
innermost active state; substates are reachable only via explicit
transitions. This is the "microwave Standby" pattern — Standby
has substates like LowPower that you enter only on demand, and
`=> Standby;` lands at Standby itself with no descent.
* Targets anywhere. The default target may be any state in the chart
— a child (the classic descent case), a sibling, an ancestor,
anywhere. `default(<sibling-or-ancestor>)` exits the just-entered
state as part of the default-fire transition; the same rule fires
whether you wrote it for descent, redirection, or up-bounce.
* Cycle-checked at compile time. The default-edge graph (out-degree
≤ 1 per node) is rejected if it contains any cycle, including
`default(self)`. `state A { default(A); }` and `A → B → A` chains
fail to compile with a pinpoint error message naming the cycle.
This guarantees default chains terminate at runtime.
Implementation:
* `validate.rs`: drop the "must be direct child" and "must have
children" restrictions; add `validate_default_graph` (iterative
three-color cycle detection via chain walk).
* `ir.rs`: keep the unresolved default ident through to
`resolve_transitions` so non-child targets resolve against the
global state-name map (the same map transition targets use).
* `codegen.rs`: precomputed `(from, to)` paths no longer fold default
descent into the enter slice — each path is LCA-relative
`(exit, enter)` ending exactly at the explicit target.
`descend_defaults` (a parent-pointer walk) is replaced by
`follow_defaults`, which fires real transitions through
`apply_path` and emits `TransitionFired{Internal}` /
`TransitionComplete` brackets per link. Up-transitions don't
trigger default-following (nothing was freshly entered, so no
state's default fires).
* `active_durings_per_innermost_state`: predicate widened to include
composites without a default (they can now be the innermost active
state, so any durings they declare must be raced when current).
BREAKING CHANGES:
* Journal format. Default-fires now emit `TransitionFired` (with
`reason: TransitionReason::Internal`) and `TransitionComplete`
brackets around their entry sequence. `Internal` was previously
reserved and never emitted; it is now active. Tests that
hand-build expected journal sequences must include these brackets
around every default-fire.
* Validation. `default(<non-child>)` and `default` on a childless
state previously raised compile-time errors. Both are now valid.
Code relying on these as guard rails must adapt.
Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>
91 lines
2.5 KiB
Rust
91 lines
2.5 KiB
Rust
#![allow(dead_code)]
|
|
//! Deterministic-flow tests: `default(...)` chains. Hub → Spoke1 →
|
|
//! Spoke2. Each link fires as a real LCA-aware transition. The
|
|
//! compile-time default-graph cycle check guarantees this terminates.
|
|
|
|
#![cfg(all(feature = "tokio", feature = "journal"))]
|
|
#![allow(unexpected_cfgs)]
|
|
|
|
use hsmc::{statechart, TraceEvent};
|
|
|
|
#[derive(Default)]
|
|
pub struct Ctx;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Ev {
|
|
Halt,
|
|
}
|
|
|
|
statechart! {
|
|
ChainedDefault {
|
|
context: Ctx;
|
|
events: Ev;
|
|
default(Hub);
|
|
terminate(Halt);
|
|
|
|
state Hub {
|
|
entry: hub_in;
|
|
default(Spoke1);
|
|
}
|
|
state Spoke1 {
|
|
entry: s1_in;
|
|
exit: s1_out;
|
|
default(Spoke2);
|
|
}
|
|
state Spoke2 {
|
|
entry: s2_in;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl ChainedDefaultActions for ChainedDefaultActionContext<'_> {
|
|
async fn hub_in(&mut self) {}
|
|
async fn s1_in(&mut self) {}
|
|
async fn s1_out(&mut self) {}
|
|
async fn s2_in(&mut self) {}
|
|
}
|
|
|
|
const CD_ROOT: u16 = 0;
|
|
const CD_HUB: u16 = 1;
|
|
const CD_SPOKE1: u16 = 2;
|
|
const CD_SPOKE2: u16 = 3;
|
|
|
|
#[tokio::test(flavor = "current_thread")]
|
|
async fn det_chained_defaults_terminate_at_chain_end() {
|
|
tokio::task::LocalSet::new()
|
|
.run_until(async {
|
|
let mut m = ChainedDefault::new(Ctx);
|
|
let _ = m.step(hsmc::Duration::ZERO).await;
|
|
assert_eq!(m.current_state(), ChainedDefaultState::Spoke2);
|
|
|
|
let j = m.take_journal();
|
|
let entered: Vec<u16> = j
|
|
.iter()
|
|
.filter_map(|e| match e {
|
|
TraceEvent::Entered { state } => Some(*state),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
assert_eq!(entered, vec![CD_ROOT, CD_HUB, CD_SPOKE1, CD_SPOKE2]);
|
|
|
|
let exited: Vec<u16> = j
|
|
.iter()
|
|
.filter_map(|e| match e {
|
|
TraceEvent::Exited { state } => Some(*state),
|
|
_ => None,
|
|
})
|
|
.collect();
|
|
// Each default fires as a sibling-transition: Hub → Spoke1
|
|
// (exits Hub), then Spoke1 → Spoke2 (exits Spoke1).
|
|
assert_eq!(exited, vec![CD_HUB, CD_SPOKE1]);
|
|
|
|
// At least 2 TransitionFired events for the chained defaults.
|
|
let txn_count = j
|
|
.iter()
|
|
.filter(|e| matches!(e, TraceEvent::TransitionFired { .. }))
|
|
.count();
|
|
assert!(txn_count >= 2);
|
|
})
|
|
.await;
|
|
}
|