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    let impls = match &input.data {
149        Data::Struct(data_struct) if has_repr_c(&input.attrs) => {
150            (unmanaged::serialize(data_struct), unmanaged::deserialize(data_struct))
151        }
152        Data::Struct(data_struct) if attrs.is_transparent && is_single_field_i32(data_struct) => {
153            (generate_transparent_serialize(), generate_transparent_deserialize())
154        }
155        Data::Struct(_) if attrs.is_circular => {
156            (generate_circular_serialize(&input.data), generate_circular_deserialize(&input.data))
157        }
158        Data::Struct(_) if attrs.is_version_tolerant => (
159            generate_version_tolerant_serialize(&input.data),
160            generate_version_tolerant_deserialize(&input.data)
161        ),
162        Data::Struct(_) => (
163            generate_serialize(&input.data),
164            generate_deserialize(&input.data, DeserializationMode::Input)
165        ),
166        Data::Enum(data_enum) if attrs.is_union => {
167            (generate_union_serialize(data_enum), generate_union_deserialize(name, data_enum))
168        }
169        Data::Enum(data_enum) => {
170            let has_explicit = has_explicit_discriminants(data_enum);
171
172            if !attrs.has_repr_i32 && !has_explicit {
173                return Err(syn::Error::new_spanned(
174                    input,
175                    "C-like enums for MemoryPack must have either #[repr(i32)] or explicit discriminants"
176                ));
177            }
178
179            let deserialize = generate_enum_deserialize_safe(data_enum);
180
181            (generate_enum_serialize(), deserialize)
182        }
183        Data::Union(_) => {
184            return Err(syn::Error::new_spanned(
185                input,
186                "MemoryPackable cannot be derived for Rust unions"
187            ));
188        }
189    };
190
191    Ok(impls)
192}
193
194fn validate_arena_attributes(input: &DeriveInput, attributes: &AttributeFlags) -> syn::Result<()> {
195    if !attributes.is_arena {
196        return Ok(());
197    }
198
199    if !matches!(input.data, Data::Struct(_))
200        || attributes.is_circular
201        || attributes.is_version_tolerant
202        || attributes.is_transparent
203        || has_repr_c(&input.attrs)
204    {
205        return Err(syn::Error::new_spanned(
206            input,
207            "arena deserialization supports regular structs"
208        ));
209    }
210
211    Ok(())
212}
213
214fn validate_formatter_attributes(
215    input: &DeriveInput,
216    attributes: &AttributeFlags
217) -> syn::Result<()> {
218    if FieldAttributes::parse(&input.attrs)?
219        .formatter
220        .is_some()
221    {
222        return Err(syn::Error::new_spanned(
223            input,
224            "MemoryPack formatters must be applied to fields"
225        ));
226    }
227
228    let fields: Vec<_> = match &input.data {
229        Data::Struct(data) => data.fields.iter().collect(),
230        Data::Enum(data) => {
231            for variant in &data.variants {
232                if FieldAttributes::parse(&variant.attrs)?
233                    .formatter
234                    .is_some()
235                {
236                    return Err(syn::Error::new_spanned(
237                        variant,
238                        "MemoryPack formatters must be applied to struct fields"
239                    ));
240                }
241            }
242
243            data.variants
244                .iter()
245                .flat_map(|variant| &variant.fields)
246                .collect()
247        }
248        Data::Union(data) => data.fields.named.iter().collect()
249    };
250
251    for field in fields {
252        if FieldAttributes::parse(&field.attrs)?
253            .formatter
254            .is_none()
255        {
256            continue;
257        }
258
259        validate_formatter_field(input, attributes, field)?;
260    }
261
262    Ok(())
263}
264
265fn validate_formatter_field(
266    input: &DeriveInput,
267    attributes: &AttributeFlags,
268    field: &syn::Field
269) -> syn::Result<()> {
270    let Data::Struct(structure) = &input.data else {
271        return Err(syn::Error::new_spanned(
272            field,
273            "MemoryPack formatters are supported on struct fields"
274        ));
275    };
276
277    if has_repr_c(&input.attrs) || (attributes.is_transparent && is_single_field_i32(structure)) {
278        return Err(syn::Error::new_spanned(
279            field,
280            "MemoryPack formatters cannot be used with unmanaged layouts"
281        ));
282    }
283
284    if should_skip_field(field) {
285        return Err(syn::Error::new_spanned(
286            field,
287            "MemoryPack formatters cannot be used on skipped fields"
288        ));
289    }
290
291    Ok(())
292}