Support custom fields in the builder struct

derive_builder/src/lib.rs

@@ -635,6 +635,46 @@
 //! # }
 //! ```
 //!
+//! # Completely custom fields in the builder
+//!
+//! Instead of having an `Option`, you can have whatever type you like:
+//!
+//! ```rust
+//! # #[macro_use]
+//! # extern crate derive_builder;
+//! #[derive(Debug, PartialEq, Default, Builder, Clone)]
+//! #[builder(derive(Debug, PartialEq))]
+//! struct Lorem {
+//!     #[builder(setter(into), field(type = "u32"))]
+//!     ipsum: u32,
+//!
+//!     #[builder(field(type = "String", build = "()"))]
+//!     dolor: (),
+//!
+//!     #[builder(field(type = "&'static str", build = "self.amet.parse()?"))]
+//!     amet: u32,
+//! }
+//!
+//! impl From<std::num::ParseIntError> for LoremBuilderError { // ...
+//! #     fn from(e: std::num::ParseIntError) -> LoremBuilderError {
+//! #         e.to_string().into()
+//! #     }
+//! # }
+//!
+//! # fn main() {
+//! let mut builder = LoremBuilder::default();
+//! builder.ipsum(42u16).dolor("sit".into()).amet("12");
+//! assert_eq!(builder, LoremBuilder { ipsum: 42, dolor: "sit".into(), amet: "12" });
+//! let lorem = builder.build().unwrap();
+//! assert_eq!(lorem, Lorem { ipsum: 42, dolor: (), amet: 12 });
+//! # }
+//! ```
+//!
+//! The builder field type (`type =`) must implement `Default`.
+//!
+//! The argument to `build` must be a literal string containing Rust code for the contents of a block, which must evaluate to the type of the target field.
+//! It may refer to the builder struct as `self`, use `?`, etc.
+//!
 //! # **`#![no_std]`** Support (on Nightly)
 //!
 //! You can activate support for `#![no_std]` by adding `#[builder(no_std)]` to your struct

derive_builder/tests/builder_field_custom.rs

@@ -0,0 +1,51 @@
+#[macro_use]
+extern crate pretty_assertions;
+#[macro_use]
+extern crate derive_builder;
+
+use std::num::ParseIntError;
+
+#[derive(Debug, PartialEq, Default, Builder, Clone)]
+pub struct Lorem {
+    #[builder(field(type = "Option<usize>", build = "self.ipsum.unwrap_or(42) + 1"))]
+    ipsum: usize,
+
+    #[builder(field(type = "String", build = "self.dolor.parse()?"))]
+    dolor: u32,
+}
+
+impl From<ParseIntError> for LoremBuilderError {
+    fn from(e: ParseIntError) -> LoremBuilderError {
+        LoremBuilderError::ValidationError(e.to_string())
+    }
+}
+
+#[test]
+fn custom_fields() {
+    let x = LoremBuilder::default().dolor("7".into()).build().unwrap();
+
+    assert_eq!(
+        x,
+        Lorem {
+            ipsum: 43,
+            dolor: 7,
+        }
+    );
+
+    let x = LoremBuilder::default()
+        .ipsum(Some(12))
+        .dolor("66".into())
+        .build()
+        .unwrap();
+
+    assert_eq!(
+        x,
+        Lorem {
+            ipsum: 13,
+            dolor: 66,
+        }
+    );
+
+    let x = LoremBuilder::default().build().unwrap_err().to_string();
+    assert_eq!(x, "cannot parse integer from empty string");
+}

derive_builder/tests/compile-fail/builder_field_custom.rs

@@ -0,0 +1,10 @@
+#[macro_use]
+extern crate derive_builder;
+
+#[derive(Debug, PartialEq, Default, Builder, Clone)]
+pub struct Lorem {
+    #[builder(default = "88", field(type = "usize", build = "self.ipsum.unwrap_or_else(42) + 1"))]
+    ipsum: usize,
+}
+
+fn main() {}

