Add generic parameter to some types (errors can now add trait bounds)

Author: pengowen123

src/backtrace.rs

@@ -43,7 +43,7 @@ mod imp {
                     };
                     ENABLED.store(enabled as usize + 1, Ordering::SeqCst);
                     if !enabled {
-                        return InternalBacktrace { backtrace: None }
+                        return InternalBacktrace { backtrace: None };
                     }
                 }
                 1 => return InternalBacktrace { backtrace: None },

src/error_chain.rs

@@ -80,13 +80,13 @@ macro_rules! impl_error_chain_processed {
             pub $error_kind_name,
             /// Contains the error chain and the backtrace.
             #[doc(hidden)]
-            pub $crate::State,
+            pub $crate::State<Trait>,
         );
 
-        impl $crate::ChainedError for $error_name {
+        impl $crate::ChainedError<Trait> for $error_name {
             type ErrorKind = $error_kind_name;
 
-            fn new(kind: $error_kind_name, state: $crate::State) -> $error_name {
+            fn new(kind: $error_kind_name, state: $crate::State<Trait>) -> $error_name {
                 $error_name(kind, state)
             }
 

src/example_generated.rs

@@ -20,10 +20,11 @@
 //! arise frequently.
 
 /// Another code generated by the macro.
+
 pub mod inner {
     error_chain! {
         derive {
-            PartialEq, Eq
+            PartialEq
         }
     }
 }
@@ -40,11 +41,11 @@ error_chain! {
         Custom
     }
     derive {
-        PartialEq, Eq
+        PartialEq
     }
 }
 
-fn foo<T: PartialEq + Eq>() {}
+fn foo<T: PartialEq>() {}
 fn bar() {
     foo::<Error>();
 }

src/lib.rs

@@ -539,6 +539,7 @@
 use std::error;
 use std::iter::Iterator;
 use std::fmt;
+use std::marker::PhantomData;
 
 #[macro_use]
 mod impl_error_chain_kind;
@@ -581,18 +582,21 @@ impl<'a> Iterator for Iter<'a> {
 
 /// This trait is implemented on all the errors generated by the `error_chain`
 /// macro.
-pub trait ChainedError: error::Error + Send + 'static {
+pub trait ChainedError<S: ?Sized>: error::Error + Send + 'static {
     /// Associated kind type.
     type ErrorKind;
 
     /// Constructs an error from a kind, and generates a backtrace.
-    fn from_kind(kind: Self::ErrorKind) -> Self where Self: Sized;
+    fn from_kind(kind: Self::ErrorKind) -> Self
+    where
+        Self: Sized;
 
     /// 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: ::std::error::Error + Send + 'static,
+        K: Into<Self::ErrorKind>;
 
     /// Returns the kind of the error.
     fn kind(&self) -> &Self::ErrorKind;
@@ -608,31 +612,36 @@ pub trait ChainedError: error::Error + Send + 'static {
     ///
     /// The full cause chain and backtrace, if present, will be printed.
     fn display_chain<'a>(&'a self) -> DisplayChain<'a, Self> {
-        DisplayChain(self)
+        DisplayChain(self, PhantomData)
     }
 
     /// Extends the error chain with a new entry.
     fn chain_err<F, EK>(self, error: F) -> Self
-        where F: FnOnce() -> EK,
-              EK: Into<Self::ErrorKind>;
+    where
+        F: FnOnce() -> EK,
+        EK: Into<Self::ErrorKind>;
 
     /// Creates an error from its parts.
     #[doc(hidden)]
-    fn new(kind: Self::ErrorKind, state: State) -> Self where Self: Sized;
+    fn new(kind: Self::ErrorKind, state: State<S>) -> Self
+    where
+        Self: Sized;
 
     /// 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;
+    where
+        Self: Sized;
 }
 
 /// A struct which formats an error for output.
 #[derive(Debug)]
-pub struct DisplayChain<'a, T: 'a + ?Sized>(&'a T);
+pub struct DisplayChain<'a, T: 'a + ?Sized, S: ?Sized>(&'a T, PhantomData<S>);
 
-impl<'a, T> fmt::Display for DisplayChain<'a, T>
-    where T: ChainedError
+impl<'a, T, S> fmt::Display for DisplayChain<'a, T, S>
+where
+    T: ChainedError<S>,
 {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Keep `try!` for 1.10 support
@@ -653,37 +662,35 @@ impl<'a, T> fmt::Display for DisplayChain<'a, T>
 /// Common state between errors.
 #[derive(Debug)]
 #[doc(hidden)]
-pub struct State {
+pub struct State<T: ?Sized> {
     /// Next error in the error chain.
-    pub next_error: Option<Box<error::Error + Send>>,
+    pub next_error: Option<Box<T>>,
     /// Backtrace for the current error.
     pub backtrace: InternalBacktrace,
 }
 
-impl Default for State {
-    fn default() -> State {
+impl<T> Default for State<T> {
+    #[cfg(feature = "backtrace")]
+    fn default() -> Self {
         State {
             next_error: None,
             backtrace: InternalBacktrace::new(),
         }
     }
 }
 
-impl State {
+impl<T> State<T>
+where
+    T: error::Error + Send + 'static,
+{
     /// Creates a new State type
     pub fn new<CE: ChainedError>(e: Box<error::Error + Send>) -> State {
-        let backtrace = CE::extract_backtrace(&*e)
-            .unwrap_or_else(InternalBacktrace::new);
+        let backtrace = CE::extract_backtrace(&*e).unwrap_or_else(InternalBacktrace::new);
         State {
             next_error: Some(e),
             backtrace: backtrace,
         }
     }
-
-    /// Returns the inner backtrace if present.
-    pub fn backtrace(&self) -> Option<&Backtrace> {
-        self.backtrace.as_backtrace()
-    }
 }
 
 /// Exits a function early with an error