use proc_macro2::Span;
use syn::spanned::Spanned;
use syn::{Data, DeriveInput, Type};
use layline_codegen::{BitOrder, Endian, Param, Root, Scalar};
use crate::ty::scalar_of;
pub(super) struct MessageAttr {
pub(super) endian: Endian,
pub(super) root: Root,
pub(super) closed: Option<Span>,
pub(super) bits: Option<(BitOrder, Span)>,
pub(super) needs: Option<(Vec<Param>, Span)>,
}
pub(super) const MESSAGE_ATTRS: &[&str] = &[
"message", "count", "len", "stride", "fill", "seek", "at", "codec", "bits", "bytes", "text",
"until", "var", "switch", "when", "with", "present", "checksum", "magic", "value", "other",
"range",
];
fn refuse_misplaced_on_container(input: &DeriveInput) -> syn::Result<()> {
let catalogue = matches!(input.data, Data::Enum(_));
for attr in &input.attrs {
let Some(name) = crate::attr::registered(attr, MESSAGE_ATTRS) else { continue };
if name == "message" {
continue;
}
let ident = &input.ident;
let arm = matches!(name, "value" | "other");
let msg = match (catalogue, arm) {
(false, false) => format!(
"`{ident}`: `#[{name}]` belongs on a field, not the struct. Move it to a field"
),
(false, true) => format!(
"`{ident}`: `#[{name}]` belongs on an enum variant, not a struct. \
Use `#[switch(n)]` on a field and `#[value(N)]` on the arms"
),
(true, true) => format!(
"`{ident}`: `#[{name}]` belongs on a variant, not the enum. Move it to a variant"
),
(true, false) => format!(
"`{ident}`: `#[{name}]` belongs on a field, not the enum. \
Move it to a field of an arm's type"
),
};
return Err(syn::Error::new(attr.meta.span(), msg));
}
Ok(())
}
fn parse_needs(
meta: &syn::meta::ParseNestedMeta<'_>,
ident: &syn::Ident,
) -> syn::Result<Vec<Param>> {
let shape = format!("`{ident}`: `needs` takes `name: type` pairs, such as `needs(stride: u8)`");
if !meta.input.peek(syn::token::Paren) {
return Err(meta.error(shape));
}
let content;
syn::parenthesized!(content in meta.input);
let mut out = Vec::new();
while !content.is_empty() {
let name: syn::Ident = content.parse()?;
content.parse::<syn::Token![:]>()?;
let ty: Type = content.parse()?;
let Some(repr @ (Scalar::U(_) | Scalar::I(_))) = scalar_of(&ty) else {
return Err(syn::Error::new(
ty.span(),
format!(
"`{ident}`: parameter `{name}` must be an integer, not `{}`",
crate::attr::spelled(&ty),
),
));
};
out.push(Param::new(&crate::attr::name(&name), repr));
if content.is_empty() {
break;
}
content.parse::<syn::Token![,]>()?;
}
if out.is_empty() {
return Err(syn::Error::new(
meta.path.span(),
format!("`{ident}`: `needs()` lists no parameters. Add one, or remove `needs`"),
));
}
Ok(out)
}
pub(super) fn container_attr(input: &DeriveInput) -> syn::Result<MessageAttr> {
refuse_misplaced_on_container(input)?;
let default = || MessageAttr {
endian: Endian::Le,
root: Root::default(),
closed: None,
bits: None,
needs: None,
};
let ident = &input.ident;
let Some(attr) = crate::attr::single(&input.attrs, "message", format_args!("`{ident}`"))?
else {
return Ok(default());
};
let (mut endian, mut order, mut bits_span) = (None, None, None);
let (mut needs, mut closed, mut root) = (None, None, None);
attr.parse_nested_meta(|meta| {
let span = meta.path.span();
if meta.path.is_ident("endian") {
crate::attr::once_key(&mut endian, &meta, ident, "message", || {
Ok((crate::attr::endian_value(&meta, ident)?, span))
})
} else if meta.path.is_ident("order") {
crate::attr::once_key(&mut order, &meta, ident, "message", || {
Ok((crate::attr::order_value(&meta, ident)?, span))
})
} else if meta.path.is_ident("needs") {
crate::attr::once_key(&mut needs, &meta, ident, "message", || {
Ok((parse_needs(&meta, ident)?, span))
})
} else if meta.path.is_ident("closed") {
crate::attr::once_key(&mut closed, &meta, ident, "message", || Ok(span))
} else if meta.path.is_ident("crate") {
crate::attr::once_key(&mut root, &meta, ident, "message", || {
crate::root::parse_arg(&meta)
})
} else if meta.path.is_ident("bits") && !meta.input.peek(syn::Token![=]) {
crate::attr::once_key(&mut bits_span, &meta, ident, "message", || Ok(span))
} else if meta.path.is_ident("bits")
|| meta.path.is_ident("bytes")
|| meta.path.is_ident("words")
{
Err(meta.error(format!(
"`{ident}`: a message has no fixed size. \
Remove `bits = N`, or use a `#[derive(Layout)]` type"
)))
} else {
Err(meta.error(format!(
"`{ident}`: expected `endian`, `bits`, `order`, `needs`, `closed`, or `crate`"
)))
}
})?;
let out = MessageAttr {
endian: endian.map_or(Endian::Le, |(e, _)| e),
root: root.unwrap_or_default(),
closed,
bits: None,
needs,
};
match (bits_span, endian, order) {
(Some(_), Some((_, span)), _) => Err(syn::Error::new(
span,
format!("`{ident}`: a bit-addressed message has no byte order. Remove `endian`"),
)),
(None, _, Some((_, span))) => Err(syn::Error::new(
span,
format!(
"`{ident}`: `order` needs `bits`. \
Write `#[message(bits, order = msb)]`, or remove `order`"
),
)),
(Some(span), None, order) => {
Ok(MessageAttr { bits: Some((order.map_or(BitOrder::Lsb, |(o, _)| o), span)), ..out })
}
(None, _, None) => Ok(out),
}
}