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}