Skip to main content

macro3681/
lib.rs

1use proc_macro::TokenStream;
2use quote::{format_ident, quote};
3use syn::parse::{Parse, ParseStream, Parser, Result};
4use syn::punctuated::Punctuated;
5use syn::{parse_macro_input, token, Attribute, Expr, Generics, Ident, Token, Type, Visibility};
6
7/// ```rust
8/// use macro3681::default_field_values;
9///
10/// default_field_values! {
11///     pub struct Foo {
12///         i: i32,
13///         j: u32 = 1,
14///         string: String = {
15///             let s = format!("{} {}", "foo", "bar");
16///             s
17///         }
18///     }
19/// }
20/// ```
21#[proc_macro]
22pub fn default_field_values(input: TokenStream) -> TokenStream {
23    let many_struct = parse_macro_input!(input as ManyStruct);
24    let mut tokens = TokenStream::new();
25    for struct_kind in many_struct.0 {
26        let token_stream = match struct_kind {
27            StructKind::Braced(b) => gen_braced(b),
28            StructKind::Parenthesized(p) => gen_parenthesized(p),
29        };
30        tokens.extend(token_stream);
31    }
32    tokens
33}
34
35fn gen_braced(def: BracedDef) -> TokenStream {
36    let BracedDef {
37        attrs,
38        visibility,
39        name,
40        generics,
41        fields,
42    } = def;
43    let field_defs = fields.iter().map(|f| {
44        let attrs = &f.attrs;
45        let visibility = &f.visibility;
46        let ident = &f.ident;
47        let ty = &f.ty;
48        quote! {
49            #(#attrs)*
50            #visibility #ident: #ty
51        }
52    });
53
54    let constructor_args = fields.iter().filter_map(|f| match &f.default {
55        DefaultValue::None => {
56            let ident = &f.ident;
57            let ty = &f.ty;
58            Some(quote! { #ident: #ty })
59        }
60        _ => None,
61    });
62
63    let constructor_inits = fields.iter().map(|f| {
64        let ident = &f.ident;
65        match &f.default {
66            DefaultValue::None => quote! { #ident },
67            DefaultValue::Underscore => quote! { #ident: Default::default() },
68            DefaultValue::Expr(default_expr) => quote! { #ident: #default_expr },
69        }
70    });
71
72    let (impl_gen, type_gen, where_gen) = generics.split_for_impl();
73    let expanded = if has_derive_default(&attrs) {
74        let has_default_inits = fields.iter().filter_map(|f| {
75            let ident = &f.ident;
76            match &f.default {
77                DefaultValue::None => None,
78                DefaultValue::Underscore => Some(quote! { #ident: Default::default() }),
79                DefaultValue::Expr(default_expr) => Some(quote! { #ident: #default_expr }),
80            }
81        });
82
83        let no_default_inits = fields.iter().filter_map(|f| match &f.default {
84            DefaultValue::None => {
85                let ident = &f.ident;
86                Some(quote! { #ident: Default::default() })
87            }
88            DefaultValue::Underscore => None,
89            DefaultValue::Expr(_) => None,
90        });
91        let strip_default_attrs = strip_default_from_derive(attrs);
92        quote! {
93            #(#strip_default_attrs)*
94            #visibility struct #name #type_gen #where_gen {
95                #(#field_defs,)*
96            }
97
98            impl #impl_gen #name #type_gen #where_gen {
99                pub fn new(#(#constructor_args),*) -> Self {
100                    Self {
101                        #(#constructor_inits,)*
102                    }
103                }
104            }
105
106            impl #impl_gen Default for #name #type_gen #where_gen {
107                fn default() -> Self {
108                    Self {
109                        #(#has_default_inits,)*
110                        #(#no_default_inits,)*
111                    }
112                }
113            }
114
115        }
116    } else {
117        quote! {
118            #(#attrs)*
119            #visibility struct #name #type_gen #where_gen {
120                #(#field_defs,)*
121            }
122
123            impl #impl_gen #name #type_gen #where_gen {
124                pub fn new(#(#constructor_args),*) -> Self {
125                    Self {
126                        #(#constructor_inits,)*
127                    }
128                }
129            }
130        }
131    };
132    TokenStream::from(expanded)
133}
134
135fn gen_parenthesized(def: ParenthesizedDef) -> TokenStream {
136    let ParenthesizedDef {
137        attrs,
138        visibility,
139        name,
140        generics,
141        elements,
142    } = def;
143    let element_defs = elements.iter().map(|f| {
144        let attrs = &f.attrs;
145        let visibility = &f.visibility;
146        let ty = &f.ty;
147        quote! {
148            #(#attrs)*
149            #visibility #ty
150        }
151    });
152
153    let constructor_args = elements
154        .iter()
155        .enumerate()
156        .filter_map(|(i, e)| match &e.default {
157            DefaultValue::None => {
158                let ident = format_ident!("_{}", i);
159                let ty = &e.ty;
160                Some(quote! { #ident: #ty })
161            }
162            _ => None,
163        });
164
165    let constructor_inits = elements.iter().enumerate().map(|(i, e)| {
166        let ident = format_ident!("_{}", i);
167        match &e.default {
168            DefaultValue::None => quote! { #ident },
169            DefaultValue::Underscore => quote! { Default::default() },
170            DefaultValue::Expr(default_expr) => quote! { #default_expr },
171        }
172    });
173
174    let (impl_gen, type_gen, _) = generics.split_for_impl();
175    let expanded = if has_derive_default(&attrs) {
176        let inits = elements.iter().filter_map(|e| match &e.default {
177            DefaultValue::None | DefaultValue::Underscore => Some(quote! { Default::default() }),
178            DefaultValue::Expr(default_expr) => Some(quote! { #default_expr }),
179        });
180        let strip_default_attrs = strip_default_from_derive(attrs);
181        quote! {
182            #(#strip_default_attrs)*
183            #visibility struct #name #type_gen(#(#element_defs,)*);
184
185            impl #impl_gen #name #type_gen {
186                pub fn new(#(#constructor_args),*) -> Self {
187                    Self(#(#constructor_inits,)*)
188                }
189            }
190
191            impl #impl_gen Default for #name #type_gen {
192                fn default() -> Self {
193                    Self(#(#inits,)*)
194                }
195            }
196        }
197    } else {
198        quote! {
199            #(#attrs)*
200            #visibility struct #name #type_gen(#(#element_defs,)*);
201
202            impl #impl_gen #name #type_gen {
203                pub fn new(#(#constructor_args),*) -> Self {
204                    Self (#(#constructor_inits,)*)
205                }
206            }
207        }
208    };
209    TokenStream::from(expanded)
210}
211
212fn has_derive_default(attrs: &[Attribute]) -> bool {
213    attrs.iter().any(|attr| {
214        if !attr.path().is_ident("derive") {
215            return false;
216        }
217        attr.parse_args_with(|parser: ParseStream| {
218            let idents = Punctuated::<Ident, Token![,]>::parse_terminated(parser)?;
219            Ok(idents.iter().any(|ident| ident == "Default"))
220        })
221        .unwrap_or(false)
222    })
223}
224
225fn strip_default_from_derive(attrs: Vec<Attribute>) -> Vec<Attribute> {
226    let mut output: Vec<Attribute> = Vec::new();
227    for attr in attrs {
228        if attr.path().is_ident("derive") {
229            if let Ok(punct) = attr.parse_args_with(|parser: ParseStream| {
230                Punctuated::<Ident, Token![,]>::parse_terminated(parser)
231            }) {
232                let mut iter = punct.into_iter().peekable();
233                let mut kept = Vec::new();
234                while let Some(ident) = iter.next() {
235                    if ident == "Default" {
236                        continue;
237                    }
238                    kept.push(ident);
239                }
240
241                if kept.is_empty() {
242                    continue;
243                }
244
245                let new_tokens = quote! { #[derive(#(#kept),*)] };
246                match Attribute::parse_outer.parse2(new_tokens) {
247                    Ok(new_attrs) => output.extend(new_attrs),
248                    Err(_) => output.push(attr),
249                }
250            } else {
251                output.push(attr);
252            }
253        } else {
254            output.push(attr);
255        }
256    }
257    output
258}
259
260enum DefaultValue {
261    None,
262    Underscore,
263    Expr(Expr),
264}
265
266struct BracedDef {
267    attrs: Vec<Attribute>,
268    visibility: Visibility,
269    name: Ident,
270    generics: Generics,
271    fields: Vec<Field>,
272}
273
274struct ParenthesizedDef {
275    attrs: Vec<Attribute>,
276    visibility: Visibility,
277    name: Ident,
278    generics: Generics,
279    elements: Vec<Element>,
280}
281
282#[allow(unused)]
283struct Field {
284    attrs: Vec<Attribute>,
285    visibility: Visibility,
286    ident: Ident,
287    ty: Type,
288    default: DefaultValue,
289}
290
291#[allow(unused)]
292struct Element {
293    attrs: Vec<Attribute>,
294    visibility: Visibility,
295    ty: Type,
296    default: DefaultValue,
297}
298
299enum StructKind {
300    Braced(BracedDef),
301    Parenthesized(ParenthesizedDef),
302}
303
304struct ManyStruct(Vec<StructKind>);
305
306impl Parse for ManyStruct {
307    fn parse(input: ParseStream) -> Result<Self> {
308        let mut structs: Vec<StructKind> = Vec::new();
309        while !input.is_empty() {
310            structs.push(input.parse()?);
311        }
312        Ok(ManyStruct(structs))
313    }
314}
315
316impl Parse for StructKind {
317    fn parse(input: ParseStream) -> Result<Self> {
318        let attrs = input.call(Attribute::parse_outer)?;
319        let visibility = input.parse()?;
320        let _ = input.parse::<Token![struct]>()?;
321        let name: Ident = input.parse()?;
322        let mut generics: Generics = input.parse()?;
323        generics.where_clause = input.parse()?;
324        let content;
325        if input.peek(token::Brace) {
326            syn::braced!(content in input);
327            let mut fields = Vec::new();
328            while !content.is_empty() {
329                fields.push(content.parse()?);
330            }
331            let def = BracedDef {
332                attrs,
333                visibility,
334                name,
335                generics,
336                fields,
337            };
338            Ok(StructKind::Braced(def))
339        } else {
340            syn::parenthesized!(content in input);
341            let mut fields = Vec::new();
342            while !content.is_empty() {
343                fields.push(content.parse()?);
344            }
345            let _ = input.parse::<Token![;]>()?;
346            let def = ParenthesizedDef {
347                attrs,
348                visibility,
349                name,
350                generics,
351                elements: fields,
352            };
353            Ok(StructKind::Parenthesized(def))
354        }
355    }
356}
357
358impl Parse for DefaultValue {
359    fn parse(input: ParseStream) -> Result<Self> {
360        if input.peek(Token![_]) {
361            input.parse::<Token![_]>()?;
362            Ok(DefaultValue::Underscore)
363        } else {
364            let expr: Expr = input.parse()?;
365            Ok(DefaultValue::Expr(expr))
366        }
367    }
368}
369
370impl Parse for Field {
371    fn parse(input: ParseStream) -> Result<Self> {
372        let attrs = input.call(Attribute::parse_outer)?;
373        let visibility = input.parse()?;
374        let ident: Ident = input.parse()?;
375        let _colon_token: Token![:] = input.parse()?;
376        let ty: Type = input.parse()?;
377
378        let default = if input.peek(Token![=]) {
379            let _eq_token: Token![=] = input.parse()?;
380            let default: DefaultValue = input.parse()?;
381            default
382        } else {
383            DefaultValue::None
384        };
385
386        let _comma_token: Result<Token![,]> = input.parse();
387
388        Ok(Field {
389            attrs,
390            visibility,
391            ident,
392            ty,
393            default,
394        })
395    }
396}
397
398impl Parse for Element {
399    fn parse(input: ParseStream) -> Result<Self> {
400        let attrs = input.call(Attribute::parse_outer)?;
401        let visibility = input.parse()?;
402        let ty: Type = input.parse()?;
403
404        let default = if input.peek(Token![=]) {
405            let _eq_token: Token![=] = input.parse()?;
406            let default: DefaultValue = input.parse()?;
407            default
408        } else {
409            DefaultValue::None
410        };
411
412        let _comma_token: Result<Token![,]> = input.parse();
413
414        Ok(Element {
415            attrs,
416            visibility,
417            ty,
418            default,
419        })
420    }
421}