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

Author: pengowen123

src/error_chain.rs

@@ -78,13 +78,13 @@ macro_rules! 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

@@ -502,6 +502,7 @@ use std::iter::Iterator;
 #[cfg(feature = "backtrace")]
 use std::sync::Arc;
 use std::fmt;
+use std::marker::PhantomData;
 
 #[cfg(feature = "backtrace")]
 pub use backtrace::Backtrace;
@@ -558,7 +559,7 @@ 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 {
+pub trait ChainedError<S: ?Sized>: error::Error + Send + 'static {
     /// Associated kind type.
     type ErrorKind;
 
@@ -585,7 +586,7 @@ 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.
@@ -595,7 +596,7 @@ pub trait ChainedError: error::Error + Send + 'static {
 
     /// 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`.
@@ -607,10 +608,17 @@ pub trait ChainedError: error::Error + Send + 'static {
 
 /// A struct which formats an error for output.
 #[derive(Debug)]
+<<<<<<< HEAD
 pub struct DisplayChain<'a, T: 'a + ?Sized>(&'a T);
 
 impl<'a, T> fmt::Display for DisplayChain<'a, T>
     where T: ChainedError
+=======
+pub struct Display<'a, T: 'a + ?Sized, S: ?Sized>(&'a T, PhantomData<S>);
+
+impl<'a, T, S> fmt::Display for Display<'a, T, S>
+    where T: ChainedError<S>
+>>>>>>> Add generic parameter to some types (errors can now add trait bounds)
 {
     fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
         // Keep `try!` for 1.10 support
@@ -631,33 +639,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.
     #[cfg(feature = "backtrace")]
     pub backtrace: Option<Arc<Backtrace>>,
 }
 
-impl Default for State {
+impl<T> Default for State<T> {
     #[cfg(feature = "backtrace")]
-    fn default() -> State {
+    fn default() -> Self {
         State {
             next_error: None,
             backtrace: make_backtrace(),
         }
     }
 
     #[cfg(not(feature = "backtrace"))]
-    fn default() -> State {
+    fn default() -> Self {
         State { next_error: None }
     }
 }
 
-impl State {
+impl<T> State<T>
+    where T: error::Error + Send + 'static
+{
     /// Creates a new State type
     #[cfg(feature = "backtrace")]
-    pub fn new<CE: ChainedError>(e: Box<error::Error + Send>) -> State {
+    pub fn new<CE: ChainedError<T>>(e: Box<T>) -> Self {
         let backtrace = CE::extract_backtrace(&*e).or_else(make_backtrace);
         State {
             next_error: Some(e),
@@ -667,7 +677,7 @@ impl State {
 
     /// Creates a new State type
     #[cfg(not(feature = "backtrace"))]
-    pub fn new<CE: ChainedError>(e: Box<error::Error + Send>) -> State {
+    pub fn new<CE: ChainedError>(e: Box<error::Error + Send>) -> Self {
         State { next_error: Some(e) }
     }