From 36a7bf6244b63f60f208cfcbdad91332cdbb9641 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 10:26:31 +0200 Subject: [PATCH 1/7] make `Deserializer` pure --- serde/src/de/mod.rs | 212 ++++++++++++++++-------------------- serde/src/de/value.rs | 167 ++++++++++++++++++++++++++++ serde_test/src/de.rs | 14 +++ serde_test/src/lib.rs | 1 + testing/tests/test.rs.in | 3 + testing/tests/test_bytes.rs | 16 +++ 6 files changed, 293 insertions(+), 120 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 47033dde..8c3e28fe 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -10,6 +10,68 @@ use collections::{String, Vec}; use core::fmt; +/////////////////////////////////////////////////////////////////////////////// +/// Macro helper to not have to re-implement all the defaulted methods. +/// Every given method ignores all arguments and forwards to `deserialize`. +/// Note that `deserialize_enum` simply returns an `Error::invalid_type`. +#[macro_export] +macro_rules! de_forward_to_deserialize { + ($($func:ident),*) => { + $(de_forward_to_deserialize!{func: $func})* + }; + (func: deserialize_unit_struct) => { + de_forward_to_deserialize!{named: deserialize_unit_struct} + }; + (func: deserialize_newtype_struct) => { + de_forward_to_deserialize!{named: deserialize_newtype_struct} + }; + (func: deserialize_tuple) => { + de_forward_to_deserialize!{tup_fn: deserialize_tuple} + }; + (func: deserialize_fixed_size_array) => { + de_forward_to_deserialize!{tup_fn: deserialize_fixed_size_array} + }; + (func: deserialize_tuple_struct) => { + fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::Visitor { + self.deserialize(visitor) + } + }; + (func: deserialize_struct) => { + fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::Visitor { + self.deserialize(visitor) + } + }; + (func: deserialize_enum) => { + fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::EnumVisitor { + Err($crate::de::Error::invalid_type($crate::de::Type::Enum)) + } + }; + (named: $func:ident) => { + fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::Visitor { + self.deserialize(visitor) + } + }; + (tup_fn: $func: ident) => { + fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::Visitor { + self.deserialize(visitor) + } + }; + (func: $func:ident) => { + fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: $crate::de::Visitor { + self.deserialize(visitor) + } + }; +} + +/////////////////////////////////////////////////////////////////////////////// +// modules come after macros + pub mod impls; pub mod value; mod from_primitive; @@ -245,157 +307,100 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a `bool` value. #[inline] fn deserialize_bool(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `usize` value. #[inline] fn deserialize_usize(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_u64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u8` value. #[inline] fn deserialize_u8(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_u64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u16` value. #[inline] fn deserialize_u16(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_u64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u32` value. #[inline] fn deserialize_u32(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_u64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u64` value. #[inline] fn deserialize_u64(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `isize` value. #[inline] fn deserialize_isize(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_i64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i8` value. #[inline] fn deserialize_i8(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_i64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i16` value. #[inline] fn deserialize_i16(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_i64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i32` value. #[inline] fn deserialize_i32(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_i64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i64` value. #[inline] fn deserialize_i64(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f32` value. #[inline] fn deserialize_f32(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_f64(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f64` value. #[inline] fn deserialize_f64(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `char` value. #[inline] fn deserialize_char(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `&str` value. #[inline] fn deserialize_str(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `String` value. #[inline] fn deserialize_string(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_str(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `unit` value. #[inline] fn deserialize_unit(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows /// deserializers that encode an optional value as a nullable value to convert the null value /// into a `None`, and a regular value as `Some(value)`. #[inline] fn deserialize_option(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a sequence value. This allows /// deserializers to parse sequences that aren't tagged as sequences. #[inline] fn deserialize_seq(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows /// deserializers to parse arrays that aren't tagged as arrays. @@ -405,29 +410,20 @@ pub trait Deserializer { fn deserialize_fixed_size_array(&mut self, _len: usize, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `Vec`. This allows /// deserializers that provide a custom byte vector serialization to properly deserialize the /// type. #[inline] fn deserialize_bytes(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_seq(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a map of values. This allows /// deserializers to parse sequences that aren't tagged as maps. #[inline] fn deserialize_map(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a unit struct. This allows /// deserializers to a unit struct that aren't tagged as a unit struct. @@ -435,10 +431,7 @@ pub trait Deserializer { fn deserialize_unit_struct(&mut self, _name: &'static str, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_unit(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows /// deserializers to a newtype struct that aren't tagged as a newtype struct. @@ -446,10 +439,7 @@ pub trait Deserializer { fn deserialize_newtype_struct(&mut self, name: &'static str, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_tuple_struct(name, 1, visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows /// deserializers to parse sequences that aren't tagged as sequences. @@ -458,10 +448,7 @@ pub trait Deserializer { _name: &'static str, len: usize, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_tuple(len, visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a struct. This allows /// deserializers to parse sequences that aren't tagged as maps. @@ -470,29 +457,20 @@ pub trait Deserializer { _name: &'static str, _fields: &'static [&'static str], visitor: V) -> Result - where V: Visitor, - { - self.deserialize_map(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting some sort of struct field /// name. This allows deserializers to choose between &str, usize, or &[u8] to properly /// deserialize a struct field. #[inline] fn deserialize_struct_field(&mut self, visitor: V) -> Result - where V: Visitor, - { - self.deserialize(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting a tuple value. This allows /// deserializers that provide a custom tuple serialization to properly deserialize the type. #[inline] fn deserialize_tuple(&mut self, _len: usize, visitor: V) -> Result - where V: Visitor, - { - self.deserialize_seq(visitor) - } + where V: Visitor; /// This method hints that the `Deserialize` type is expecting an enum value. This allows /// deserializers that provide a custom enumeration serialization to properly deserialize the @@ -502,19 +480,13 @@ pub trait Deserializer { _enum: &'static str, _variants: &'static [&'static str], _visitor: V) -> Result - where V: EnumVisitor, - { - Err(Error::invalid_type(Type::Enum)) - } + where V: EnumVisitor; /// This method hints that the `Deserialize` type needs to deserialize a value whose type /// doesn't matter because it is ignored. #[inline] fn deserialize_ignored_any(&mut self, visitor: V) -> Result - where V: Visitor - { - self.deserialize(visitor) - } + where V: Visitor; } /////////////////////////////////////////////////////////////////////////////// diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 65499ee3..be65e231 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -174,6 +174,22 @@ impl de::Deserializer for UnitDeserializer { type Error = E; + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct + } + fn deserialize(&mut self, mut visitor: V) -> Result where V: de::Visitor, { @@ -209,6 +225,23 @@ macro_rules! primitive_deserializer { { type Error = E; + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } + fn deserialize(&mut self, mut visitor: V) -> Result where V: de::Visitor, { @@ -273,6 +306,22 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E> { visitor.visit(self) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E> @@ -331,6 +380,22 @@ impl de::Deserializer for StringDeserializer { visitor.visit(self) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } #[cfg(any(feature = "std", feature = "collections"))] @@ -384,6 +449,23 @@ impl de::Deserializer for SeqDeserializer { visitor.visit_seq(self) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } impl de::SeqVisitor for SeqDeserializer @@ -490,6 +572,23 @@ impl de::Deserializer for SeqVisitorDeserializer fn deserialize(&mut self, mut visitor: V) -> Result { visitor.visit_seq(&mut self.visitor) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } /////////////////////////////////////////////////////////////////////////////// @@ -537,6 +636,23 @@ impl de::Deserializer for MapDeserializer { visitor.visit_map(self) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } impl de::MapVisitor for MapDeserializer @@ -648,6 +764,23 @@ impl de::Deserializer for MapVisitorDeserializer fn deserialize(&mut self, mut visitor: V) -> Result { visitor.visit_map(&mut self.visitor) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } /////////////////////////////////////////////////////////////////////////////// @@ -678,6 +811,23 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E> None => Err(de::Error::end_of_stream()), } } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } @@ -712,4 +862,21 @@ impl de::Deserializer for ByteBufDeserializer None => Err(de::Error::end_of_stream()), } } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index 24dabe19..99c6e0a7 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -110,6 +110,20 @@ impl de::Deserializer for Deserializer { type Error = Error; + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_bytes, + deserialize_unit, + deserialize_seq, + deserialize_map, + deserialize_struct_field + } + fn deserialize(&mut self, mut visitor: V) -> Result where V: Visitor, { diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index 945262c0..53f966f6 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -1,3 +1,4 @@ +#[macro_use] extern crate serde; mod assert; diff --git a/testing/tests/test.rs.in b/testing/tests/test.rs.in index 32c00054..22437ac4 100644 --- a/testing/tests/test.rs.in +++ b/testing/tests/test.rs.in @@ -1,3 +1,6 @@ +#[macro_use] +extern crate serde; + #[macro_use] mod macros; diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index b2e21b2e..a8bb2f9f 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -306,6 +306,22 @@ impl serde::Deserializer for BytesDeserializer { { visitor.visit_byte_buf(self.bytes.take().unwrap()) } + + de_forward_to_deserialize!{ + deserialize_bool, + deserialize_f64, deserialize_f32, + deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, + deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, + deserialize_char, deserialize_str, deserialize_string, + deserialize_ignored_any, + deserialize_unit_struct, deserialize_unit, + deserialize_seq, deserialize_fixed_size_array, + deserialize_map, deserialize_newtype_struct, deserialize_struct_field, + deserialize_tuple, + deserialize_enum, + deserialize_struct, deserialize_tuple_struct, + deserialize_option + } } /////////////////////////////////////////////////////////////////////////////// From 4722571a4deffd51bd40619ef74008a1b493f916 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 10:33:28 +0200 Subject: [PATCH 2/7] make `VariantVisitor` pure --- serde/src/de/mod.rs | 16 +++------------ serde/src/de/value.rs | 46 +++++++++++++++++++++++++++++++++++++++++++ 2 files changed, 49 insertions(+), 13 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 8c3e28fe..4c3e0cbd 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -846,29 +846,19 @@ pub trait VariantVisitor { /// uses the `visit_tuple` method to deserialize the value. #[inline] fn visit_newtype(&mut self) -> Result - where T: Deserialize, - { - let (value,) = try!(self.visit_tuple(1, impls::TupleVisitor1::new())); - Ok(value) - } + where T: Deserialize; /// `visit_tuple` is called when deserializing a tuple-like variant. fn visit_tuple(&mut self, _len: usize, _visitor: V) -> Result - where V: Visitor - { - Err(Error::invalid_type(Type::TupleVariant)) - } + where V: Visitor; /// `visit_struct` is called when deserializing a struct-like variant. fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result - where V: Visitor - { - Err(Error::invalid_type(Type::StructVariant)) - } + where V: Visitor; } impl<'a, T> VariantVisitor for &'a mut T where T: VariantVisitor { diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index be65e231..1428ff22 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -338,6 +338,29 @@ impl<'a, E> de::VariantVisitor for StrDeserializer<'a, E> fn visit_unit(&mut self) -> Result<(), Self::Error> { Ok(()) } + + fn visit_newtype(&mut self) -> Result + where T: super::Deserialize, + { + let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new())); + Ok(value) + } + + fn visit_tuple(&mut self, + _len: usize, + _visitor: V) -> Result + where V: super::Visitor + { + Err(super::Error::invalid_type(super::Type::TupleVariant)) + } + + fn visit_struct(&mut self, + _fields: &'static [&'static str], + _visitor: V) -> Result + where V: super::Visitor + { + Err(super::Error::invalid_type(super::Type::StructVariant)) + } } /////////////////////////////////////////////////////////////////////////////// @@ -413,6 +436,29 @@ impl<'a, E> de::VariantVisitor for StringDeserializer fn visit_unit(&mut self) -> Result<(), Self::Error> { Ok(()) } + + fn visit_newtype(&mut self) -> Result + where T: super::Deserialize, + { + let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new())); + Ok(value) + } + + fn visit_tuple(&mut self, + _len: usize, + _visitor: V) -> Result + where V: super::Visitor + { + Err(super::Error::invalid_type(super::Type::TupleVariant)) + } + + fn visit_struct(&mut self, + _fields: &'static [&'static str], + _visitor: V) -> Result + where V: super::Visitor + { + Err(super::Error::invalid_type(super::Type::StructVariant)) + } } /////////////////////////////////////////////////////////////////////////////// From d10a69b243f20a4d8b85a2bfcca5b8dd310e962b Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 10:42:14 +0200 Subject: [PATCH 3/7] document some hints for defaults --- serde/src/de/mod.rs | 21 ++++++++++++++++----- 1 file changed, 16 insertions(+), 5 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 4c3e0cbd..e4e68d13 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -310,21 +310,25 @@ pub trait Deserializer { where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `usize` value. + /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. #[inline] fn deserialize_usize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u8` value. + /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. #[inline] fn deserialize_u8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u16` value. + /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. #[inline] fn deserialize_u16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u32` value. + /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. #[inline] fn deserialize_u32(&mut self, visitor: V) -> Result where V: Visitor; @@ -335,21 +339,25 @@ pub trait Deserializer { where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `isize` value. + /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. #[inline] fn deserialize_isize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i8` value. + /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. #[inline] fn deserialize_i8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i16` value. + /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. #[inline] fn deserialize_i16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i32` value. + /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. #[inline] fn deserialize_i32(&mut self, visitor: V) -> Result where V: Visitor; @@ -360,6 +368,7 @@ pub trait Deserializer { where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f32` value. + /// A reasonable default is to forward to `deserialize_f64` and cast the yielded value. #[inline] fn deserialize_f32(&mut self, visitor: V) -> Result where V: Visitor; @@ -404,8 +413,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows /// deserializers to parse arrays that aren't tagged as arrays. - /// - /// By default, this deserializes arrays from a sequence. #[inline] fn deserialize_fixed_size_array(&mut self, _len: usize, @@ -435,6 +442,7 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows /// deserializers to a newtype struct that aren't tagged as a newtype struct. + /// A reasonable default is to simply deserialize the expected value directly. #[inline] fn deserialize_newtype_struct(&mut self, name: &'static str, @@ -842,19 +850,22 @@ pub trait VariantVisitor { Err(Error::invalid_type(Type::UnitVariant)) } - /// `visit_newtype` is called when deserializing a variant with a single value. By default this - /// uses the `visit_tuple` method to deserialize the value. - #[inline] + /// `visit_newtype` is called when deserializing a variant with a single value. + /// A good default is often to use the `visit_tuple` method to deserialize a `(value,)`. fn visit_newtype(&mut self) -> Result where T: Deserialize; /// `visit_tuple` is called when deserializing a tuple-like variant. + /// If no tuple variants are expected, yield a + /// `Err(serde::de::Error::invalid_type(serde::de::Type::TupleVariant))` fn visit_tuple(&mut self, _len: usize, _visitor: V) -> Result where V: Visitor; /// `visit_struct` is called when deserializing a struct-like variant. + /// If no struct variants are expected, yield a + /// `Err(serde::de::Error::invalid_type(serde::de::Type::StructVariant))` fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result From 65eb116a85d8998f774b01d079a37340c5df37ad Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 19:18:45 +0200 Subject: [PATCH 4/7] address comments --- serde/src/de/mod.rs | 54 +++++++++++++-------------------------------- 1 file changed, 15 insertions(+), 39 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index e4e68d13..668f5895 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -32,36 +32,42 @@ macro_rules! de_forward_to_deserialize { de_forward_to_deserialize!{tup_fn: deserialize_fixed_size_array} }; (func: deserialize_tuple_struct) => { + #[inline] fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: deserialize_struct) => { + #[inline] fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: deserialize_enum) => { + #[inline] fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::EnumVisitor { Err($crate::de::Error::invalid_type($crate::de::Type::Enum)) } }; (named: $func:ident) => { + #[inline] fn $func<__V>(&mut self, _: &str, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (tup_fn: $func: ident) => { + #[inline] fn $func<__V>(&mut self, _: usize, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) } }; (func: $func:ident) => { + #[inline] fn $func<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> where __V: $crate::de::Visitor { self.deserialize(visitor) @@ -305,115 +311,95 @@ pub trait Deserializer { where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `bool` value. - #[inline] fn deserialize_bool(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `usize` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_usize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u8` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u16` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u32` value. - /// A reasonable default is to forward to `deserialize_u64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_u64`. fn deserialize_u32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `u64` value. - #[inline] fn deserialize_u64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `isize` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_isize(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i8` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i8(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i16` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i16(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i32` value. - /// A reasonable default is to forward to `deserialize_i64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_i64`. fn deserialize_i32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `i64` value. - #[inline] fn deserialize_i64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f32` value. - /// A reasonable default is to forward to `deserialize_f64` and cast the yielded value. - #[inline] + /// A reasonable default is to forward to `deserialize_f64`. fn deserialize_f32(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `f64` value. - #[inline] fn deserialize_f64(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `char` value. - #[inline] fn deserialize_char(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `&str` value. - #[inline] fn deserialize_str(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a `String` value. - #[inline] fn deserialize_string(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `unit` value. - #[inline] fn deserialize_unit(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an `Option` value. This allows /// deserializers that encode an optional value as a nullable value to convert the null value /// into a `None`, and a regular value as `Some(value)`. - #[inline] fn deserialize_option(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a sequence value. This allows /// deserializers to parse sequences that aren't tagged as sequences. - #[inline] fn deserialize_seq(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows /// deserializers to parse arrays that aren't tagged as arrays. - #[inline] fn deserialize_fixed_size_array(&mut self, _len: usize, visitor: V) -> Result @@ -422,19 +408,16 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a `Vec`. This allows /// deserializers that provide a custom byte vector serialization to properly deserialize the /// type. - #[inline] fn deserialize_bytes(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a map of values. This allows /// deserializers to parse sequences that aren't tagged as maps. - #[inline] fn deserialize_map(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a unit struct. This allows /// deserializers to a unit struct that aren't tagged as a unit struct. - #[inline] fn deserialize_unit_struct(&mut self, _name: &'static str, visitor: V) -> Result @@ -443,7 +426,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a newtype struct. This allows /// deserializers to a newtype struct that aren't tagged as a newtype struct. /// A reasonable default is to simply deserialize the expected value directly. - #[inline] fn deserialize_newtype_struct(&mut self, name: &'static str, visitor: V) -> Result @@ -451,7 +433,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a tuple struct. This allows /// deserializers to parse sequences that aren't tagged as sequences. - #[inline] fn deserialize_tuple_struct(&mut self, _name: &'static str, len: usize, @@ -460,7 +441,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a struct. This allows /// deserializers to parse sequences that aren't tagged as maps. - #[inline] fn deserialize_struct(&mut self, _name: &'static str, _fields: &'static [&'static str], @@ -470,20 +450,17 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting some sort of struct field /// name. This allows deserializers to choose between &str, usize, or &[u8] to properly /// deserialize a struct field. - #[inline] fn deserialize_struct_field(&mut self, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting a tuple value. This allows /// deserializers that provide a custom tuple serialization to properly deserialize the type. - #[inline] fn deserialize_tuple(&mut self, _len: usize, visitor: V) -> Result where V: Visitor; /// This method hints that the `Deserialize` type is expecting an enum value. This allows /// deserializers that provide a custom enumeration serialization to properly deserialize the /// type. - #[inline] fn deserialize_enum(&mut self, _enum: &'static str, _variants: &'static [&'static str], @@ -492,7 +469,6 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type needs to deserialize a value whose type /// doesn't matter because it is ignored. - #[inline] fn deserialize_ignored_any(&mut self, visitor: V) -> Result where V: Visitor; } From 4280dd466decd49845c31ec3f34a3d8301a2fe45 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Wed, 20 Jul 2016 19:20:31 +0200 Subject: [PATCH 5/7] rename deserialize_fixed_size_array to deserialize_seq_fixed_size --- serde/src/de/impls.rs | 2 +- serde/src/de/mod.rs | 6 +++--- serde/src/de/value.rs | 20 ++++++++++---------- serde_test/src/de.rs | 2 +- testing/tests/test_bytes.rs | 2 +- 5 files changed, 16 insertions(+), 16 deletions(-) diff --git a/serde/src/de/impls.rs b/serde/src/de/impls.rs index 4096fa8f..1680312b 100644 --- a/serde/src/de/impls.rs +++ b/serde/src/de/impls.rs @@ -593,7 +593,7 @@ macro_rules! array_impls { fn deserialize(deserializer: &mut D) -> Result<[T; $len], D::Error> where D: Deserializer, { - deserializer.deserialize_fixed_size_array($len, $visitor::new()) + deserializer.deserialize_seq_fixed_size($len, $visitor::new()) } } )+ diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index 668f5895..eb79562b 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -28,8 +28,8 @@ macro_rules! de_forward_to_deserialize { (func: deserialize_tuple) => { de_forward_to_deserialize!{tup_fn: deserialize_tuple} }; - (func: deserialize_fixed_size_array) => { - de_forward_to_deserialize!{tup_fn: deserialize_fixed_size_array} + (func: deserialize_seq_fixed_size) => { + de_forward_to_deserialize!{tup_fn: deserialize_seq_fixed_size} }; (func: deserialize_tuple_struct) => { #[inline] @@ -400,7 +400,7 @@ pub trait Deserializer { /// This method hints that the `Deserialize` type is expecting a fixed size array. This allows /// deserializers to parse arrays that aren't tagged as arrays. - fn deserialize_fixed_size_array(&mut self, + fn deserialize_seq_fixed_size(&mut self, _len: usize, visitor: V) -> Result where V: Visitor; diff --git a/serde/src/de/value.rs b/serde/src/de/value.rs index 1428ff22..f8e98bf8 100644 --- a/serde/src/de/value.rs +++ b/serde/src/de/value.rs @@ -183,7 +183,7 @@ impl de::Deserializer for UnitDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -234,7 +234,7 @@ macro_rules! primitive_deserializer { deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -316,7 +316,7 @@ impl<'a, E> de::Deserializer for StrDeserializer<'a, E> deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_struct, deserialize_tuple_struct, @@ -413,7 +413,7 @@ impl de::Deserializer for StringDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_struct, deserialize_tuple_struct, @@ -505,7 +505,7 @@ impl de::Deserializer for SeqDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -628,7 +628,7 @@ impl de::Deserializer for SeqVisitorDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -692,7 +692,7 @@ impl de::Deserializer for MapDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -820,7 +820,7 @@ impl de::Deserializer for MapVisitorDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -867,7 +867,7 @@ impl<'a, E> de::Deserializer for BytesDeserializer<'a, E> deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, @@ -918,7 +918,7 @@ impl de::Deserializer for ByteBufDeserializer deserialize_ignored_any, deserialize_bytes, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index 99c6e0a7..c9a5aeeb 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -255,7 +255,7 @@ impl de::Deserializer for Deserializer } } - fn deserialize_fixed_size_array(&mut self, + fn deserialize_seq_fixed_size(&mut self, len: usize, visitor: V) -> Result where V: Visitor, diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index a8bb2f9f..021baa64 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -315,7 +315,7 @@ impl serde::Deserializer for BytesDeserializer { deserialize_char, deserialize_str, deserialize_string, deserialize_ignored_any, deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_fixed_size_array, + deserialize_seq, deserialize_seq_fixed_size, deserialize_map, deserialize_newtype_struct, deserialize_struct_field, deserialize_tuple, deserialize_enum, From 124bacd871d9b6cacf26468019ed3afb356a37ab Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 21 Jul 2016 10:11:04 +0200 Subject: [PATCH 6/7] fix for 1.8, 1.9 and stable --- serde/src/de/mod.rs | 1 - serde_test/src/de.rs | 99 +++++++++++++++++--- serde_test/src/lib.rs | 1 - testing/tests/test.rs.in | 1 - testing/tests/test_bytes.rs | 174 ++++++++++++++++++++++++++++-------- testing/tests/test_de.rs | 3 +- 6 files changed, 226 insertions(+), 53 deletions(-) diff --git a/serde/src/de/mod.rs b/serde/src/de/mod.rs index eb79562b..c9eea554 100644 --- a/serde/src/de/mod.rs +++ b/serde/src/de/mod.rs @@ -14,7 +14,6 @@ use core::fmt; /// Macro helper to not have to re-implement all the defaulted methods. /// Every given method ignores all arguments and forwards to `deserialize`. /// Note that `deserialize_enum` simply returns an `Error::invalid_type`. -#[macro_export] macro_rules! de_forward_to_deserialize { ($($func:ident),*) => { $(de_forward_to_deserialize!{func: $func})* diff --git a/serde_test/src/de.rs b/serde_test/src/de.rs index c9a5aeeb..121dcd3d 100644 --- a/serde_test/src/de.rs +++ b/serde_test/src/de.rs @@ -110,18 +110,93 @@ impl de::Deserializer for Deserializer { type Error = Error; - de_forward_to_deserialize!{ - deserialize_bool, - deserialize_f64, deserialize_f32, - deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, - deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, - deserialize_char, deserialize_str, deserialize_string, - deserialize_ignored_any, - deserialize_bytes, - deserialize_unit, - deserialize_seq, - deserialize_map, - deserialize_struct_field + fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_bytes<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) } fn deserialize(&mut self, mut visitor: V) -> Result diff --git a/serde_test/src/lib.rs b/serde_test/src/lib.rs index 53f966f6..945262c0 100644 --- a/serde_test/src/lib.rs +++ b/serde_test/src/lib.rs @@ -1,4 +1,3 @@ -#[macro_use] extern crate serde; mod assert; diff --git a/testing/tests/test.rs.in b/testing/tests/test.rs.in index 22437ac4..fca1ff46 100644 --- a/testing/tests/test.rs.in +++ b/testing/tests/test.rs.in @@ -1,4 +1,3 @@ -#[macro_use] extern crate serde; #[macro_use] diff --git a/testing/tests/test_bytes.rs b/testing/tests/test_bytes.rs index 021baa64..cc30f149 100644 --- a/testing/tests/test_bytes.rs +++ b/testing/tests/test_bytes.rs @@ -1,20 +1,21 @@ use std::fmt; use std::error; -extern crate serde; -use self::serde::Serialize; -use self::serde::bytes::{ByteBuf, Bytes}; +use serde::{Serialize, Serializer, Deserialize, Deserializer}; +use serde::bytes::{ByteBuf, Bytes}; +use serde::ser; +use serde::de; /////////////////////////////////////////////////////////////////////////////// #[derive(Debug, PartialEq)] struct Error; -impl serde::ser::Error for Error { +impl ser::Error for Error { fn custom>(_: T) -> Error { Error } } -impl serde::de::Error for Error { +impl de::Error for Error { fn custom>(_: T) -> Error { Error } fn end_of_stream() -> Error { Error } @@ -50,7 +51,7 @@ impl BytesSerializer { } } -impl serde::Serializer for BytesSerializer { +impl Serializer for BytesSerializer { type Error = Error; type SeqState = (); type MapState = (); @@ -137,19 +138,19 @@ impl serde::Serializer for BytesSerializer { } fn serialize_some(&mut self, _value: V) -> Result<(), Error> - where V: serde::Serialize, + where V: Serialize, { Err(Error) } fn serialize_newtype_struct(&mut self, _: &'static str, _value: V) -> Result<(), Error> - where V: serde::Serialize, + where V: Serialize, { Err(Error) } fn serialize_newtype_variant(&mut self, _: &'static str, _: usize, _: &'static str, _value: V) -> Result<(), Error> - where V: serde::Serialize, + where V: Serialize, { Err(Error) } @@ -165,7 +166,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_seq_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: serde::Serialize + where T: Serialize { Err(Error) } @@ -181,7 +182,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_tuple_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: serde::Serialize + where T: Serialize { Err(Error) } @@ -197,7 +198,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_tuple_struct_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: serde::Serialize + where T: Serialize { Err(Error) } @@ -213,7 +214,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_tuple_variant_elt(&mut self, _: &mut (), _value: T) -> Result<(), Error> - where T: serde::Serialize + where T: Serialize { Err(Error) } @@ -229,8 +230,8 @@ impl serde::Serializer for BytesSerializer { } fn serialize_map_elt(&mut self, _: &mut (), _key: K, _value: V) -> Result<(), Error> - where K: serde::Serialize, - V: serde::Serialize, + where K: Serialize, + V: Serialize, { Err(Error) } @@ -246,7 +247,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_struct_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> - where V: serde::Serialize, + where V: Serialize, { Err(Error) } @@ -262,7 +263,7 @@ impl serde::Serializer for BytesSerializer { } fn serialize_struct_variant_elt(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error> - where V: serde::Serialize, + where V: Serialize, { Err(Error) } @@ -292,35 +293,136 @@ impl BytesDeserializer { } } -impl serde::Deserializer for BytesDeserializer { +impl Deserializer for BytesDeserializer { type Error = Error; fn deserialize(&mut self, _visitor: V) -> Result - where V: serde::de::Visitor, + where V: de::Visitor, { Err(Error) } fn deserialize_bytes(&mut self, mut visitor: V) -> Result - where V: serde::de::Visitor, + where V: de::Visitor, { visitor.visit_byte_buf(self.bytes.take().unwrap()) } - de_forward_to_deserialize!{ - deserialize_bool, - deserialize_f64, deserialize_f32, - deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize, - deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize, - deserialize_char, deserialize_str, deserialize_string, - deserialize_ignored_any, - deserialize_unit_struct, deserialize_unit, - deserialize_seq, deserialize_seq_fixed_size, - deserialize_map, deserialize_newtype_struct, deserialize_struct_field, - deserialize_tuple, - deserialize_enum, - deserialize_struct, deserialize_tuple_struct, - deserialize_option + fn deserialize_seq<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_struct_field<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_map<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_unit<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_ignored_any<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_string<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_str<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_char<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_i8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u16<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_u8<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_f32<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_f64<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_bool<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_usize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_isize<__V>(&mut self, visitor: __V) -> Result<__V::Value, Self::Error> + where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_option<__V>(&mut self, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_seq_fixed_size<__V>(&mut self, _: usize, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_unit_struct<__V>(&mut self, _: &str, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_newtype_struct<__V>(&mut self, _: &str, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_tuple_struct<__V>(&mut self, _: &str, _: usize, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_struct<__V>(&mut self, _: &str, _: &[&str], visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_tuple<__V>(&mut self, _: usize, visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::Visitor { + self.deserialize(visitor) + } + fn deserialize_enum<__V>(&mut self, _: &str, _: &[&str], _visitor: __V) + -> Result<__V::Value, Self::Error> where __V: de::EnumVisitor { + Err(Error) } } @@ -344,10 +446,10 @@ fn test_bytes_ser_bytes() { #[test] fn test_byte_buf_de_bytes() { let mut de = BytesDeserializer::new(vec![]); - let bytes = serde::Deserialize::deserialize(&mut de); + let bytes = Deserialize::deserialize(&mut de); assert_eq!(bytes, Ok(ByteBuf::new())); let mut de = BytesDeserializer::new(vec![1, 2, 3]); - let bytes = serde::Deserialize::deserialize(&mut de); + let bytes = Deserialize::deserialize(&mut de); assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3]))); } diff --git a/testing/tests/test_de.rs b/testing/tests/test_de.rs index 8a73bf38..63b6b6f7 100644 --- a/testing/tests/test_de.rs +++ b/testing/tests/test_de.rs @@ -2,8 +2,7 @@ use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet}; use std::net; use std::path::PathBuf; -extern crate serde; -use self::serde::Deserialize; +use serde::Deserialize; extern crate fnv; use self::fnv::FnvHasher; From 89549e2567ee3bcac43966ce33b4c7ce206123e0 Mon Sep 17 00:00:00 2001 From: Oliver Schneider Date: Thu, 21 Jul 2016 10:49:02 +0200 Subject: [PATCH 7/7] fix nightly --- serde_macros/tests/test.rs | 1 - 1 file changed, 1 deletion(-) diff --git a/serde_macros/tests/test.rs b/serde_macros/tests/test.rs index e9211218..e0462787 100644 --- a/serde_macros/tests/test.rs +++ b/serde_macros/tests/test.rs @@ -1,7 +1,6 @@ #![feature(test, custom_attribute, custom_derive, plugin)] #![plugin(serde_macros)] -extern crate serde; extern crate test; include!("../../testing/tests/test.rs.in");