Optionally transform Extend fields to add items one by one

examples/example.rs

@@ -1,5 +1,15 @@
+use std::{collections::HashMap, iter};
+
 use typed_builder::TypedBuilder;
 
+macro_rules! extend {
+ [$init:expr; $($expr:expr),*$(,)?] => {{
+ let mut e = $init;
+ $(e.extend(iter::once($expr));)*
+ e
+ }};
+}
+
 #[derive(PartialEq, TypedBuilder)]
 struct Foo {
  // Mandatory Field:
@@ -13,16 +23,82 @@ struct Foo {
  // Or you can set the default
  #[builder(default = 20)]
  z: i32,
+
+ // #[builder(default)] without parameter - don't require this field
+ // #[builder(setter(extend))] without parameter - start with the default and extend from there
+ #[builder(default, setter(extend(from_first, item_name = i0)))]
+ v0: Vec<i32>,
+
+ // No `default`: This field must be set at least once.
+ // You can explicitly create the collection from the first item (but this is not required even without `default`).
+ #[builder(setter(extend(from_first = |first| vec![first])))]
+ v1: Vec<i32>,
+
+ // Other `Extend` types are also supported.
+ #[builder(default, setter(extend))]
+ h: HashMap<i32, i32>,
 }
 
 fn main() {
- assert!(Foo::builder().x(1).y(2).z(3).build() == Foo { x: 1, y: Some(2), z: 3 });
+ assert!(
+ Foo::builder().x(1).y(2).z(3).i0(4).v1_item(5).h_item((6, 7)).build()
+ == Foo {
+ x: 1,
+ y: Some(2),
+ z: 3,
+ v0: vec![4],
+ v1: vec![5],
+ h: extend![HashMap::new(); (6, 7)],
+ }
+ );
 
  // Change the order of construction:
- assert!(Foo::builder().z(1).x(2).y(3).build() == Foo { x: 2, y: Some(3), z: 1 });
+ assert!(
+ Foo::builder().z(1).x(2).h_item((3, 4)).v1_item(5).i0(6).y(7).build()
+ == Foo {
+ x: 2,
+ y: Some(7),
+ z: 1,
+ v0: vec![6],
+ v1: vec![5],
+ h: extend![HashMap::new(); (3, 4)],
+ }
+ );
 
  // Optional fields are optional:
- assert!(Foo::builder().x(1).build() == Foo { x: 1, y: None, z: 20 });
+ assert!(
+ Foo::builder().x(1).v1_item(2).build()
+ == Foo {
+ x: 1,
+ y: None,
+ z: 20,
+ v0: vec![],
+ v1: vec![2],
+ h: HashMap::new(),
+ }
+ );
+
+ // Extend fields can be set multiple times:
+ assert!(
+ Foo::builder()
+ .x(1)
+ .i0(2)
+ .i0(3)
+ .i0(4)
+ .v1_item(5)
+ .v1_item(6)
+ .h_item((7, 8))
+ .h_item((9, 10))
+ .build()
+ == Foo {
+ x: 1,
+ y: None,
+ z: 20,
+ v0: vec![3, 4],
+ v1: vec![5, 6],
+ h: extend![HashMap::new(); (7, 8), (9, 10)],
+ }
+ );
 
  // This will not compile - because we did not set x:
  // Foo::builder().build();

src/field_info.rs

@@ -1,9 +1,9 @@
-use proc_macro2::TokenStream;
+use proc_macro2::{Span, TokenStream};
 use quote::quote;
 use syn::parse::Error;
 use syn::spanned::Spanned;
 
-use crate::util::{expr_to_single_string, ident_to_type, path_to_single_string, strip_raw_ident_prefix};
+use crate::util::{expr_to_single_string, ident_to_type, path_to_single_ident, path_to_single_string, strip_raw_ident_prefix};
 
 #[derive(Debug)]
 pub struct FieldInfo<'a> {
@@ -89,9 +89,52 @@ pub struct SetterSettings {
  pub doc: Option<syn::Expr>,
  pub skip: bool,
  pub auto_into: bool,
+ pub extend: Option<ExtendField>,
  pub strip_option: bool,
 }
 
+#[derive(Debug, Clone)]
+pub enum Configurable<T> {
+ Unset,
+ Auto { keyword_span: Span },
+ Custom { keyword_span: Span, value: T },
+}
+
+#[derive(Debug, Clone)]
+pub struct Configured<T> {
+ pub keyword_span: Span,
+ pub value: T,
+}
+
+impl<T> Configurable<T> {
+ pub fn into_configured(self, auto: impl FnOnce(Span) -> T) -> Option<Configured<T>> {
+ match self {
+ Configurable::Unset => None,
+ Configurable::Auto { keyword_span } => Some(Configured {
+ keyword_span,
+ value: auto(keyword_span),
+ }),
+ Configurable::Custom { keyword_span, value } => Some(Configured { keyword_span, value }),
+ }
+ }
+
+ pub fn ensure_unset(&self, error_span: Span) -> Result<(), Error> {
+ if matches!(self, Configurable::Unset) {
+ Ok(())
+ } else {
+ Err(Error::new(error_span, "Duplicate option"))
+ }
+ }
+}
+
+#[derive(Debug, Clone)]
+pub struct ExtendField {
+ pub keyword_span: Span,
+ pub from_first: Configurable<syn::ExprClosure>,
+ pub from_iter: Configurable<syn::ExprClosure>,
+ pub item_name: Option<syn::Ident>,
+}
+
 impl FieldBuilderAttr {
  pub fn with(mut self, attrs: &[syn::Attribute]) -> Result<Self, Error> {
  let mut skip_tokens = None;
@@ -234,6 +277,110 @@ impl SetterSettings {
  _ => Err(Error::new_spanned(&assign, format!("Unknown parameter {:?}", name))),
  }
  }
+ syn::Expr::Call(call) => {
+ let name =
+ expr_to_single_string(&call.func).ok_or_else(|| Error::new_spanned(&call.func, "Expected identifier"))?;
+ match name.as_str() {
+ "extend" => {
+ if self.extend.is_some() {
+ Err(Error::new(
+ call.span(),
+ "Illegal setting - field is already calling extend(...) with the argument",
+ ))
+ } else if let Some(attr) = call.attrs.first() {
+ Err(Error::new_spanned(attr, "Unexpected attribute"))
+ } else {
+ let mut extend = ExtendField {
+ keyword_span: name.span(),
+ from_first: Configurable::Unset,
+ from_iter: Configurable::Unset,
+ item_name: None,
+ };
+ for arg in call.args {
+ match arg {
+ syn::Expr::Assign(assign) => {
+ let name = expr_to_single_string(&assign.left)
+ .ok_or_else(|| Error::new_spanned(&assign.left, "Expected identifier"))?;
+ match name.as_str() {
+ "from_first" => {
+ extend.from_first.ensure_unset(assign.left.span())?;
+ match *assign.right {
+ syn::Expr::Closure(closure) => {
+ extend.from_first = Configurable::Custom {
+ keyword_span: assign.left.span(),
+ value: closure,
+ }
+ }
+ other => {
+ return Err(Error::new_spanned(other, "Expected closure (|first| <...>)"))
+ }
+ }
+ }
+ "from_iter" => {
+ extend.from_iter.ensure_unset(assign.left.span())?;
+ match *assign.right {
+ syn::Expr::Closure(closure) => {
+ extend.from_iter = Configurable::Custom {
+ keyword_span: assign.left.span(),
+ value: closure,
+ }
+ }
+ other => {
+ return Err(Error::new_spanned(other, "Expected closure (|iter| <...>)"))
+ }
+ }
+ }
+ "item_name" => {
+ if extend.item_name.is_some() {
+ return Err(Error::new_spanned(assign.left, "Duplicate option"));
+ }
+ match *assign.right {
+ syn::Expr::Path(path) => {
+ let name = path_to_single_ident(&path.path)
+ .ok_or_else(|| Error::new_spanned(&path, "Expected identifier"))?;
+ extend.item_name = Some(name.clone())
+ }
+ other => return Err(Error::new_spanned(other, "Expected identifier")),
+ }
+ }
+ _ => {
+ return Err(Error::new_spanned(
+ &assign.left,
+ format!("Unknown parameter {:?}", name),
+ ))
+ }
+ }
+ }
+ syn::Expr::Path(path) => {
+ let name = path_to_single_string(&path.path)
+ .ok_or_else(|| Error::new_spanned(&path, "Expected identifier"))?;
+ match name.as_str() {
+ "from_first" => {
+ extend.from_first.ensure_unset(path.span())?;
+ extend.from_first = Configurable::Auto {
+ keyword_span: path.span(),
+ };
+ }
+ "from_iter" => {
+ extend.from_iter.ensure_unset(path.span())?;
+ extend.from_iter = Configurable::Auto {
+ keyword_span: path.span(),
+ };
+ }
+ "item_name" => return Err(Error::new_spanned(path, "Expected (item_name = <...>)")),
+ _ => return Err(Error::new_spanned(path, format!("Unknown parameter {:?}", name))),
+ }
+ }
+ _ => return Err(Error::new_spanned(arg, "Expected (<...>) or (<...>=<...>)")),
+ }
+ }
+ self.extend = Some(extend);
+ Ok(())
+ }
+ }
+ _ => Err(Error::new_spanned(&call.func, format!("Unknown parameter {:?}", name))),
+ }
+ }
  syn::Expr::Path(path) => {
  let name = path_to_single_string(&path.path).ok_or_else(|| Error::new_spanned(&path, "Expected identifier"))?;
  macro_rules! handle_fields {
@@ -249,6 +396,19 @@ impl SetterSettings {
  }
  }
  )*
+ "extend" => {
+ if self.extend.is_some() {
+ Err(Error::new(path.span(), "Illegal setting - field is already calling extend(...) with the argument"))
+ } else {
+ self.extend = Some(ExtendField {
+ keyword_span: name.span(),
+ from_first: Configurable::Auto { keyword_span:name.span() },
+ from_iter: Configurable::Auto { keyword_span:name.span() },
+ item_name: None,
+ });
+ Ok(())
+ }
+ }
  _ => Err(Error::new_spanned(
  &path,
  format!("Unknown setter parameter {:?}", name),
@@ -283,6 +443,10 @@ impl SetterSettings {
  self.auto_into = false;
  Ok(())
  }
+ "extend" => {
+ self.extend = None;
+ Ok(())
+ }
  "strip_option" => {
  self.strip_option = false;
  Ok(())
@@ -293,7 +457,7 @@ impl SetterSettings {
  Err(Error::new_spanned(expr, "Expected simple identifier".to_owned()))
  }
  }
- _ => Err(Error::new_spanned(expr, "Expected (<...>=<...>)")),
+ _ => Err(Error::new_spanned(expr, "Expected (<...>=<...>) or (<...>(<...>))")),
  }
  }
 }