derive_builder/tests/compile-fail/builder_field_custom.stderr

@@ -0,0 +1,5 @@
+error: Unexpected meta-item format `#[builder(default)] and #[builder(build="...")] cannot be used together`
+ --> tests/compile-fail/builder_field_custom.rs:6:25
+  |
+6 |     #[builder(default = "88", field(type = "usize", build = "self.ipsum.unwrap_or_else(42) + 1"))]
+  |                         ^^^^

derive_builder_core/src/block.rs

@@ -44,6 +44,21 @@ impl From<syn::Expr> for BlockContents {
     }
 }
 
+impl darling::FromMeta for BlockContents {
+    fn from_value(value: &syn::Lit) -> darling::Result<Self> {
+        if let syn::Lit::Str(s) = value {
+            let contents = BlockContents::try_from(s)?;
+            if contents.is_empty() {
+                Err(darling::Error::unknown_value("").with_span(s))
+            } else {
+                Ok(contents)
+            }
+        } else {
+            Err(darling::Error::unexpected_lit_type(value))
+        }
+    }
+}
+
 #[cfg(test)]
 mod test {
     use std::convert::TryInto;

derive_builder_core/src/builder_field.rs

@@ -33,45 +33,41 @@ use syn;
 pub struct BuilderField<'a> {
     /// Name of the target field.
     pub field_ident: &'a syn::Ident,
-    /// Type of the target field.
-    ///
-    /// The corresonding builder field will be `Option<field_type>`.
-    pub field_type: &'a syn::Type,
-    /// Whether the builder implements a setter for this field.
-    ///
-    /// Note: We will fallback to `PhantomData` if the setter is disabled
-    ///       to hack around issues with unused generic type parameters - at
-    ///       least for now.
-    pub field_enabled: bool,
+    /// Type of the builder field.
+    pub field_type: BuilderFieldType<'a>,
     /// Visibility of this builder field, e.g. `syn::Visibility::Public`.
     pub field_visibility: Cow<'a, syn::Visibility>,
     /// Attributes which will be attached to this builder field.
     pub attrs: &'a [syn::Attribute],
 }
 
