Skip to main content

memorypack_derive/
lib.rs

1mod generation;
2
3use proc_macro::TokenStream;
4use quote::quote;
5use syn::{Data, DeriveInput, parse_macro_input};
6
7use crate::generation::attributes::{AttributeFlags, FieldAttributes};
8use crate::generation::circular::{
9    generate_circular_deserialize,
10    generate_circular_serialize,
11    generate_graph_impl
12};
13use crate::generation::enums::{
14    generate_enum_deserialize_safe,
15    generate_enum_serialize,
16    generate_flags_impls,
17    generate_transparent_deserialize,
18    generate_transparent_serialize
19};
20use crate::generation::helpers::{
21    DeserializationMode,
22    generate_deserialization_impl,
23    generate_size_hint,
24    has_explicit_discriminants,
25    has_repr_c,
26    is_single_field_i32,
27    prepare_serialization_generics,
28    should_skip_field
29};
30use crate::generation::regular::{generate_deserialize, generate_serialize};
31use crate::generation::unions::{generate_union_deserialize, generate_union_serialize};
32use crate::generation::version_tolerant::{
33    generate_version_tolerant_deserialize,
34    generate_version_tolerant_serialize
35};
36use crate::generation::{fixed_size, unmanaged};
37
38#[proc_macro_derive(MemoryPackable, attributes(memorypack, tag))]
39pub fn derive_memorypack(input: TokenStream) -> TokenStream {
40    let input = parse_macro_input!(input as DeriveInput);
41    let name = &input.ident;
42    let (_, ty_generics, _) = input.generics.split_for_impl();
43    let attrs = AttributeFlags::parse(&input.attrs);
44
45    if let Err(error) = validate_formatter_attributes(&input, &attrs) {
46        return error.to_compile_error().into();
47    }
48
49    if let Err(error) = validate_arena_attributes(&input, &attrs) {
50        return error.to_compile_error().into();
51    }
52
53    let serialization_generics = prepare_serialization_generics(&input);
54    let (serialization_impl_generics, _, serialization_where_clause) =
55        serialization_generics.split_for_impl();
56
57    let (serialize_impl, deserialize_body) = match generate_impls(&input, &attrs) {
58        Ok(impls) => impls,
59        Err(error) => return error.to_compile_error().into()
60    };
61    let is_value_type = is_value_type(&input, &attrs);
62    let deserialize_impl = generate_deserialization_impl(
63        &input,
64        DeserializationMode::Input,
65        &deserialize_body,
66        is_value_type
67    );
68    let arena_impl = generate_arena_impl(&input, &attrs);
69    let fixed_size_impl = is_value_type.then(|| fixed_size::generate_impl(&input));
70    let nullable_serialize = is_value_type.then(fixed_size::generate_nullable_serialize);
71
72    let graph_impl = attrs
73        .is_circular
74        .then(|| generate_graph_impl(&input));
75
76    let flags_impl = if attrs.is_flags && attrs.is_transparent {
77        generate_flags_impls(name)
78    } else {
79        quote! {}
80    };
81
82    let size_hint_impl = if is_value_type {
83        quote! { <Self as memorypack::MemoryPackFixedSize>::SIZE }
84    } else {
85        generate_size_hint(
86            &input.data,
87            attrs.is_union,
88            attrs.is_version_tolerant,
89            attrs.is_circular
90        )
91    };
92
93    quote! {
94        impl #serialization_impl_generics memorypack::MemoryPackSerialize for #name #ty_generics #serialization_where_clause {
95            #[inline]
96            fn serialize(&self, writer: &mut memorypack::MemoryPackWriter) -> Result<(), memorypack::MemoryPackError> {
97                #serialize_impl
98
99                Ok(())
100            }
101
102            #[inline]
103            fn serialized_size_hint(&self) -> usize {
104                #size_hint_impl
105            }
106
107            #nullable_serialize
108        }
109
110        #deserialize_impl
111        #arena_impl
112        #flags_impl
113        #graph_impl
114        #fixed_size_impl
115    }
116    .into()
117}
118
119fn generate_arena_impl(
120    input: &DeriveInput,
121    attributes: &AttributeFlags
122) -> proc_macro2::TokenStream {
123    if !attributes.is_arena {
124        return quote! {};
125    }
126
127    let mode = DeserializationMode::Arena;
128    let body = generate_deserialize(&input.data, mode);
129
130    generate_deserialization_impl(input, mode, &body, false)
131}
132
133fn is_value_type(input: &DeriveInput, attributes: &AttributeFlags) -> bool {
134    match &input.data {
135        Data::Struct(data) => {
136            has_repr_c(&input.attrs) || (attributes.is_transparent && is_single_field_i32(data))
137        }
138        Data::Enum(_) => !attributes.is_union,
139        Data::Union(_) => false
140    }
141}
142
143fn generate_impls(
144    input: &DeriveInput,
145    attrs: &AttributeFlags
146) -> syn::Result<(proc_macro2::TokenStream, proc_macro2::TokenStream)> {
147    let name = &input.ident;
148
149    if let Data::Struct(data) = &input.data
150        && !is_value_type(input, attrs)
151        && data
152            .fields
153            .iter()
154            .filter(|field| !should_skip_field(field))
155            .count()
156            >= 250
157    {
158        return Err(syn::Error::new_spanned(
159            input,
160            "MemoryPack objects support at most 249 members"
161        ));
162    }
163
164    let impls = match &input.data {
165        Data::Struct(data_struct) if has_repr_c(&input.attrs) => {
166            (unmanaged::serialize(data_struct), unmanaged::deserialize(data_struct))
167        }
168        Data::Struct(data_struct) if attrs.is_transparent && is_single_field_i32(data_struct) => {
169            (generate_transparent_serialize(), generate_transparent_deserialize())
170        }
171        Data::Struct(_) if attrs.is_circular => {
172            (generate_circular_serialize(&input.data), generate_circular_deserialize(&input.data))
173        }
174        Data::Struct(_) if attrs.is_version_tolerant => (
175            generate_version_tolerant_serialize(&input.data),
176            generate_version_tolerant_deserialize(&input.data)
177        ),
178        Data::Struct(_) => (
179            generate_serialize(&input.data),
180            generate_deserialize(&input.data, DeserializationMode::Input)
181        ),
182        Data::Enum(data_enum) if attrs.is_union => {
183            (generate_union_serialize(data_enum), generate_union_deserialize(name, data_enum))
184        }
185        Data::Enum(data_enum) => {
186            let has_explicit = has_explicit_discriminants(data_enum);
187
188            if !attrs.has_repr_i32 && !has_explicit {
189                return Err(syn::Error::new_spanned(
190                    input,
191                    "C-like enums for MemoryPack must have either #[repr(i32)] or explicit discriminants"
192                ));
193            }
194
195            let deserialize = generate_enum_deserialize_safe(data_enum);
196
197            (generate_enum_serialize(), deserialize)
198        }
199        Data::Union(_) => {
200            return Err(syn::Error::new_spanned(
201                input,
202                "MemoryPackable cannot be derived for Rust unions"
203            ));
204        }
205    };
206
207    Ok(impls)
208}
209
210fn validate_arena_attributes(input: &DeriveInput, attributes: &AttributeFlags) -> syn::Result<()> {
211    if !attributes.is_arena {
212        return Ok(());
213    }
214
215    if !matches!(input.data, Data::Struct(_))
216        || attributes.is_circular
217        || attributes.is_version_tolerant
218        || attributes.is_transparent
219        || has_repr_c(&input.attrs)
220    {
221        return Err(syn::Error::new_spanned(
222            input,
223            "arena deserialization supports regular structs"
224        ));
225    }
226
227    Ok(())
228}
229
230fn validate_formatter_attributes(
231    input: &DeriveInput,
232    attributes: &AttributeFlags
233) -> syn::Result<()> {
234    if FieldAttributes::parse(&input.attrs)?
235        .formatter
236        .is_some()
237    {
238        return Err(syn::Error::new_spanned(
239            input,
240            "MemoryPack formatters must be applied to fields"
241        ));
242    }
243
244    let fields: Vec<_> = match &input.data {
245        Data::Struct(data) => data.fields.iter().collect(),
246        Data::Enum(data) => {
247            for variant in &data.variants {
248                if FieldAttributes::parse(&variant.attrs)?
249                    .formatter
250                    .is_some()
251                {
252                    return Err(syn::Error::new_spanned(
253                        variant,
254                        "MemoryPack formatters must be applied to struct fields"
255                    ));
256                }
257            }
258
259            data.variants
260                .iter()
261                .flat_map(|variant| &variant.fields)
262                .collect()
263        }
264        Data::Union(data) => data.fields.named.iter().collect()
265    };
266
267    for field in fields {
268        if FieldAttributes::parse(&field.attrs)?
269            .formatter
270            .is_none()
271        {
272            continue;
273        }
274
275        validate_formatter_field(input, attributes, field)?;
276    }
277
278    Ok(())
279}
280
281fn validate_formatter_field(
282    input: &DeriveInput,
283    attributes: &AttributeFlags,
284    field: &syn::Field
285) -> syn::Result<()> {
286    let Data::Struct(structure) = &input.data else {
287        return Err(syn::Error::new_spanned(
288            field,
289            "MemoryPack formatters are supported on struct fields"
290        ));
291    };
292
293    if has_repr_c(&input.attrs) || (attributes.is_transparent && is_single_field_i32(structure)) {
294        return Err(syn::Error::new_spanned(
295            field,
296            "MemoryPack formatters cannot be used with unmanaged layouts"
297        ));
298    }
299
300    if should_skip_field(field) {
301        return Err(syn::Error::new_spanned(
302            field,
303            "MemoryPack formatters cannot be used on skipped fields"
304        ));
305    }
306
307    Ok(())
308}