Skip to main content

derive_refineable/
derive_refineable.rs

1use proc_macro::TokenStream;
2use proc_macro2::TokenStream as TokenStream2;
3use quote::{format_ident, quote};
4use syn::{
5    DeriveInput, Field, FieldsNamed, PredicateType, TraitBound, Type, TypeParamBound, WhereClause,
6    WherePredicate, parse_macro_input, parse_quote,
7};
8
9#[proc_macro_derive(Refineable, attributes(refineable))]
10pub fn derive_refineable(input: TokenStream) -> TokenStream {
11    let DeriveInput {
12        ident,
13        data,
14        generics,
15        attrs,
16        ..
17    } = parse_macro_input!(input);
18
19    let mut impl_debug_on_refinement = false;
20    let mut derives_serialize = false;
21    let mut refinement_traits_to_derive = vec![];
22
23    for refineable_attr in attrs
24        .iter()
25        .filter(|attr| attr.path().is_ident("refineable"))
26    {
27        let _ = refineable_attr.parse_nested_meta(|meta| {
28            if meta.path.is_ident("Debug") {
29                impl_debug_on_refinement = true;
30            } else {
31                if meta.path.is_ident("Serialize") {
32                    derives_serialize = true;
33                }
34                refinement_traits_to_derive.push(meta.path);
35            }
36            Ok(())
37        });
38    }
39
40    let refinement_ident = format_ident!("{}Refinement", ident);
41    let (impl_generics, ty_generics, where_clause) = generics.split_for_impl();
42
43    let fields = match data {
44        syn::Data::Struct(syn::DataStruct {
45            fields: syn::Fields::Named(FieldsNamed { named, .. }),
46            ..
47        }) => named.into_iter().collect::<Vec<Field>>(),
48        _ => panic!("This derive macro only supports structs with named fields"),
49    };
50
51    let field_names: Vec<_> = fields.iter().map(|f| f.ident.as_ref().unwrap()).collect();
52    let field_visibilities: Vec<_> = fields.iter().map(|f| &f.vis).collect();
53    let wrapped_types: Vec<_> = fields.iter().map(|f| get_wrapper_type(f, &f.ty)).collect();
54
55    let field_attributes: Vec<TokenStream2> = fields
56        .iter()
57        .map(|f| {
58            if derives_serialize {
59                if is_refineable_field(f) {
60                    quote! { #[serde(default, skip_serializing_if = "::refineable::IsEmpty::is_empty")] }
61                } else {
62                    quote! { #[serde(skip_serializing_if = "::std::option::Option::is_none")] }
63                }
64            } else {
65                quote! {}
66            }
67        })
68        .collect();
69
70    // Create trait bound that each wrapped type must implement Clone
71    let type_param_bounds: Vec<_> = wrapped_types
72        .iter()
73        .map(|ty| {
74            WherePredicate::Type(PredicateType {
75                lifetimes: None,
76                bounded_ty: ty.clone(),
77                colon_token: Default::default(),
78                bounds: {
79                    let mut punctuated = syn::punctuated::Punctuated::new();
80                    punctuated.push_value(TypeParamBound::Trait(TraitBound {
81                        paren_token: None,
82                        modifier: syn::TraitBoundModifier::None,
83                        lifetimes: None,
84                        path: parse_quote!(Clone),
85                    }));
86
87                    punctuated
88                },
89            })
90        })
91        .collect();
92
93    // Append to where_clause or create a new one if it doesn't exist
94    let where_clause = match where_clause.cloned() {
95        Some(mut where_clause) => {
96            where_clause.predicates.extend(type_param_bounds);
97            where_clause.clone()
98        }
99        None => WhereClause {
100            where_token: Default::default(),
101            predicates: type_param_bounds.into_iter().collect(),
102        },
103    };
104
105    let refineable_refine_assignments: Vec<TokenStream2> = fields
106        .iter()
107        .map(|field| {
108            let name = &field.ident;
109            let is_refineable = is_refineable_field(field);
110            let is_optional = is_optional_field(field);
111
112            if is_refineable {
113                quote! {
114                    self.#name.refine(&refinement.#name);
115                }
116            } else if is_optional {
117                quote! {
118                    if let Some(value) = &refinement.#name {
119                        self.#name = Some(value.clone());
120                    }
121                }
122            } else {
123                quote! {
124                    if let Some(value) = &refinement.#name {
125                        self.#name = value.clone();
126                    }
127                }
128            }
129        })
130        .collect();
131
132    let refineable_refined_assignments: Vec<TokenStream2> = fields
133        .iter()
134        .map(|field| {
135            let name = &field.ident;
136            let is_refineable = is_refineable_field(field);
137            let is_optional = is_optional_field(field);
138
139            if is_refineable {
140                quote! {
141                    self.#name = self.#name.refined(refinement.#name);
142                }
143            } else if is_optional {
144                quote! {
145                    if let Some(value) = refinement.#name {
146                        self.#name = Some(value);
147                    }
148                }
149            } else {
150                quote! {
151                    if let Some(value) = refinement.#name {
152                        self.#name = value;
153                    }
154                }
155            }
156        })
157        .collect();
158
159    let refinement_refine_assignments: Vec<TokenStream2> = fields
160        .iter()
161        .map(|field| {
162            let name = &field.ident;
163            let is_refineable = is_refineable_field(field);
164
165            if is_refineable {
166                quote! {
167                    self.#name.refine(&refinement.#name);
168                }
169            } else {
170                quote! {
171                    if let Some(value) = &refinement.#name {
172                        self.#name = Some(value.clone());
173                    }
174                }
175            }
176        })
177        .collect();
178
179    let refinement_refined_assignments: Vec<TokenStream2> = fields
180        .iter()
181        .map(|field| {
182            let name = &field.ident;
183            let is_refineable = is_refineable_field(field);
184
185            if is_refineable {
186                quote! {
187                    self.#name = self.#name.refined(refinement.#name);
188                }
189            } else {
190                quote! {
191                    if let Some(value) = refinement.#name {
192                        self.#name = Some(value);
193                    }
194                }
195            }
196        })
197        .collect();
198
199    let from_refinement_assignments: Vec<TokenStream2> = fields
200        .iter()
201        .map(|field| {
202            let name = &field.ident;
203            let is_refineable = is_refineable_field(field);
204            let is_optional = is_optional_field(field);
205
206            if is_refineable {
207                quote! {
208                    #name: value.#name.into(),
209                }
210            } else if is_optional {
211                quote! {
212                    #name: value.#name.map(|v| v.into()),
213                }
214            } else {
215                quote! {
216                    #name: value.#name.map(|v| v.into()).unwrap_or_default(),
217                }
218            }
219        })
220        .collect();
221
222    let debug_impl = if impl_debug_on_refinement {
223        let refinement_field_debugs: Vec<TokenStream2> = fields
224            .iter()
225            .map(|field| {
226                let name = &field.ident;
227                quote! {
228                    if self.#name.is_some() {
229                        debug_struct.field(stringify!(#name), &self.#name);
230                    } else {
231                        all_some = false;
232                    }
233                }
234            })
235            .collect();
236
237        quote! {
238            impl #impl_generics std::fmt::Debug for #refinement_ident #ty_generics
239                #where_clause
240            {
241                fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
242                    let mut debug_struct = f.debug_struct(stringify!(#refinement_ident));
243                    let mut all_some = true;
244                    #( #refinement_field_debugs )*
245                    if all_some {
246                        debug_struct.finish()
247                    } else {
248                        debug_struct.finish_non_exhaustive()
249                    }
250                }
251            }
252        }
253    } else {
254        quote! {}
255    };
256
257    let refinement_is_empty_conditions: Vec<TokenStream2> = fields
258        .iter()
259        .enumerate()
260        .map(|(i, field)| {
261            let name = &field.ident;
262
263            let condition = if is_refineable_field(field) {
264                quote! { self.#name.is_empty() }
265            } else {
266                quote! { self.#name.is_none() }
267            };
268
269            if i < fields.len() - 1 {
270                quote! { #condition && }
271            } else {
272                condition
273            }
274        })
275        .collect();
276
277    let refineable_is_superset_conditions: Vec<TokenStream2> = fields
278        .iter()
279        .map(|field| {
280            let name = &field.ident;
281            let is_refineable = is_refineable_field(field);
282            let is_optional = is_optional_field(field);
283
284            if is_refineable {
285                quote! {
286                    if !self.#name.is_superset_of(&refinement.#name) {
287                        return false;
288                    }
289                }
290            } else if is_optional {
291                quote! {
292                    if refinement.#name.is_some() && &self.#name != &refinement.#name {
293                        return false;
294                    }
295                }
296            } else {
297                quote! {
298                    if let Some(refinement_value) = &refinement.#name {
299                        if &self.#name != refinement_value {
300                            return false;
301                        }
302                    }
303                }
304            }
305        })
306        .collect();
307
308    let refinement_is_superset_conditions: Vec<TokenStream2> = fields
309        .iter()
310        .map(|field| {
311            let name = &field.ident;
312            let is_refineable = is_refineable_field(field);
313
314            if is_refineable {
315                quote! {
316                    if !self.#name.is_superset_of(&refinement.#name) {
317                        return false;
318                    }
319                }
320            } else {
321                quote! {
322                    if refinement.#name.is_some() && &self.#name != &refinement.#name {
323                        return false;
324                    }
325                }
326            }
327        })
328        .collect();
329
330    let refineable_subtract_assignments: Vec<TokenStream2> = fields
331        .iter()
332        .map(|field| {
333            let name = &field.ident;
334            let is_refineable = is_refineable_field(field);
335            let is_optional = is_optional_field(field);
336
337            if is_refineable {
338                quote! {
339                    #name: self.#name.subtract(&refinement.#name),
340                }
341            } else if is_optional {
342                quote! {
343                    #name: if &self.#name == &refinement.#name {
344                        None
345                    } else {
346                        self.#name.clone()
347                    },
348                }
349            } else {
350                quote! {
351                    #name: if let Some(refinement_value) = &refinement.#name {
352                        if &self.#name == refinement_value {
353                            None
354                        } else {
355                            Some(self.#name.clone())
356                        }
357                    } else {
358                        Some(self.#name.clone())
359                    },
360                }
361            }
362        })
363        .collect();
364
365    let refinement_subtract_assignments: Vec<TokenStream2> = fields
366        .iter()
367        .map(|field| {
368            let name = &field.ident;
369            let is_refineable = is_refineable_field(field);
370
371            if is_refineable {
372                quote! {
373                    #name: self.#name.subtract(&refinement.#name),
374                }
375            } else {
376                quote! {
377                    #name: if &self.#name == &refinement.#name {
378                        None
379                    } else {
380                        self.#name.clone()
381                    },
382                }
383            }
384        })
385        .collect();
386
387    let mut derive_stream = quote! {};
388    for trait_to_derive in refinement_traits_to_derive {
389        derive_stream.extend(quote! { #[derive(#trait_to_derive)] })
390    }
391
392    let r#gen = quote! {
393        /// A refinable version of [`#ident`], see that documentation for details.
394        #[derive(Clone)]
395        #derive_stream
396        pub struct #refinement_ident #impl_generics {
397            #(
398                #[allow(missing_docs)]
399                #field_attributes
400                #field_visibilities #field_names: #wrapped_types
401            ),*
402        }
403
404        impl #impl_generics Refineable for #ident #ty_generics
405            #where_clause
406        {
407            type Refinement = #refinement_ident #ty_generics;
408
409            fn refine(&mut self, refinement: &Self::Refinement) {
410                #( #refineable_refine_assignments )*
411            }
412
413            fn refined(mut self, refinement: Self::Refinement) -> Self {
414                #( #refineable_refined_assignments )*
415                self
416            }
417
418            fn is_superset_of(&self, refinement: &Self::Refinement) -> bool
419            {
420                #( #refineable_is_superset_conditions )*
421                true
422            }
423
424            fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement
425            {
426                #refinement_ident {
427                    #( #refineable_subtract_assignments )*
428                }
429            }
430        }
431
432        impl #impl_generics Refineable for #refinement_ident #ty_generics
433            #where_clause
434        {
435            type Refinement = #refinement_ident #ty_generics;
436
437            fn refine(&mut self, refinement: &Self::Refinement) {
438                #( #refinement_refine_assignments )*
439            }
440
441            fn refined(mut self, refinement: Self::Refinement) -> Self {
442                #( #refinement_refined_assignments )*
443                self
444            }
445
446            fn is_superset_of(&self, refinement: &Self::Refinement) -> bool
447            {
448                #( #refinement_is_superset_conditions )*
449                true
450            }
451
452            fn subtract(&self, refinement: &Self::Refinement) -> Self::Refinement
453            {
454                #refinement_ident {
455                    #( #refinement_subtract_assignments )*
456                }
457            }
458        }
459
460        impl #impl_generics ::refineable::IsEmpty for #refinement_ident #ty_generics
461            #where_clause
462        {
463            fn is_empty(&self) -> bool {
464                #( #refinement_is_empty_conditions )*
465            }
466        }
467
468        impl #impl_generics From<#refinement_ident #ty_generics> for #ident #ty_generics
469            #where_clause
470        {
471            fn from(value: #refinement_ident #ty_generics) -> Self {
472                Self {
473                    #( #from_refinement_assignments )*
474                }
475            }
476        }
477
478        impl #impl_generics ::core::default::Default for #refinement_ident #ty_generics
479            #where_clause
480        {
481            fn default() -> Self {
482                #refinement_ident {
483                    #( #field_names: Default::default() ),*
484                }
485            }
486        }
487
488        impl #impl_generics #refinement_ident #ty_generics
489            #where_clause
490        {
491            /// Returns `true` if all fields are `Some`
492            pub fn is_some(&self) -> bool {
493                #(
494                    if self.#field_names.is_some() {
495                        return true;
496                    }
497                )*
498                false
499            }
500        }
501
502        #debug_impl
503    };
504    r#gen.into()
505}
506
507fn is_refineable_field(f: &Field) -> bool {
508    f.attrs
509        .iter()
510        .any(|attr| attr.path().is_ident("refineable"))
511}
512
513fn is_optional_field(f: &Field) -> bool {
514    if let Type::Path(typepath) = &f.ty
515        && typepath.qself.is_none()
516    {
517        let segments = &typepath.path.segments;
518        if segments.len() == 1 && segments.iter().any(|s| s.ident == "Option") {
519            return true;
520        }
521    }
522    false
523}
524
525fn get_wrapper_type(field: &Field, ty: &Type) -> syn::Type {
526    if is_refineable_field(field) {
527        let struct_name = if let Type::Path(tp) = ty {
528            tp.path.segments.last().unwrap().ident.clone()
529        } else {
530            panic!("Expected struct type for a refineable field");
531        };
532
533        let refinement_struct_name = if struct_name.to_string().ends_with("Refinement") {
534            format_ident!("{}", struct_name)
535        } else {
536            format_ident!("{}Refinement", struct_name)
537        };
538        let generics = if let Type::Path(tp) = ty {
539            &tp.path.segments.last().unwrap().arguments
540        } else {
541            &syn::PathArguments::None
542        };
543        parse_quote!(#refinement_struct_name #generics)
544    } else if is_optional_field(field) {
545        ty.clone()
546    } else {
547        parse_quote!(Option<#ty>)
548    }
549}