derive_builder_core/
setter.rs

Help
1#![allow(clippy::useless_let_if_seq)]
2use std::borrow::Cow;
3
4use proc_macro2::{Span, TokenStream};
5use quote::{ToTokens, TokenStreamExt};
6
7use crate::{BuilderFieldType, BuilderPattern, Each};
8
9/// Setter for the struct fields in the build method, implementing
10/// `quote::ToTokens`.
11///
12/// # Examples
13///
14/// Will expand to something like the following (depending on settings):
15///
16/// ```rust,ignore
17/// # extern crate proc_macro2;
18/// # #[macro_use]
19/// # extern crate quote;
20/// # extern crate syn;
21/// # #[macro_use]
22/// # extern crate derive_builder_core;
23/// # use derive_builder_core::{Setter, BuilderPattern};
24/// # fn main() {
25/// #     let mut setter = default_setter!();
26/// #     setter.pattern = BuilderPattern::Mutable;
27/// #
28/// #     assert_eq!(quote!(#setter).to_string(), quote!(
29/// # #[allow(unused_mut)]
30/// pub fn foo(&mut self, value: Foo) -> &mut Self {
31///     let mut new = self;
32///     new.foo = ::derive_builder::export::core::option::Option::Some(value);
33///     new
34/// }
35/// #     ).to_string());
36/// # }
37/// ```
38#[derive(Debug, Clone)]
39pub struct Setter<'a> {
40    /// Path to the root of the derive_builder crate.
41    pub crate_root: &'a syn::Path,
42    /// Enables code generation for this setter fn.
43    pub setter_enabled: bool,
44    /// Enables code generation for the `try_` variant of this setter fn.
45    pub try_setter: bool,
46    /// Visibility of the setter, e.g. `syn::Visibility::Public`.
47    pub visibility: Cow<'a, syn::Visibility>,
48    /// How the setter method takes and returns `self` (e.g. mutably).
49    pub pattern: BuilderPattern,
50    /// Attributes which will be attached to this setter fn.
51    pub attrs: &'a [syn::Attribute],
52    /// Name of this setter fn.
53    pub ident: syn::Ident,
54    /// Name of the target field.
55    pub field_ident: &'a syn::Ident,
56    /// Type of the builder field.
57    ///
58    /// The corresonding builder field will be `Option<field_type>`.
59    pub field_type: BuilderFieldType<'a>,
60    /// Make the setter generic over `Into<T>`, where `T` is the field type.
61    pub generic_into: bool,
62    /// Make the setter remove the Option wrapper from the setter, remove the need to call Some(...).
63    /// when combined with into, the into is used on the content Type of the Option.
64    pub strip_option: bool,
65    /// Emit extend method.
66    pub each: Option<&'a Each>,
67}
68
69impl<'a> ToTokens for Setter<'a> {
70    fn to_tokens(&self, tokens: &mut TokenStream) {
71        if self.setter_enabled {
72            let crate_root = self.crate_root;
73            let pattern = self.pattern;
74            let vis = &self.visibility;
75            let field_ident = self.field_ident;
76            let ident = &self.ident;
77            let attrs = self.attrs;
78
79            let self_param: TokenStream;
80            let return_ty: TokenStream;
81            let self_into_return_ty: TokenStream;
82
83            match pattern {
84                BuilderPattern::Owned => {
85                    self_param = quote!(self);
86                    return_ty = quote!(Self);
87                    self_into_return_ty = quote!(self);
88                }
89                BuilderPattern::Mutable => {
90                    self_param = quote!(&mut self);
91                    return_ty = quote!(&mut Self);
92                    self_into_return_ty = quote!(self);
93                }
94                BuilderPattern::Immutable => {
95                    self_param = quote!(&self);
96                    return_ty = quote!(Self);
97                    self_into_return_ty =
98                        quote!(#crate_root::export::core::clone::Clone::clone(self));
99                }
100            };
101
102            let ty_params: TokenStream;
103            let param_ty: TokenStream;
104            let mut into_value: TokenStream;
105
106            let (field_type, builder_field_is_option) = self.field_type.setter_type_info();
107
108            let (ty, stripped_option) = {
109                if self.strip_option {
110                    match extract_type_from_option(field_type) {
111                        Some(ty) => (ty, true),
112                        None => (field_type, false),
113                    }
114                } else {
115                    (field_type, false)
116                }
117            };
118
119            if self.generic_into {
120                ty_params = quote!(<VALUE: #crate_root::export::core::convert::Into<#ty>>);
121                param_ty = quote!(VALUE);
122                into_value = quote!(value.into());
123            } else {
124                ty_params = quote!();
125                param_ty = quote!(#ty);
126                into_value = quote!(value);
127            }
128            // If both `stripped_option` and `builder_field_is_option`, the target field is `Option<field_type>`,
129            // the builder field is `Option<Option<field_type>>`, and the setter takes `file_type`, so we must wrap it twice.
130            if stripped_option {
131                into_value = wrap_expression_in_some(crate_root, into_value);
132            }
133            if builder_field_is_option {
134                into_value = wrap_expression_in_some(crate_root, into_value);
135            }
136
137            tokens.append_all(quote!(
138                #(#attrs)*
139                #[allow(unused_mut)]
140                #vis fn #ident #ty_params (#self_param, value: #param_ty)
141                    -> #return_ty
142                {
143                    let mut new = #self_into_return_ty;
144                    new.#field_ident = #into_value;
145                    new
146                }
147            ));
148
149            if self.try_setter {
150                let try_ty_params =
151                    quote!(<VALUE: #crate_root::export::core::convert::TryInto<#ty>>);
152                let try_ident = syn::Ident::new(&format!("try_{}", ident), Span::call_site());
153
154                let mut converted = quote! {converted};
155                if builder_field_is_option {
156                    converted = wrap_expression_in_some(crate_root, converted);
157                }
158                if stripped_option {
159                    converted = wrap_expression_in_some(crate_root, converted);
160                }
161
162                tokens.append_all(quote!(
163                    #(#attrs)*
164                    #vis fn #try_ident #try_ty_params (#self_param, value: VALUE)
165                        -> #crate_root::export::core::result::Result<#return_ty, VALUE::Error>
166                    {
167                        let converted : #ty = value.try_into()?;
168                        let mut new = #self_into_return_ty;
169                        new.#field_ident = #converted;
170                        Ok(new)
171                    }
172                ));
173            }
174
175            if let Some(each) = self.each {
176                let ident_each = &each.name;
177
178                // Access the collection to extend, initialising with default value if necessary.
179                let get_initialized_collection = if stripped_option {
180                    // Outer (builder) Option -> Inner (field) Option -> collection.
181                    quote!(get_or_insert_with(|| Some(
182                        #crate_root::export::core::default::Default::default()
183                    ))
184                    .get_or_insert_with(#crate_root::export::core::default::Default::default))
185                } else {
186                    // Outer (builder) Option -> collection.
187                    quote!(get_or_insert_with(
188                        #crate_root::export::core::default::Default::default
189                    ))
190                };
191
192                let ty_params: TokenStream;
193                let param_ty: TokenStream;
194                let into_item: TokenStream;
195
196                if each.into {
197                    ty_params = quote!(<VALUE, FROM_VALUE: #crate_root::export::core::convert::Into<VALUE>>);
198                    param_ty = quote!(FROM_VALUE);
199                    into_item = quote!(#crate_root::export::core::convert::Into::into(item));
200                } else {
201                    ty_params = quote!(<VALUE>);
202                    param_ty = quote!(VALUE);
203                    into_item = quote!(item);
204                }
205
206                tokens.append_all(quote!(
207                    #(#attrs)*
208                    #[allow(unused_mut)]
209                    #vis fn #ident_each #ty_params(#self_param, item: #param_ty) -> #return_ty
210                    where
211                        #ty: #crate_root::export::core::default::Default + #crate_root::export::core::iter::Extend<VALUE>,
212                    {
213                        let mut new = #self_into_return_ty;
214                        new.#field_ident
215                            .#get_initialized_collection
216                            .extend(#crate_root::export::core::option::Option::Some(#into_item));
217                        new
218                    }
219                ));
220            }
221        }
222    }
223}
224
225/// Returns expression wrapping `bare_value` in `Some`
226fn wrap_expression_in_some(crate_root: &syn::Path, bare_value: impl ToTokens) -> TokenStream {
227    quote!( #crate_root::export::core::option::Option::Some(#bare_value) )
228}
229
230// adapted from https://stackoverflow.com/a/55277337/469066
231// Note that since syn is a parser, it works with tokens.
232// We cannot know for sure that this is an Option.
233// The user could, for example, `type MaybeString = std::option::Option<String>`
234// We cannot handle those arbitrary names.
235fn extract_type_from_option(ty: &syn::Type) -> Option<&syn::Type> {
236    use syn::punctuated::Pair;
237    use syn::token::PathSep;
238    use syn::{GenericArgument, Path, PathArguments, PathSegment};
239
240    fn extract_type_path(ty: &syn::Type) -> Option<&Path> {
241        match *ty {
242            syn::Type::Path(ref typepath) if typepath.qself.is_none() => Some(&typepath.path),
243            _ => None,
244        }
245    }
246
247    // TODO store (with lazy static) precomputed parsing of Option when support of rust 1.18 will be removed (incompatible with lazy_static)
248    // TODO maybe optimization, reverse the order of segments
249    fn extract_option_segment(path: &Path) -> Option<Pair<&PathSegment, &PathSep>> {
250        let idents_of_path = path.segments.iter().fold(String::new(), |mut acc, v| {
251            acc.push_str(&v.ident.to_string());
252            acc.push('|');
253            acc
254        });
255        vec!["Option|", "std|option|Option|", "core|option|Option|"]
256            .into_iter()
257            .find(|s| idents_of_path == *s)
258            .and_then(|_| path.segments.last().map(Pair::End))
259    }
260
261    extract_type_path(ty)
262        .and_then(extract_option_segment)
263        .and_then(|pair_path_segment| {
264            let type_params = &pair_path_segment.into_value().arguments;
265            // It should have only on angle-bracketed param ("<String>"):
266            match *type_params {
267                PathArguments::AngleBracketed(ref params) => params.args.first(),
268                _ => None,
269            }
270        })
271        .and_then(|generic_arg| match *generic_arg {
272            GenericArgument::Type(ref ty) => Some(ty),
273            _ => None,
274        })
275}
276
277/// Helper macro for unit tests. This is _only_ public in order to be accessible
278/// from doc-tests too.
279#[doc(hidden)]
280#[macro_export]
281macro_rules! default_setter {
282    () => {
283        Setter {
284            // Deliberately don't use the default value here - make sure
285            // that all test cases are passing crate_root through properly.
286            crate_root: &parse_quote!(::db),
287            setter_enabled: true,
288            try_setter: false,
289            visibility: ::std::borrow::Cow::Owned(parse_quote!(pub)),
290            pattern: BuilderPattern::Mutable,
291            attrs: &vec![],
292            ident: syn::Ident::new("foo", ::proc_macro2::Span::call_site()),
293            field_ident: &syn::Ident::new("foo", ::proc_macro2::Span::call_site()),
294            field_type: BuilderFieldType::Optional(Box::leak(Box::new(parse_quote!(Foo)))),
295            generic_into: false,
296            strip_option: false,
297            each: None,
298        }
299    };
300}
301
302#[cfg(test)]
303mod tests {
304    #[allow(unused_imports)]
305    use super::*;
306
307    #[test]
308    fn immutable() {
309        let mut setter = default_setter!();
310        setter.pattern = BuilderPattern::Immutable;
311
312        assert_eq!(
313            quote!(#setter).to_string(),
314            quote!(
315                #[allow(unused_mut)]
316                pub fn foo(&self, value: Foo) -> Self {
317                    let mut new = ::db::export::core::clone::Clone::clone(self);
318                    new.foo = ::db::export::core::option::Option::Some(value);
319                    new
320                }
321            )
322            .to_string()
323        );
324    }
325
326    #[test]
327    fn mutable() {
328        let mut setter = default_setter!();
329        setter.pattern = BuilderPattern::Mutable;
330
331        assert_eq!(
332            quote!(#setter).to_string(),
333            quote!(
334                #[allow(unused_mut)]
335                pub fn foo(&mut self, value: Foo) -> &mut Self {
336                    let mut new = self;
337                    new.foo = ::db::export::core::option::Option::Some(value);
338                    new
339                }
340            )
341            .to_string()
342        );
343    }
344
345    #[test]
346    fn owned() {
347        let mut setter = default_setter!();
348        setter.pattern = BuilderPattern::Owned;
349
350        assert_eq!(
351            quote!(#setter).to_string(),
352            quote!(
353                #[allow(unused_mut)]
354                pub fn foo(self, value: Foo) -> Self {
355                    let mut new = self;
356                    new.foo = ::db::export::core::option::Option::Some(value);
357                    new
358                }
359            )
360            .to_string()
361        );
362    }
363
364    #[test]
365    fn private() {
366        let vis = Cow::Owned(syn::Visibility::Inherited);
367
368        let mut setter = default_setter!();
369        setter.visibility = vis;
370
371        assert_eq!(
372            quote!(#setter).to_string(),
373            quote!(
374                #[allow(unused_mut)]
375                fn foo(&mut self, value: Foo) -> &mut Self {
376                    let mut new = self;
377                    new.foo = ::db::export::core::option::Option::Some(value);
378                    new
379                }
380            )
381            .to_string()
382        );
383    }
384
385    #[test]
386    fn generic() {
387        let mut setter = default_setter!();
388        setter.generic_into = true;
389
390        #[rustfmt::skip]
391        assert_eq!(
392            quote!(#setter).to_string(),
393            quote!(
394                #[allow(unused_mut)]
395                pub fn foo<VALUE: ::db::export::core::convert::Into<Foo>>(
396                    &mut self,
397                    value: VALUE
398                ) -> &mut Self {
399                    let mut new = self;
400                    new.foo = ::db::export::core::option::Option::Some(value.into());
401                    new
402                }
403            )
404            .to_string()
405        );
406    }
407
408    #[test]
409    fn strip_option() {
410        let ty = parse_quote!(Option<Foo>);
411        let mut setter = default_setter!();
412        setter.strip_option = true;
413        setter.field_type = BuilderFieldType::Optional(&ty);
414
415        #[rustfmt::skip]
416        assert_eq!(
417            quote!(#setter).to_string(),
418            quote!(
419                #[allow(unused_mut)]
420                pub fn foo(&mut self, value: Foo) -> &mut Self {
421                    let mut new = self;
422                    new.foo = ::db::export::core::option::Option::Some(
423                        ::db::export::core::option::Option::Some(value)
424                    );
425                    new
426                }
427            )
428            .to_string()
429        );
430    }
431
432    #[test]
433    fn strip_option_into() {
434        let ty = parse_quote!(Option<Foo>);
435        let mut setter = default_setter!();
436        setter.strip_option = true;
437        setter.generic_into = true;
438        setter.field_type = BuilderFieldType::Optional(&ty);
439
440        #[rustfmt::skip]
441        assert_eq!(
442            quote!(#setter).to_string(),
443            quote!(
444                #[allow(unused_mut)]
445                pub fn foo<VALUE: ::db::export::core::convert::Into<Foo>>(
446                    &mut self,
447                    value: VALUE
448                ) -> &mut Self {
449                    let mut new = self;
450                    new.foo = ::db::export::core::option::Option::Some(
451                        ::db::export::core::option::Option::Some(value.into())
452                    );
453                    new
454                }
455            )
456            .to_string()
457        );
458    }
459    #[test]
460    fn strip_option_try_setter() {
461        let ty = parse_quote!(Option<Foo>);
462        let mut setter = default_setter!();
463        setter.strip_option = true;
464        setter.try_setter = true;
465        setter.generic_into = true;
466        setter.field_type = BuilderFieldType::Optional(&ty);
467        #[rustfmt::skip]
468        assert_eq!(
469            quote!(#setter).to_string(),
470            quote!(
471                #[allow(unused_mut)]
472                pub fn foo<VALUE: ::db::export::core::convert::Into<Foo>>(
473                    &mut self,
474                    value: VALUE
475                ) -> &mut Self {
476                    let mut new = self;
477                    new.foo = ::db::export::core::option::Option::Some(
478                        ::db::export::core::option::Option::Some(value.into())
479                    );
480                    new
481                }
482                pub fn try_foo<VALUE: ::db::export::core::convert::TryInto<Foo>>(
483                    &mut self,
484                    value: VALUE
485                ) -> ::db::export::core::result::Result<&mut Self, VALUE::Error> {
486                    let converted: Foo = value.try_into()?;
487                    let mut new = self;
488                    new.foo = ::db::export::core::option::Option::Some(
489                        ::db::export::core::option::Option::Some(converted)
490                    );
491                    Ok(new)
492                }
493            )
494            .to_string()
495        );
496    }
497
498    // including try_setter
499    #[test]
500    fn full() {
501        //named!(outer_attrs -> Vec<syn::Attribute>, many0!(syn::Attribute::parse_outer));
502        //let attrs = outer_attrs.parse_str("#[some_attr]").unwrap();
503        let attrs: Vec<syn::Attribute> = vec![parse_quote!(#[some_attr])];
504
505        let mut setter = default_setter!();
506        setter.attrs = attrs.as_slice();
507        setter.generic_into = true;
508        setter.try_setter = true;
509
510        #[rustfmt::skip]
511        assert_eq!(
512            quote!(#setter).to_string(),
513            quote!(
514            #[some_attr]
515            #[allow(unused_mut)]
516            pub fn foo <VALUE: ::db::export::core::convert::Into<Foo>>(&mut self, value: VALUE) -> &mut Self {
517                let mut new = self;
518                new.foo = ::db::export::core::option::Option::Some(value.into());
519                new
520            }
521
522            #[some_attr]
523            pub fn try_foo<VALUE: ::db::export::core::convert::TryInto<Foo>>(&mut self, value: VALUE)
524                -> ::db::export::core::result::Result<&mut Self, VALUE::Error> {
525                let converted : Foo = value.try_into()?;
526                let mut new = self;
527                new.foo = ::db::export::core::option::Option::Some(converted);
528                Ok(new)
529            }
530        ).to_string()
531        );
532    }
533
534    #[test]
535    fn no_std() {
536        let mut setter = default_setter!();
537        setter.pattern = BuilderPattern::Immutable;
538
539        assert_eq!(
540            quote!(#setter).to_string(),
541            quote!(
542                #[allow(unused_mut)]
543                pub fn foo(&self, value: Foo) -> Self {
544                    let mut new = ::db::export::core::clone::Clone::clone(self);
545                    new.foo = ::db::export::core::option::Option::Some(value);
546                    new
547                }
548            )
549            .to_string()
550        );
551    }
552
553    #[test]
554    fn no_std_generic() {
555        let mut setter = default_setter!();
556        setter.generic_into = true;
557
558        #[rustfmt::skip]
559        assert_eq!(
560            quote!(#setter).to_string(),
561            quote!(
562                #[allow(unused_mut)]
563                pub fn foo<VALUE: ::db::export::core::convert::Into<Foo>>(
564                    &mut self,
565                    value: VALUE
566                ) -> &mut Self {
567                    let mut new = self;
568                    new.foo = ::db::export::core::option::Option::Some(value.into());
569                    new
570                }
571            )
572            .to_string()
573        );
574    }
575
576    #[test]
577    fn setter_disabled() {
578        let mut setter = default_setter!();
579        setter.setter_enabled = false;
580
581        assert_eq!(quote!(#setter).to_string(), quote!().to_string());
582    }
583
584    #[test]
585    fn try_setter() {
586        let mut setter: Setter = default_setter!();
587        setter.pattern = BuilderPattern::Mutable;
588        setter.try_setter = true;
589
590        #[rustfmt::skip]
591        assert_eq!(
592            quote!(#setter).to_string(),
593            quote!(
594                #[allow(unused_mut)]
595                pub fn foo(&mut self, value: Foo) -> &mut Self {
596                    let mut new = self;
597                    new.foo = ::db::export::core::option::Option::Some(value);
598                    new
599                }
600
601                pub fn try_foo<VALUE: ::db::export::core::convert::TryInto<Foo>>(
602                    &mut self,
603                    value: VALUE
604                ) -> ::db::export::core::result::Result<&mut Self, VALUE::Error> {
605                    let converted: Foo = value.try_into()?;
606                    let mut new = self;
607                    new.foo = ::db::export::core::option::Option::Some(converted);
608                    Ok(new)
609                }
610            )
611            .to_string()
612        );
613    }
614
615    #[test]
616    fn extract_type_from_option_on_simple_type() {
617        let ty_foo = parse_quote!(Foo);
618        assert_eq!(extract_type_from_option(&ty_foo), None);
619
620        for s in vec![
621            parse_quote!(Option<Foo>),
622            parse_quote!(std::option::Option<Foo>),
623            parse_quote!(::std::option::Option<Foo>),
624            parse_quote!(core::option::Option<Foo>),
625            parse_quote!(::core::option::Option<Foo>),
626        ] {
627            assert_eq!(extract_type_from_option(&s), Some(&ty_foo));
628        }
629    }
630}
derive_builder_core/setter.rs

derive_builder_core/
setter.rs
