Have serde:🇩🇪:Error require std::error::Error

serde/src/de/mod.rs

@@ -1,5 +1,7 @@
 //! Generic deserialization framework.
 
+use std::error;
+
 pub mod impls;
 pub mod value;
 
@@ -7,7 +9,7 @@ pub mod value;
 
 /// `Error` is a trait that allows a `Deserialize` to generically create a
 /// `Deserializer` error.
-pub trait Error: Sized {
+pub trait Error: Sized + error::Error {
     /// Raised when there is general error when deserializing a type.
     fn syntax(msg: &str) -> Self;
 

serde/src/de/value.rs

@@ -11,6 +11,8 @@ use std::collections::{
     hash_set,
 };
 use std::hash::Hash;
+use std::error;
+use std::fmt;
 use std::vec;
 
 use de;
@@ -41,6 +43,27 @@ impl de::Error for Error {
     fn missing_field(field: &'static str) -> Self { Error::MissingFieldError(field) }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        match *self {
+            Error::SyntaxError => formatter.write_str("SyntaxError"),
+            Error::EndOfStreamError => formatter.write_str("EndOfStreamError"),
+            Error::UnknownFieldError(ref field) => formatter.write_str(format!("Unknown field: {}", field).as_ref()),
+            Error::MissingFieldError(ref field) => formatter.write_str(format!("Missing field: {}", field).as_ref()),
+        }
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 /// This trait converts primitive types into a deserializer.

serde_tests/benches/bench_enum.rs

@@ -1,4 +1,6 @@
 use test::Bencher;
+use std::error;
+use std::fmt;
 use rustc_serialize::{Decoder, Decodable};
 use serde;
 use serde::de::{Deserializer, Deserialize};
@@ -29,6 +31,22 @@ impl serde::de::Error for Error {
     fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////////
 
 mod decoder {

serde_tests/benches/bench_map.rs

@@ -1,4 +1,6 @@
 use std::fmt::Debug;
+use std::fmt;
+use std::error;
 use std::collections::HashMap;
 use test::Bencher;
 
@@ -28,6 +30,21 @@ impl serde::de::Error for Error {
     }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
 //////////////////////////////////////////////////////////////////////////////
 
 mod decoder {

serde_tests/benches/bench_struct.rs

@@ -1,5 +1,7 @@
 use std::collections::HashMap;
 use test::Bencher;
+use std::fmt;
+use std::error;
 
 use rustc_serialize::{Decoder, Decodable};
 
@@ -44,6 +46,22 @@ impl serde::de::Error for Error {
     }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 mod decoder {
     use std::collections::HashMap;
     use rustc_serialize::Decoder;

serde_tests/benches/bench_vec.rs

@@ -1,4 +1,6 @@
 use std::fmt::Debug;
+use std::fmt;
+use std::error;
 use test::Bencher;
 
 use rustc_serialize::{Decoder, Decodable};
@@ -24,6 +26,21 @@ impl serde::de::Error for Error {
     fn missing_field(_: &'static str) -> Error { Error::SyntaxError }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
 //////////////////////////////////////////////////////////////////////////////
 
 mod decoder {

serde_tests/tests/test_bytes.rs

@@ -1,4 +1,6 @@
 use serde;
+use std::fmt;
+use std::error;
 use serde::Serialize;
 use serde::bytes::{ByteBuf, Bytes};
 
@@ -17,6 +19,22 @@ impl serde::de::Error for Error {
     fn missing_field(_field: &'static str) -> Error { Error }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 
 struct BytesSerializer {

serde_tests/tests/token.rs

@@ -1,5 +1,6 @@
 use std::fmt;
 use std::iter;
+use std::error;
 
 use serde::{ser, de};
 use serde::de::value::{self, ValueDeserializer};
@@ -333,6 +334,22 @@ impl de::Error for Error {
     }
 }
 
+impl fmt::Display for Error {
+    fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
+        formatter.write_str(format!("{:?}", self).as_ref())
+    }
+}
+
+impl error::Error for Error {
+    fn description(&self) -> &str {
+        "Serde Deserialization Error"
+    }
+
+    fn cause(&self) -> Option<&error::Error> {
+        None
+    }
+}
+
 impl From<value::Error> for Error {
     fn from(error: value::Error) -> Error {
         Error::ValueError(error)