mod generation;
use proc_macro::TokenStream;
use quote::quote;
use syn::{Data, DeriveInput, parse_macro_input};
use crate::generation::attributes::{AttributeFlags, FieldAttributes};
use crate::generation::circular::{
generate_circular_deserialize,
generate_circular_serialize,
generate_graph_impl
};
use crate::generation::enums::{
generate_enum_deserialize_safe,
generate_enum_serialize,
generate_flags_impls,
generate_transparent_deserialize,
generate_transparent_serialize
};
use crate::generation::helpers::{
DeserializationMode,
generate_deserialization_impl,
generate_size_hint,
has_explicit_discriminants,
has_repr_c,
is_single_field_i32,
prepare_serialization_generics,
should_skip_field
};
use crate::generation::regular::{generate_deserialize, generate_serialize};
use crate::generation::unions::{generate_union_deserialize, generate_union_serialize};
use crate::generation::version_tolerant::{
generate_version_tolerant_deserialize,
generate_version_tolerant_serialize
};
use crate::generation::{fixed_size, unmanaged};
#[proc_macro_derive(MemoryPackable, attributes(memorypack, tag))]
pub fn derive_memorypack(input: TokenStream) -> TokenStream {
let input = parse_macro_input!(input as DeriveInput);
let name = &input.ident;
let (_, ty_generics, _) = input.generics.split_for_impl();
let attrs = AttributeFlags::parse(&input.attrs);
if let Err(error) = validate_formatter_attributes(&input, &attrs) {
return error.to_compile_error().into();
}
if let Err(error) = validate_arena_attributes(&input, &attrs) {
return error.to_compile_error().into();
}
let serialization_generics = prepare_serialization_generics(&input);
let (serialization_impl_generics, _, serialization_where_clause) =
serialization_generics.split_for_impl();
let (serialize_impl, deserialize_body) = match generate_impls(&input, &attrs) {
Ok(impls) => impls,
Err(error) => return error.to_compile_error().into()
};
let is_value_type = is_value_type(&input, &attrs);
let deserialize_impl = generate_deserialization_impl(
&input,
DeserializationMode::Input,
&deserialize_body,
is_value_type
);
let arena_impl = generate_arena_impl(&input, &attrs);
let fixed_size_impl = is_value_type.then(|| fixed_size::generate_impl(&input));
let nullable_serialize = is_value_type.then(fixed_size::generate_nullable_serialize);
let graph_impl = attrs
.is_circular
.then(|| generate_graph_impl(&input));
let flags_impl = if attrs.is_flags && attrs.is_transparent {
generate_flags_impls(name)
} else {
quote! {}
};
let size_hint_impl = if is_value_type {
quote! { <Self as memorypack::MemoryPackFixedSize>::SIZE }
} else {
generate_size_hint(
&input.data,
attrs.is_union,
attrs.is_version_tolerant,
attrs.is_circular
)
};
quote! {
impl #serialization_impl_generics memorypack::MemoryPackSerialize for #name #ty_generics #serialization_where_clause {
#[inline]
fn serialize(&self, writer: &mut memorypack::MemoryPackWriter) -> Result<(), memorypack::MemoryPackError> {
#serialize_impl
Ok(())
}
#[inline]
fn serialized_size_hint(&self) -> usize {
#size_hint_impl
}
#nullable_serialize
}
#deserialize_impl
#arena_impl
#flags_impl
#graph_impl
#fixed_size_impl
}
.into()
}
fn generate_arena_impl(
input: &DeriveInput,
attributes: &AttributeFlags
) -> proc_macro2::TokenStream {
if !attributes.is_arena {
return quote! {};
}
let mode = DeserializationMode::Arena;
let body = generate_deserialize(&input.data, mode);
generate_deserialization_impl(input, mode, &body, false)
}
fn is_value_type(input: &DeriveInput, attributes: &AttributeFlags) -> bool {
match &input.data {
Data::Struct(data) => {
has_repr_c(&input.attrs) || (attributes.is_transparent && is_single_field_i32(data))
}
Data::Enum(_) => !attributes.is_union,
Data::Union(_) => false
}
}
fn generate_impls(
input: &DeriveInput,
attrs: &AttributeFlags
) -> syn::Result<(proc_macro2::TokenStream, proc_macro2::TokenStream)> {
let name = &input.ident;
if let Data::Struct(data) = &input.data
&& !is_value_type(input, attrs)
&& data
.fields
.iter()
.filter(|field| !should_skip_field(field))
.count()
>= 250
{
return Err(syn::Error::new_spanned(
input,
"MemoryPack objects support at most 249 members"
));
}
let impls = match &input.data {
Data::Struct(data_struct) if has_repr_c(&input.attrs) => {
(unmanaged::serialize(data_struct), unmanaged::deserialize(data_struct))
}
Data::Struct(data_struct) if attrs.is_transparent && is_single_field_i32(data_struct) => {
(generate_transparent_serialize(), generate_transparent_deserialize())
}
Data::Struct(_) if attrs.is_circular => {
(generate_circular_serialize(&input.data), generate_circular_deserialize(&input.data))
}
Data::Struct(_) if attrs.is_version_tolerant => (
generate_version_tolerant_serialize(&input.data),
generate_version_tolerant_deserialize(&input.data)
),
Data::Struct(_) => (
generate_serialize(&input.data),
generate_deserialize(&input.data, DeserializationMode::Input)
),
Data::Enum(data_enum) if attrs.is_union => {
(generate_union_serialize(data_enum), generate_union_deserialize(name, data_enum))
}
Data::Enum(data_enum) => {
let has_explicit = has_explicit_discriminants(data_enum);
if !attrs.has_repr_i32 && !has_explicit {
return Err(syn::Error::new_spanned(
input,
"C-like enums for MemoryPack must have either #[repr(i32)] or explicit discriminants"
));
}
let deserialize = generate_enum_deserialize_safe(data_enum);
(generate_enum_serialize(), deserialize)
}
Data::Union(_) => {
return Err(syn::Error::new_spanned(
input,
"MemoryPackable cannot be derived for Rust unions"
));
}
};
Ok(impls)
}
fn validate_arena_attributes(input: &DeriveInput, attributes: &AttributeFlags) -> syn::Result<()> {
if !attributes.is_arena {
return Ok(());
}
if !matches!(input.data, Data::Struct(_))
|| attributes.is_circular
|| attributes.is_version_tolerant
|| attributes.is_transparent
|| has_repr_c(&input.attrs)
{
return Err(syn::Error::new_spanned(
input,
"arena deserialization supports regular structs"
));
}
Ok(())
}
fn validate_formatter_attributes(
input: &DeriveInput,
attributes: &AttributeFlags
) -> syn::Result<()> {
if FieldAttributes::parse(&input.attrs)?
.formatter
.is_some()
{
return Err(syn::Error::new_spanned(
input,
"MemoryPack formatters must be applied to fields"
));
}
let fields: Vec<_> = match &input.data {
Data::Struct(data) => data.fields.iter().collect(),
Data::Enum(data) => {
for variant in &data.variants {
if FieldAttributes::parse(&variant.attrs)?
.formatter
.is_some()
{
return Err(syn::Error::new_spanned(
variant,
"MemoryPack formatters must be applied to struct fields"
));
}
}
data.variants
.iter()
.flat_map(|variant| &variant.fields)
.collect()
}
Data::Union(data) => data.fields.named.iter().collect()
};
for field in fields {
if FieldAttributes::parse(&field.attrs)?
.formatter
.is_none()
{
continue;
}
validate_formatter_field(input, attributes, field)?;
}
Ok(())
}
fn validate_formatter_field(
input: &DeriveInput,
attributes: &AttributeFlags,
field: &syn::Field
) -> syn::Result<()> {
let Data::Struct(structure) = &input.data else {
return Err(syn::Error::new_spanned(
field,
"MemoryPack formatters are supported on struct fields"
));
};
if has_repr_c(&input.attrs) || (attributes.is_transparent && is_single_field_i32(structure)) {
return Err(syn::Error::new_spanned(
field,
"MemoryPack formatters cannot be used with unmanaged layouts"
));
}
if should_skip_field(field) {
return Err(syn::Error::new_spanned(
field,
"MemoryPack formatters cannot be used on skipped fields"
));
}
Ok(())
}