Structural error

derive_builder/build/skeptic.rs

@@ -62,7 +62,7 @@ use std::io::{Write, Read};
 const DOC_TPL_DIR: &'static str = "src/doc_tpl/";
 const DOC_TPL_OUT_DIR: &'static str = "doc_tpl/";
 
-fn generate_doc_tpl_tests() -> Result<Vec<String>, Box<Error>> {
+fn generate_doc_tpl_tests() -> Result<Vec<String>, Box<dyn Error>> {
     trace!("Generating doc template tests");
     let root_dir = PathBuf::from(env::var("CARGO_MANIFEST_DIR")?);
     let mut tpl_dir = root_dir;

derive_builder/examples/validation.rs

@@ -30,5 +30,5 @@ fn main() {
     let x = LoremBuilder::default().ipsum(120).build().unwrap_err();
 
     // .. the build will fail:
-    assert_eq!(&x, "You'll tire yourself out");
+    assert_eq!(&x.to_string(), "You'll tire yourself out");
 }

derive_builder/src/lib.rs

@@ -63,7 +63,8 @@
 //!
 //! You can easily opt into different patterns and control many other aspects.
 //!
-//! The build method returns `Result<T, String>`, where `T` is the struct you started with.
+//! The build method returns `Result<T, E>`, where `T` is the struct you started with
+//! and E is a generated builder error type.
 //! It returns `Err` if you didn't initialize all fields and no default values were
 //! provided.
 //!
@@ -74,7 +75,7 @@
 //! ```rust
 //! # #[macro_use] extern crate derive_builder;
 //! # #[derive(Builder)] struct Lorem { ipsum: u32 }
-//! # fn try_main() -> Result<(), String> {
+//! # fn try_main() -> Result<(), Box<dyn std::error::Error>> {
 //! let x: Lorem = LoremBuilder::default().ipsum(42).build()?;
 //! # Ok(())
 //! # } fn main() { try_main().unwrap(); }
@@ -87,7 +88,7 @@
 //! ```rust
 //! # #[macro_use] extern crate derive_builder;
 //! # #[derive(Builder)] struct Lorem { ipsum: u32 }
-//! # fn try_main() -> Result<(), String> {
+//! # fn try_main() -> Result<(), Box<dyn std::error::Error>> {
 //! # let geek = true;
 //! let mut builder = LoremBuilder::default();
 //! if geek {
@@ -439,7 +440,7 @@
 //!     let x = LoremBuilder::default().ipsum(120).build().unwrap_err();
 //!
 //!     // .. the build will fail:
-//!     assert_eq!(&x, "You'll tire yourself out");
+//!     assert_eq!(&x.to_string(), "You'll tire yourself out");
 //! }
 //! ```
 //!

derive_builder/src/options/darling_opts.rs

@@ -319,6 +319,14 @@ impl Options {
             .expect("Struct name with Builder suffix should be an ident")
     }
 
+    pub fn builder_error_ident(&self) -> Ident {
+        if let Some(ref custom) = self.name {
+            format_ident!("{}Error", custom)
+        } else {
+            format_ident!("{}BuilderError", self.ident)
+        }
+    }
+
     /// The visibility of the builder struct.
     /// If a visibility was declared in attributes, that will be used;
     /// otherwise the struct's own visibility will be used.
@@ -393,6 +401,7 @@ impl Options {
             pattern: self.pattern,
             target_ty: &self.ident,
             target_ty_generics: Some(ty_generics),
+            error_ty: self.builder_error_ident(),
             initializers: Vec::with_capacity(self.field_count()),
             doc_comment: None,
             bindings: self.bindings(),

derive_builder/tests/builder_name.rs

@@ -13,9 +13,9 @@ struct Lorem {
 }
 
 #[test]
-#[should_panic(expected = "`ipsum` must be initialized")]
-fn panic_if_uninitialized() {
-    MyBuilder::default().build().unwrap();
+fn error_if_uninitialized() {
+    let error = MyBuilder::default().build().unwrap_err();
+    assert_eq!(&error.to_string(), "`ipsum` must be initialized");
 }
 
 #[test]

derive_builder/tests/custom_default.rs

@@ -24,9 +24,9 @@ mod field_level {
     }
 
     #[test]
-    #[should_panic(expected = "`required` must be initialized")]
-    fn panic_if_uninitialized() {
-        LoremBuilder::default().build().unwrap();
+    fn error_if_uninitialized() {
+        let error = LoremBuilder::default().build().unwrap_err();
+        assert_eq!(&error.to_string(), "`required` must be initialized");
     }
 
     #[test]

derive_builder/tests/generic_structs.rs

@@ -24,9 +24,9 @@ where
 }
 
 #[test]
-#[should_panic(expected = "`ipsum` must be initialized")]
-fn panic_if_uninitialized() {
-    GenericBuilder::<String>::default().build().unwrap();
+fn error_if_uninitialized() {
+    let error = GenericBuilder::<String>::default().build().unwrap_err();
+    assert_eq!(&error.to_string(), "`ipsum` must be initialized");
 }
 
 #[test]

derive_builder/tests/lifetime.rs

@@ -9,9 +9,9 @@ struct Lorem<'a> {
 }
 
 #[test]
-#[should_panic(expected = "`ipsum` must be initialized")]
-fn panic_if_uninitialized() {
-    LoremBuilder::default().build().unwrap();
+fn error_if_uninitialized() {
+    let error = LoremBuilder::default().build().unwrap_err();
+    assert_eq!(&error.to_string(), "`ipsum` must be initialized");
 }
 
 #[test]

derive_builder/tests/run-pass/custom_types.rs

@@ -3,12 +3,26 @@
 #[macro_use]
 extern crate derive_builder;
 
-type Clone = ();
-type Into = ();
-type Option = ();
-type Result = ();
-type Some = ();
-type String = ();
+struct Unit;
+
+type Clone = Unit;
+type Into = Unit;
+type Option = Unit;
+type Result = Unit;
+type Some = Unit;
+type String = Unit;
+
+impl core::fmt::Debug for Unit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "()")
+    }
+}
+
+impl core::fmt::Display for Unit {
+    fn fmt(&self, f: &mut core::fmt::Formatter) -> core::fmt::Result {
+        write!(f, "()")
+    }
+}
 
 #[derive(Builder)]
 struct IgnoreEmptyStruct {}

derive_builder/tests/setter_visibility.rs

@@ -53,12 +53,11 @@ pub mod foo {
 }
 
 #[test]
-#[should_panic(expected = "`private` must be initialized")]
 fn public_setters_foreign_module() {
-    let y = foo::IpsumBuilder::default()
+    let error = foo::IpsumBuilder::default()
         .public("Hello")
         .build()
-        .unwrap();
+        .unwrap_err();
 
-    assert_eq!(y.public, "Hello".to_string());
+    assert_eq!(&error.to_string(), "`private` must be initialized");
 }

derive_builder/tests/try_setter.rs

@@ -36,14 +36,14 @@ struct Ipsum {
     pub source: MyAddr,
 }
 
-fn exact_helper() -> Result<Lorem, String> {
+fn exact_helper() -> Result<Lorem, LoremBuilderError> {
     LoremBuilder::default()
         .source(IpAddr::from_str("1.2.3.4").unwrap())
         .dest(IpAddr::from_str("0.0.0.0").unwrap())
         .build()
 }
 
-fn try_helper() -> Result<Lorem, String> {
+fn try_helper() -> Result<Lorem, LoremBuilderError> {
     LoremBuilder::default()
         .try_source("1.2.3.4")
         .map_err(|e| e.to_string())?

derive_builder/tests/validation.rs

@@ -43,14 +43,19 @@ impl LoremBuilder {
 #[test]
 fn out_of_bounds() {
     assert_eq!(
-        &LoremBuilder::default().my_effort(120).build().unwrap_err(),
+        &LoremBuilder::default()
+            .my_effort(120)
+            .build()
+            .unwrap_err()
+            .to_string(),
         "Don't wear yourself out"
     );
     assert_eq!(
         &LoremBuilder::default()
             .rivals_effort(120)
             .build()
-            .unwrap_err(),
+            .unwrap_err()
+            .to_string(),
         "Your rival is cheating"
     );
 }

derive_builder_core/src/build_method.rs

@@ -27,7 +27,7 @@ use DEFAULT_STRUCT_NAME;
 /// #    let build_method = default_build_method!();
 /// #
 /// #    assert_eq!(quote!(#build_method).to_string(), quote!(
-/// pub fn build(&self) -> ::std::result::Result<Foo, ::std::string::String> {
+/// pub fn build(&self) -> ::std::result::Result<Foo, FooBuilderError> {
 ///     Ok(Foo {
 ///         foo: self.foo,
 ///     })
@@ -51,6 +51,8 @@ pub struct BuildMethod<'a> {
     pub target_ty: &'a syn::Ident,
     /// Type parameters and lifetimes attached to this builder struct.
     pub target_ty_generics: Option<syn::TypeGenerics<'a>>,
+    /// Type of error.
+    pub error_ty: syn::Ident,
     /// Field initializers for the target type.
     pub initializers: Vec<TokenStream>,
     /// Doc-comment of the builder struct.
@@ -84,14 +86,14 @@ impl<'a> ToTokens for BuildMethod<'a> {
         });
         let validate_fn = self.validate_fn.as_ref().map(|vfn| quote!(#vfn(&self)?;));
         let result = self.bindings.result_ty();
-        let string = self.bindings.string_ty();
+        let error_ty = &self.error_ty;
 
         if self.enabled {
             trace!("Deriving build method `{}`.", self.ident);
             tokens.append_all(quote!(
                 #doc_comment
                 #vis fn #ident(#self_param)
-                    -> #result<#target_ty #target_ty_generics, #string>
+                    -> #result<#target_ty #target_ty_generics, #error_ty>
                 {
                     #validate_fn
                     #default_struct
@@ -137,6 +139,7 @@ macro_rules! default_build_method {
             pattern: BuilderPattern::Mutable,
             target_ty: &syn::Ident::new("Foo", ::proc_macro2::Span::call_site()),
             target_ty_generics: None,
+            error_ty: syn::Ident::new("FooBuilderError", ::proc_macro2::Span::call_site()),
             initializers: vec![quote!(foo: self.foo,)],
             doc_comment: None,
             bindings: Default::default(),
@@ -159,7 +162,7 @@ mod tests {
         assert_eq!(
             quote!(#build_method).to_string(),
             quote!(
-                pub fn build(&self) -> ::std::result::Result<Foo, ::std::string::String> {
+                pub fn build(&self) -> ::std::result::Result<Foo, FooBuilderError> {
                     Ok(Foo {
                         foo: self.foo,
                     })
@@ -178,7 +181,7 @@ mod tests {
         assert_eq!(
             quote!(#build_method).to_string(),
             quote!(
-                pub fn build(&self) -> ::core::result::Result<Foo, ::alloc::string::String> {
+                pub fn build(&self) -> ::core::result::Result<Foo, FooBuilderError> {
                     Ok(Foo {
                         foo: self.foo,
                     })
@@ -197,7 +200,7 @@ mod tests {
         assert_eq!(
             quote!(#build_method).to_string(),
             quote!(
-                pub fn build(&self) -> ::std::result::Result<Foo, ::std::string::String> {
+                pub fn build(&self) -> ::std::result::Result<Foo, FooBuilderError> {
                     let __default: Foo = { Default::default() };
                     Ok(Foo {
                         foo: self.foo,
@@ -227,7 +230,7 @@ mod tests {
         assert_eq!(
             quote!(#build_method).to_string(),
             quote!(
-                pub fn finish(&self) -> ::std::result::Result<Foo, ::std::string::String> {
+                pub fn finish(&self) -> ::std::result::Result<Foo, FooBuilderError> {
                     Ok(Foo {
                         foo: self.foo,
                     })
@@ -249,7 +252,7 @@ mod tests {
         assert_eq!(
             quote!(#build_method).to_string(),
             quote!(
-                pub fn build(&self) -> ::std::result::Result<Foo, ::std::string::String> {
+                pub fn build(&self) -> ::std::result::Result<Foo, FooBuilderError> {
                     IpsumBuilder::validate(&self)?;
 
                     Ok(Foo {