[WIP] Add boxed-error feature.

Fixes #44.

Author: Yamakaky

Cargo.toml

@@ -15,8 +15,9 @@ repository = "https://github.com/brson/error-chain"
 license = "MIT/Apache-2.0"
 
 [features]
-default = ["backtrace", "example_generated"]
-example_generated = []
+default = ["backtrace", "example-generated"]
+example-generated = []
+boxed-error = []
 
 [dependencies]
 backtrace = { version = "0.3", optional = true }

src/error_chain.rs

@@ -26,8 +26,7 @@ macro_rules! error_chain_processed {
             }
             $( $rest )*
         }
-        /// Convenient wrapper around `std::Result`.
-        pub type $result_name<T> = ::std::result::Result<T, $error_name>;
+        result_wrapper!($result_name, $error_name);
     };
     // Without `Result` wrapper.
     (
@@ -70,14 +69,9 @@ macro_rules! error_chain_processed {
 
         impl $crate::ChainedError for $error_name {
             type ErrorKind = $error_kind_name;
+            maybe_boxed_error!();
 
-            fn new(kind: $error_kind_name, state: $crate::State) -> $error_name {
-                $error_name {
-                    kind: kind,
-                    state: state,
-                }
-            }
-
+            impl_chained_error_new!($error_name, $error_kind_name);
             impl_extract_backtrace!($error_name
                                     $error_kind_name
                                     $([$link_error_path, $(#[$meta_links])*])*);
@@ -148,6 +142,15 @@ macro_rules! error_chain_processed {
                     }
                 }
             }
+            $(#[$meta_links])*
+            impl From<$link_error_path> for Box<$error_name> {
+                fn from(e: $link_error_path) -> Self {
+                    Box::new($error_name {
+                        kind: $error_kind_name::$link_variant(e.kind),
+                        state: e.state,
+                    })
+                }
+            }
         ) *
 
         $(
@@ -159,6 +162,14 @@ macro_rules! error_chain_processed {
                     )
                 }
             }
+            $(#[$meta_foreign_links])*
+            impl From<$foreign_link_error_path> for Box<$error_name> {
+                fn from(e: $foreign_link_error_path) -> Self {
+                    Box::new($error_name::from_kind(
+                        $error_kind_name::$foreign_link_variant(e)
+                    ))
+                }
+            }
         ) *
 
         impl From<$error_kind_name> for $error_name {
@@ -360,3 +371,69 @@ macro_rules! impl_extract_backtrace {
      $error_kind_name: ident
      $([$link_error_path: path, $(#[$meta_links: meta])*])*) => {}
 }
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(feature = "boxed-error")]
+macro_rules! result_wrapper {
+    ($result_name: ident, $error_name: ident) => {
+        /// Convenient wrapper around `std::Result`.
+        pub type $result_name<T> = ::std::result::Result<T, Box<$error_name>>;
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(not(feature = "boxed-error"))]
+macro_rules! result_wrapper {
+    ($result_name: ident, $error_name: ident) => {
+        /// Convenient wrapper around `std::Result`.
+        pub type $result_name<T> = ::std::result::Result<T, $error_name>;
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(feature = "boxed-error")]
+macro_rules! maybe_boxed_error {
+    () => {
+        type Error = Box<Self>;
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(not(feature = "boxed-error"))]
+macro_rules! maybe_boxed_error {
+    () => {
+        type Error = Self;
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(feature = "boxed-error")]
+macro_rules! impl_chained_error_new {
+    ($error_name: ident, $error_kind_name: ident) => {
+        fn new(kind: $error_kind_name, state: $crate::State) -> Box<$error_name> {
+            Box::new($error_name {
+                kind: kind,
+                state: state,
+            })
+        }
+    }
+}
+
+#[macro_export]
+#[doc(hidden)]
+#[cfg(not(feature = "boxed-error"))]
+macro_rules! impl_chained_error_new {
+    ($error_name: ident, $error_kind_name: ident) => {
+        fn new(kind: $error_kind_name, state: $crate::State) -> $error_name {
+            $error_name {
+                kind: kind,
+                state: state,
+            }
+        }
+    }
+}

src/lib.rs

@@ -269,7 +269,7 @@ pub type Backtrace = ();
 mod quick_error;
 #[macro_use]
 mod error_chain;
-#[cfg(feature = "example_generated")]
+#[cfg(feature = "example-generated")]
 pub mod example_generated;
 
 /// Iterator over the error chain using the `Error::cause()` method.
@@ -304,12 +304,15 @@ pub fn make_backtrace() -> Option<Arc<Backtrace>> {
 /// This trait is implemented on all the errors generated by the `error_chain`
 /// macro.
 pub trait ChainedError: error::Error + Send + 'static {
+    /// Type used as the second type parameter of `Result`.
+    type Error;
+
     /// Associated kind type.
     type ErrorKind;
 
     /// Creates an error from it's parts.
     #[doc(hidden)]
-    fn new(kind: Self::ErrorKind, state: State) -> Self;
+    fn new(kind: Self::ErrorKind, state: State) -> Self::Error;
 
     /// Returns the first known backtrace, either from it's State or from one
     /// of the errors from `foreign_links`.
@@ -320,18 +323,18 @@ pub trait ChainedError: error::Error + Send + 'static {
 }
 
 /// Additionnal methods for `Result`, for easy interaction with this crate.
-pub trait ResultExt<T, E, CE: ChainedError> {
+pub trait ResultExt<T, E> {
     /// If the `Result` is an `Err` then `chain_err` evaluates the closure,
     /// which returns *some type that can be converted to `ErrorKind`*, boxes
     /// the original error to store as the cause, then returns a new error
     /// containing the original error.
-    fn chain_err<F, EK>(self, callback: F) -> Result<T, CE>
+    fn chain_err<F, EK, CE: ChainedError>(self, callback: F) -> Result<T, CE::Error>
         where F: FnOnce() -> EK,
         EK: Into<CE::ErrorKind>;
 }
 
-impl<T, E, CE> ResultExt<T, E, CE> for Result<T, E> where CE: ChainedError, E: error::Error + Send + 'static {
-    fn chain_err<F, EK>(self, callback: F) -> Result<T, CE>
+impl<T, E> ResultExt<T, E> for Result<T, E> where E: error::Error + Send + 'static {
+    fn chain_err<F, EK, CE: ChainedError>(self, callback: F) -> Result<T, CE::Error>
         where F: FnOnce() -> EK,
         EK: Into<CE::ErrorKind> {
         self.map_err(move |e| {