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#[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}