derive_builder_core/
builder.rs

Help
1use std::borrow::Cow;
2
3use proc_macro2::TokenStream;
4use quote::{format_ident, ToTokens, TokenStreamExt};
5use syn::punctuated::Punctuated;
6use syn::{Path, TraitBound, TraitBoundModifier, TypeParamBound};
7
8use crate::{doc_comment_from, BuildMethod, BuilderField, BuilderPattern, Setter};
9
10const ALLOC_NOT_ENABLED_ERROR: &str = r#"`alloc` is disabled within 'derive_builder', consider one of the following:
11* enable feature `alloc` on 'dervie_builder' if a `global_allocator` is present
12* use a custom error `#[builder(build_fn(error = "path::to::Error"))]
13* disable the validation error `#[builder(build_fn(error(validation_error = false)))]"#;
14
15/// Builder, implementing `quote::ToTokens`.
16///
17/// # Examples
18///
19/// Will expand to something like the following (depending on settings):
20///
21/// ```rust,ignore
22/// # extern crate proc_macro2;
23/// # #[macro_use]
24/// # extern crate quote;
25/// # extern crate syn;
26/// # #[macro_use]
27/// # extern crate derive_builder_core;
28/// # use quote::TokenStreamExt;
29/// # use derive_builder_core::{Builder, DeprecationNotes};
30/// # fn main() {
31/// #    let builder = default_builder!();
32/// #
33/// #    assert_eq!(
34/// #       quote!(#builder).to_string(),
35/// #       {
36/// #           let mut result = quote!();
37/// #           #[cfg(not(feature = "clippy"))]
38/// #           result.append_all(quote!(#[allow(clippy::all)]));
39/// #
40/// #           result.append_all(quote!(
41/// #[derive(Clone)]
42/// pub struct FooBuilder {
43///     foo: u32,
44/// }
45///
46/// #[doc="Error type for FooBuilder"]
47/// #[derive(Debug)]
48/// #[non_exhaustive]
49/// pub enum FooBuilderError {
50///     /// Uninitialized field
51///     UninitializedField(&'static str),
52///     /// Custom validation error
53///     ValidationError(::derive_builder::export::core::string::String),
54/// }
55///
56/// impl ::derive_builder::export::core::convert::From<... various ...> for FooBuilderError {}
57///
58/// #[cfg(not(no_std))]
59/// impl std::error::Error for FooBuilderError {}
60/// #           ));
61/// #           #[cfg(not(feature = "clippy"))]
62/// #           result.append_all(quote!(#[allow(clippy::all)]));
63/// #
64/// #           result.append_all(quote!(
65///
66/// #[allow(dead_code)]
67/// impl FooBuilder {
68///     fn bar () -> {
69///         unimplemented!()
70///     }
71/// }
72///
73/// impl ::derive_builder::export::core::default::Default for FooBuilder {
74///     fn default() -> Self {
75///         Self {
76///            foo: ::derive_builder::export::core::default::Default::default(),
77///         }
78///     }
79/// }
80///
81/// #           ));
82/// #           result
83/// #       }.to_string()
84/// #   );
85/// # }
86/// ```
87#[derive(Debug)]
88pub struct Builder<'a> {
89    /// Path to the root of the derive_builder crate.
90    pub crate_root: &'a Path,
91    /// Enables code generation for this builder struct.
92    pub enabled: bool,
93    /// Name of this builder struct.
94    pub ident: syn::Ident,
95    /// Pattern of this builder struct.
96    pub pattern: BuilderPattern,
97    /// Traits to automatically derive on the builder type.
98    pub derives: &'a [Path],
99    /// Attributes to include on the builder `struct` declaration.
100    pub struct_attrs: &'a [syn::Attribute],
101    /// Attributes to include on the builder's inherent `impl` block.
102    pub impl_attrs: &'a [syn::Attribute],
103    /// When true, generate `impl Default for #ident` which calls the `create_empty` inherent method.
104    ///
105    /// Note that the name of `create_empty` can be overridden; see the `create_empty` field for more.
106    pub impl_default: bool,
107    /// The identifier of the inherent method that creates a builder with all fields set to
108    /// `None` or `PhantomData`.
109    ///
110    /// This method will be invoked by `impl Default` for the builder, but it is also accessible
111    /// to `impl` blocks on the builder that expose custom constructors.
112    pub create_empty: syn::Ident,
113    /// Type parameters and lifetimes attached to this builder's struct
114    /// definition.
115    pub generics: Option<&'a syn::Generics>,
116    /// Visibility of the builder struct, e.g. `syn::Visibility::Public`.
117    pub visibility: Cow<'a, syn::Visibility>,
118    /// Fields of the builder struct, e.g. `foo: u32,`
119    ///
120    /// Expects each entry to be terminated by a comma.
121    pub fields: Vec<TokenStream>,
122    /// Builder field initializers, e.g. `foo: Default::default(),`
123    ///
124    /// Expects each entry to be terminated by a comma.
125    pub field_initializers: Vec<TokenStream>,
126    /// Functions of the builder struct, e.g. `fn bar() -> { unimplemented!() }`
127    pub functions: Vec<TokenStream>,
128    /// Whether or not a generated error type is required.
129    ///
130    /// This would be `false` in the case where an already-existing error is to be used.
131    pub generate_error: bool,
132    /// Whether to include `ValidationError` in the generated enum. Necessary to avoid dependency
133    /// on `alloc::string`.
134    ///
135    /// This would be `false` when `build_fn.error.as_validation_error() == Some((false, _))`. This
136    /// has no effect when `generate_error` is `false`.
137    pub generate_validation_error: bool,
138    /// Indicator of `cfg!(not(any(feature = "alloc", feature = "std")))`, as a field for tests
139    pub no_alloc: bool,
140    /// Whether this builder must derive `Clone`.
141    ///
142    /// This is true even for a builder using the `owned` pattern if there is a field whose setter
143    /// uses a different pattern.
144    pub must_derive_clone: bool,
145    /// Doc-comment of the builder struct.
146    pub doc_comment: Option<syn::Attribute>,
147    /// Whether or not a libstd is used.
148    pub std: bool,
149}
150
151impl<'a> ToTokens for Builder<'a> {
152    fn to_tokens(&self, tokens: &mut TokenStream) {
153        if self.enabled {
154            let crate_root = self.crate_root;
155            let builder_vis = &self.visibility;
156            let builder_ident = &self.ident;
157            // Splitting because Generics doesn't output WhereClause, see dtolnay/syn#782
158            let (struct_generics, struct_where_clause) = (
159                self.generics,
160                self.generics.and_then(|g| g.where_clause.as_ref()),
161            );
162            let bounded_generics = self.compute_impl_bounds();
163            let (impl_generics, impl_ty_generics, impl_where_clause) =
164                bounded_generics.split_for_impl();
165            let builder_fields = &self.fields;
166            let builder_field_initializers = &self.field_initializers;
167            let create_empty = &self.create_empty;
168            let functions = &self.functions;
169
170            // Create the comma-separated set of derived traits for the builder
171            let derive_attr = {
172                let clone_trait: Path = parse_quote!(Clone);
173
174                let mut traits: Punctuated<&Path, Token![,]> = Default::default();
175                if self.must_derive_clone {
176                    traits.push(&clone_trait);
177                }
178                traits.extend(self.derives);
179
180                if traits.is_empty() {
181                    quote!()
182                } else {
183                    quote!(#[derive(#traits)])
184                }
185            };
186
187            let struct_attrs = self.struct_attrs;
188            let impl_attrs = self.impl_attrs;
189
190            let builder_doc_comment = &self.doc_comment;
191
192            #[cfg(not(feature = "clippy"))]
193            tokens.append_all(quote!(#[allow(clippy::all)]));
194
195            // struct_attrs MUST come after derive_attr, otherwise attributes for a derived
196            // trait will appear before its derivation. As of rustc 1.59.0 this is a compiler
197            // warning; see https://github.com/rust-lang/rust/issues/79202
198            tokens.append_all(quote!(
199                #derive_attr
200                #(#struct_attrs)*
201                #builder_doc_comment
202                #builder_vis struct #builder_ident #struct_generics #struct_where_clause {
203                    #(#builder_fields)*
204                }
205            ));
206
207            #[cfg(not(feature = "clippy"))]
208            tokens.append_all(quote!(#[allow(clippy::all)]));
209
210            tokens.append_all(quote!(
211                #(#impl_attrs)*
212                #[allow(dead_code)]
213                impl #impl_generics #builder_ident #impl_ty_generics #impl_where_clause {
214                    #(#functions)*
215
216                    /// Create an empty builder, with all fields set to `None` or `PhantomData`.
217                    fn #create_empty() -> Self {
218                        Self {
219                            #(#builder_field_initializers)*
220                        }
221                    }
222                }
223            ));
224
225            if self.impl_default {
226                tokens.append_all(quote!(
227                    impl #impl_generics #crate_root::export::core::default::Default for #builder_ident #impl_ty_generics #impl_where_clause {
228                        fn default() -> Self {
229                            Self::#create_empty()
230                        }
231                    }
232                ));
233            }
234
235            if self.no_alloc && self.generate_error && self.generate_validation_error {
236                let err = syn::Error::new_spanned(&self.ident, ALLOC_NOT_ENABLED_ERROR);
237                tokens.append_all(err.to_compile_error());
238            } else if self.generate_error {
239                let builder_error_ident = format_ident!("{}Error", builder_ident);
240                let builder_error_doc = format!("Error type for {}", builder_ident);
241
242                let validation_error = if self.generate_validation_error {
243                    quote!(
244                        /// Custom validation error
245                        ValidationError(#crate_root::export::core::string::String),
246                    )
247                } else {
248                    TokenStream::new()
249                };
250                let validation_from = if self.generate_validation_error {
251                    quote!(
252                        impl #crate_root::export::core::convert::From<#crate_root::export::core::string::String> for #builder_error_ident {
253                            fn from(s: #crate_root::export::core::string::String) -> Self {
254                                Self::ValidationError(s)
255                            }
256                        }
257                    )
258                } else {
259                    TokenStream::new()
260                };
261                let validation_display = if self.generate_validation_error {
262                    quote!(
263                        Self::ValidationError(ref error) => write!(f, "{}", error),
264                    )
265                } else {
266                    TokenStream::new()
267                };
268
269                tokens.append_all(quote!(
270                    #[doc=#builder_error_doc]
271                    #[derive(Debug)]
272                    #[non_exhaustive]
273                    #builder_vis enum #builder_error_ident {
274                        /// Uninitialized field
275                        UninitializedField(&'static str),
276                        #validation_error
277                    }
278
279                    impl #crate_root::export::core::convert::From<#crate_root::UninitializedFieldError> for #builder_error_ident {
280                        fn from(s: #crate_root::UninitializedFieldError) -> Self {
281                            Self::UninitializedField(s.field_name())
282                        }
283                    }
284
285                    #validation_from
286
287                    impl #crate_root::export::core::fmt::Display for #builder_error_ident {
288                        fn fmt(&self, f: &mut #crate_root::export::core::fmt::Formatter) -> #crate_root::export::core::fmt::Result {
289                            match self {
290                                Self::UninitializedField(ref field) => write!(f, "`{}` must be initialized", field),
291                                #validation_display
292                            }
293                        }
294                    }
295                ));
296
297                if self.std {
298                    tokens.append_all(quote!(
299                        impl std::error::Error for #builder_error_ident {}
300                    ));
301                }
302            }
303        }
304    }
305}
306
307impl<'a> Builder<'a> {
308    /// Set a doc-comment for this item.
309    pub fn doc_comment(&mut self, s: String) -> &mut Self {
310        self.doc_comment = Some(doc_comment_from(s));
311        self
312    }
313
314    /// Add a field to the builder
315    pub fn push_field(&mut self, f: BuilderField) -> &mut Self {
316        self.fields.push(quote!(#f));
317        self.field_initializers.push(f.default_initializer_tokens());
318        self
319    }
320
321    /// Add a setter function to the builder
322    pub fn push_setter_fn(&mut self, f: Setter) -> &mut Self {
323        self.functions.push(quote!(#f));
324        self
325    }
326
327    /// Add final build function to the builder
328    pub fn push_build_fn(&mut self, f: BuildMethod) -> &mut Self {
329        self.functions.push(quote!(#f));
330        self
331    }
332
333    /// Add `Clone` trait bound to generic types for non-owned builders.
334    /// This enables target types to declare generics without requiring a
335    /// `Clone` impl. This is the same as how the built-in derives for
336    /// `Clone`, `Default`, `PartialEq`, and other traits work.
337    fn compute_impl_bounds(&self) -> syn::Generics {
338        if let Some(type_gen) = self.generics {
339            let mut generics = type_gen.clone();
340
341            if !self.pattern.requires_clone() || type_gen.type_params().next().is_none() {
342                return generics;
343            }
344
345            let crate_root = self.crate_root;
346
347            let clone_bound = TypeParamBound::Trait(TraitBound {
348                paren_token: None,
349                modifier: TraitBoundModifier::None,
350                lifetimes: None,
351                path: syn::parse_quote!(#crate_root::export::core::clone::Clone),
352            });
353
354            for typ in generics.type_params_mut() {
355                typ.bounds.push(clone_bound.clone());
356            }
357
358            generics
359        } else {
360            Default::default()
361        }
362    }
363}
364
365/// Helper macro for unit tests. This is _only_ public in order to be accessible
366/// from doc-tests too.
367#[doc(hidden)]
368#[macro_export]
369macro_rules! default_builder {
370    () => {
371        Builder {
372            // Deliberately don't use the default value here - make sure
373            // that all test cases are passing crate_root through properly.
374            crate_root: &parse_quote!(::db),
375            enabled: true,
376            ident: syn::Ident::new("FooBuilder", ::proc_macro2::Span::call_site()),
377            pattern: Default::default(),
378            derives: &vec![],
379            struct_attrs: &vec![],
380            impl_attrs: &vec![],
381            impl_default: true,
382            create_empty: syn::Ident::new("create_empty", ::proc_macro2::Span::call_site()),
383            generics: None,
384            visibility: ::std::borrow::Cow::Owned(parse_quote!(pub)),
385            fields: vec![quote!(foo: u32,)],
386            field_initializers: vec![quote!(foo: ::db::export::core::default::Default::default(), )],
387            functions: vec![quote!(fn bar() -> { unimplemented!() })],
388            generate_error: true,
389            generate_validation_error: true,
390            no_alloc: false,
391            must_derive_clone: true,
392            doc_comment: None,
393            std: true,
394        }
395    };
396}
397
398#[cfg(test)]
399mod tests {
400    #[allow(unused_imports)]
401    use super::*;
402    use syn::Ident;
403
404    fn add_simple_foo_builder(result: &mut TokenStream) {
405        #[cfg(not(feature = "clippy"))]
406        result.append_all(quote!(#[allow(clippy::all)]));
407
408        result.append_all(quote!(
409            #[derive(Clone)]
410            pub struct FooBuilder {
411                foo: u32,
412            }
413        ));
414
415        #[cfg(not(feature = "clippy"))]
416        result.append_all(quote!(#[allow(clippy::all)]));
417
418        result.append_all(quote!(
419            #[allow(dead_code)]
420            impl FooBuilder {
421                fn bar () -> {
422                    unimplemented!()
423                }
424
425                /// Create an empty builder, with all fields set to `None` or `PhantomData`.
426                fn create_empty() -> Self {
427                    Self {
428                        foo: ::db::export::core::default::Default::default(),
429                    }
430                }
431            }
432
433            impl ::db::export::core::default::Default for FooBuilder {
434                fn default() -> Self {
435                    Self::create_empty()
436                }
437            }
438        ));
439    }
440
441    fn add_generated_error(result: &mut TokenStream) {
442        result.append_all(quote!(
443            #[doc="Error type for FooBuilder"]
444            #[derive(Debug)]
445            #[non_exhaustive]
446            pub enum FooBuilderError {
447                /// Uninitialized field
448                UninitializedField(&'static str),
449                /// Custom validation error
450                ValidationError(::db::export::core::string::String),
451            }
452
453            impl ::db::export::core::convert::From<::db::UninitializedFieldError> for FooBuilderError {
454                fn from(s: ::db::UninitializedFieldError) -> Self {
455                    Self::UninitializedField(s.field_name())
456                }
457            }
458
459            impl ::db::export::core::convert::From<::db::export::core::string::String> for FooBuilderError {
460                fn from(s: ::db::export::core::string::String) -> Self {
461                    Self::ValidationError(s)
462                }
463            }
464
465            impl ::db::export::core::fmt::Display for FooBuilderError {
466                fn fmt(&self, f: &mut ::db::export::core::fmt::Formatter) -> ::db::export::core::fmt::Result {
467                    match self {
468                        Self::UninitializedField(ref field) => write!(f, "`{}` must be initialized", field),
469                        Self::ValidationError(ref error) => write!(f, "{}", error),
470                    }
471                }
472            }
473
474            impl std::error::Error for FooBuilderError {}
475        ));
476    }
477
478    #[test]
479    fn simple() {
480        let builder = default_builder!();
481
482        assert_eq!(
483            quote!(#builder).to_string(),
484            {
485                let mut result = quote!();
486
487                add_simple_foo_builder(&mut result);
488
489                add_generated_error(&mut result);
490
491                result
492            }
493            .to_string()
494        );
495    }
496
497    #[test]
498    fn rename_create_empty() {
499        let mut builder = default_builder!();
500        builder.create_empty = Ident::new("empty", proc_macro2::Span::call_site());
501
502        assert_eq!(
503            quote!(#builder).to_string(),
504            {
505                let mut result = quote!();
506
507                #[cfg(not(feature = "clippy"))]
508                result.append_all(quote!(#[allow(clippy::all)]));
509
510                result.append_all(quote!(
511                    #[derive(Clone)]
512                    pub struct FooBuilder {
513                        foo: u32,
514                    }
515                ));
516
517                #[cfg(not(feature = "clippy"))]
518                result.append_all(quote!(#[allow(clippy::all)]));
519
520                result.append_all(quote!(
521                    #[allow(dead_code)]
522                    impl FooBuilder {
523                        fn bar () -> {
524                            unimplemented!()
525                        }
526
527                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
528                        fn empty() -> Self {
529                            Self {
530                                foo: ::db::export::core::default::Default::default(),
531                            }
532                        }
533                    }
534
535                    impl ::db::export::core::default::Default for FooBuilder {
536                        fn default() -> Self {
537                            Self::empty()
538                        }
539                    }
540                ));
541
542                add_generated_error(&mut result);
543
544                result
545            }
546            .to_string()
547        );
548    }
549
550    // This test depends on the exact formatting of the `stringify`'d code,
551    // so we don't automatically format the test
552    #[rustfmt::skip]
553    #[test]
554    fn generic() {
555        let ast: syn::DeriveInput = parse_quote! {
556            struct Lorem<'a, T: Debug> where T: PartialEq { }
557        };
558        let generics = ast.generics;
559        let mut builder = default_builder!();
560        builder.generics = Some(&generics);
561
562        assert_eq!(
563            quote!(#builder).to_string(),
564            {
565                let mut result = quote!();
566
567                #[cfg(not(feature = "clippy"))]
568                result.append_all(quote!(#[allow(clippy::all)]));
569
570                result.append_all(quote!(
571                    #[derive(Clone)]
572                    pub struct FooBuilder<'a, T: Debug> where T: PartialEq {
573                        foo: u32,
574                    }
575                ));
576
577                #[cfg(not(feature = "clippy"))]
578                result.append_all(quote!(#[allow(clippy::all)]));
579
580                result.append_all(quote!(
581                    #[allow(dead_code)]
582                    impl<'a, T: Debug + ::db::export::core::clone::Clone> FooBuilder<'a, T> where T: PartialEq {
583                        fn bar() -> {
584                            unimplemented!()
585                        }
586
587                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
588                        fn create_empty() -> Self {
589                            Self {
590                                foo: ::db::export::core::default::Default::default(),
591                            }
592                        }
593                    }
594
595                    impl<'a, T: Debug + ::db::export::core::clone::Clone> ::db::export::core::default::Default for FooBuilder<'a, T> where T: PartialEq {
596                        fn default() -> Self {
597                            Self::create_empty()
598                        }
599                    }
600                ));
601
602                add_generated_error(&mut result);
603
604                result
605            }.to_string()
606        );
607    }
608
609    // This test depends on the exact formatting of the `stringify`'d code,
610    // so we don't automatically format the test
611    #[rustfmt::skip]
612    #[test]
613    fn generic_reference() {
614        let ast: syn::DeriveInput = parse_quote! {
615            struct Lorem<'a, T: 'a + Default> where T: PartialEq{ }
616        };
617
618        let generics = ast.generics;
619        let mut builder = default_builder!();
620        builder.generics = Some(&generics);
621
622        assert_eq!(
623            quote!(#builder).to_string(),
624            {
625                let mut result = quote!();
626
627                #[cfg(not(feature = "clippy"))]
628                result.append_all(quote!(#[allow(clippy::all)]));
629
630                result.append_all(quote!(
631                    #[derive(Clone)]
632                    pub struct FooBuilder<'a, T: 'a + Default> where T: PartialEq {
633                        foo: u32,
634                    }
635                ));
636
637                #[cfg(not(feature = "clippy"))]
638                result.append_all(quote!(#[allow(clippy::all)]));
639
640                result.append_all(quote!(
641                    #[allow(dead_code)]
642                    impl<'a, T: 'a + Default + ::db::export::core::clone::Clone> FooBuilder<'a, T>
643                    where
644                        T: PartialEq
645                    {
646                        fn bar() -> {
647                            unimplemented!()
648                        }
649                        
650                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
651                        fn create_empty() -> Self {
652                            Self {
653                                foo: ::db::export::core::default::Default::default(),
654                            }
655                        }
656                    }
657
658                    impl<'a, T: 'a + Default + ::db::export::core::clone::Clone> ::db::export::core::default::Default for FooBuilder<'a, T> where T: PartialEq {
659                        fn default() -> Self {
660                            Self::create_empty()
661                        }
662                    }
663                ));
664
665                add_generated_error(&mut result);
666
667                result
668            }.to_string()
669        );
670    }
671
672    // This test depends on the exact formatting of the `stringify`'d code,
673    // so we don't automatically format the test
674    #[rustfmt::skip]
675    #[test]
676    fn generic_with_default_type() {
677        let ast: syn::DeriveInput = parse_quote! {
678            struct Lorem<T = ()> { }
679        };
680
681        let generics = ast.generics;
682        let mut builder = default_builder!();
683        builder.generics = Some(&generics);
684
685        assert_eq!(
686            quote!(#builder).to_string(),
687            {
688                let mut result = quote!();
689
690                #[cfg(not(feature = "clippy"))]
691                result.append_all(quote!(#[allow(clippy::all)]));
692
693                result.append_all(quote!(
694                    #[derive(Clone)]
695                    pub struct FooBuilder<T = ()> {
696                        foo: u32,
697                    }
698                ));
699
700                #[cfg(not(feature = "clippy"))]
701                result.append_all(quote!(#[allow(clippy::all)]));
702
703                result.append_all(quote!(
704                    #[allow(dead_code)]
705                    impl<T: ::db::export::core::clone::Clone> FooBuilder<T>
706                    {
707                        fn bar() -> {
708                            unimplemented!()
709                        }
710
711                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
712                        fn create_empty() -> Self {
713                            Self {
714                                foo: ::db::export::core::default::Default::default(),
715                            }
716                        }
717                    }
718
719                    impl<T: ::db::export::core::clone::Clone> ::db::export::core::default::Default for FooBuilder<T> {
720                        fn default() -> Self {
721                            Self::create_empty()
722                        }
723                    }
724                ));
725
726                add_generated_error(&mut result);
727
728                result
729            }.to_string()
730        );
731    }
732
733    // This test depends on the exact formatting of the `stringify`'d code,
734    // so we don't automatically format the test
735    #[rustfmt::skip]
736    #[test]
737    fn owned_generic() {
738        let ast: syn::DeriveInput = parse_quote! {
739            struct Lorem<'a, T: Debug> where T: PartialEq { }
740        };
741        let generics = ast.generics;
742        let mut builder = default_builder!();
743        builder.generics = Some(&generics);
744        builder.pattern = BuilderPattern::Owned;
745        builder.must_derive_clone = false;
746
747        assert_eq!(
748            quote!(#builder).to_string(),
749            {
750                let mut result = quote!();
751
752                #[cfg(not(feature = "clippy"))]
753                result.append_all(quote!(#[allow(clippy::all)]));
754
755                result.append_all(quote!(
756                    pub struct FooBuilder<'a, T: Debug> where T: PartialEq {
757                        foo: u32,
758                    }
759                ));
760
761                #[cfg(not(feature = "clippy"))]
762                result.append_all(quote!(#[allow(clippy::all)]));
763
764                result.append_all(quote!(
765                    #[allow(dead_code)]
766                    impl<'a, T: Debug> FooBuilder<'a, T> where T: PartialEq {
767                        fn bar() -> {
768                            unimplemented!()
769                        }
770
771                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
772                        fn create_empty() -> Self {
773                            Self {
774                                foo: ::db::export::core::default::Default::default(),
775                            }
776                        }
777                    }
778
779                    impl<'a, T: Debug> ::db::export::core::default::Default for FooBuilder<'a, T>
780                    where T: PartialEq {
781                        fn default() -> Self {
782                            Self::create_empty()
783                        }
784                    }
785                ));
786
787                add_generated_error(&mut result);
788
789                result
790            }.to_string()
791        );
792    }
793
794    #[test]
795    fn disabled() {
796        let mut builder = default_builder!();
797        builder.enabled = false;
798
799        assert_eq!(quote!(#builder).to_string(), quote!().to_string());
800    }
801
802    #[test]
803    fn add_derives() {
804        let derives = vec![parse_quote!(Serialize)];
805        let mut builder = default_builder!();
806        builder.derives = &derives;
807
808        assert_eq!(
809            quote!(#builder).to_string(),
810            {
811                let mut result = quote!();
812
813                #[cfg(not(feature = "clippy"))]
814                result.append_all(quote!(#[allow(clippy::all)]));
815
816                result.append_all(quote!(
817                    #[derive(Clone, Serialize)]
818                    pub struct FooBuilder {
819                        foo: u32,
820                    }
821                ));
822
823                #[cfg(not(feature = "clippy"))]
824                result.append_all(quote!(#[allow(clippy::all)]));
825
826                result.append_all(quote!(
827                    #[allow(dead_code)]
828                    impl FooBuilder {
829                        fn bar () -> {
830                            unimplemented!()
831                        }
832
833                        /// Create an empty builder, with all fields set to `None` or `PhantomData`.
834                        fn create_empty() -> Self {
835                            Self {
836                                foo: ::db::export::core::default::Default::default(),
837                            }
838                        }
839                    }
840
841                    impl ::db::export::core::default::Default for FooBuilder {
842                        fn default() -> Self {
843                            Self::create_empty()
844                        }
845                    }
846                ));
847
848                add_generated_error(&mut result);
849
850                result
851            }
852            .to_string()
853        );
854    }
855
856    #[test]
857    fn no_validation_error() {
858        let mut builder = default_builder!();
859        builder.generate_validation_error = false;
860
861        assert_eq!(
862            quote!(#builder).to_string(),
863            {
864                let mut result = quote!();
865
866                add_simple_foo_builder(&mut result);
867
868                result.append_all(quote!(
869                    #[doc="Error type for FooBuilder"]
870                    #[derive(Debug)]
871                    #[non_exhaustive]
872                    pub enum FooBuilderError {
873                        /// Uninitialized field
874                        UninitializedField(&'static str),
875                    }
876
877                    impl ::db::export::core::convert::From<::db::UninitializedFieldError> for FooBuilderError {
878                        fn from(s: ::db::UninitializedFieldError) -> Self {
879                            Self::UninitializedField(s.field_name())
880                        }
881                    }
882
883                    impl ::db::export::core::fmt::Display for FooBuilderError {
884                        fn fmt(&self, f: &mut ::db::export::core::fmt::Formatter) -> ::db::export::core::fmt::Result {
885                            match self {
886                                Self::UninitializedField(ref field) => write!(f, "`{}` must be initialized", field),
887                            }
888                        }
889                    }
890
891                    impl std::error::Error for FooBuilderError {}
892                ));
893
894                result
895            }
896                .to_string()
897        );
898    }
899
900    #[test]
901    fn no_alloc_bug_using_string() {
902        let mut builder = default_builder!();
903        builder.no_alloc = true;
904
905        assert_eq!(
906            quote!(#builder).to_string(),
907            {
908                let mut result = quote!();
909
910                add_simple_foo_builder(&mut result);
911
912                result.append_all(quote!(::core::compile_error! { #ALLOC_NOT_ENABLED_ERROR }));
913
914                result
915            }
916            .to_string()
917        );
918    }
919}
derive_builder_core/builder.rs

derive_builder_core/
builder.rs
