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}