derive_refineable/
derive_refineable.rs1use 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 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 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 #[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 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}