feat: ValueDeserializers are generic over the error type

This makes it possible to remove the `From<de::value::Error>` trait
bound from the `de::Error` trait.

An example for using a `ValueDeserializer` to forward deserializing to
another type's visitor:

```rust
fn visit_u8<E>(&mut self, value: u8) -> Result<Self::Value, E>
    where E: de::Error
{
    try!(Deserialize::deserialize(&mut value.into_deserializer()))
}
```

Please note that there is an regression in serde-rs/json which needs to
be fixed.

serde/src/de/value.rs

@@ -12,6 +12,7 @@ use std::collections::{
 };
 use std::hash::Hash;
 use std::vec;
+use std::marker::PhantomData;
 
 use de;
 use bytes;
@@ -52,9 +53,9 @@ impl de::Error for Error {
 ///////////////////////////////////////////////////////////////////////////////
 
 /// This trait converts primitive types into a deserializer.
-pub trait ValueDeserializer {
+pub trait ValueDeserializer<E: de::Error = Error> {
     /// The actual deserializer type.
-    type Deserializer: de::Deserializer<Error=Error>;
+    type Deserializer: de::Deserializer<Error=E>;
 
     /// Convert this value into a deserializer.
     fn into_deserializer(self) -> Self::Deserializer;
@@ -62,27 +63,31 @@ pub trait ValueDeserializer {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl ValueDeserializer for () {
+impl<E> ValueDeserializer<E> for ()
-    type Deserializer = UnitDeserializer;
+    where E: de::Error,
+{
+    type Deserializer = UnitDeserializer<E>;
 
-    fn into_deserializer(self) -> UnitDeserializer {
+    fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer
+        UnitDeserializer(PhantomData)
     }
 }
 
 /// A helper deserializer that deserializes a `()`.
-pub struct UnitDeserializer;
+pub struct UnitDeserializer<E>(PhantomData<E>);
 
-impl de::Deserializer for UnitDeserializer {
+impl<E> de::Deserializer for UnitDeserializer<E>
-    type Error = Error;
+    where E: de::Error
+{
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_unit()
     }
 
-    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit_option<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_none()
@@ -94,20 +99,24 @@ impl de::Deserializer for UnitDeserializer {
 macro_rules! primitive_deserializer {
     ($ty:ty, $name:ident, $method:ident) => {
         /// A helper deserializer that deserializes a number.
-        pub struct $name(Option<$ty>);
+        pub struct $name<E>(Option<$ty>, PhantomData<E>);
 
-        impl ValueDeserializer for $ty {
+        impl<E> ValueDeserializer<E> for $ty
-            type Deserializer = $name;
+            where E: de::Error,
+        {
+            type Deserializer = $name<E>;
 
-            fn into_deserializer(self) -> $name {
+            fn into_deserializer(self) -> $name<E> {
-                $name(Some(self))
+                $name(Some(self), PhantomData)
             }
         }
 
-        impl de::Deserializer for $name {
+        impl<E> de::Deserializer for $name<E>
-            type Error = Error;
+            where E: de::Error,
+        {
+            type Error = E;
 
-            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+            fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
                 where V: de::Visitor,
             {
                 match self.0.take() {
@@ -137,20 +146,24 @@ primitive_deserializer!(char, CharDeserializer, visit_char);
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a `&str`.
-pub struct StrDeserializer<'a>(Option<&'a str>);
+pub struct StrDeserializer<'a, E>(Option<&'a str>, PhantomData<E>);
 
-impl<'a> ValueDeserializer for &'a str {
+impl<'a, E> ValueDeserializer<E> for &'a str
-    type Deserializer = StrDeserializer<'a>;
+    where E: de::Error,
+{
+    type Deserializer = StrDeserializer<'a, E>;
 
-    fn into_deserializer(self) -> StrDeserializer<'a> {
+    fn into_deserializer(self) -> StrDeserializer<'a, E> {
-        StrDeserializer(Some(self))
+        StrDeserializer(Some(self), PhantomData)
     }
 }
 
-impl<'a> de::Deserializer for StrDeserializer<'a> {
+impl<'a, E> de::Deserializer for StrDeserializer<'a, E>
-    type Error = Error;
+    where E: de::Error,
+{
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         match self.0.take() {
@@ -162,23 +175,25 @@ impl<'a> de::Deserializer for StrDeserializer<'a> {
     fn visit_enum<V>(&mut self,
                      _name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
+                     mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::EnumVisitor,
     {
         visitor.visit(self)
     }
 }
 
-impl<'a> de::VariantVisitor for StrDeserializer<'a> {
+impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E>
-    type Error = Error;
+    where E: de::Error,
+{
+    type Error = E;
 
-    fn visit_variant<T>(&mut self) -> Result<T, Error>
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
         where T: de::Deserialize,
     {
         de::Deserialize::deserialize(self)
     }
 
-    fn visit_unit(&mut self) -> Result<(), Error> {
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
 }
@@ -186,20 +201,24 @@ impl<'a> de::VariantVisitor for StrDeserializer<'a> {
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a `String`.
-pub struct StringDeserializer(Option<String>);
+pub struct StringDeserializer<E>(Option<String>, PhantomData<E>);
 
-impl ValueDeserializer for String {
+impl<E> ValueDeserializer<E> for String
-    type Deserializer = StringDeserializer;
+    where E: de::Error,
+{
+    type Deserializer = StringDeserializer<E>;
 
-    fn into_deserializer(self) -> StringDeserializer {
+    fn into_deserializer(self) -> StringDeserializer<E> {
-        StringDeserializer(Some(self))
+        StringDeserializer(Some(self), PhantomData)
     }
 }
 
-impl de::Deserializer for StringDeserializer {
+impl<E> de::Deserializer for StringDeserializer<E>
-    type Error = Error;
+    where E: de::Error,
+{
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         match self.0.take() {
@@ -211,23 +230,25 @@ impl de::Deserializer for StringDeserializer {
     fn visit_enum<V>(&mut self,
                      _name: &str,
                      _variants: &'static [&'static str],
-                     mut visitor: V) -> Result<V::Value, Error>
+                     mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::EnumVisitor,
     {
         visitor.visit(self)
     }
 }
 
-impl<'a> de::VariantVisitor for StringDeserializer {
+impl<'a, E> de::VariantVisitor for StringDeserializer<E>
-    type Error = Error;
+    where E: de::Error,
+{
+    type Error = E;
 
-    fn visit_variant<T>(&mut self) -> Result<T, Error>
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
         where T: de::Deserialize,
     {
         de::Deserialize::deserialize(self)
     }
 
-    fn visit_unit(&mut self) -> Result<(), Error> {
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
         Ok(())
     }
 }
@@ -235,41 +256,47 @@ impl<'a> de::VariantVisitor for StringDeserializer {
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a sequence.
-pub struct SeqDeserializer<I> {
+pub struct SeqDeserializer<I, E> {
     iter: I,
     len: usize,
+    marker: PhantomData<E>,
 }
 
-impl<I> SeqDeserializer<I> {
+impl<I, E> SeqDeserializer<I, E>
+    where E: de::Error,
+{
     /// Construct a new `SeqDeserializer<I>`.
     pub fn new(iter: I, len: usize) -> Self {
         SeqDeserializer {
             iter: iter,
             len: len,
+            marker: PhantomData,
         }
     }
 }
 
-impl<I, T> de::Deserializer for SeqDeserializer<I>
+impl<I, T, E> de::Deserializer for SeqDeserializer<I, E>
     where I: Iterator<Item=T>,
-          T: ValueDeserializer,
+          T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         visitor.visit_seq(self)
     }
 }
 
-impl<I, T> de::SeqVisitor for SeqDeserializer<I>
+impl<I, T, E> de::SeqVisitor for SeqDeserializer<I, E>
     where I: Iterator<Item=T>,
-          T: ValueDeserializer,
+          T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;
 
-    fn visit<V>(&mut self) -> Result<Option<V>, Error>
+    fn visit<V>(&mut self) -> Result<Option<V>, Self::Error>
         where V: de::Deserialize
     {
         match self.iter.next() {
@@ -282,7 +309,7 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
         }
     }
 
-    fn end(&mut self) -> Result<(), Error> {
+    fn end(&mut self) -> Result<(), Self::Error> {
         if self.len == 0 {
             Ok(())
         } else {
@@ -297,34 +324,37 @@ impl<I, T> de::SeqVisitor for SeqDeserializer<I>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<T> ValueDeserializer for Vec<T>
+impl<T, E> ValueDeserializer<E> for Vec<T>
-    where T: ValueDeserializer,
+    where T: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<vec::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<vec::IntoIter<T>, E>;
 
-    fn into_deserializer(self) -> SeqDeserializer<vec::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
         let len = self.len();
         SeqDeserializer::new(self.into_iter(), len)
     }
 }
 
-impl<T> ValueDeserializer for BTreeSet<T>
+impl<T, E> ValueDeserializer<E> for BTreeSet<T>
-    where T: ValueDeserializer + Eq + Ord,
+    where T: ValueDeserializer<E> + Eq + Ord,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<btree_set::IntoIter<T>, E>;
 
-    fn into_deserializer(self) -> SeqDeserializer<btree_set::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
         let len = self.len();
         SeqDeserializer::new(self.into_iter(), len)
     }
 }
 
-impl<T> ValueDeserializer for HashSet<T>
+impl<T, E> ValueDeserializer<E> for HashSet<T>
-    where T: ValueDeserializer + Eq + Hash,
+    where T: ValueDeserializer<E> + Eq + Hash,
+          E: de::Error,
 {
-    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>>;
+    type Deserializer = SeqDeserializer<hash_set::IntoIter<T>, E>;
 
-    fn into_deserializer(self) -> SeqDeserializer<hash_set::IntoIter<T>> {
+    fn into_deserializer(self) -> Self::Deserializer {
         let len = self.len();
         SeqDeserializer::new(self.into_iter(), len)
     }
@@ -333,20 +363,23 @@ impl<T> ValueDeserializer for HashSet<T>
 ///////////////////////////////////////////////////////////////////////////////
 
 /// A helper deserializer that deserializes a map.
-pub struct MapDeserializer<I, K, V>
+pub struct MapDeserializer<I, K, V, E>
     where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
+          K: ValueDeserializer<E>,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
     iter: I,
     value: Option<V>,
     len: usize,
+    marker: PhantomData<E>,
 }
 
-impl<I, K, V> MapDeserializer<I, K, V>
+impl<I, K, V, E> MapDeserializer<I, K, V, E>
     where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
+          K: ValueDeserializer<E>,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
     /// Construct a new `MapDeserializer<I, K, V>`.
     pub fn new(iter: I, len: usize) -> Self {
@@ -354,32 +387,35 @@ impl<I, K, V> MapDeserializer<I, K, V>
             iter: iter,
             value: None,
             len: len,
+            marker: PhantomData,
         }
     }
 }
 
-impl<I, K, V> de::Deserializer for MapDeserializer<I, K, V>
+impl<I, K, V, E> de::Deserializer for MapDeserializer<I, K, V, E>
     where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
+          K: ValueDeserializer<E>,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;
 
-    fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Error>
+    fn visit<V_>(&mut self, mut visitor: V_) -> Result<V_::Value, Self::Error>
         where V_: de::Visitor,
     {
         visitor.visit_map(self)
     }
 }
 
-impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
+impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
     where I: Iterator<Item=(K, V)>,
-          K: ValueDeserializer,
+          K: ValueDeserializer<E>,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Error = Error;
+    type Error = E;
 
-    fn visit_key<T>(&mut self) -> Result<Option<T>, Error>
+    fn visit_key<T>(&mut self) -> Result<Option<T>, Self::Error>
         where T: de::Deserialize,
     {
         match self.iter.next() {
@@ -393,7 +429,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
         }
     }
 
-    fn visit_value<T>(&mut self) -> Result<T, Error>
+    fn visit_value<T>(&mut self) -> Result<T, Self::Error>
         where T: de::Deserialize,
     {
         match self.value.take() {
@@ -405,7 +441,7 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
         }
     }
 
-    fn end(&mut self) -> Result<(), Error> {
+    fn end(&mut self) -> Result<(), Self::Error> {
         if self.len == 0 {
             Ok(())
         } else {
@@ -420,25 +456,27 @@ impl<I, K, V> de::MapVisitor for MapDeserializer<I, K, V>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<K, V> ValueDeserializer for BTreeMap<K, V>
+impl<K, V, E> ValueDeserializer<E> for BTreeMap<K, V>
-    where K: ValueDeserializer + Eq + Ord,
+    where K: ValueDeserializer<E> + Eq + Ord,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V>;
+    type Deserializer = MapDeserializer<btree_map::IntoIter<K, V>, K, V, E>;
 
-    fn into_deserializer(self) -> MapDeserializer<btree_map::IntoIter<K, V>, K, V> {
+    fn into_deserializer(self) -> Self::Deserializer {
         let len = self.len();
         MapDeserializer::new(self.into_iter(), len)
     }
 }
 
-impl<K, V> ValueDeserializer for HashMap<K, V>
+impl<K, V, E> ValueDeserializer<E> for HashMap<K, V>
-    where K: ValueDeserializer + Eq + Hash,
+    where K: ValueDeserializer<E> + Eq + Hash,
-          V: ValueDeserializer,
+          V: ValueDeserializer<E>,
+          E: de::Error,
 {
-    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V>;
+    type Deserializer = MapDeserializer<hash_map::IntoIter<K, V>, K, V, E>;
 
-    fn into_deserializer(self) -> MapDeserializer<hash_map::IntoIter<K, V>, K, V> {
+    fn into_deserializer(self) -> Self::Deserializer {
         let len = self.len();
         MapDeserializer::new(self.into_iter(), len)
     }
@@ -446,22 +484,25 @@ impl<K, V> ValueDeserializer for HashMap<K, V>
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl<'a> ValueDeserializer for bytes::Bytes<'a>
+impl<'a, E> ValueDeserializer<E> for bytes::Bytes<'a>
+    where E: de::Error,
 {
-    type Deserializer = BytesDeserializer<'a>;
+    type Deserializer = BytesDeserializer<'a, E>;
 
-    fn into_deserializer(self) -> BytesDeserializer<'a> {
+    fn into_deserializer(self) -> BytesDeserializer<'a, E> {
-        BytesDeserializer(Some(self.into()))
+        BytesDeserializer(Some(self.into()), PhantomData)
     }
 }
 
 /// A helper deserializer that deserializes a `&[u8]`.
-pub struct BytesDeserializer<'a> (Option<&'a [u8]>);
+pub struct BytesDeserializer<'a, E> (Option<&'a [u8]>, PhantomData<E>);
 
-impl<'a> de::Deserializer for BytesDeserializer<'a> {
+impl<'a, E> de::Deserializer for BytesDeserializer<'a, E>
-    type Error = Error;
+    where E: de::Error
+{
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         match self.0.take() {
@@ -474,22 +515,25 @@ impl<'a> de::Deserializer for BytesDeserializer<'a> {
 
 ///////////////////////////////////////////////////////////////////////////////
 
-impl ValueDeserializer for bytes::ByteBuf
+impl<E> ValueDeserializer<E> for bytes::ByteBuf
+    where E: de::Error,
 {
-    type Deserializer = ByteBufDeserializer;
+    type Deserializer = ByteBufDeserializer<E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
-        ByteBufDeserializer(Some(self.into()))
+        ByteBufDeserializer(Some(self.into()), PhantomData)
     }
 }
 
 /// A helper deserializer that deserializes a `Vec<u8>`.
-pub struct ByteBufDeserializer(Option<Vec<u8>>);
+pub struct ByteBufDeserializer<E>(Option<Vec<u8>>, PhantomData<E>);
 
-impl de::Deserializer for ByteBufDeserializer {
+impl<E> de::Deserializer for ByteBufDeserializer<E>
-    type Error = Error;
+    where E: de::Error,
+{
+    type Error = E;
 
-    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
+    fn visit<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
         where V: de::Visitor,
     {
         match self.0.take() {