-impl<'a> ToTokens for BuilderField<'a> {
+impl<'a> ToTokens for BuilderFieldType<'a> {
     fn to_tokens(&self, tokens: &mut TokenStream) {
-        if self.field_enabled {
-            let vis = &self.field_visibility;
-            let ident = self.field_ident;
-            let ty = self.field_type;
-            let attrs = self.attrs;
-
-            tokens.append_all(quote!(
-                #(#attrs)* #vis #ident: ::derive_builder::export::core::option::Option<#ty>,
-            ));
-        } else {
-            let ident = self.field_ident;
-            let ty = self.field_type;
-            let attrs = self.attrs;
-
-            tokens.append_all(quote!(
-                #(#attrs)* #ident: ::derive_builder::export::core::marker::PhantomData<#ty>,
-            ));
+        match self {
+            BuilderFieldType::Optional(ty) => tokens.append_all(quote!(
+                ::derive_builder::export::core::option::Option<#ty>
+            )),
+            BuilderFieldType::Precise(ty) => ty.to_tokens(tokens),
+            BuilderFieldType::Phantom(ty) => tokens.append_all(quote!(
+                ::derive_builder::export::core::marker::PhantomData<#ty>
+            )),
         }
     }
 }
 
+impl<'a> ToTokens for BuilderField<'a> {
+    fn to_tokens(&self, tokens: &mut TokenStream) {
+        let ident = self.field_ident;
+        let vis = &self.field_visibility;
+        let ty = &self.field_type;
+        let attrs = self.attrs;
+        tokens.append_all(quote!(
+            #(#attrs)* #vis #ident: #ty,
+        ));
+        // K let ty = self.field_type.target_type();
+    }
+}
+
 impl<'a> BuilderField<'a> {
     /// Emits a struct field initializer that initializes the field to `Default::default`.
     pub fn default_initializer_tokens(&self) -> TokenStream {
@@ -82,20 +78,55 @@ impl<'a> BuilderField<'a> {
 
 /// Helper macro for unit tests. This is _only_ public in order to be accessible
 /// from doc-tests too.
+#[cfg(test)] // This contains a Box::leak, so is suitable only for tests
 #[doc(hidden)]
 #[macro_export]
 macro_rules! default_builder_field {
     () => {{
         BuilderField {
             field_ident: &syn::Ident::new("foo", ::proc_macro2::Span::call_site()),
-            field_type: &parse_quote!(String),
-            field_enabled: true,
+            field_type: BuilderFieldType::Optional(Box::leak(Box::new(parse_quote!(String)))),
             field_visibility: ::std::borrow::Cow::Owned(parse_quote!(pub)),
             attrs: &[parse_quote!(#[some_attr])],
         }
     }};
 }
 
+/// The type of a field in the builder struct
+#[derive(Debug, Clone)]
+pub enum BuilderFieldType<'a> {
+    /// The corresonding builder field will be `Option<field_type>`.
+    Optional(&'a syn::Type),
+    /// The corresponding builder field will be just this type
+    Precise(&'a syn::Type),
+    /// The corresponding builder field will be a PhantomData
+    ///
+    /// We do this if if the field is disabled.  We mustn't just completely omit the field from the builder:
+    /// if we did that, the builder might have unused generic parameters (since we copy the generics from
+    /// the target struct).   Using a PhantomData of the original field type provides the right generic usage
+    /// (and the right variance).  The alternative would be to give the user a way to separately control
+    /// the generics of the builder struct, which would be very awkward to use and complex to document.
+    /// We could just include the field anyway, as `Option<T>`, but this is wasteful of space, and it
+    /// seems good to explicitly suppress the existence of a variable that won't be set or read.
+    Phantom(&'a syn::Type),
+}
+
+impl<'a> BuilderFieldType<'a> {
+    /// Obtain type information for the builder field setter
+    ///
+    /// Return value:
+    ///  * `.0`: type of the argument to the setter function
+    ///          (before application of `strip_option`, `into`)
+    ///  * `.1`: whether the builder field is `Option<type>` rather than just `type`
+    pub fn setter_type_info(&'a self) -> (&'a syn::Type, bool) {
+        match self {
+            BuilderFieldType::Optional(ty) => (ty, true),
+            BuilderFieldType::Precise(ty) => (ty, false),
+            BuilderFieldType::Phantom(_ty) => panic!("phantom fields should never have setters"),
+        }
+    }
+}
+
 #[cfg(test)]
 mod tests {
     #[allow(unused_imports)]
@@ -117,7 +148,11 @@ mod tests {
     #[test]
     fn setter_disabled() {
         let mut field = default_builder_field!();
-        field.field_enabled = false;
+        field.field_visibility = Cow::Owned(syn::Visibility::Inherited);
+        field.field_type = match field.field_type {
+            BuilderFieldType::Optional(ty) => BuilderFieldType::Phantom(ty),
+            _ => panic!(),
+        };
 
         assert_eq!(
             quote!(#field).to_string(),

derive_builder_core/src/default_expression.rs

@@ -1,5 +1,3 @@
-use std::convert::TryFrom;
-
 use crate::BlockContents;
 use quote::{ToTokens, TokenStreamExt};
 
@@ -23,16 +21,7 @@ impl darling::FromMeta for DefaultExpression {
     }
 
     fn from_value(value: &syn::Lit) -> darling::Result<Self> {
-        if let syn::Lit::Str(s) = value {
-            let contents = BlockContents::try_from(s)?;
-            if contents.is_empty() {
-                Err(darling::Error::unknown_value("").with_span(s))
-            } else {
-                Ok(Self::Explicit(contents))
-            }
-        } else {
-            Err(darling::Error::unexpected_lit_type(value))
-        }
+        Ok(Self::Explicit(BlockContents::from_value(value)?))
     }
 }