Add try_setter option and generate appropriate methods

derive_builder/Cargo.toml

@@ -25,6 +25,7 @@ proc-macro = true
 logging = [ "log", "env_logger", "derive_builder_core/logging" ]
 struct_default = []
 skeptic_tests = ["skeptic"]
+try_setter = []
 
 [dependencies]
 syn = "0.11"

derive_builder/src/options/field_mode.rs

@@ -81,6 +81,7 @@ impl OptionsBuilder<FieldMode> {
             setter_vis: f!(setter_vis),
             default_expression: f!(default_expression),
             setter_into: f!(setter_into),
+            try_setter_enabled: f!(try_setter_enabled),
             no_std: f!(no_std),
             mode: mode,
         }
@@ -133,6 +134,7 @@ impl From<OptionsBuilder<FieldMode>> for FieldOptions {
             field_ident: field_ident,
             field_type: field_type,
             setter_into: b.setter_into.unwrap_or(false),
+            try_setter_enabled: b.try_setter_enabled.unwrap_or(false),
             deprecation_notes: b.mode.deprecation_notes.clone(),
             default_expression: b.default_expression.clone(),
             use_default_struct: b.mode.use_default_struct,

derive_builder/src/options/field_options.rs

@@ -31,6 +31,8 @@ pub struct FieldOptions {
     pub attrs: Vec<syn::Attribute>,
     /// Bindings to libstd or libcore.
     pub bindings: Bindings,
+    /// Enables code generation for the TryInto setter.
+    pub try_setter_enabled: bool,
 }
 
 impl DefaultExpression {
@@ -58,6 +60,7 @@ impl FieldOptions {
     pub fn as_setter<'a>(&'a self) -> Setter<'a> {
         Setter {
             enabled: self.setter_enabled,
+            try_enabled: cfg!(feature = "try_setter") && self.try_setter_enabled,
             visibility: &self.setter_visibility,
             pattern: self.builder_pattern,
             attrs: &self.attrs,

derive_builder/src/options/mod.rs

@@ -45,6 +45,7 @@ pub struct OptionsBuilder<Mode> {
     setter_vis: Option<syn::Visibility>,
     default_expression: Option<DefaultExpression>,
     setter_into: Option<bool>,
+    try_setter_enabled: Option<bool>,
     no_std: Option<bool>,
     mode: Mode,
 }
@@ -66,6 +67,7 @@ impl<Mode> From<Mode> for OptionsBuilder<Mode> {
             setter_prefix: None,
             setter_name: None,
             setter_vis: None,
+            try_setter_enabled: None,
             default_expression: None,
             setter_into: None,
             no_std: None,
@@ -100,6 +102,12 @@ impl<Mode> OptionsBuilder<Mode> where
         desc: "setter type conversion",
         map: |x: bool| { x },
     }
+
+    impl_setter!{
+        ident: try_setter_enabled,
+        desc: "try_setter activation",
+        map: |x: bool| { x },
+    }
 
     impl_setter!{
         ident: default_expression,
@@ -198,6 +206,9 @@ impl<Mode> OptionsBuilder<Mode> where
                 // setter implicitly enabled
                 self.setter_enabled(true)
             },
+            "try_setter" => {
+                self.try_setter_enabled(true)
+            }
             "default" => {
                 if !cfg!(feature = "struct_default") && self.mode.struct_mode() {
                     let where_info = self.where_diagnostics();

derive_builder/src/options/struct_mode.rs

@@ -78,6 +78,7 @@ impl From<OptionsBuilder<StructMode>> for (StructOptions, OptionsBuilder<FieldMo
             setter_prefix: b.setter_prefix,
             setter_vis: b.setter_vis,
             setter_into: b.setter_into,
+            try_setter_enabled: b.try_setter_enabled,
             default_expression: field_default_expression,
             no_std: b.no_std,
             mode: {

derive_builder/tests/try_setter.rs

@@ -0,0 +1,79 @@
+#![cfg_attr(feature = "try_setter", feature(try_from))]
+
+#[macro_use]
+extern crate derive_builder;
+
+#[allow(unused_imports)]
+mod struct_level {
+    #[cfg(feature = "try_setter")]
+    use std::convert::TryFrom;
+
+    use std::net::{IpAddr, AddrParseError};
+    use std::str::FromStr;
+    use std::string::ToString;
+
+    #[derive(Debug, Clone, PartialEq)]
+    pub struct MyAddr(IpAddr);
+
+    impl From<IpAddr> for MyAddr {
+        fn from(v: IpAddr) -> Self {
+            MyAddr(v)
+        }
+    }
+
+    #[cfg(feature = "try_setter")]
+    impl<'a> TryFrom<&'a str> for MyAddr {
+        type Err = AddrParseError;
+
+        fn try_from(v: &str) -> Result<Self, Self::Err> {
+            Ok(MyAddr(v.parse()?))
+        }
+    }
+
+    #[derive(Debug, PartialEq, Builder)]
+    #[builder(try_setter, setter(into))]
+    struct Lorem {
+        pub source: MyAddr,
+        pub dest: MyAddr,
+    }
+
+    #[test]
+    fn infallible_set() {
+        let _ = LoremBuilder::default().source(IpAddr::from_str("1.2.3.4").unwrap()).build();
+    }
+
+    #[test]
+    #[cfg(feature = "try_setter")]
+    fn fallible_set() {
+        let mut builder = LoremBuilder::default();
+        let try_result = builder.try_source("1.2.3.4");
+        let built = try_result.expect("Passed well-formed address")
+            .dest(IpAddr::from_str("0.0.0.0").unwrap())
+            .build()
+            .unwrap();
+        assert_eq!(built, exact_helper().unwrap());
+    }
+
+    // Allow dead code here since the test that uses this depends on the try_setter feature.
+    #[cfg_attr(not(feature = "try_setter"), allow(dead_code))]
+    fn exact_helper() -> Result<Lorem, String> {
+        LoremBuilder::default()
+            .source(IpAddr::from_str("1.2.3.4").unwrap())
+            .dest(IpAddr::from_str("0.0.0.0").unwrap())
+            .build()
+    }
+
+    #[cfg(feature = "try_setter")]
+    fn try_helper() -> Result<Lorem, String> {
+        LoremBuilder::default()
+            .try_source("1.2.3.4").map_err(|e| e.to_string())?
+            .try_dest("0.0.0.0").map_err(|e| e.to_string())?
+            .build()
+    }
+
+    #[test]
+    #[cfg(feature = "try_setter")]
+    fn with_helper() {
+        assert_eq!(exact_helper().unwrap(), try_helper().unwrap());
+    }
+}

derive_builder_core/src/bindings.rs

@@ -70,6 +70,15 @@ impl Bindings {
             ":: std :: convert :: Into"
         })
     }
+
+    /// TryInto trait.
+    pub fn try_into_trait(&self) -> RawTokens<&'static str> {
+        RawTokens(if self.no_std {
+            ":: core :: convert :: TryInto"
+        } else {
+            ":: std :: convert :: TryInto"
+        })
+    }
 }
 
 #[test]

derive_builder_core/src/setter.rs

@@ -34,6 +34,8 @@ use Bindings;
 pub struct Setter<'a> {
     /// Enables code generation for this setter fn.
     pub enabled: bool,
+    /// Enables code generation for the `try_` variant of this setter fn.
+    pub try_enabled: bool,
     /// Visibility of the setter, e.g. `syn::Visibility::Public`.
     pub visibility: &'a syn::Visibility,
     /// How the setter method takes and returns `self` (e.g. mutably).
@@ -58,7 +60,7 @@ pub struct Setter<'a> {
 
 impl<'a> ToTokens for Setter<'a> {
     fn to_tokens(&self, tokens: &mut Tokens) {
-        if self.enabled {
+        if self.enabled || self.try_enabled {
             trace!("Deriving setter for `{}`.", self.field_ident);
             let ty = self.field_type;
             let pattern = self.pattern;
@@ -117,6 +119,27 @@ impl<'a> ToTokens for Setter<'a> {
                     new.#field_ident = #option::Some(#into_value);
                     new
             }));
+
+            if self.try_enabled {
+                let try_into = self.bindings.try_into_trait();
+                let try_ty_params = quote!(<VALUE: #try_into<#ty>>);
+                let try_ident = syn::Ident::new(format!("try_{}", ident));
+                let result = self.bindings.result_ty();
+
+                tokens.append(quote!(
+                    #(#attrs)*
+                    #vis fn #try_ident #try_ty_params (#self_param, value: VALUE)
+                        -> #result<#return_ty, VALUE::Err>
+                    {
+                        #deprecation_notes
+                        let value : #ty = value.try_into()?;
+                        let mut new = #self_into_return_ty;
+                        new.#field_ident = #option::Some(value);
+                        Ok(new)
+                }));
+            } else {
+                trace!("Skipping try_setter for `{}`.", self.field_ident);
+            }
         } else {
             trace!("Skipping setter for `{}`.", self.field_ident);
         }
@@ -131,6 +154,7 @@ macro_rules! default_setter {
     () => {
         Setter {
             enabled: true,
+            try_enabled: false,
             visibility: &syn::Visibility::Public,
             pattern: BuilderPattern::Mutable,
             attrs: &vec![],