1#![expect(
50 clippy::panic,
51 reason = "a derive macro's \"runtime\" is the compiler's expansion pass, so a \
52panic here surfaces as a build failure on the offending type, never as a fault in \
53a running binary. Reporting via syn::Error would point at a tighter source span \
54and is worth doing, but these panics cannot reach production code"
55)]
56
57use proc_macro::TokenStream;
58use proc_macro2::TokenStream as TokenStream2;
59use quote::quote;
60use syn::{Attribute, Data, DataEnum, DeriveInput, Expr, Fields, FieldsNamed, FieldsUnnamed, Ident, Index, Lit, Meta, Variant, parse_macro_input};
61
62fn parse_xdr_value(attrs: &[Attribute]) -> Option<u32> {
67 for attr in attrs {
68 if attr.path().is_ident("xdr")
69 && let Meta::List(meta_list) = &attr.meta
70 && let Ok(Expr::Lit(syn::ExprLit { lit: Lit::Int(lit_int), .. })) = meta_list.parse_args::<Expr>()
71 && let Ok(value) = lit_int.base10_parse::<u32>()
72 {
73 return Some(value);
74 }
75 }
76 None
77}
78
79struct NamedFieldsGenerator<'a> {
81 fields: &'a FieldsNamed,
82}
83
84impl<'a> NamedFieldsGenerator<'a> {
85 const fn new(fields: &'a FieldsNamed) -> Self {
86 Self { fields }
87 }
88
89 fn pack_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
90 self.fields.named.iter().map(|f| {
91 let name = &f.ident;
92 quote! {
93 total_write += self.#name.pack(out)?;
94 }
95 })
96 }
97
98 fn packed_size_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
99 self.fields.named.iter().map(|f| {
100 let name = &f.ident;
101 quote! {
102 total_size += ::onc_xdr::Pack::packed_size(&self.#name);
103 }
104 })
105 }
106
107 fn unpack_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
108 self.fields.named.iter().map(|f| {
109 let name = &f.ident;
110 quote! {
111 let (#name, read_bytes) = ::onc_xdr::Unpack::unpack(input)?;
112 total_read += read_bytes;
113 }
114 })
115 }
116
117 fn struct_construction_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
118 self.fields.named.iter().map(|f| {
119 let name = &f.ident;
120 quote! { #name, }
121 })
122 }
123}
124
125struct UnnamedFieldsGenerator<'a> {
127 fields: &'a FieldsUnnamed,
128}
129
130impl<'a> UnnamedFieldsGenerator<'a> {
131 const fn new(fields: &'a FieldsUnnamed) -> Self {
132 Self { fields }
133 }
134
135 fn pack_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
136 self.fields.unnamed.iter().enumerate().map(|(i, _)| {
137 let index = Index::from(i);
138 quote! {
139 total_write += self.#index.pack(out)?;
140 }
141 })
142 }
143
144 fn packed_size_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
145 self.fields.unnamed.iter().enumerate().map(|(i, _)| {
146 let index = Index::from(i);
147 quote! {
148 total_size += ::onc_xdr::Pack::packed_size(&self.#index);
149 }
150 })
151 }
152
153 fn unpack_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
154 self.fields.unnamed.iter().enumerate().map(|(i, _)| {
155 let var_name = Ident::new(&format!("field_{i}"), proc_macro2::Span::call_site());
156 quote! {
157 let (#var_name, read_bytes) = ::onc_xdr::Unpack::unpack(input)?;
158 total_read += read_bytes;
159 }
160 })
161 }
162
163 fn struct_construction_fields(&self) -> impl Iterator<Item = TokenStream2> + '_ {
164 (0..self.fields.unnamed.len()).map(|i| {
165 let var_name = Ident::new(&format!("field_{i}"), proc_macro2::Span::call_site());
166 quote! { #var_name }
167 })
168 }
169}
170
171fn generate_struct_impl(name: &Ident, generics: &syn::Generics, fields: &Fields) -> TokenStream2 {
176 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
177
178 match fields {
179 Fields::Named(named_fields) => {
180 let generator = NamedFieldsGenerator::new(named_fields);
181 let pack_fields = generator.pack_fields();
182 let packed_size_fields = generator.packed_size_fields();
183 let unpack_fields = generator.unpack_fields();
184 let struct_fields = generator.struct_construction_fields();
185
186 quote! {
187 impl #impl_generics ::onc_xdr::Pack for #name #ty_generics
188 #where_clause {
189 fn packed_size(&self) -> usize {
190 let mut total_size = 0;
191 #(#packed_size_fields)*
192 total_size
193 }
194
195 fn pack(&self, out: &mut impl std::io::Write) -> ::onc_xdr::Result<usize> {
196 use ::onc_xdr::Pack;
197 let mut total_write = 0;
198 #(#pack_fields)*
199 Ok(total_write)
200 }
201 }
202 impl #impl_generics ::onc_xdr::Unpack for #name #ty_generics
203 #where_clause {
204 fn unpack(input: &mut impl std::io::Read) -> ::onc_xdr::Result<(Self, usize)> {
205 use ::onc_xdr::Unpack;
206 let mut total_read = 0;
207 #(#unpack_fields)*
208 Ok((Self { #(#struct_fields)* }, total_read))
209 }
210 }
211 }
212 },
213 Fields::Unnamed(unnamed_fields) => {
214 let generator = UnnamedFieldsGenerator::new(unnamed_fields);
215 let pack_fields = generator.pack_fields();
216 let packed_size_fields = generator.packed_size_fields();
217 let unpack_fields = generator.unpack_fields();
218 let struct_fields = generator.struct_construction_fields();
219
220 quote! {
221 impl #impl_generics ::onc_xdr::Pack for #name #ty_generics
222 #where_clause {
223 fn packed_size(&self) -> usize {
224 let mut total_size = 0;
225 #(#packed_size_fields)*
226 total_size
227 }
228
229 fn pack(&self, out: &mut impl std::io::Write) -> ::onc_xdr::Result<usize> {
230 use ::onc_xdr::Pack;
231 let mut total_write = 0;
232 #(#pack_fields)*
233 Ok(total_write)
234 }
235 }
236 impl #impl_generics ::onc_xdr::Unpack for #name #ty_generics
237 #where_clause {
238 fn unpack(input: &mut impl std::io::Read) -> ::onc_xdr::Result<(Self, usize)> {
239 use ::onc_xdr::Unpack;
240 let mut total_read = 0;
241 #(#unpack_fields)*
242 Ok((Self(#(#struct_fields),*), total_read))
243 }
244 }
245 }
246 },
247 Fields::Unit => {
248 quote! {
249 impl #impl_generics ::onc_xdr::Pack for #name #ty_generics
250 #where_clause {
251 fn packed_size(&self) -> usize {
252 0
253 }
254
255 fn pack(&self, _out: &mut impl std::io::Write) -> ::onc_xdr::Result<usize> {
256 Ok(0)
257 }
258 }
259 impl #impl_generics ::onc_xdr::Unpack for #name #ty_generics
260 #where_clause {
261 fn unpack(_input: &mut impl std::io::Read) -> ::onc_xdr::Result<(Self, usize)> {
262 Ok((Self, 0))
263 }
264 }
265 }
266 },
267 }
268}
269
270fn validate_complex_enum_variant(variant: &Variant) -> Result<(), String> {
275 match &variant.fields {
276 Fields::Unit => Ok(()),
277 Fields::Unnamed(fields) if fields.unnamed.len() == 1 => Ok(()),
278 _ => Err(format!("Complex enum variant '{}' must be either unit or have exactly one unnamed field", variant.ident)),
279 }
280}
281
282fn generate_complex_enum_pack_variant(variant: &Variant) -> TokenStream2 {
284 let ident = &variant.ident;
285 let xdr_value = parse_xdr_value(&variant.attrs).unwrap_or_else(|| {
286 panic!("Complex enum variant '{ident}' must have #[xdr(value)] attribute");
287 });
288
289 match &variant.fields {
290 Fields::Unit => {
291 quote! {
292 Self::#ident => #xdr_value.pack(out),
293 }
294 },
295 Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
296 quote! {
297 Self::#ident(val) => {
298 let mut len = #xdr_value.pack(out)?;
299 len += val.pack(out)?;
300 Ok(len)
301 },
302 }
303 },
304 _ => panic!("Invalid complex enum variant: {ident}"),
305 }
306}
307
308fn generate_complex_enum_packed_size_variant(variant: &Variant) -> TokenStream2 {
313 let ident = &variant.ident;
314
315 match &variant.fields {
316 Fields::Unit => {
317 quote! {
318 Self::#ident => 4,
319 }
320 },
321 Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
322 quote! {
323 Self::#ident(val) => 4 + val.packed_size(),
324 }
325 },
326 _ => panic!("Invalid complex enum variant: {ident}"),
327 }
328}
329
330fn generate_complex_enum_unpack_variant(variant: &Variant) -> TokenStream2 {
332 let ident = &variant.ident;
333 let xdr_value = parse_xdr_value(&variant.attrs).unwrap_or_else(|| {
334 panic!("Complex enum variant '{ident}' must have #[xdr(value)] attribute");
335 });
336
337 match &variant.fields {
338 Fields::Unit => {
339 quote! {
340 #xdr_value => Ok(Self::#ident),
341 }
342 },
343 Fields::Unnamed(fields) if fields.unnamed.len() == 1 => {
344 quote! {
345 #xdr_value => {
346 let (val, val_bytes) = ::onc_xdr::Unpack::unpack(input)?;
347 bytes_read += val_bytes;
348 Ok(Self::#ident(val))
349 },
350 }
351 },
352 _ => panic!("Invalid complex enum variant: {ident}"),
353 }
354}
355
356fn generate_simple_enum_impl(name: &Ident, generics: &syn::Generics, data: &DataEnum) -> TokenStream2 {
361 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
362
363 let pack_variants = data.variants.iter().map(|v| {
364 let ident = &v.ident;
365 quote! {
366 Self::#ident => (*self as u32).pack(out),
367 }
368 });
369
370 let unpack_variants = data.variants.iter().map(|v| {
371 let ident = &v.ident;
372 quote! {
373 x if x == Self::#ident as u32 => Ok(Self::#ident),
374 }
375 });
376
377 quote! {
378 impl #impl_generics ::onc_xdr::Pack for #name #ty_generics
379 #where_clause {
380 fn packed_size(&self) -> usize {
381 4
382 }
383
384 fn pack(&self, out: &mut impl std::io::Write) -> ::onc_xdr::Result<usize> {
385 use ::onc_xdr::Pack;
386 match self {
387 #(#pack_variants)*
388 }
389 }
390 }
391 impl #impl_generics ::onc_xdr::Unpack for #name #ty_generics
392 #where_clause {
393 fn unpack(input: &mut impl std::io::Read) -> ::onc_xdr::Result<(Self, usize)> {
394 let (tag, bytes_read) = u32::unpack(input)?;
395 let result = match tag {
396 #(#unpack_variants)*
397 _ => Err(::onc_xdr::Error::InvalidEnumValue(tag)),
398 };
399 result.map(|value| (value, bytes_read))
400 }
401 }
402 }
403}
404
405fn generate_complex_enum_impl(name: &Ident, generics: &syn::Generics, data: &DataEnum) -> TokenStream2 {
410 let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
411
412 for variant in &data.variants {
414 if let Err(err) = validate_complex_enum_variant(variant) {
415 panic!("{}", err);
416 }
417 }
418
419 let pack_variants = data.variants.iter().map(generate_complex_enum_pack_variant);
420 let packed_size_variants = data.variants.iter().map(generate_complex_enum_packed_size_variant);
421 let unpack_variants = data.variants.iter().map(generate_complex_enum_unpack_variant);
422
423 quote! {
424 impl #impl_generics ::onc_xdr::Pack for #name #ty_generics
425 #where_clause {
426 fn packed_size(&self) -> usize {
427 match self {
428 #(#packed_size_variants)*
429 }
430 }
431
432 fn pack(&self, out: &mut impl std::io::Write) -> ::onc_xdr::Result<usize> {
433 use ::onc_xdr::Pack;
434 match self {
435 #(#pack_variants)*
436 }
437 }
438 }
439 impl #impl_generics ::onc_xdr::Unpack for #name #ty_generics
440 #where_clause {
441 fn unpack(input: &mut impl std::io::Read) -> ::onc_xdr::Result<(Self, usize)> {
442 use ::onc_xdr::Unpack;
443 let (tag, mut bytes_read) = u32::unpack(input)?;
444 let result = match tag {
445 #(#unpack_variants)*
446 _ => Err(::onc_xdr::Error::InvalidEnumValue(tag)),
447 };
448 result.map(|value| (value, bytes_read))
449 }
450 }
451 }
452}
453
454fn generate_enum_impl(name: &Ident, generics: &syn::Generics, data: &DataEnum) -> TokenStream2 {
456 let has_data_variants = data.variants.iter().any(|v| !matches!(v.fields, Fields::Unit));
457
458 if has_data_variants { generate_complex_enum_impl(name, generics, data) } else { generate_simple_enum_impl(name, generics, data) }
459}
460
461#[proc_macro_derive(XdrCodec, attributes(xdr))]
472pub fn derive_xdr_codec(input: TokenStream) -> TokenStream {
473 let input = parse_macro_input!(input as DeriveInput);
474 let name = &input.ident;
475 let generics = &input.generics;
476
477 let result = match &input.data {
478 Data::Struct(data_struct) => generate_struct_impl(name, generics, &data_struct.fields),
479 Data::Enum(data_enum) => generate_enum_impl(name, generics, data_enum),
480 Data::Union(_) => panic!("XdrCodec can only be derived for structs and enums"),
481 };
482
483 result.into()
484}
485
486#[cfg(test)]
489mod _dev_dep_anchors {
490 use onc_xdr as _;
491 use trybuild as _;
492}