darling_core/options/
input_field.rs

Help
1use std::borrow::Cow;
2
3use syn::{parse_quote_spanned, spanned::Spanned};
4
5use crate::codegen;
6use crate::options::{Core, DefaultExpression, ParseAttribute};
7use crate::util::{Flag, SpannedValue};
8use crate::{Error, FromMeta, Result};
9
10#[derive(Debug, Clone)]
11pub struct InputField {
12    pub ident: syn::Ident,
13    pub attr_name: Option<String>,
14    pub ty: syn::Type,
15    pub default: Option<DefaultExpression>,
16    pub with: Option<syn::Path>,
17
18    /// If `true`, generated code will not look for this field in the input meta item,
19    /// instead always falling back to either `InputField::default` or `Default::default`.
20    pub skip: Option<SpannedValue<bool>>,
21    pub post_transform: Option<codegen::PostfixTransform>,
22    pub multiple: Option<bool>,
23    pub flatten: Flag,
24}
25
26impl InputField {
27    /// Generate a view into this field that can be used for code generation.
28    pub fn as_codegen_field(&self) -> codegen::Field<'_> {
29        codegen::Field {
30            ident: &self.ident,
31            name_in_attr: self
32                .attr_name
33                .as_ref()
34                .map_or_else(|| Cow::Owned(self.ident.to_string()), Cow::Borrowed),
35            ty: &self.ty,
36            default_expression: self.as_codegen_default(),
37            with_path: self.with.as_ref().map_or_else(
38                || {
39                    Cow::Owned(
40                        parse_quote_spanned!(self.ty.span()=> ::darling::FromMeta::from_meta),
41                    )
42                },
43                Cow::Borrowed,
44            ),
45            skip: *self.skip.unwrap_or_default(),
46            post_transform: self.post_transform.as_ref(),
47            multiple: self.multiple.unwrap_or_default(),
48            flatten: self.flatten.is_present(),
49        }
50    }
51
52    /// Generate a codegen::DefaultExpression for this field. This requires the field name
53    /// in the `Inherit` case.
54    fn as_codegen_default(&self) -> Option<codegen::DefaultExpression<'_>> {
55        self.default.as_ref().map(|expr| match *expr {
56            DefaultExpression::Explicit(ref path) => codegen::DefaultExpression::Explicit(path),
57            DefaultExpression::Inherit => codegen::DefaultExpression::Inherit(&self.ident),
58            DefaultExpression::Trait { span } => codegen::DefaultExpression::Trait { span },
59        })
60    }
61
62    fn new(ident: syn::Ident, ty: syn::Type) -> Self {
63        InputField {
64            ident,
65            ty,
66            attr_name: None,
67            default: None,
68            with: None,
69            skip: None,
70            post_transform: Default::default(),
71            multiple: None,
72            flatten: Default::default(),
73        }
74    }
75
76    pub fn from_field(f: &syn::Field, parent: Option<&Core>) -> Result<Self> {
77        let ident = f
78            .ident
79            .clone()
80            .unwrap_or_else(|| syn::Ident::new("__unnamed", ::proc_macro2::Span::call_site()));
81        let ty = f.ty.clone();
82        let base = Self::new(ident, ty).parse_attributes(&f.attrs)?;
83
84        Ok(if let Some(container) = parent {
85            base.with_inherited(container)
86        } else {
87            base
88        })
89    }
90
91    /// Apply inherited settings from the container. This is done _after_ parsing
92    /// to ensure deference to explicit field-level settings.
93    fn with_inherited(mut self, parent: &Core) -> Self {
94        // explicit renamings take precedence over rename rules on the container,
95        // but in the absence of an explicit name we apply the rule.
96        if self.attr_name.is_none() {
97            self.attr_name = Some(parent.rename_rule.apply_to_field(self.ident.to_string()));
98        }
99
100        // Determine the default expression for this field, based on three pieces of information:
101        // 1. Will we look for this field in the attribute?
102        // 1. Is there a locally-defined default?
103        // 1. Did the parent define a default?
104        self.default = match (&self.skip, self.default.is_some(), parent.default.is_some()) {
105            // If we have a default, use it.
106            (_, true, _) => self.default,
107
108            // If there isn't an explicit default but the struct sets a default, we'll
109            // inherit from that.
110            (_, false, true) => Some(DefaultExpression::Inherit),
111
112            // If we're skipping the field and no defaults have been expressed then we should
113            // use the ::darling::export::Default trait, and set the span to the skip keyword
114            // so that an error caused by the skipped field's type not implementing `Default`
115            // will correctly identify why darling is trying to use `Default`.
116            (Some(v), false, false) if **v => Some(DefaultExpression::Trait { span: v.span() }),
117
118            // If we don't have or need a default, then leave it blank.
119            (_, false, false) => None,
120        };
121
122        self
123    }
124}
125
126impl ParseAttribute for InputField {
127    fn parse_nested(&mut self, mi: &syn::Meta) -> Result<()> {
128        let path = mi.path();
129
130        if path.is_ident("rename") {
131            if self.attr_name.is_some() {
132                return Err(Error::duplicate_field_path(path).with_span(mi));
133            }
134
135            self.attr_name = FromMeta::from_meta(mi)?;
136
137            if self.flatten.is_present() {
138                return Err(
139                    Error::custom("`flatten` and `rename` cannot be used together").with_span(mi),
140                );
141            }
142        } else if path.is_ident("default") {
143            if self.default.is_some() {
144                return Err(Error::duplicate_field_path(path).with_span(mi));
145            }
146            self.default = FromMeta::from_meta(mi)?;
147        } else if path.is_ident("with") {
148            if self.with.is_some() {
149                return Err(Error::duplicate_field_path(path).with_span(mi));
150            }
151
152            self.with = Some(FromMeta::from_meta(mi)?);
153
154            if self.flatten.is_present() {
155                return Err(
156                    Error::custom("`flatten` and `with` cannot be used together").with_span(mi),
157                );
158            }
159        } else if path.is_ident("skip") {
160            if self.skip.is_some() {
161                return Err(Error::duplicate_field_path(path).with_span(mi));
162            }
163
164            self.skip = FromMeta::from_meta(mi)?;
165
166            if self.skip.map(|v| *v).unwrap_or_default() && self.flatten.is_present() {
167                return Err(
168                    Error::custom("`flatten` and `skip` cannot be used together").with_span(mi),
169                );
170            }
171        } else if path.is_ident("map") || path.is_ident("and_then") {
172            let transformer = path.get_ident().unwrap().clone();
173            if let Some(post_transform) = &self.post_transform {
174                if transformer == post_transform.transformer {
175                    return Err(Error::duplicate_field_path(path).with_span(mi));
176                } else {
177                    return Err(Error::custom(format!(
178                        "Options `{}` and `{}` are mutually exclusive",
179                        transformer, post_transform.transformer
180                    ))
181                    .with_span(mi));
182                }
183            }
184
185            self.post_transform = Some(codegen::PostfixTransform::new(
186                transformer,
187                FromMeta::from_meta(mi)?,
188            ));
189        } else if path.is_ident("multiple") {
190            if self.multiple.is_some() {
191                return Err(Error::duplicate_field_path(path).with_span(mi));
192            }
193
194            self.multiple = FromMeta::from_meta(mi)?;
195
196            if self.multiple == Some(true) && self.flatten.is_present() {
197                return Err(
198                    Error::custom("`flatten` and `multiple` cannot be used together").with_span(mi),
199                );
200            }
201        } else if path.is_ident("flatten") {
202            if self.flatten.is_present() {
203                return Err(Error::duplicate_field_path(path).with_span(mi));
204            }
205
206            self.flatten = FromMeta::from_meta(mi)?;
207
208            let mut conflicts = Error::accumulator();
209
210            if self.multiple == Some(true) {
211                conflicts.push(
212                    Error::custom("`flatten` and `multiple` cannot be used together").with_span(mi),
213                );
214            }
215
216            if self.attr_name.is_some() {
217                conflicts.push(
218                    Error::custom("`flatten` and `rename` cannot be used together").with_span(mi),
219                );
220            }
221
222            if self.with.is_some() {
223                conflicts.push(
224                    Error::custom("`flatten` and `with` cannot be used together").with_span(mi),
225                );
226            }
227
228            if self.skip.map(|v| *v).unwrap_or_default() {
229                conflicts.push(
230                    Error::custom("`flatten` and `skip` cannot be used together").with_span(mi),
231                );
232            }
233
234            conflicts.finish()?;
235        } else {
236            return Err(Error::unknown_field_path(path).with_span(mi));
237        }
238
239        Ok(())
240    }
241}
darling_core/options/input_field.rs

darling_core/options/
input_field.rs
