derive_builder_core/macro_options/
darling_opts.rs

Help
1use std::convert::TryFrom;
2use std::{borrow::Cow, vec::IntoIter};
3
4use crate::BuildMethod;
5
6use darling::util::{Flag, PathList, SpannedValue};
7use darling::{Error, FromMeta};
8use proc_macro2::Span;
9use syn::{spanned::Spanned, Attribute, Generics, Ident, Meta, Path};
10
11use crate::{
12    BlockContents, Builder, BuilderField, BuilderFieldType, BuilderPattern, DefaultExpression,
13    Each, FieldConversion, Initializer, Setter,
14};
15
16#[derive(Debug, Clone)]
17enum VisibilityAttr {
18    /// `public`
19    Public(Span),
20    /// `private`
21    Private,
22    /// `vis = "pub(crate)"`
23    Explicit(syn::Visibility),
24    None,
25}
26
27impl VisibilityAttr {
28    pub fn to_explicit_visibility(&self) -> Option<Cow<syn::Visibility>> {
29        match self {
30            Self::Public(span) => Some(Cow::Owned(syn::Visibility::Public(
31                parse_quote_spanned!(*span=> pub),
32            ))),
33            Self::Private => Some(Cow::Owned(syn::Visibility::Inherited)),
34            Self::Explicit(v) => Some(Cow::Borrowed(v)),
35            Self::None => None,
36        }
37    }
38}
39
40impl Default for VisibilityAttr {
41    fn default() -> Self {
42        Self::None
43    }
44}
45
46impl FromMeta for VisibilityAttr {
47    fn from_list(items: &[darling::ast::NestedMeta]) -> darling::Result<Self> {
48        #[derive(FromMeta)]
49        struct VisibilityAttrInternal {
50            public: Flag,
51            private: Flag,
52            vis: Option<syn::Visibility>,
53        }
54
55        let VisibilityAttrInternal {
56            public,
57            private,
58            vis: explicit,
59        } = VisibilityAttrInternal::from_list(items)?;
60
61        let mut conflicts = Error::accumulator();
62
63        if public.is_present() {
64            if private.is_present() {
65                conflicts.push(
66                    Error::custom("`public` and `private` cannot be used together")
67                        .with_span(&private.span()),
68                );
69            }
70
71            if let Some(vis) = explicit {
72                conflicts.push(
73                    Error::custom("`public` and `vis` cannot be used together").with_span(&vis),
74                );
75            }
76
77            conflicts.finish_with(Self::Public(public.span()))
78        } else if let Some(vis) = explicit {
79            if private.is_present() {
80                conflicts.push(Error::custom("`vis` and `private` cannot be used together"));
81            }
82
83            conflicts.finish_with(Self::Explicit(vis))
84        } else if private.is_present() {
85            conflicts.finish_with(Self::Private)
86        } else {
87            conflicts.finish_with(Self::None)
88        }
89    }
90}
91
92#[derive(Debug, Clone, FromMeta)]
93struct BuildFnErrorGenerated {
94    /// Indicates whether or not the generated error should have
95    /// a validation variant that takes a `String` as its contents.
96    validation_error: SpannedValue<bool>,
97}
98
99#[derive(Debug, Clone)]
100enum BuildFnError {
101    Existing(Path),
102    Generated(BuildFnErrorGenerated),
103}
104
105impl BuildFnError {
106    fn as_existing(&self) -> Option<&Path> {
107        match self {
108            BuildFnError::Existing(p) => Some(p),
109            BuildFnError::Generated(_) => None,
110        }
111    }
112
113    fn as_generated(&self) -> Option<&BuildFnErrorGenerated> {
114        match self {
115            BuildFnError::Generated(e) => Some(e),
116            BuildFnError::Existing(_) => None,
117        }
118    }
119}
120
121impl FromMeta for BuildFnError {
122    fn from_meta(item: &Meta) -> darling::Result<Self> {
123        match item {
124            Meta::Path(_) => Err(Error::unsupported_format("word").with_span(item)),
125            Meta::List(_) => BuildFnErrorGenerated::from_meta(item).map(Self::Generated),
126            Meta::NameValue(i) => Path::from_expr(&i.value).map(Self::Existing),
127        }
128    }
129}
130
131/// Options for the `build_fn` property in struct-level builder options.
132/// There is no inheritance for these settings from struct-level to field-level,
133/// so we don't bother using `Option` for values in this struct.
134#[derive(Debug, Clone, FromMeta)]
135#[darling(default, and_then = Self::validation_needs_error)]
136pub struct BuildFn {
137    skip: bool,
138    name: Ident,
139    validate: Option<Path>,
140    #[darling(flatten)]
141    visibility: VisibilityAttr,
142    /// Either the path to an existing error type that the build method should return or a meta
143    /// list of options to modify the generated error.
144    ///
145    /// Setting this to a path will prevent `derive_builder` from generating an error type for the
146    /// build method.
147    ///
148    /// This options supports to formats: path `error = "path::to::Error"` and meta list
149    /// `error(<options>)`. Supported mata list options are the following:
150    ///
151    /// * `validation_error = bool` - Whether to generate `ValidationError(String)` as a variant
152    ///   of the build error type. Setting this to `false` will prevent `derive_builder` from
153    ///   using the `validate` function but this also means it does not generate any usage of the
154    ///   `alloc` crate (useful when disabling the `alloc` feature in `no_std`).
155    ///
156    /// # Type Bounds for Custom Error
157    /// This type's bounds depend on other settings of the builder.
158    ///
159    /// * If uninitialized fields cause `build()` to fail, then this type
160    ///   must `impl From<UninitializedFieldError>`. Uninitialized fields do not cause errors
161    ///   when default values are provided for every field or at the struct level.
162    /// * If `validate` is specified, then this type must provide a conversion from the specified
163    ///   function's error type.
164    error: Option<BuildFnError>,
165}
166
167impl BuildFn {
168    fn validation_needs_error(self) -> darling::Result<Self> {
169        let mut acc = Error::accumulator();
170        if self.validate.is_some() {
171            if let Some(BuildFnError::Generated(e)) = &self.error {
172                if !*e.validation_error {
173                    acc.push(
174                        Error::custom(
175                            "Cannot set `error(validation_error = false)` when using `validate`",
176                        )
177                        .with_span(&e.validation_error.span()),
178                    )
179                }
180            }
181        }
182
183        acc.finish_with(self)
184    }
185}
186
187impl Default for BuildFn {
188    fn default() -> Self {
189        BuildFn {
190            skip: false,
191            name: Ident::new("build", Span::call_site()),
192            validate: None,
193            visibility: Default::default(),
194            error: None,
195        }
196    }
197}
198
199/// Contents of the `field` meta in `builder` attributes at the field level.
200//
201// This is a superset of the attributes permitted in `field` at the struct level.
202#[derive(Debug, Clone, Default, FromMeta)]
203pub struct FieldLevelFieldMeta {
204    #[darling(flatten)]
205    visibility: VisibilityAttr,
206    /// Custom builder field type
207    #[darling(rename = "ty")]
208    builder_type: Option<syn::Type>,
209    /// Custom builder field method, for making target struct field value
210    build: Option<BlockContents>,
211}
212
213#[derive(Debug, Clone, Default, FromMeta)]
214pub struct StructLevelSetter {
215    prefix: Option<Ident>,
216    into: Option<bool>,
217    strip_option: Option<bool>,
218    skip: Option<bool>,
219}
220
221impl StructLevelSetter {
222    /// Check if setters are explicitly enabled or disabled at
223    /// the struct level.
224    pub fn enabled(&self) -> Option<bool> {
225        self.skip.map(|x| !x)
226    }
227}
228
229/// Create `Each` from an attribute's `Meta`.
230///
231/// Two formats are supported:
232///
233/// * `each = "..."`, which provides the name of the `each` setter and otherwise uses default values
234/// * `each(name = "...")`, which allows setting additional options on the `each` setter
235fn parse_each(meta: &Meta) -> darling::Result<Option<Each>> {
236    if let Meta::NameValue(mnv) = meta {
237        Ident::from_meta(meta)
238            .map(Each::from)
239            .map(Some)
240            .map_err(|e| e.with_span(&mnv.value))
241    } else {
242        Each::from_meta(meta).map(Some)
243    }
244}
245
246/// The `setter` meta item on fields in the input type.
247/// Unlike the `setter` meta item at the struct level, this allows specific
248/// name overrides.
249#[derive(Debug, Clone, Default, FromMeta)]
250pub struct FieldLevelSetter {
251    prefix: Option<Ident>,
252    name: Option<Ident>,
253    into: Option<bool>,
254    strip_option: Option<bool>,
255    skip: Option<bool>,
256    custom: Option<bool>,
257    #[darling(with = parse_each)]
258    each: Option<Each>,
259}
260
261impl FieldLevelSetter {
262    /// Get whether the setter should be emitted. The rules are the same as
263    /// for `field_enabled`, except we only skip the setter if `setter(custom)` is present.
264    pub fn setter_enabled(&self) -> Option<bool> {
265        if self.custom.is_some() {
266            return self.custom.map(|x| !x);
267        }
268
269        self.field_enabled()
270    }
271
272    /// Get whether or not this field-level setter indicates a setter and
273    /// field should be emitted. The setter shorthand rules are that the
274    /// presence of a `setter` with _any_ properties set forces the setter
275    /// to be emitted.
276    pub fn field_enabled(&self) -> Option<bool> {
277        if self.skip.is_some() {
278            return self.skip.map(|x| !x);
279        }
280
281        if self.prefix.is_some()
282            || self.name.is_some()
283            || self.into.is_some()
284            || self.strip_option.is_some()
285            || self.each.is_some()
286        {
287            return Some(true);
288        }
289
290        None
291    }
292}
293
294/// `derive_builder` allows the calling code to use `setter` as a word to enable
295/// setters when they've been disabled at the struct level.
296fn field_setter(meta: &Meta) -> darling::Result<FieldLevelSetter> {
297    // it doesn't matter what the path is; the fact that this function
298    // has been called means that a valueless path is the shorthand case.
299    if let Meta::Path(_) = meta {
300        Ok(FieldLevelSetter {
301            skip: Some(false),
302            ..Default::default()
303        })
304    } else {
305        FieldLevelSetter::from_meta(meta)
306    }
307}
308
309#[derive(Debug, Clone, Default)]
310struct FieldForwardedAttrs {
311    pub field: Vec<Attribute>,
312    pub setter: Vec<Attribute>,
313}
314
315impl TryFrom<Vec<Attribute>> for FieldForwardedAttrs {
316    type Error = Error;
317
318    fn try_from(value: Vec<Attribute>) -> Result<Self, Self::Error> {
319        let mut result = Self::default();
320        distribute_and_unnest_attrs(
321            value,
322            &mut [
323                ("builder_field_attr", &mut result.field),
324                ("builder_setter_attr", &mut result.setter),
325            ],
326        )?;
327        Ok(result)
328    }
329}
330
331/// Data extracted from the fields of the input struct.
332#[derive(Debug, Clone, FromField)]
333#[darling(
334    attributes(builder),
335    forward_attrs(doc, cfg, allow, builder_field_attr, builder_setter_attr),
336    and_then = "Self::resolve"
337)]
338pub struct Field {
339    ident: Option<Ident>,
340    #[darling(with = TryFrom::try_from)]
341    attrs: FieldForwardedAttrs,
342    ty: syn::Type,
343    /// Field-level override for builder pattern.
344    /// Note that setting this may force the builder to derive `Clone`.
345    pattern: Option<BuilderPattern>,
346    #[darling(flatten)]
347    visibility: VisibilityAttr,
348    // See the documentation for `FieldSetterMeta` to understand how `darling`
349    // is interpreting this field.
350    #[darling(default, with = field_setter)]
351    setter: FieldLevelSetter,
352    /// The value for this field if the setter is never invoked.
353    ///
354    /// A field can get its default one of three ways:
355    ///
356    /// 1. An explicit `default = "..."` expression
357    /// 2. An explicit `default` word, in which case the field type's `Default::default()`
358    ///    value is used
359    /// 3. Inherited from the field's value in the struct's `default` value.
360    ///
361    /// This property only captures the first two, the third is computed in `FieldWithDefaults`.
362    default: Option<DefaultExpression>,
363    try_setter: Flag,
364    #[darling(default)]
365    field: FieldLevelFieldMeta,
366}
367
368impl Field {
369    /// Resolve and check (post-parsing) options which come from multiple darling options
370    ///
371    ///  * Check that we don't have a custom field type or builder *and* a default value
372    fn resolve(self) -> darling::Result<Self> {
373        let mut errors = darling::Error::accumulator();
374
375        // `default` can be preempted by properties in `field`. Silently ignoring a
376        // `default` could cause the direct user of `derive_builder` to see unexpected
377        // behavior from the builder, so instead we require that the deriving struct
378        // not pass any ignored instructions.
379        if let Field {
380            default: Some(field_default),
381            ..
382        } = &self
383        {
384            // `field.build` is stronger than `default`, as it contains both instructions on how to
385            // deal with a missing value and conversions to do on the value during target type
386            // construction.
387            if self.field.build.is_some() {
388                errors.push(
389                    darling::Error::custom(
390                        r#"#[builder(default)] and #[builder(field(build="..."))] cannot be used together"#,
391                    )
392                    .with_span(&field_default.span()),
393                );
394            }
395
396            // `field.ty` being set means `default` will not be used, since we don't know how
397            // to check a custom field type for the absence of a value and therefore we'll never
398            // know that we should use the `default` value.
399            if self.field.builder_type.is_some() {
400                errors.push(
401                    darling::Error::custom(
402                        r#"#[builder(default)] and #[builder(field(ty="..."))] cannot be used together"#,
403                    )
404                    .with_span(&field_default.span())
405                )
406            }
407        };
408
409        errors.finish_with(self)
410    }
411}
412
413/// Divide a list of attributes into multiple partially-overlapping output lists.
414///
415/// Some attributes from the macro input will be added to the output in multiple places;
416/// for example, a `cfg` attribute must be replicated to both the struct and its impl block or
417/// the resulting code will not compile.
418///
419/// Other attributes are scoped to a specific output by their path, e.g. `builder_field_attr`.
420/// These attributes will only appear in one output list, but need that outer path removed.
421///
422/// For performance reasons, we want to do this in one pass through the list instead of
423/// first distributing and then iterating through each of the output lists.
424///
425/// Each item in `outputs` contains the attribute name unique to that output, and the `Vec` where all attributes for that output should be inserted.
426/// Attributes whose path matches any value in `outputs` will be added only to the first matching one, and will be "unnested".
427/// Other attributes are not unnested, and simply copied for each decoratee.
428fn distribute_and_unnest_attrs(
429    mut input: Vec<Attribute>,
430    outputs: &mut [(&'static str, &mut Vec<Attribute>)],
431) -> darling::Result<()> {
432    let mut errors = vec![];
433
434    for (name, list) in &*outputs {
435        assert!(list.is_empty(), "Output Vec for '{}' was not empty", name);
436    }
437
438    for attr in input.drain(..) {
439        let destination = outputs
440            .iter_mut()
441            .find(|(ptattr, _)| attr.path().is_ident(ptattr));
442
443        if let Some((_, destination)) = destination {
444            match unnest_from_one_attribute(attr) {
445                Ok(n) => destination.push(n),
446                Err(e) => errors.push(e),
447            }
448        } else {
449            for (_, output) in outputs.iter_mut() {
450                output.push(attr.clone());
451            }
452        }
453    }
454
455    if !errors.is_empty() {
456        return Err(darling::Error::multiple(errors));
457    }
458
459    Ok(())
460}
461
462fn unnest_from_one_attribute(attr: syn::Attribute) -> darling::Result<Attribute> {
463    match &attr.style {
464        syn::AttrStyle::Outer => (),
465        syn::AttrStyle::Inner(bang) => {
466            return Err(darling::Error::unsupported_format(&format!(
467                "{} must be an outer attribute",
468                attr.path()
469                    .get_ident()
470                    .map(Ident::to_string)
471                    .unwrap_or_else(|| "Attribute".to_string())
472            ))
473            .with_span(bang));
474        }
475    };
476
477    let original_span = attr.span();
478
479    let pound = attr.pound_token;
480    let meta = attr.meta;
481
482    match meta {
483        Meta::Path(_) => Err(Error::unsupported_format("word").with_span(&meta)),
484        Meta::NameValue(_) => Err(Error::unsupported_format("name-value").with_span(&meta)),
485        Meta::List(list) => {
486            let inner = list.tokens;
487            Ok(parse_quote_spanned!(original_span=> #pound [ #inner ]))
488        }
489    }
490}
491
492fn default_crate_root() -> Path {
493    parse_quote!(::derive_builder)
494}
495
496fn default_create_empty() -> Ident {
497    Ident::new("create_empty", Span::call_site())
498}
499
500#[derive(Debug, Clone, Default)]
501struct StructForwardedAttrs {
502    struct_attrs: Vec<Attribute>,
503    impl_attrs: Vec<Attribute>,
504}
505
506impl TryFrom<Vec<Attribute>> for StructForwardedAttrs {
507    type Error = Error;
508
509    fn try_from(value: Vec<Attribute>) -> Result<Self, Self::Error> {
510        let mut result = Self::default();
511        distribute_and_unnest_attrs(
512            value,
513            &mut [
514                ("builder_struct_attr", &mut result.struct_attrs),
515                ("builder_impl_attr", &mut result.impl_attrs),
516            ],
517        )?;
518
519        Ok(result)
520    }
521}
522
523#[derive(Debug, Clone, FromDeriveInput)]
524#[darling(
525    attributes(builder),
526    forward_attrs(cfg, allow, builder_struct_attr, builder_impl_attr),
527    supports(struct_named)
528)]
529pub struct Options {
530    ident: Ident,
531
532    #[darling(with = TryFrom::try_from)]
533    attrs: StructForwardedAttrs,
534
535    /// The visibility of the deriving struct. Do not confuse this with `#[builder(vis = "...")]`,
536    /// which is received by `Options::visibility`.
537    vis: syn::Visibility,
538
539    generics: Generics,
540
541    /// The name of the generated builder. Defaults to `#{ident}Builder`.
542    name: Option<Ident>,
543
544    /// The path to the root of the derive_builder crate used in generated
545    /// code.
546    #[darling(rename = "crate", default = default_crate_root)]
547    crate_root: Path,
548
549    #[darling(default)]
550    pattern: BuilderPattern,
551
552    #[darling(default)]
553    build_fn: BuildFn,
554
555    /// Additional traits to derive on the builder.
556    #[darling(default)]
557    derive: PathList,
558
559    custom_constructor: Flag,
560
561    /// The ident of the inherent method which takes no arguments and returns
562    /// an instance of the builder with all fields empty.
563    #[darling(default = default_create_empty)]
564    create_empty: Ident,
565
566    /// Setter options applied to all field setters in the struct.
567    #[darling(default)]
568    setter: StructLevelSetter,
569
570    /// Struct-level value to use in place of any unfilled fields
571    default: Option<DefaultExpression>,
572
573    /// Desired visibility of the builder struct.
574    ///
575    /// Do not confuse this with `Options::vis`, which is the visibility of the deriving struct.
576    #[darling(flatten)]
577    visibility: VisibilityAttr,
578
579    /// The parsed body of the derived struct.
580    data: darling::ast::Data<darling::util::Ignored, Field>,
581
582    no_std: Flag,
583
584    /// When present, emit additional fallible setters alongside each regular
585    /// setter.
586    try_setter: Flag,
587
588    #[darling(default)]
589    field: VisibilityAttr,
590}
591
592/// Accessors for parsed properties.
593impl Options {
594    pub fn builder_ident(&self) -> Ident {
595        if let Some(ref custom) = self.name {
596            return custom.clone();
597        }
598
599        format_ident!("{}Builder", self.ident)
600    }
601
602    pub fn builder_error_ident(&self) -> Path {
603        if let Some(BuildFnError::Existing(existing)) = self.build_fn.error.as_ref() {
604            existing.clone()
605        } else if let Some(ref custom) = self.name {
606            format_ident!("{}Error", custom).into()
607        } else {
608            format_ident!("{}BuilderError", self.ident).into()
609        }
610    }
611
612    /// The visibility of the builder struct.
613    /// If a visibility was declared in attributes, that will be used;
614    /// otherwise the struct's own visibility will be used.
615    pub fn builder_vis(&self) -> Cow<syn::Visibility> {
616        self.visibility
617            .to_explicit_visibility()
618            .unwrap_or_else(|| Cow::Borrowed(&self.vis))
619    }
620
621    /// Get the visibility of the emitted `build` method.
622    /// This defaults to the visibility of the parent builder, but can be overridden.
623    pub fn build_method_vis(&self) -> Cow<syn::Visibility> {
624        self.build_fn
625            .visibility
626            .to_explicit_visibility()
627            .unwrap_or_else(|| self.builder_vis())
628    }
629
630    pub fn raw_fields(&self) -> Vec<&Field> {
631        self.data
632            .as_ref()
633            .take_struct()
634            .expect("Only structs supported")
635            .fields
636    }
637
638    /// A builder requires `Clone` to be derived if its build method or any of its setters
639    /// use the mutable or immutable pattern.
640    pub fn requires_clone(&self) -> bool {
641        self.pattern.requires_clone() || self.fields().any(|f| f.pattern().requires_clone())
642    }
643
644    /// Get an iterator over the input struct's fields which pulls fallback
645    /// values from struct-level settings.
646    pub fn fields(&self) -> FieldIter {
647        FieldIter(self, self.raw_fields().into_iter())
648    }
649
650    pub fn field_count(&self) -> usize {
651        self.raw_fields().len()
652    }
653}
654
655/// Converters to codegen structs
656impl Options {
657    pub fn as_builder(&self) -> Builder {
658        Builder {
659            crate_root: &self.crate_root,
660            enabled: true,
661            ident: self.builder_ident(),
662            pattern: self.pattern,
663            derives: &self.derive,
664            struct_attrs: &self.attrs.struct_attrs,
665            impl_attrs: &self.attrs.impl_attrs,
666            impl_default: !self.custom_constructor.is_present(),
667            create_empty: self.create_empty.clone(),
668            generics: Some(&self.generics),
669            visibility: self.builder_vis(),
670            fields: Vec::with_capacity(self.field_count()),
671            field_initializers: Vec::with_capacity(self.field_count()),
672            functions: Vec::with_capacity(self.field_count()),
673            generate_error: self
674                .build_fn
675                .error
676                .as_ref()
677                .and_then(BuildFnError::as_existing)
678                .is_none(),
679            generate_validation_error: self
680                .build_fn
681                .error
682                .as_ref()
683                .and_then(BuildFnError::as_generated)
684                .map(|e| *e.validation_error)
685                .unwrap_or(true),
686            no_alloc: cfg!(not(any(feature = "alloc", feature = "lib_has_std"))),
687            must_derive_clone: self.requires_clone(),
688            doc_comment: None,
689            std: !self.no_std.is_present(),
690        }
691    }
692
693    pub fn as_build_method(&self) -> BuildMethod {
694        let (_, ty_generics, _) = self.generics.split_for_impl();
695        BuildMethod {
696            crate_root: &self.crate_root,
697            enabled: !self.build_fn.skip,
698            ident: &self.build_fn.name,
699            visibility: self.build_method_vis(),
700            pattern: self.pattern,
701            target_ty: &self.ident,
702            target_ty_generics: Some(ty_generics),
703            error_ty: self.builder_error_ident(),
704            initializers: Vec::with_capacity(self.field_count()),
705            doc_comment: None,
706            default_struct: self.default.as_ref(),
707            validate_fn: self.build_fn.validate.as_ref(),
708        }
709    }
710}
711
712/// Accessor for field data which can pull through options from the parent
713/// struct.
714pub struct FieldWithDefaults<'a> {
715    parent: &'a Options,
716    field: &'a Field,
717}
718
719/// Accessors for parsed properties, with transparent pull-through from the
720/// parent struct's configuration.
721impl<'a> FieldWithDefaults<'a> {
722    /// Check if this field should emit a setter.
723    pub fn setter_enabled(&self) -> bool {
724        self.field
725            .setter
726            .setter_enabled()
727            .or_else(|| self.parent.setter.enabled())
728            .unwrap_or(true)
729    }
730
731    pub fn field_enabled(&self) -> bool {
732        self.field
733            .setter
734            .field_enabled()
735            .or_else(|| self.parent.setter.enabled())
736            .unwrap_or(true)
737    }
738
739    /// Check if this field should emit a fallible setter.
740    /// This depends on the `TryFrom` trait, which hasn't yet stabilized.
741    pub fn try_setter(&self) -> bool {
742        self.field.try_setter.is_present() || self.parent.try_setter.is_present()
743    }
744
745    /// Get the prefix that should be applied to the field name to produce
746    /// the setter ident, if any.
747    pub fn setter_prefix(&self) -> Option<&Ident> {
748        self.field
749            .setter
750            .prefix
751            .as_ref()
752            .or(self.parent.setter.prefix.as_ref())
753    }
754
755    /// Get the ident of the emitted setter method
756    pub fn setter_ident(&self) -> syn::Ident {
757        if let Some(ref custom) = self.field.setter.name {
758            return custom.clone();
759        }
760
761        let ident = &self.field.ident;
762
763        if let Some(ref prefix) = self.setter_prefix() {
764            return format_ident!("{}_{}", prefix, ident.as_ref().unwrap());
765        }
766
767        ident.clone().unwrap()
768    }
769
770    /// Checks if the emitted setter should be generic over types that impl
771    /// `Into<FieldType>`.
772    pub fn setter_into(&self) -> bool {
773        self.field
774            .setter
775            .into
776            .or(self.parent.setter.into)
777            .unwrap_or_default()
778    }
779
780    /// Checks if the emitted setter should strip the wrapper Option over types that impl
781    /// `Option<FieldType>`.
782    pub fn setter_strip_option(&self) -> bool {
783        self.field
784            .setter
785            .strip_option
786            .or(self.parent.setter.strip_option)
787            .unwrap_or_default()
788    }
789
790    /// Get the visibility of the emitted setter, if there will be one.
791    pub fn setter_vis(&self) -> Cow<syn::Visibility> {
792        self.field
793            .visibility
794            .to_explicit_visibility()
795            .or_else(|| self.parent.visibility.to_explicit_visibility())
796            .unwrap_or_else(|| Cow::Owned(syn::parse_quote!(pub)))
797    }
798
799    /// Get the ident of the input field. This is also used as the ident of the
800    /// emitted field.
801    pub fn field_ident(&self) -> &syn::Ident {
802        self.field
803            .ident
804            .as_ref()
805            .expect("Tuple structs are not supported")
806    }
807
808    pub fn field_vis(&self) -> Cow<syn::Visibility> {
809        self.field
810            .field
811            .visibility
812            .to_explicit_visibility()
813            .or_else(
814                // Disabled fields become a PhantomData in the builder.  We make that field
815                // non-public, even if the rest of the builder is public, since this field is just
816                // there to make sure the struct's generics are properly handled.
817                || {
818                    if self.field_enabled() {
819                        None
820                    } else {
821                        Some(Cow::Owned(syn::Visibility::Inherited))
822                    }
823                },
824            )
825            .or_else(|| self.parent.field.to_explicit_visibility())
826            .unwrap_or(Cow::Owned(syn::Visibility::Inherited))
827    }
828
829    pub fn field_type(&'a self) -> BuilderFieldType<'a> {
830        if !self.field_enabled() {
831            BuilderFieldType::Phantom(&self.field.ty)
832        } else if let Some(custom_ty) = self.field.field.builder_type.as_ref() {
833            BuilderFieldType::Precise(custom_ty)
834        } else {
835            BuilderFieldType::Optional(&self.field.ty)
836        }
837    }
838
839    pub fn conversion(&'a self) -> FieldConversion<'a> {
840        match (&self.field.field.builder_type, &self.field.field.build) {
841            (_, Some(block)) => FieldConversion::Block(block),
842            (Some(_), None) => FieldConversion::Move,
843            (None, None) => FieldConversion::OptionOrDefault,
844        }
845    }
846
847    pub fn pattern(&self) -> BuilderPattern {
848        self.field.pattern.unwrap_or(self.parent.pattern)
849    }
850
851    pub fn use_parent_default(&self) -> bool {
852        self.field.default.is_none() && self.parent.default.is_some()
853    }
854}
855
856/// Converters to codegen structs
857impl<'a> FieldWithDefaults<'a> {
858    /// Returns a `Setter` according to the options.
859    pub fn as_setter(&'a self) -> Setter<'a> {
860        Setter {
861            crate_root: &self.parent.crate_root,
862            setter_enabled: self.setter_enabled(),
863            try_setter: self.try_setter(),
864            visibility: self.setter_vis(),
865            pattern: self.pattern(),
866            attrs: &self.field.attrs.setter,
867            ident: self.setter_ident(),
868            field_ident: self.field_ident(),
869            field_type: self.field_type(),
870            generic_into: self.setter_into(),
871            strip_option: self.setter_strip_option(),
872            each: self.field.setter.each.as_ref(),
873        }
874    }
875
876    /// Returns an `Initializer` according to the options.
877    ///
878    /// # Panics
879    ///
880    /// if `default_expression` can not be parsed as `Block`.
881    pub fn as_initializer(&'a self) -> Initializer<'a> {
882        Initializer {
883            crate_root: &self.parent.crate_root,
884            field_enabled: self.field_enabled(),
885            field_ident: self.field_ident(),
886            builder_pattern: self.pattern(),
887            default_value: self.field.default.as_ref(),
888            use_default_struct: self.use_parent_default(),
889            conversion: self.conversion(),
890            custom_error_type_span: self.parent.build_fn.error.as_ref().and_then(|err_ty| {
891                match err_ty {
892                    BuildFnError::Existing(p) => Some(p.span()),
893                    _ => None,
894                }
895            }),
896        }
897    }
898
899    pub fn as_builder_field(&'a self) -> BuilderField<'a> {
900        BuilderField {
901            crate_root: &self.parent.crate_root,
902            field_ident: self.field_ident(),
903            field_type: self.field_type(),
904            field_visibility: self.field_vis(),
905            attrs: &self.field.attrs.field,
906        }
907    }
908}
909
910pub struct FieldIter<'a>(&'a Options, IntoIter<&'a Field>);
911
912impl<'a> Iterator for FieldIter<'a> {
913    type Item = FieldWithDefaults<'a>;
914
915    fn next(&mut self) -> Option<Self::Item> {
916        self.1.next().map(|field| FieldWithDefaults {
917            parent: self.0,
918            field,
919        })
920    }
921}
derive_builder_core/macro_options/darling_opts.rs

derive_builder_core/macro_options/
darling_opts.rs
