Change derive block to take the derive macro name and path to the trait

Author: pengowen123

src/error_chain.rs

@@ -56,10 +56,10 @@ macro_rules! impl_error_chain_processed {
         }
 
         derive {
-            $($bound:ident),*
+            $($derive:ident, $bound:path);*
         }
     ) => {
-        create_super_trait!(Trait: ::std::fmt::Debug, ::std::error::Error, Send $(, $bound)*);
+        create_super_trait!(Trait: ::std::fmt::Debug, ::std::error::Error, $crate::ToError , Send $(, $bound)*);
 
         /// The Error type.
         ///
@@ -70,7 +70,7 @@ macro_rules! impl_error_chain_processed {
         ///   internals, containing:
         ///   - a backtrace, generated when the error is created.
         ///   - an error chain, used for the implementation of `Error::cause()`.
-        #[derive(Debug, $($bound),*)]
+        #[derive(Debug, $($derive),*)]
         pub struct $error_name(
             // The members must be `pub` for `links`.
             /// The kind of the error.
@@ -80,6 +80,12 @@ macro_rules! impl_error_chain_processed {
             pub $crate::State<Trait>,
         );
 
+        impl $crate::ToError for $error_name {
+            fn to_error(&self) -> &(::std::error::Error + Send + 'static) {
+                self
+            }
+        }
+
         impl $crate::ChainedError<Trait> for $error_name {
             type ErrorKind = $error_kind_name;
 
@@ -93,7 +99,7 @@ macro_rules! impl_error_chain_processed {
 
             fn with_chain<E, K>(error: E, kind: K)
                 -> Self
-                where E: ::std::error::Error + Send + 'static,
+                where E: $crate::ToError + ::std::error::Error + Send + 'static,
                       K: Into<Self::ErrorKind>
             {
                 Self::with_chain(error, kind)
@@ -135,7 +141,7 @@ macro_rules! impl_error_chain_processed {
             /// Constructs a chained error from another error and a kind, and generates a backtrace.
             pub fn with_chain<E, K>(error: E, kind: K)
                 -> $error_name
-                where E: ::std::error::Error + Send + 'static,
+                where E: Trait + 'static,
                       K: Into<$error_kind_name>
             {
                 $error_name::with_boxed_chain(Box::new(error), kind)
@@ -188,7 +194,7 @@ macro_rules! impl_error_chain_processed {
             #[allow(unknown_lints, unused_doc_comment)]
             fn cause(&self) -> Option<&::std::error::Error> {
                 match self.1.next_error {
-                    Some(ref c) => Some(&**c),
+                    Some(ref c) => Some(c.to_error()),
                     None => {
                         match self.0 {
                             $(
@@ -257,7 +263,7 @@ macro_rules! impl_error_chain_processed {
 
         impl_error_chain_kind! {
             /// The kind of an error.
-            #[derive(Debug, $($bound),*)]
+            #[derive(Debug, $($derive),*)]
             pub enum $error_kind_name {
 
                 /// A convenient variant for String.
@@ -326,12 +332,14 @@ macro_rules! impl_error_chain_processed {
                       EK: Into<$error_kind_name>;
         }
 
-        impl<T, E> $result_ext_name<T> for ::std::result::Result<T, E> where E: ::std::error::Error + Send + 'static {
+        impl<T, E> $result_ext_name<T, E> for ::std::result::Result<T, E>
+            where E: Trait + 'static
+        {
             fn chain_err<F, EK>(self, callback: F) -> ::std::result::Result<T, $error_name>
                 where F: FnOnce() -> EK,
                       EK: Into<$error_kind_name> {
                 self.map_err(move |e| {
-                    let state = $crate::State::new::<$error_name>(Box::new(e), );
+                    let state = $crate::State::new::<$error_name>(Box::new(e));
                     $crate::ChainedError::new(callback().into(), state)
                 })
             }

src/example_generated.rs

@@ -24,7 +24,7 @@
 pub mod inner {
     error_chain! {
         derive {
-            PartialEq
+            PartialEq, PartialEq<Error>
         }
     }
 }
@@ -34,18 +34,18 @@ error_chain! {
         Inner(inner::Error, inner::ErrorKind) #[doc = "Link to another `ErrorChain`."];
     }
     foreign_links {
-        Io(::std::io::Error) #[doc = "Link to a `std::error::Error` type."];
+        //Io(::std::io::Error) #[doc = "Link to a `std::error::Error` type."];
     }
     errors {
         #[doc = "A custom error kind."]
         Custom
     }
     derive {
-        PartialEq
+        PartialEq, PartialEq<Error>
     }
 }
 
-fn foo<T: PartialEq>() {}
-fn bar() {
-    foo::<Error>();
-}
+//fn foo<T: PartialEq>() {}
+//fn bar() {
+    //foo::<Error>();
+//}

src/lib.rs

@@ -360,7 +360,6 @@
 //! mod utils {
 //!     error_chain! {
 //!         errors {
-//!             BadStuff {
 //!                 description("bad stuff")
 //!             }
 //!         }
@@ -593,10 +592,9 @@ pub trait ChainedError<S: ?Sized>: error::Error + Send + 'static {
 
     /// Constructs a chained error from another error and a kind, and generates a backtrace.
     fn with_chain<E, K>(error: E, kind: K) -> Self
-    where
-        Self: Sized,
-        E: ::std::error::Error + Send + 'static,
-        K: Into<Self::ErrorKind>;
+    where Self: Sized,
+          E: ToError + ::std::error::Error + Send + 'static,
+          K: Into<Self::ErrorKind>;
 
     /// Returns the kind of the error.
     fn kind(&self) -> &Self::ErrorKind;
@@ -630,9 +628,11 @@ pub trait ChainedError<S: ?Sized>: error::Error + Send + 'static {
     /// Returns the first known backtrace, either from its State or from one
     /// of the errors from `foreign_links`.
     #[doc(hidden)]
-    fn extract_backtrace(e: &(error::Error + Send + 'static)) -> Option<InternalBacktrace>
-    where
-        Self: Sized;
+    fn extract_backtrace(e: &(error::Error + Send + 'static)) -> Option<InternalBacktrace>;
+}
+
+pub trait ToError {
+    fn to_error(&self) -> &(error::Error + Send + 'static);
 }
 
 /// A struct which formats an error for output.
@@ -669,7 +669,7 @@ pub struct State<T: ?Sized> {
     pub backtrace: InternalBacktrace,
 }
 
-impl<T> Default for State<T> {
+impl<T: ?Sized> Default for State<T> {
     #[cfg(feature = "backtrace")]
     fn default() -> Self {
         State {