Only generate ValidationError when needed

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
+- Only generate a validation error variant when necessary #201
+
 ## [0.10.0] - 2021-03-31
 - Requires Rust 1.40.0 or newer (was 1.37.0) #169
 - Logging feature is removed #177

derive_builder/examples/custom_defaults.rs

@@ -1,7 +1,19 @@
+use derive_builder::UninitializedFieldError;
+
 #[macro_use]
 extern crate derive_builder;
 
+/// Marker function that tells `derive_builder` to emit a `ValidationError` variant.
+///
+/// Without this, `derive_builder` would believe that only uninitialized field errors
+/// are possible in the `build()` method, and there would be a cryptic error message
+/// about a missing conversion from `String`.
+fn phantom_validate<T>(_: T) -> Result<(), String> {
+    Ok(())
+}
+
 #[derive(Builder, PartialEq, Debug)]
+#[builder(build_fn(validate = "phantom_validate"))]
 struct Lorem {
     ipsum: String,
     #[builder(default = "self.default_dolor()?")]
@@ -13,10 +25,10 @@ struct Lorem {
 }
 
 impl LoremBuilder {
-    fn default_dolor(&self) -> Result<String, String> {
+    fn default_dolor(&self) -> Result<String, UninitializedFieldError> {
         self.ipsum
             .clone()
-            .ok_or_else(|| "ipsum must be initialized to build dolor".to_string())
+            .ok_or_else(|| UninitializedFieldError::new("ipsum"))
     }
 
     fn default_sit(&self) -> Result<String, String> {

derive_builder/src/lib.rs

@@ -342,22 +342,26 @@
 //! ```rust
 //! # #[macro_use]
 //! # extern crate derive_builder;
+//! # use derive_builder::UninitializedFieldError;
 //! #
 //! # #[derive(Builder, PartialEq, Debug)]
 //! struct Lorem {
 //!     ipsum: String,
 //!     // Custom defaults can delegate to helper methods
 //!     // and pass errors to the enclosing `build()` method via `?`.
+//!     //
+//!     // When doing this, it is recommended that you use a custom error type
+//!     // unless you are only returning UninitializedFieldError.
 //!     #[builder(default = "self.default_dolor()?")]
 //!     dolor: String,
 //! }
 //!
 //! impl LoremBuilder {
 //!     // Private helper method with access to the builder struct.
-//!     fn default_dolor(&self) -> Result<String, String> {
+//!     fn default_dolor(&self) -> Result<String, UninitializedFieldError> {
 //!         match self.ipsum {
-//!             Some(ref x) if x.chars().count() > 3 => Ok(format!("dolor {}", x)),
-//!             _ => Err("ipsum must at least 3 chars to build dolor".to_string()),
+//!             Some(ref x) => Ok(format!("dolor {}", x)),
+//!             _ => Err(UninitializedFieldError::new("ipsum")),
 //!         }
 //!     }
 //! }

derive_builder/tests/try_setter.rs

@@ -4,7 +4,8 @@ extern crate derive_builder;
 use std::convert::TryFrom;
 use std::net::{AddrParseError, IpAddr};
 use std::str::FromStr;
-use std::string::ToString;
+
+use derive_builder::UninitializedFieldError;
 
 #[derive(Debug, Clone, PartialEq)]
 pub struct MyAddr(IpAddr);
@@ -23,8 +24,29 @@ impl<'a> TryFrom<&'a str> for MyAddr {
     }
 }
 
+#[derive(Debug)]
+enum LoremBuilderError {
+    UninitializedField(&'static str),
+    InvalidValue { field: &'static str, error: String },
+}
+
+impl LoremBuilderError {
+    fn invalid_value(field: &'static str, error: impl std::fmt::Display) -> Self {
+        Self::InvalidValue {
+            field,
+            error: format!("{}", error),
+        }
+    }
+}
+
+impl From<UninitializedFieldError> for LoremBuilderError {
+    fn from(e: UninitializedFieldError) -> Self {
+        Self::UninitializedField(e.field_name())
+    }
+}
+
 #[derive(Debug, PartialEq, Builder)]
-#[builder(try_setter, setter(into))]
+#[builder(try_setter, setter(into), build_fn(error = "LoremBuilderError"))]
 struct Lorem {
     pub source: MyAddr,
     pub dest: MyAddr,
@@ -46,9 +68,9 @@ fn exact_helper() -> Result<Lorem, LoremBuilderError> {
 fn try_helper() -> Result<Lorem, LoremBuilderError> {
     LoremBuilder::default()
         .try_source("1.2.3.4")
-        .map_err(|e| e.to_string())?
+        .map_err(|e| LoremBuilderError::invalid_value("source", e))?
         .try_dest("0.0.0.0")
-        .map_err(|e| e.to_string())?
+        .map_err(|e| LoremBuilderError::invalid_value("dest", e))?
         .build()
 }
 

derive_builder_core/src/block.rs

@@ -67,7 +67,7 @@ mod test {
     use super::*;
 
     #[test]
-    #[should_panic(expected = r#"LexError"#)]
+    #[should_panic]
     fn block_invalid_token_trees() {
         Block::from_str("let x = 2; { x+1").unwrap();
     }