use proc_macro2::TokenStream;
use quote::quote;
use syn::{parse::Parser as _, Meta, Path};
#[derive(Debug, Clone, Copy, PartialEq, Eq, thiserror::Error)]
#[non_exhaustive]
pub enum ErrorReason {
#[error("unsupported caller JSON input attribute on a cleanup-enabled message")]
Unsupported,
#[error("invalid caller JSON default on a cleanup-enabled message")]
InvalidDefault,
#[error("invalid caller JSON attribute syntax on a cleanup-enabled message")]
InvalidSyntax,
}
#[derive(Default)]
pub(crate) struct Policy {
skips: Vec<Vec<Meta>>,
pub(crate) defaults: Vec<DefaultRule>,
}
pub(crate) struct DefaultRule {
conditions: Vec<Meta>,
path: Option<Path>,
}
impl DefaultRule {
pub(crate) fn expression(&self) -> TokenStream {
match &self.path {
Some(path) => quote! { #path() },
None => quote! { ::core::default::Default::default() },
}
}
pub(crate) fn gate(&self, tokens: TokenStream) -> TokenStream {
gate(condition(&self.conditions), tokens)
}
}
fn condition(conditions: &[Meta]) -> Option<TokenStream> {
(!conditions.is_empty()).then(|| quote! { all(#(#conditions),*) })
}
pub(crate) fn gate(condition: Option<TokenStream>, tokens: TokenStream) -> TokenStream {
match condition {
Some(condition) => quote! { #[cfg(#condition)] #tokens },
None => tokens,
}
}
impl Policy {
pub(crate) fn acceptance(&self) -> Option<TokenStream> {
if self.skips.is_empty() {
return None;
}
let skips = self.skips.iter().map(|parts| {
let condition = condition(parts);
condition.unwrap_or_else(|| quote! { all() })
});
Some(quote! { not(any(#(#skips),*)) })
}
}
fn options(
list: &syn::MetaList,
) -> Result<syn::punctuated::Punctuated<Meta, syn::Token![,]>, ErrorReason> {
list.parse_args_with(syn::punctuated::Punctuated::<Meta, syn::Token![,]>::parse_terminated)
.map_err(|_| ErrorReason::InvalidSyntax)
}
fn collect(
meta: &Meta,
conditions: &[Meta],
policy: &mut Policy,
container: bool,
) -> Result<(), ErrorReason> {
let Meta::List(list) = meta else {
return Ok(());
};
if list.path.is_ident("cfg_attr") {
let mut nested = options(list)?.into_iter();
let predicate = nested.next().ok_or(ErrorReason::InvalidSyntax)?;
let mut conditions = conditions.to_vec();
conditions.push(predicate);
for meta in nested {
collect(&meta, &conditions, policy, container)?;
}
} else if list.path.is_ident("cfg") {
return Err(ErrorReason::Unsupported);
} else if list.path.is_ident("serde") {
for option in options(list)? {
if option.path().is_ident("skip_serializing")
|| option.path().is_ident("skip_serializing_if")
|| option.path().is_ident("serialize_with")
{
continue;
}
if container {
return Err(ErrorReason::Unsupported);
}
if option.path().is_ident("skip") || option.path().is_ident("skip_deserializing") {
if !matches!(option, Meta::Path(_)) {
return Err(ErrorReason::InvalidSyntax);
}
policy.skips.push(conditions.to_vec());
} else if option.path().is_ident("default") {
let path = match option {
Meta::Path(_) => None,
Meta::NameValue(value) => {
let syn::Expr::Lit(syn::ExprLit {
lit: syn::Lit::Str(path),
..
}) = value.value
else {
return Err(ErrorReason::InvalidDefault);
};
Some(
path.parse::<Path>()
.map_err(|_| ErrorReason::InvalidDefault)?,
)
}
_ => return Err(ErrorReason::InvalidDefault),
};
policy.defaults.push(DefaultRule {
conditions: conditions.to_vec(),
path,
});
} else {
return Err(ErrorReason::Unsupported);
}
}
}
Ok(())
}
pub(crate) fn parse(attributes: &TokenStream, container: bool) -> Result<Policy, ErrorReason> {
let mut policy = Policy::default();
for attribute in syn::Attribute::parse_outer
.parse2(attributes.clone())
.map_err(|_| ErrorReason::InvalidSyntax)?
{
collect(&attribute.meta, &[], &mut policy, container)?;
}
Ok(policy)
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn defaults_and_skips_retain_nested_conditions() {
let policy = parse(
"e! {
#[serde(default)]
#[cfg_attr(feature = "selected", cfg_attr(all(), serde(skip_deserializing)))]
},
false,
)
.unwrap();
assert_eq!(policy.defaults.len(), 1);
assert_eq!(
policy.defaults[0].expression().to_string(),
quote! { ::core::default::Default::default() }.to_string()
);
assert_eq!(policy.skips[0].len(), 2);
}
#[test]
fn malformed_defaults_have_typed_redacted_errors() {
for attribute in [
quote! { #[serde(default = 17)] },
quote! { #[serde(default = "private path!")] },
] {
assert!(matches!(
parse(&attribute, false),
Err(ErrorReason::InvalidDefault)
));
}
assert!(matches!(
parse("e! { #[cfg(any())] }, false),
Err(ErrorReason::Unsupported)
));
}
}