swaits/hsmc
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

chore: prepare 0.1.0 for crates.io publish

Browse Source 
Add LICENSE-MIT and LICENSE-APACHE at workspace root and in each member package so the dual MIT OR Apache-2.0 license ships in the published .crate.

Fill in publish metadata (authors, repository, homepage, readme, keywords, categories) across the workspace and both members.

Add CHANGELOG.md with a 0.1.0 initial release entry.

Fix clippy lints: unused enumerate index, collapsible if, Default impls for TimerTable, SimRadio, and Ctx, use RangeInclusive::contains.

Exclude examples/microwave_tui.rs from the published package. The file stays in-tree but has known unawaited async log futures that need a dedicated pass before it ships.

Apply cargo fmt across the workspace.
This commit is contained in:
swaits committed 2026-04-22 09:13:04 -06:00
1 parent 0341cf9379
commit bc7e17e58e
23 files changed
+2046 -849
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

hsmc-macros/src/codegen.rs
+253 -179
View File
@@ -154,7 +154,7 @@ fn render_state(
out.push('\n');
let child_prefix = format!("{}{}", prefix, if is_last { " " } else { "│ " });
// Entry actions
for (_i, aid) in s.entries.iter().enumerate() {
for aid in &s.entries {
let name = &ir.actions[*aid as usize].name;
out.push_str(&child_prefix);
out.push_str("• entry: ");
@@ -289,7 +289,8 @@ fn emit_embassy_race_arms_with_channel(ir: &Ir) -> Vec<TokenStream> {
let (sel_fn, variants) = embassy_select_for_arity(n + 2);
let ch_variant = &variants[n];
let tm_variant = &variants[n + 1];
let call_args = binds.iter()
let call_args = binds
.iter()
.map(|b| quote! { #b })
.chain(std::iter::once(quote! { rx.receive() }))
.chain(std::iter::once(quote! { timer_fut }));
@@ -352,7 +353,8 @@ fn emit_embassy_race_arms_timer_only(ir: &Ir) -> Vec<TokenStream> {
}
let (binds, stmts) = emit_during_bindings(&chain);
let (sel_fn, variants) = embassy_select_for_arity(n + 1);
let call_args = binds.iter()
let call_args = binds
.iter()
.map(|b| quote! { #b })
.chain(std::iter::once(quote! { timer_fut }));
let either_path = if n + 1 == 2 {
@@ -412,203 +414,275 @@ pub fn generate(ir: &Ir) -> TokenStream {
.map(|s| s.name.clone())
.collect();
let entries_of_arms: Vec<_> = ir.states.iter().map(|s| {
let sid = s.id;
let entries_tok: Vec<_> = s.entries.iter().map(|a| quote! { #a }).collect();
quote! { #sid => &[#(#entries_tok),*], }
}).collect();
let exits_of_arms: Vec<_> = ir.states.iter().map(|s| {
let sid = s.id;
let exits_tok: Vec<_> = s.exits.iter().map(|a| quote! { #a }).collect();
quote! { #sid => &[#(#exits_tok),*], }
}).collect();
let entries_of_arms: Vec<_> = ir
.states
.iter()
.map(|s| {
let sid = s.id;
let entries_tok: Vec<_> = s.entries.iter().map(|a| quote! { #a }).collect();
quote! { #sid => &[#(#entries_tok),*], }
})
.collect();
let exits_of_arms: Vec<_> = ir
.states
.iter()
.map(|s| {
let sid = s.id;
let exits_tok: Vec<_> = s.exits.iter().map(|a| quote! { #a }).collect();
quote! { #sid => &[#(#exits_tok),*], }
})
.collect();
let parent_table = ir.states.iter().map(|s| match s.parent {
Some(p) => quote! { Some(#p) },
None => quote! { None },
}).collect::<Vec<_>>();
let depth_table = ir.states.iter().map(|s| {
let d = s.depth;
quote! { #d }
}).collect::<Vec<_>>();
let default_child_table = ir.states.iter().map(|s| match s.default_child {
Some(c) => quote! { Some(#c) },
None => quote! { None },
}).collect::<Vec<_>>();
let state_id_to_variant_arms = ir.states.iter().filter(|s| s.parent.is_some()).map(|s| {
let id = s.id;
let nm = &s.name;
quote! { #id => #state_enum_name::#nm, }
}).collect::<Vec<_>>();
let parent_table = ir
.states
.iter()
.map(|s| match s.parent {
Some(p) => quote! { Some(#p) },
None => quote! { None },
})
.collect::<Vec<_>>();
let depth_table = ir
.states
.iter()
.map(|s| {
let d = s.depth;
quote! { #d }
})
.collect::<Vec<_>>();
let default_child_table = ir
.states
.iter()
.map(|s| match s.default_child {
Some(c) => quote! { Some(#c) },
None => quote! { None },
})
.collect::<Vec<_>>();
let state_id_to_variant_arms = ir
.states
.iter()
.filter(|s| s.parent.is_some())
.map(|s| {
let id = s.id;
let nm = &s.name;
quote! { #id => #state_enum_name::#nm, }
})
.collect::<Vec<_>>();
// Trait methods, possibly with typed params for payload-bearing actions.
let action_methods_sync = ir.actions.iter().map(|a| {
let name = &a.name;
let params = a.params.iter().map(|f| {
let n = &f.name;
let t = &f.ty;
quote! { #n: #t }
});
quote! { fn #name(&mut self, #(#params),*); }
}).collect::<Vec<_>>();
let action_methods_async = ir.actions.iter().map(|a| {
let name = &a.name;
let params = a.params.iter().map(|f| {
let n = &f.name;
let t = &f.ty;
quote! { #n: #t }
});
quote! {
fn #name(&mut self, #(#params),*) -> impl ::core::future::Future<Output = ()>;
}
}).collect::<Vec<_>>();
let action_methods_sync = ir
.actions
.iter()
.map(|a| {
let name = &a.name;
let params = a.params.iter().map(|f| {
let n = &f.name;
let t = &f.ty;
quote! { #n: #t }
});
quote! { fn #name(&mut self, #(#params),*); }
})
.collect::<Vec<_>>();
let action_methods_async = ir
.actions
.iter()
.map(|a| {
let name = &a.name;
let params = a.params.iter().map(|f| {
let n = &f.name;
let t = &f.ty;
quote! { #n: #t }
});
quote! {
fn #name(&mut self, #(#params),*) -> impl ::core::future::Future<Output = ()>;
}
})
.collect::<Vec<_>>();
// Dispatch arms: for unit-signature actions call straight through; for
// payload-bearing actions, re-match on the passed event and destructure.
// Payload dispatch binds each field by reference (scrutinee is `&Ev`)
// then `.clone()`s it to produce an owned value matching the handler's
// declared signature. For `Copy` types this optimizes away.
let run_action_arms_sync = ir.actions.iter().enumerate().map(|(i, a)| {
let i = i as u16;
let name = &a.name;
if a.params.is_empty() {
quote! { #i => <Ctx as #actions_trait_name>::#name(ctx), }
} else {
let field_idents: Vec<_> = a.params.iter().map(|f| f.name.clone()).collect();
let clone_args = field_idents.iter().map(|n| quote! { #n.clone() });
let variant_arms = a.bound_variants.iter().map(|bv| {
let vname = &bv.name;
let binds = &field_idents;
let call = {
let clones = clone_args.clone();
quote! { <Ctx as #actions_trait_name>::#name(ctx, #(#clones),*); }
};
match bv.kind {
PayloadKind::Tuple => quote! {
#ev_ty::#vname(#(#binds),*) => { #call }
},
PayloadKind::Struct => quote! {
#ev_ty::#vname { #(#binds),* } => { #call }
},
}
});
quote! {
#i => {
if let Some(__ev) = __event {
match __ev {
#(#variant_arms)*
_ => {}
let run_action_arms_sync = ir
.actions
.iter()
.enumerate()
.map(|(i, a)| {
let i = i as u16;
let name = &a.name;
if a.params.is_empty() {
quote! { #i => <Ctx as #actions_trait_name>::#name(ctx), }
} else {
let field_idents: Vec<_> = a.params.iter().map(|f| f.name.clone()).collect();
let clone_args = field_idents.iter().map(|n| quote! { #n.clone() });
let variant_arms = a.bound_variants.iter().map(|bv| {
let vname = &bv.name;
let binds = &field_idents;
let call = {
let clones = clone_args.clone();
quote! { <Ctx as #actions_trait_name>::#name(ctx, #(#clones),*); }
};
match bv.kind {
PayloadKind::Tuple => quote! {
#ev_ty::#vname(#(#binds),*) => { #call }
},
PayloadKind::Struct => quote! {
#ev_ty::#vname { #(#binds),* } => { #call }
},
}
});
quote! {
#i => {
if let Some(__ev) = __event {
match __ev {
#(#variant_arms)*
_ => {}
}
}
}
}
}
}
}).collect::<Vec<_>>();
let run_action_arms_async = ir.actions.iter().enumerate().map(|(i, a)| {
let i = i as u16;
let name = &a.name;
if a.params.is_empty() {
quote! { #i => <Ctx as #actions_trait_name>::#name(ctx).await, }
} else {
let field_idents: Vec<_> = a.params.iter().map(|f| f.name.clone()).collect();
let clone_args = field_idents.iter().map(|n| quote! { #n.clone() });
let variant_arms = a.bound_variants.iter().map(|bv| {
let vname = &bv.name;
let binds = &field_idents;
let call = {
let clones = clone_args.clone();
quote! { <Ctx as #actions_trait_name>::#name(ctx, #(#clones),*).await; }
};
match bv.kind {
PayloadKind::Tuple => quote! {
#ev_ty::#vname(#(#binds),*) => { #call }
},
PayloadKind::Struct => quote! {
#ev_ty::#vname { #(#binds),* } => { #call }
},
}
});
quote! {
#i => {
if let Some(__ev) = __event {
match __ev {
#(#variant_arms)*
_ => {}
})
.collect::<Vec<_>>();
let run_action_arms_async = ir
.actions
.iter()
.enumerate()
.map(|(i, a)| {
let i = i as u16;
let name = &a.name;
if a.params.is_empty() {
quote! { #i => <Ctx as #actions_trait_name>::#name(ctx).await, }
} else {
let field_idents: Vec<_> = a.params.iter().map(|f| f.name.clone()).collect();
let clone_args = field_idents.iter().map(|n| quote! { #n.clone() });
let variant_arms = a.bound_variants.iter().map(|bv| {
let vname = &bv.name;
let binds = &field_idents;
let call = {
let clones = clone_args.clone();
quote! { <Ctx as #actions_trait_name>::#name(ctx, #(#clones),*).await; }
};
match bv.kind {
PayloadKind::Tuple => quote! {
#ev_ty::#vname(#(#binds),*) => { #call }
},
PayloadKind::Struct => quote! {
#ev_ty::#vname { #(#binds),* } => { #call }
},
}
});
quote! {
#i => {
if let Some(__ev) = __event {
match __ev {
#(#variant_arms)*
_ => {}
}
}
}
}
}
}
}).collect::<Vec<_>>();
let duration_expr_arms = ir.duration_triggers.iter().enumerate().map(|(i, d)| {
let i = i as u16;
let expr = &d.expr;
quote! { #i => { let __d: ::hsmc::Duration = #expr; __d }, }
}).collect::<Vec<_>>();
let duration_repeat_arms = ir.duration_triggers.iter().enumerate().map(|(i, d)| {
let i = i as u16;
let repeat = d.repeat;
quote! { #i => #repeat, }
}).collect::<Vec<_>>();
let event_variant_arms = ir.event_variants.iter().enumerate().map(|(i, v)| {
let i = i as u16;
let name = &v.name;
let pat = match v.kind {
VariantKind::Unit => quote! { #ev_ty::#name },
VariantKind::Tuple => quote! { #ev_ty::#name(..) },
VariantKind::Struct => quote! { #ev_ty::#name { .. } },
};
quote! { #pat => #i, }
}).collect::<Vec<_>>();
let state_handler_arms = ir.states.iter().map(|s| {
use std::collections::BTreeMap;
#[derive(Default)]
struct Group { action_ids: Vec<u16>, transition_target: Option<u16> }
let mut groups: BTreeMap<(u8, u16), Group> = BTreeMap::new();
let mut handlers = s.handlers.iter().collect::<Vec<_>>();
handlers.sort_by_key(|h| h.decl_index);
for h in handlers {
let key = match &h.trigger {
TriggerIr::Event(id, _, _) => (0u8, *id),
TriggerIr::Duration(id) => (1u8, *id),
})
.collect::<Vec<_>>();
let duration_expr_arms = ir
.duration_triggers
.iter()
.enumerate()
.map(|(i, d)| {
let i = i as u16;
let expr = &d.expr;
quote! { #i => { let __d: ::hsmc::Duration = #expr; __d }, }
})
.collect::<Vec<_>>();
let duration_repeat_arms = ir
.duration_triggers
.iter()
.enumerate()
.map(|(i, d)| {
let i = i as u16;
let repeat = d.repeat;
quote! { #i => #repeat, }
})
.collect::<Vec<_>>();
let event_variant_arms = ir
.event_variants
.iter()
.enumerate()
.map(|(i, v)| {
let i = i as u16;
let name = &v.name;
let pat = match v.kind {
VariantKind::Unit => quote! { #ev_ty::#name },
VariantKind::Tuple => quote! { #ev_ty::#name(..) },
VariantKind::Struct => quote! { #ev_ty::#name { .. } },
};
let g = groups.entry(key).or_default();
match &h.kind {
HandlerKindIr::Action(aid, _) => g.action_ids.push(*aid),
HandlerKindIr::Transition(_, Some(tid)) => g.transition_target = Some(*tid),
HandlerKindIr::Transition(_, None) => {}
quote! { #pat => #i, }
})
.collect::<Vec<_>>();
let state_handler_arms = ir
.states
.iter()
.map(|s| {
use std::collections::BTreeMap;
#[derive(Default)]
struct Group {
action_ids: Vec<u16>,
transition_target: Option<u16>,
}
}
let sid = s.id;
let inner_arms = groups.iter().map(|((kind, tid), g)| {
let kind = *kind;
let tid = *tid;
let actions = g.action_ids.iter().map(|a| quote! { #a });
let transition_tok = match g.transition_target {
Some(t) => quote! { Some(#t) },
None => quote! { None },
};
let mut groups: BTreeMap<(u8, u16), Group> = BTreeMap::new();
let mut handlers = s.handlers.iter().collect::<Vec<_>>();
handlers.sort_by_key(|h| h.decl_index);
for h in handlers {
let key = match &h.trigger {
TriggerIr::Event(id, _, _) => (0u8, *id),
TriggerIr::Duration(id) => (1u8, *id),
};
let g = groups.entry(key).or_default();
match &h.kind {
HandlerKindIr::Action(aid, _) => g.action_ids.push(*aid),
HandlerKindIr::Transition(_, Some(tid)) => g.transition_target = Some(*tid),
HandlerKindIr::Transition(_, None) => {}
}
}
let sid = s.id;
let inner_arms = groups
.iter()
.map(|((kind, tid), g)| {
let kind = *kind;
let tid = *tid;
let actions = g.action_ids.iter().map(|a| quote! { #a });
let transition_tok = match g.transition_target {
Some(t) => quote! { Some(#t) },
None => quote! { None },
};
quote! {
(#kind, #tid) => {
let actions: &'static [u16] = &[#(#actions),*];
let target: Option<u16> = #transition_tok;
return Some((actions, target));
}
}
})
.collect::<Vec<_>>();
quote! {
(#kind, #tid) => {
let actions: &'static [u16] = &[#(#actions),*];
let target: Option<u16> = #transition_tok;
return Some((actions, target));
#sid => {
match (trigger_kind, trigger_id) {
#(#inner_arms)*
_ => {}
}
}
}
}).collect::<Vec<_>>();
quote! {
#sid => {
match (trigger_kind, trigger_id) {
#(#inner_arms)*
_ => {}
}
}
}
}).collect::<Vec<_>>();
let owned_timers_arms = ir.states.iter().map(|s| {
let sid = s.id;
let ids = s.owned_timers.iter().map(|t| quote! { #t });
quote! { #sid => &[#(#ids),*], }
}).collect::<Vec<_>>();
})
.collect::<Vec<_>>();
let owned_timers_arms = ir
.states
.iter()
.map(|s| {
let sid = s.id;
let ids = s.owned_timers.iter().map(|t| quote! { #t });
quote! { #sid => &[#(#ids),*], }
})
.collect::<Vec<_>>();
let terminate_match = if let Some(tev) = &ir.terminate_event {
// Use the kind recorded for this variant (unit/tuple/struct).
let kind = ir
hsmc-macros/src/ir.rs
+19 -22
View File
@@ -143,7 +143,13 @@ pub fn build_ir(input: StatechartInput) -> syn::Result<Ir> {
let name_span = ir.name.span();
let root_name = Ident::new("__Root", name_span);
let root_id = alloc_state(&mut ir, root_name, None, 0, root_body.default_span.unwrap_or(name_span));
let root_id = alloc_state(
&mut ir,
root_name,
None,
0,
root_body.default_span.unwrap_or(name_span),
);
lower_body(&mut ir, root_id, &root_body, true, &state_names)?;
Ok(ir)
@@ -271,11 +277,7 @@ fn params_match(a: &[PayloadField], b: &[PayloadField]) -> bool {
})
}
fn intern_event(
ir: &mut Ir,
i: &Ident,
payload: Option<&EventPayload>,
) -> syn::Result<u16> {
fn intern_event(ir: &mut Ir, i: &Ident, payload: Option<&EventPayload>) -> syn::Result<u16> {
let kind = match payload {
None => VariantKind::Unit,
Some(p) => match p.kind {
@@ -348,13 +350,7 @@ fn variant_kind_name(k: VariantKind) -> &'static str {
}
}
fn intern_duration(
ir: &mut Ir,
expr: &Expr,
key: &str,
repeat: bool,
span: Span,
) -> u16 {
fn intern_duration(ir: &mut Ir, expr: &Expr, key: &str, repeat: bool, span: Span) -> u16 {
let full_key = format!("{}:{}", key, repeat);
if let Some(dt) = ir.duration_triggers.iter().find(|d| d.key == full_key) {
return dt.id;
@@ -395,7 +391,12 @@ fn lower_body(
let id = intern_event(ir, variant, payload.as_ref())?;
TriggerIr::Event(id, variant.clone(), payload.clone())
}
Trigger::Duration { expr, key, span, repeat } => {
Trigger::Duration {
expr,
key,
span,
repeat,
} => {
let id = intern_duration(ir, expr, key, *repeat, *span);
let owned = &mut ir.states[state_id as usize].owned_timers;
if !owned.contains(&id) {
@@ -477,13 +478,9 @@ fn classify_target(
} else {
// Action handler.
let aid = match trig {
TriggerIr::Event(_, variant, Some(payload)) => intern_action_with_params(
ir,
target,
&payload.fields,
variant,
payload.kind,
)?,
TriggerIr::Event(_, variant, Some(payload)) => {
intern_action_with_params(ir, target, &payload.fields, variant, payload.kind)?
}
_ => intern_action_unit(ir, target)?,
};
Ok(HandlerKindIr::Action(aid, target.clone()))
@@ -495,7 +492,7 @@ pub fn resolve_transitions(ir: &mut Ir) -> syn::Result<()> {
let mut name_map = std::collections::HashMap::new();
for s in &ir.states {
if s.name != "__Root" {
if name_map.insert(s.name.to_string(), s.id).is_some() {}
name_map.insert(s.name.to_string(), s.id);
}
}
hsmc-macros/src/lib.rs
+3 -3
View File
@@ -4,10 +4,10 @@
use proc_macro::TokenStream;
mod parse;
mod ir;
mod validate;
mod codegen;
mod ir;
mod parse;
mod validate;
/// See the `hsmc` crate for documentation.
#[proc_macro]
hsmc-macros/src/parse.rs
+23 -5
View File
@@ -176,7 +176,10 @@ fn parse_body(input: ParseStream, is_root: bool) -> syn::Result<StateBody> {
let ty: Type = input.parse()?;
input.parse::<Token![;]>()?;
if !is_root {
return Err(syn::Error::new(ident.span(), "`context:` is only valid at root"));
return Err(syn::Error::new(
ident.span(),
"`context:` is only valid at root",
));
}
body.context_ty = Some(ty);
}
@@ -186,7 +189,10 @@ fn parse_body(input: ParseStream, is_root: bool) -> syn::Result<StateBody> {
let ty: Type = input.parse()?;
input.parse::<Token![;]>()?;
if !is_root {
return Err(syn::Error::new(ident.span(), "`events:` is only valid at root"));
return Err(syn::Error::new(
ident.span(),
"`events:` is only valid at root",
));
}
body.event_ty = Some(ty);
}
@@ -290,10 +296,17 @@ fn parse_body(input: ParseStream, is_root: bool) -> syn::Result<StateBody> {
let content;
braced!(content in input);
let cbody = parse_body(&content, false)?;
body.children.push(StateDecl { name: sname.clone(), body: cbody, span: sname.span() });
body.children.push(StateDecl {
name: sname.clone(),
body: cbody,
span: sname.span(),
});
}
other => {
return Err(syn::Error::new(ident.span(), format!("unknown item `{}` in statechart body", other)));
return Err(syn::Error::new(
ident.span(),
format!("unknown item `{}` in statechart body", other),
));
}
}
} else {
@@ -423,7 +436,12 @@ fn parse_duration_rest(input: ParseStream, repeat: bool) -> syn::Result<Trigger>
}
}
let key = expr_to_string(&expr);
Ok(Trigger::Duration { expr, key, span, repeat })
Ok(Trigger::Duration {
expr,
key,
span,
repeat,
})
}
fn expr_to_string(e: &Expr) -> String {
hsmc-macros/src/validate.rs
+26 -7
View File
@@ -15,7 +15,10 @@ pub fn validate(ir: &Ir) -> syn::Result<()> {
continue;
}
if let Some(_prev) = seen.insert(s.name.to_string(), s.id) {
return Err(syn::Error::new(s.span, format!("duplicate state name `{}`", s.name)));
return Err(syn::Error::new(
s.span,
format!("duplicate state name `{}`", s.name),
));
}
}
@@ -90,7 +93,10 @@ pub fn validate(ir: &Ir) -> syn::Result<()> {
if !s.children.is_empty() && s.default_child.is_none() {
return Err(syn::Error::new(
s.span,
format!("state `{}` has children but no `default` declaration", s.name),
format!(
"state `{}` has children but no `default` declaration",
s.name
),
));
}
@@ -118,7 +124,10 @@ pub fn validate(ir: &Ir) -> syn::Result<()> {
if let Some(_prev) = trig_txn_seen.insert(key.clone(), h.decl_index) {
return Err(syn::Error::new(
trig_span,
format!("duplicate transition on trigger `{}` in state `{}`", trig_display, s.name),
format!(
"duplicate transition on trigger `{}` in state `{}`",
trig_display, s.name
),
));
}
if !name_map.contains_key(&target.to_string()) {
@@ -181,25 +190,35 @@ pub fn validate_parse_tree(input: &StatechartInput) -> syn::Result<()> {
fn validate_body(body: &StateBody, is_root: bool, state_name: &str) -> syn::Result<()> {
if body.default_count > 1 {
return Err(syn::Error::new(
body.default_span.unwrap_or_else(proc_macro2::Span::call_site),
body.default_span
.unwrap_or_else(proc_macro2::Span::call_site),
format!("multiple `default` declarations in state `{}`", state_name),
));
}
if body.terminate_count > 1 {
return Err(syn::Error::new(
body.terminate.as_ref().map(|(_, s)| *s).unwrap_or_else(proc_macro2::Span::call_site),
body.terminate
.as_ref()
.map(|(_, s)| *s)
.unwrap_or_else(proc_macro2::Span::call_site),
"multiple `terminate` declarations",
));
}
if !is_root {
if let Some((_, span)) = &body.terminate {
return Err(syn::Error::new(*span, "`terminate` is only valid at the root level"));
return Err(syn::Error::new(
*span,
"`terminate` is only valid at the root level",
));
}
}
if body.default_child.is_some() && body.children.is_empty() {
return Err(syn::Error::new(
body.default_span.unwrap(),
format!("`default` in state `{}` which has no child states", state_name),
format!(
"`default` in state `{}` which has no child states",
state_name
),
));
}
if let (Some((dc, dspan)), false) = (&body.default_child, body.children.is_empty()) {