#![deny(missing_docs)]
use proc_macro::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput, Error, Expr, Path, parse_macro_input, spanned::Spanned};
#[proc_macro_derive(SensorData, attributes(sensor))]
pub fn derive_sensor_data(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
expand(input)
.unwrap_or_else(Error::into_compile_error)
.into()
}
struct SensorAttr {
id: Option<Expr>,
version: Option<Expr>,
krate: Option<Path>,
}
fn expand(input: DeriveInput) -> Result<proc_macro2::TokenStream, Error> {
reject_unsupported_shape(&input)?;
let attr = parse_sensor_attr(&input)?;
let Some(id) = attr.id else {
return Err(Error::new(
input.ident.span(),
"missing `#[sensor(id = ...)]`\n\
help: every `SensorData` type must name the sensor ID it is stored \
under, e.g. `#[sensor(id = 0x01)]`",
));
};
let version = attr.version.unwrap_or_else(|| syn::parse_quote!(0u8));
let krate = attr.krate.unwrap_or_else(|| syn::parse_quote!(::sensor_db));
let name = &input.ident;
let (impl_generics, ty_generics, where_clause) = input.generics.split_for_impl();
Ok(quote! {
#[automatically_derived]
impl #impl_generics #krate::SensorData for #name #ty_generics #where_clause {
const SENSOR_ID: u16 = #id;
const SCHEMA_VERSION: u8 = #version;
}
})
}
fn reject_unsupported_shape(input: &DeriveInput) -> Result<(), Error> {
match &input.data {
Data::Struct(_) => Ok(()),
Data::Enum(_) => Err(Error::new(
input.ident.span(),
"`SensorData` cannot be derived for an enum\n\
note: a stored payload is reinterpreted from raw flash bytes, so it \
must have a fixed layout with no invalid bit patterns\n\
help: store the discriminant as an integer field in a struct",
)),
Data::Union(_) => Err(Error::new(
input.ident.span(),
"`SensorData` cannot be derived for a union\n\
note: reading a union from flash cannot know which variant was written\n\
help: store a tag alongside the bytes, or give each variant its own \
sensor ID",
)),
}
}
fn parse_sensor_attr(input: &DeriveInput) -> Result<SensorAttr, Error> {
let mut parsed = SensorAttr {
id: None,
version: None,
krate: None,
};
for attr in input.attrs.iter().filter(|a| a.path().is_ident("sensor")) {
attr.parse_nested_meta(|meta| {
if meta.path.is_ident("id") {
set_once(&mut parsed.id, meta.value()?.parse()?, &meta.path, "id")
} else if meta.path.is_ident("version") {
let value: Expr = meta.value()?.parse()?;
check_u8_literal(&value)?;
set_once(&mut parsed.version, value, &meta.path, "version")
} else if meta.path.is_ident("crate") {
set_once(
&mut parsed.krate,
meta.value()?.parse()?,
&meta.path,
"crate",
)
} else {
Err(meta.error(
"unrecognised `sensor` option\n\
note: valid options are `id`, `version` and `crate`",
))
}
})?;
}
Ok(parsed)
}
fn set_once<T>(slot: &mut Option<T>, value: T, path: &Path, name: &str) -> Result<(), Error> {
if slot.is_some() {
return Err(Error::new(
path.span(),
format!("duplicate `sensor` option `{name}`"),
));
}
*slot = Some(value);
Ok(())
}
fn check_u8_literal(value: &Expr) -> Result<(), Error> {
let Expr::Lit(lit) = value else {
return Ok(()); };
let syn::Lit::Int(int) = &lit.lit else {
return Ok(());
};
int.base10_parse::<u8>().map_err(|_| {
Error::new(
int.span(),
format!(
"schema version {} does not fit in a `u8`\n\
note: the version is stored as a one-byte tag in front of the payload",
int.base10_digits()
),
)
})?;
Ok(())
}