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>
51 lines
1.1 KiB
Rust
51 lines
1.1 KiB
Rust
//! Compile-pass: a composite state may omit `default(...)`.
|
|
//!
|
|
//! When a composite has children but no `default`, transitions targeting
|
|
//! that composite land on the composite itself — the substates are reachable
|
|
//! only via explicit transitions. Microwave-style chart: `Standby` is the
|
|
//! resting state and `LowPower` is a sub-mode you enter only on demand.
|
|
#![allow(unexpected_cfgs)]
|
|
|
|
use hsmc::statechart;
|
|
|
|
#[derive(Debug, Clone)]
|
|
pub enum Ev {
|
|
PowerOn,
|
|
PowerOff,
|
|
EnterLowPower,
|
|
LeaveLowPower,
|
|
Halt,
|
|
}
|
|
|
|
#[derive(Default)]
|
|
pub struct Ctx;
|
|
|
|
statechart! {
|
|
Microwave {
|
|
context: Ctx;
|
|
events: Ev;
|
|
default(Standby);
|
|
terminate(Halt);
|
|
|
|
state Standby {
|
|
// No `default(...)` — Standby is itself the resting state.
|
|
on(PowerOn) => On;
|
|
on(EnterLowPower) => LowPower;
|
|
|
|
state LowPower {
|
|
on(LeaveLowPower) => Standby;
|
|
}
|
|
}
|
|
|
|
state On {
|
|
on(PowerOff) => Standby;
|
|
}
|
|
}
|
|
}
|
|
|
|
impl MicrowaveActions for MicrowaveActionContext<'_> {}
|
|
|
|
fn main() {
|
|
let _ = Microwave::new(Ctx);
|
|
}
|