From 619e0d58d3406e7a8acb4592dd2c6e1d0cc41362 Mon Sep 17 00:00:00 2001 From: ychampion <68075205+ychampion@users.noreply.github.com> Date: Sun, 15 Nov 2026 03:21:54 +0530 Subject: [PATCH] Support collection setters on custom builder field types When `#[builder(field(ty = "..."))]` overrides a builder field's type, the generated builder field is not wrapped in an outer `Option<...>`. Update `Setter::to_tokens` to match on `(builder_field_is_option, stripped_option)` when generating `each` setters so custom non-`Option` builder fields extend `new.` directly and custom `Option<...>` fields with `strip_option` unwrap a single `Option`. Fixes #287 --- derive_builder/CHANGELOG.md | 3 + derive_builder/tests/setter_extend.rs | 101 +++++++++++++++++++++ derive_builder_core/src/setter.rs | 122 +++++++++++++++++++++++--- 3 files changed, 212 insertions(+), 14 deletions(-) diff --git a/derive_builder/CHANGELOG.md b/derive_builder/CHANGELOG.md index efb9df0..20d1c3d 100644 --- a/derive_builder/CHANGELOG.md +++ b/derive_builder/CHANGELOG.md @@ -2,6 +2,9 @@ All notable changes to this project will be documented in this file. This project adheres to [Semantic Versioning](http://semver.org/). +## [Unreleased] +- Support collection setters (`setter(each = ...)`) on custom builder field types (`field(ty = "...")`) #287 + ## [0.20.2] - 2024-10-08 - Allow unquoted expressions in `builder(default = ...)` #331 diff --git a/derive_builder/tests/setter_extend.rs b/derive_builder/tests/setter_extend.rs index 1ce1d8d..651a07b 100644 --- a/derive_builder/tests/setter_extend.rs +++ b/derive_builder/tests/setter_extend.rs @@ -156,3 +156,104 @@ fn extend_field_enabled() { let x = SitBuilder::default().foo(1).foo(2).build().unwrap(); assert_eq!(x, Sit { foos: vec![1, 2] }); } + +#[derive(Debug, PartialEq, Default, Builder)] +#[builder(pattern = "owned")] +struct CustomFieldOwned { + #[builder( + field( + ty = "Vec", + build = "self.buggy.into_iter().map(|e| (e, e)).collect()" + ), + setter(each(name = "add_buggy", into)) + )] + buggy: HashMap, +} + +#[derive(Debug, PartialEq, Default, Builder, Clone)] +struct CustomFieldMutable { + #[builder( + field( + ty = "Vec", + build = "self.items.iter().cloned().enumerate().map(|(i, s)| (s, i)).collect()" + ), + setter(each(name = "add_item", into)) + )] + items: HashMap, + #[builder( + field(ty = "Option>", build = "self.opt_items.clone()"), + setter(strip_option, each = "add_opt_item") + )] + opt_items: Option>, +} + +#[derive(Debug, PartialEq, Default, Builder, Clone)] +#[builder(pattern = "immutable")] +struct CustomFieldImmutable { + #[builder( + field(ty = "Vec", build = "self.nums.iter().copied().sum()"), + setter(each = "add_num") + )] + nums: i32, +} + +#[test] +fn extend_custom_field_owned() { + let empty = CustomFieldOwnedBuilder::default().build().unwrap(); + assert_eq!( + empty, + CustomFieldOwned { + buggy: HashMap::new() + } + ); + + let built = CustomFieldOwnedBuilder::default() + .add_buggy::(1i16) + .add_buggy::(2) + .build() + .unwrap(); + assert_eq!( + built, + CustomFieldOwned { + buggy: vec![(1, 1), (2, 2)].into_iter().collect(), + } + ); +} + +#[test] +fn extend_custom_field_mutable_and_strip_option() { + let default_built = CustomFieldMutableBuilder::default().build().unwrap(); + assert_eq!( + default_built, + CustomFieldMutable { + items: HashMap::new(), + opt_items: None, + } + ); + + let built = CustomFieldMutableBuilder::default() + .add_item("first") + .add_item("second") + .add_opt_item(10) + .add_opt_item(20) + .build() + .unwrap(); + assert_eq!( + built, + CustomFieldMutable { + items: vec![("first".to_string(), 0), ("second".to_string(), 1)] + .into_iter() + .collect(), + opt_items: Some(vec![10, 20]), + } + ); +} + +#[test] +fn extend_custom_field_immutable() { + let base = CustomFieldImmutableBuilder::default().add_num(3); + let a = base.add_num(4).build().unwrap(); + let b = base.add_num(10).build().unwrap(); + assert_eq!(a, CustomFieldImmutable { nums: 7 }); + assert_eq!(b, CustomFieldImmutable { nums: 13 }); +} diff --git a/derive_builder_core/src/setter.rs b/derive_builder_core/src/setter.rs index de6f1e6..1e46add 100644 --- a/derive_builder_core/src/setter.rs +++ b/derive_builder_core/src/setter.rs @@ -176,17 +176,37 @@ impl<'a> ToTokens for Setter<'a> { let ident_each = &each.name; // Access the collection to extend, initialising with default value if necessary. - let get_initialized_collection = if stripped_option { - // Outer (builder) Option -> Inner (field) Option -> collection. - quote!(get_or_insert_with(|| Some( - #crate_root::export::core::default::Default::default() - )) - .get_or_insert_with(#crate_root::export::core::default::Default::default)) + let field_inner = match (builder_field_is_option, stripped_option) { + (true, true) => { + // Outer (builder) Option -> Inner (field) Option -> collection. + quote!( + new.#field_ident + .get_or_insert_with(|| #crate_root::export::core::option::Option::Some( + #crate_root::export::core::default::Default::default() + )) + .get_or_insert_with(#crate_root::export::core::default::Default::default) + ) + } + (true, false) | (false, true) => { + // Builder field is `Option` (either from the builder wrapping + // a non-Option field, or a custom `Option` field with `strip_option`). + quote!( + new.#field_ident + .get_or_insert_with(#crate_root::export::core::default::Default::default) + ) + } + (false, false) => { + // Custom builder field is already the collection itself. + quote!(new.#field_ident) + } + }; + + let field_inner_bound = if builder_field_is_option || stripped_option { + quote!( + #crate_root::export::core::default::Default + #crate_root::export::core::iter::Extend + ) } else { - // Outer (builder) Option -> collection. - quote!(get_or_insert_with( - #crate_root::export::core::default::Default::default - )) + quote!(#crate_root::export::core::iter::Extend) }; let ty_params: TokenStream; @@ -208,12 +228,10 @@ impl<'a> ToTokens for Setter<'a> { #[allow(unused_mut)] #vis fn #ident_each #ty_params(#self_param, item: #param_ty) -> #return_ty where - #ty: #crate_root::export::core::default::Default + #crate_root::export::core::iter::Extend, + #ty: #field_inner_bound, { let mut new = #self_into_return_ty; - new.#field_ident - .#get_initialized_collection - .extend(#crate_root::export::core::option::Option::Some(#into_item)); + #field_inner.extend(#crate_root::export::core::option::Option::Some(#into_item)); new } )); @@ -627,4 +645,80 @@ mod tests { assert_eq!(extract_type_from_option(&s), Some(&ty_foo)); } } + + #[test] + fn each_precise_field() { + let ty = parse_quote!(Vec); + let each = Each { + name: syn::Ident::new("add_foo", Span::call_site()), + into: true, + }; + let mut setter = default_setter!(); + setter.field_type = BuilderFieldType::Precise(&ty); + setter.each = Some(&each); + + #[rustfmt::skip] + assert_eq!( + quote!(#setter).to_string(), + quote!( + #[allow(unused_mut)] + pub fn foo(&mut self, value: Vec) -> &mut Self { + let mut new = self; + new.foo = value; + new + } + #[allow(unused_mut)] + pub fn add_foo>( + &mut self, + item: FROM_VALUE + ) -> &mut Self + where + Vec: ::db::export::core::iter::Extend, + { + let mut new = self; + new.foo.extend(::db::export::core::option::Option::Some( + ::db::export::core::convert::Into::into(item) + )); + new + } + ) + .to_string() + ); + } + + #[test] + fn each_precise_option_field_strip_option() { + let ty = parse_quote!(Option>); + let each = Each::from(syn::Ident::new("add_foo", Span::call_site())); + let mut setter = default_setter!(); + setter.field_type = BuilderFieldType::Precise(&ty); + setter.strip_option = true; + setter.each = Some(&each); + + #[rustfmt::skip] + assert_eq!( + quote!(#setter).to_string(), + quote!( + #[allow(unused_mut)] + pub fn foo(&mut self, value: Vec) -> &mut Self { + let mut new = self; + new.foo = ::db::export::core::option::Option::Some(value); + new + } + #[allow(unused_mut)] + pub fn add_foo(&mut self, item: VALUE) -> &mut Self + where + Vec: ::db::export::core::default::Default + + ::db::export::core::iter::Extend, + { + let mut new = self; + new.foo + .get_or_insert_with(::db::export::core::default::Default::default) + .extend(::db::export::core::option::Option::Some(item)); + new + } + ) + .to_string() + ); + } }