1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
|
use proc_macro2::TokenStream;
use quote::quote;
use crate::ast::{Fields, Style};
use crate::codegen::Field;
pub struct FieldsGen<'a> {
fields: &'a Fields<Field<'a>>,
allow_unknown_fields: bool,
}
impl<'a> FieldsGen<'a> {
pub fn new(fields: &'a Fields<Field<'a>>, allow_unknown_fields: bool) -> Self {
Self {
fields,
allow_unknown_fields,
}
}
/// Create declarations for all the fields in the struct.
pub(in crate::codegen) fn declarations(&self) -> TokenStream {
match *self.fields {
Fields {
style: Style::Struct,
ref fields,
..
} => {
let vdr = fields.iter().map(Field::as_declaration);
quote!(#(#vdr)*)
}
_ => panic!("FieldsGen doesn't support tuples yet"),
}
}
/// Generate the loop which walks meta items looking for property matches.
pub(in crate::codegen) fn core_loop(&self) -> TokenStream {
let arms = self.fields.as_ref().map(Field::as_match);
// If there is a flatten field, buffer the unknown field so it can be passed
// to the flatten function with all other unknown fields.
let handle_unknown = if self.fields.iter().any(|f| f.flatten) {
quote! {
__flatten.push(::darling::ast::NestedMeta::Meta(__inner.clone()));
}
}
// If we're allowing unknown fields, then handling one is a no-op.
else if self.allow_unknown_fields {
quote!()
}
// Otherwise, we're going to push a new spanned error pointing at the field.
else {
let mut names = self.fields.iter().filter_map(Field::as_name).peekable();
// We can't call `unknown_field_with_alts` with an empty slice, or else it fails to
// infer the type of the slice item.
let err_fn = if names.peek().is_none() {
quote!(unknown_field(__other))
} else {
quote!(unknown_field_with_alts(__other, &[#(#names),*]))
};
quote! {
__errors.push(::darling::Error::#err_fn.with_span(__inner));
}
};
let arms = arms.iter();
quote!(
for __item in __items {
match *__item {
::darling::export::NestedMeta::Meta(ref __inner) => {
let __name = ::darling::util::path_to_string(__inner.path());
match __name.as_str() {
#(#arms)*
__other => { #handle_unknown }
}
}
::darling::export::NestedMeta::Lit(ref __inner) => {
__errors.push(::darling::Error::unsupported_format("literal")
.with_span(__inner));
}
}
}
)
}
pub fn require_fields(&self) -> TokenStream {
match *self.fields {
Fields {
style: Style::Struct,
ref fields,
..
} => {
let checks = fields.iter().map(Field::as_presence_check);
quote!(#(#checks)*)
}
_ => panic!("FieldsGen doesn't support tuples for requirement checks"),
}
}
pub(in crate::codegen) fn initializers(&self) -> TokenStream {
let inits = self.fields.as_ref().map(Field::as_initializer);
let inits = inits.iter();
quote!(#(#inits),*)
}
}
|
