From 1d719b542cb8d5471633f5a9839f7fd22f3cde3e Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Mon, 17 Oct 2016 23:12:29 -0700 Subject: [PATCH 1/5] Not safe to share Spans from one ParseSess to another Spans in the AST returned by `parse_item_from_source_str` and other parsing functions contain byte offsets into the source code they were parsed from. The pretty printer uses these Spans [here][1] to preserve the representation of literals when parsing and printing back out unmodified. In this bug, the byte offset of a string in the input to `parse_item_from_source_str` coincidentally matched the byte offset of a totally different string in the input to `parse_crate_from_file` called [here][2] by Syntex. The Span from the former triggered the pretty printer to write out the content of the latter. By using the same ParseSess, Spans from the two `parse_*` calls never collide. [1]: https://github.com/rust-lang/rust/blob/1.12.0/src/libsyntax/print/pprust.rs#L628 [2]: https://github.com/serde-rs/syntex/blob/v0.45.0/syntex/src/registry.rs#L134 --- serde_codegen/src/lib.rs | 4 ++-- 1 file changed, 2 insertions(+), 2 deletions(-) diff --git a/serde_codegen/src/lib.rs b/serde_codegen/src/lib.rs index 42e3a0c7..25a9fe03 100644 --- a/serde_codegen/src/lib.rs +++ b/serde_codegen/src/lib.rs @@ -169,8 +169,8 @@ macro_rules! shim { use syntax::parse; let name = stringify!($name).to_string(); let cfg = Vec::new(); - let sess = parse::ParseSess::new(); - let impl_item = parse::parse_item_from_source_str(name, expanded, cfg, &sess); + let sess = cx.parse_sess; + let impl_item = parse::parse_item_from_source_str(name, expanded, cfg, sess); push(::syntax::ext::base::Annotatable::Item(impl_item.unwrap().unwrap())); } }; From 1b42f3f594da4a8ad69051b4a3b5cbf08e2a2dfa Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 18 Oct 2016 21:42:39 -0700 Subject: [PATCH 2/5] Release 0.8.14 --- serde/Cargo.toml | 2 +- serde_codegen/Cargo.toml | 2 +- serde_derive/Cargo.toml | 8 ++++---- serde_test/Cargo.toml | 4 ++-- testing/Cargo.toml | 2 +- 5 files changed, 9 insertions(+), 9 deletions(-) diff --git a/serde/Cargo.toml b/serde/Cargo.toml index be52d384..27ea433c 100644 --- a/serde/Cargo.toml +++ b/serde/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "A generic serialization/deserialization framework" diff --git a/serde_codegen/Cargo.toml b/serde_codegen/Cargo.toml index 9df0192c..fdf61d22 100644 --- a/serde_codegen/Cargo.toml +++ b/serde_codegen/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_codegen" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Macros to auto-generate implementations for the serde framework" diff --git a/serde_derive/Cargo.toml b/serde_derive/Cargo.toml index 187755b6..ef27dbb1 100644 --- a/serde_derive/Cargo.toml +++ b/serde_derive/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_derive" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]" @@ -15,7 +15,7 @@ name = "serde_derive" proc-macro = true [dependencies.serde_codegen] -version = "=0.8.13" +version = "=0.8.14" path = "../serde_codegen" default-features = false features = ["with-syn"] @@ -23,5 +23,5 @@ features = ["with-syn"] [dev-dependencies] compiletest_rs = "^0.2.0" fnv = "1.0" -serde = { version = "0.8.13", path = "../serde" } -serde_test = { version = "0.8.13", path = "../serde_test" } +serde = { version = "0.8.14", path = "../serde" } +serde_test = { version = "0.8.14", path = "../serde_test" } diff --git a/serde_test/Cargo.toml b/serde_test/Cargo.toml index 63ae9b53..558569d9 100644 --- a/serde_test/Cargo.toml +++ b/serde_test/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_test" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "Token De/Serializer for testing De/Serialize implementations" @@ -12,4 +12,4 @@ keywords = ["serde", "serialization"] include = ["Cargo.toml", "src/**/*.rs"] [dependencies] -serde = { version = "0.8.13", path = "../serde" } +serde = { version = "0.8.14", path = "../serde" } diff --git a/testing/Cargo.toml b/testing/Cargo.toml index c44975b6..fb7c04e9 100644 --- a/testing/Cargo.toml +++ b/testing/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "serde_testing" -version = "0.8.13" +version = "0.8.14" authors = ["Erick Tryzelaar "] license = "MIT/Apache-2.0" description = "A generic serialization/deserialization framework" From 21c94468908c00c891a9af8da0f9745312433725 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 18 Oct 2016 22:15:54 -0700 Subject: [PATCH 3/5] Update benchmarks to serde 0.8 --- testing/benches/bench.rs | 1 + testing/benches/bench_enum.rs | 42 ++++++++++++++++++++++++++++++++- testing/benches/bench_map.rs | 7 ++++++ testing/benches/bench_struct.rs | 6 +++++ testing/benches/bench_vec.rs | 14 +++++++++++ 5 files changed, 69 insertions(+), 1 deletion(-) diff --git a/testing/benches/bench.rs b/testing/benches/bench.rs index e5b10c57..80ebadac 100644 --- a/testing/benches/bench.rs +++ b/testing/benches/bench.rs @@ -3,6 +3,7 @@ #![cfg_attr(feature = "clippy", plugin(clippy))] extern crate rustc_serialize; +#[macro_use] extern crate serde; extern crate test; diff --git a/testing/benches/bench_enum.rs b/testing/benches/bench_enum.rs index 8badbb49..0e591c5b 100644 --- a/testing/benches/bench_enum.rs +++ b/testing/benches/bench_enum.rs @@ -251,7 +251,7 @@ mod decoder { mod deserializer { use super::{Animal, Error}; - use serde::de; + use serde::de::{self, Deserialize}; #[derive(Debug)] enum State { @@ -336,6 +336,12 @@ mod deserializer { } } } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str + string unit option seq seq_fixed_size bytes map unit_struct + newtype_struct tuple_struct struct struct_field tuple ignored_any + } } struct DogVisitor<'a> { @@ -354,6 +360,24 @@ mod deserializer { fn visit_unit(&mut self) -> Result<(), Error> { de::Deserialize::deserialize(self.de) } + + fn visit_newtype(&mut self) -> Result + where T: Deserialize + { + Err(de::Error::invalid_type(de::Type::TupleVariant)) + } + + fn visit_tuple(&mut self, _len: usize, _visitor: V) -> Result + where V: de::Visitor + { + Err(de::Error::invalid_type(de::Type::TupleVariant)) + } + + fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result + where V: de::Visitor + { + Err(de::Error::invalid_type(de::Type::StructVariant)) + } } struct FrogVisitor<'a> { @@ -377,6 +401,22 @@ mod deserializer { { visitor.visit_seq(self) } + + fn visit_unit(&mut self) -> Result<(), Error> { + Err(de::Error::invalid_type(de::Type::UnitVariant)) + } + + fn visit_newtype(&mut self) -> Result + where T: Deserialize + { + Err(de::Error::invalid_type(de::Type::TupleVariant)) + } + + fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result + where V: de::Visitor + { + Err(de::Error::invalid_type(de::Type::StructVariant)) + } } impl<'a> de::SeqVisitor for FrogVisitor<'a> { diff --git a/testing/benches/bench_map.rs b/testing/benches/bench_map.rs index 32bc4415..bd2bb70f 100644 --- a/testing/benches/bench_map.rs +++ b/testing/benches/bench_map.rs @@ -286,6 +286,13 @@ mod deserializer { } } } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str + string unit option seq seq_fixed_size bytes map unit_struct + newtype_struct tuple_struct struct struct_field tuple enum + ignored_any + } } impl de::MapVisitor for IsizeDeserializer { diff --git a/testing/benches/bench_struct.rs b/testing/benches/bench_struct.rs index 82b189e1..305de666 100644 --- a/testing/benches/bench_struct.rs +++ b/testing/benches/bench_struct.rs @@ -447,6 +447,12 @@ mod deserializer { } } } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str + string unit option seq seq_fixed_size bytes map unit_struct + newtype_struct tuple_struct struct_field tuple enum ignored_any + } } struct OuterMapVisitor<'a> { diff --git a/testing/benches/bench_vec.rs b/testing/benches/bench_vec.rs index 96a4e637..eb71fae9 100644 --- a/testing/benches/bench_vec.rs +++ b/testing/benches/bench_vec.rs @@ -411,6 +411,13 @@ mod deserializer { } } } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str + string unit option seq seq_fixed_size bytes map unit_struct + newtype_struct tuple_struct struct struct_field tuple enum + ignored_any + } } impl de::SeqVisitor for Deserializer { @@ -470,6 +477,13 @@ mod deserializer { } } } + + forward_to_deserialize! { + bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str + string unit option seq seq_fixed_size bytes map unit_struct + newtype_struct tuple_struct struct struct_field tuple enum + ignored_any + } } impl de::SeqVisitor for Deserializer { From 536e78a146d477b4d89a7c72bb0c865586e37fa1 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Tue, 18 Oct 2016 22:19:07 -0700 Subject: [PATCH 4/5] Remove benchmarks Nobody noticed these did not compile for 3 months, so I am guessing nobody cares. The JSON benchmarks at https://github.com/serde-rs/json-benchmark are much more relevant. --- testing/Cargo.toml | 4 - testing/benches/bench.rs | 10 - testing/benches/bench.rs.in | 4 - testing/benches/bench_enum.rs | 506 --------------------- testing/benches/bench_map.rs | 481 -------------------- testing/benches/bench_struct.rs | 751 -------------------------------- testing/benches/bench_vec.rs | 642 --------------------------- testing/build.rs | 12 +- 8 files changed, 3 insertions(+), 2407 deletions(-) delete mode 100644 testing/benches/bench.rs delete mode 100644 testing/benches/bench.rs.in delete mode 100644 testing/benches/bench_enum.rs delete mode 100644 testing/benches/bench_map.rs delete mode 100644 testing/benches/bench_struct.rs delete mode 100644 testing/benches/bench_vec.rs diff --git a/testing/Cargo.toml b/testing/Cargo.toml index fb7c04e9..f03987e6 100644 --- a/testing/Cargo.toml +++ b/testing/Cargo.toml @@ -29,7 +29,3 @@ clippy = { version = "^0.*", optional = true } [[test]] name = "test" path = "tests/test.rs" - -[[bench]] -name = "bench" -path = "benches/bench.rs" diff --git a/testing/benches/bench.rs b/testing/benches/bench.rs deleted file mode 100644 index 80ebadac..00000000 --- a/testing/benches/bench.rs +++ /dev/null @@ -1,10 +0,0 @@ -#![feature(test)] -#![cfg_attr(feature = "clippy", feature(plugin))] -#![cfg_attr(feature = "clippy", plugin(clippy))] - -extern crate rustc_serialize; -#[macro_use] -extern crate serde; -extern crate test; - -include!(concat!(env!("OUT_DIR"), "/bench.rs")); diff --git a/testing/benches/bench.rs.in b/testing/benches/bench.rs.in deleted file mode 100644 index d79b35f0..00000000 --- a/testing/benches/bench.rs.in +++ /dev/null @@ -1,4 +0,0 @@ -mod bench_enum; -mod bench_map; -mod bench_struct; -mod bench_vec; diff --git a/testing/benches/bench_enum.rs b/testing/benches/bench_enum.rs deleted file mode 100644 index 0e591c5b..00000000 --- a/testing/benches/bench_enum.rs +++ /dev/null @@ -1,506 +0,0 @@ -use test::Bencher; -use std::error; -use std::fmt; -use rustc_serialize::Decodable; -use serde; -use serde::de::Deserialize; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub enum Animal { - Dog, - Frog(String, isize) -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Debug)] -pub enum Error { - EndOfStream, - Syntax, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { Error::Syntax } -} - -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 rustc_serialize::Decoder; - - use super::{Animal, Error}; - use super::Animal::{Dog, Frog}; - - enum State { - Animal(Animal), - Isize(isize), - String(String), - } - - pub struct AnimalDecoder { - stack: Vec, - - } - - impl AnimalDecoder { - #[inline] - pub fn new(animal: Animal) -> AnimalDecoder { - AnimalDecoder { - stack: vec!(State::Animal(animal)), - } - } - } - - impl Decoder for AnimalDecoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_isize(&mut self) -> Result { - match self.stack.pop() { - Some(State::Isize(x)) => Ok(x), - _ => Err(Error::Syntax), - } - } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(State::String(x)) => Ok(x), - _ => Err(Error::Syntax), - } - } - - // Compound types: - #[inline] - fn read_enum(&mut self, name: &str, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Animal(animal)) => { - self.stack.push(State::Animal(animal)); - if name == "Animal" { - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax) - } - } - - #[inline] - fn read_enum_variant(&mut self, names: &[&str], f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - let name = match self.stack.pop() { - Some(State::Animal(Dog)) => "Dog", - Some(State::Animal(Frog(x0, x1))) => { - self.stack.push(State::Isize(x1)); - self.stack.push(State::String(x0)); - "Frog" - } - _ => { return Err(Error::Syntax); } - }; - - let idx = match names.iter().position(|n| *n == name) { - Some(idx) => idx, - None => { return Err(Error::Syntax); } - }; - - f(self, idx) - } - - #[inline] - fn read_enum_variant_arg(&mut self, _a_idx: usize, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - f(self) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - f(self, 3) - } - - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut AnimalDecoder) -> Result, - { - Err(Error::Syntax) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use super::{Animal, Error}; - - use serde::de::{self, Deserialize}; - - #[derive(Debug)] - enum State { - Animal(Animal), - Isize(isize), - Str(&'static str), - String(String), - UnitState, - } - - pub struct AnimalDeserializer { - stack: Vec, - } - - impl AnimalDeserializer { - #[inline] - pub fn new(animal: Animal) -> AnimalDeserializer { - AnimalDeserializer { - stack: vec!(State::Animal(animal)), - } - } - } - - impl de::Deserializer for AnimalDeserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Isize(value)) => { - visitor.visit_isize(value) - } - Some(State::String(value)) => { - visitor.visit_string(value) - } - Some(State::Str(value)) => { - visitor.visit_str(value) - } - Some(State::UnitState) => { - visitor.visit_unit() - } - Some(_) => { - Err(Error::Syntax) - } - None => { - Err(Error::EndOfStream) - } - } - } - - #[inline] - fn deserialize_enum(&mut self, - _name: &str, - _variants: &[&str], - mut visitor: V) -> Result - where V: de::EnumVisitor, - { - match self.stack.pop() { - Some(State::Animal(Animal::Dog)) => { - self.stack.push(State::UnitState); - self.stack.push(State::Str("Dog")); - visitor.visit(DogVisitor { - de: self, - }) - } - Some(State::Animal(Animal::Frog(x0, x1))) => { - self.stack.push(State::Isize(x1)); - self.stack.push(State::String(x0)); - self.stack.push(State::Str("Frog")); - visitor.visit(FrogVisitor { - de: self, - state: 0, - }) - } - Some(_) => { - Err(Error::Syntax) - } - None => { - Err(Error::EndOfStream) - } - } - } - - forward_to_deserialize! { - bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str - string unit option seq seq_fixed_size bytes map unit_struct - newtype_struct tuple_struct struct struct_field tuple ignored_any - } - } - - struct DogVisitor<'a> { - de: &'a mut AnimalDeserializer, - } - - impl<'a> de::VariantVisitor for DogVisitor<'a> { - type Error = Error; - - fn visit_variant(&mut self) -> Result - where V: de::Deserialize - { - de::Deserialize::deserialize(self.de) - } - - fn visit_unit(&mut self) -> Result<(), Error> { - de::Deserialize::deserialize(self.de) - } - - fn visit_newtype(&mut self) -> Result - where T: Deserialize - { - Err(de::Error::invalid_type(de::Type::TupleVariant)) - } - - fn visit_tuple(&mut self, _len: usize, _visitor: V) -> Result - where V: de::Visitor - { - Err(de::Error::invalid_type(de::Type::TupleVariant)) - } - - fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result - where V: de::Visitor - { - Err(de::Error::invalid_type(de::Type::StructVariant)) - } - } - - struct FrogVisitor<'a> { - de: &'a mut AnimalDeserializer, - state: usize, - } - - impl<'a> de::VariantVisitor for FrogVisitor<'a> { - type Error = Error; - - fn visit_variant(&mut self) -> Result - where V: de::Deserialize - { - de::Deserialize::deserialize(self.de) - } - - fn visit_tuple(&mut self, - _len: usize, - mut visitor: V) -> Result - where V: de::Visitor, - { - visitor.visit_seq(self) - } - - fn visit_unit(&mut self) -> Result<(), Error> { - Err(de::Error::invalid_type(de::Type::UnitVariant)) - } - - fn visit_newtype(&mut self) -> Result - where T: Deserialize - { - Err(de::Error::invalid_type(de::Type::TupleVariant)) - } - - fn visit_struct(&mut self, _fields: &'static [&'static str], _visitor: V) -> Result - where V: de::Visitor - { - Err(de::Error::invalid_type(de::Type::StructVariant)) - } - } - - impl<'a> de::SeqVisitor for FrogVisitor<'a> { - type Error = Error; - - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.state { - 0 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - 1 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 2 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 2 - self.state; - (len, Some(len)) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -#[bench] -fn bench_decoder_dog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Dog; - - let mut d = decoder::AnimalDecoder::new(animal.clone()); - let value: Animal = Decodable::decode(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_decoder_frog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Frog("Henry".to_owned(), 349); - - let mut d = decoder::AnimalDecoder::new(animal.clone()); - let value: Animal = Decodable::decode(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_deserializer_dog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Dog; - - let mut d = deserializer::AnimalDeserializer::new(animal.clone()); - let value: Animal = Deserialize::deserialize(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} - -#[bench] -fn bench_deserializer_frog(b: &mut Bencher) { - b.iter(|| { - let animal = Animal::Frog("Henry".to_owned(), 349); - - let mut d = deserializer::AnimalDeserializer::new(animal.clone()); - let value: Animal = Deserialize::deserialize(&mut d).unwrap(); - - assert_eq!(value, animal); - }) -} diff --git a/testing/benches/bench_map.rs b/testing/benches/bench_map.rs deleted file mode 100644 index bd2bb70f..00000000 --- a/testing/benches/bench_map.rs +++ /dev/null @@ -1,481 +0,0 @@ -use std::fmt::Debug; -use std::fmt; -use std::error; -use std::collections::HashMap; -use test::Bencher; - -use rustc_serialize::{Decoder, Decodable}; - -use serde; -use serde::de::{Deserializer, Deserialize}; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(PartialEq, Debug)] -pub enum Error { - EndOfStream, - Syntax, - MissingField, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { - Error::MissingField - } -} - -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 std::collections::hash_map::IntoIter; - use rustc_serialize; - - use super::Error; - - enum Value { - String(String), - Isize(isize), - } - - pub struct IsizeDecoder { - len: usize, - iter: IntoIter, - stack: Vec, - } - - impl IsizeDecoder { - #[inline] - pub fn new(values: HashMap) -> IsizeDecoder { - IsizeDecoder { - len: values.len(), - iter: values.into_iter(), - stack: vec!(), - } - } - } - - impl rustc_serialize::Decoder for IsizeDecoder { - type Error = Error; - - fn error(&mut self, _msg: &str) -> Error { - Error::Syntax - } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_isize(&mut self) -> Result { - match self.stack.pop() { - Some(Value::Isize(x)) => Ok(x), - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(Value::String(x)) => Ok(x), - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - fn read_seq(&mut self, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_seq_elt(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_map(&mut self, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_map_elt_key(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(Value::Isize(value)); - self.stack.push(Value::String(key)); - f(self) - } - None => { - Err(Error::Syntax) - } - } - } - - #[inline] - fn read_map_elt_val(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut IsizeDecoder) -> Result, - { - f(self) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use std::collections::HashMap; - use std::collections::hash_map; - - use super::Error; - - use serde::de; - - #[derive(PartialEq, Debug)] - enum State { - StartState, - Key(String), - Value(isize), - } - - pub struct IsizeDeserializer { - stack: Vec, - iter: hash_map::IntoIter, - } - - impl IsizeDeserializer { - #[inline] - pub fn new(values: HashMap) -> IsizeDeserializer { - IsizeDeserializer { - stack: vec!(State::StartState), - iter: values.into_iter(), - } - } - } - - impl de::Deserializer for IsizeDeserializer { - type Error = Error; - - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::StartState) => { - visitor.visit_map(self) - } - Some(State::Key(key)) => { - visitor.visit_string(key) - } - Some(State::Value(value)) => { - visitor.visit_isize(value) - } - None => { - Err(Error::EndOfStream) - } - } - } - - forward_to_deserialize! { - bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str - string unit option seq seq_fixed_size bytes map unit_struct - newtype_struct tuple_struct struct struct_field tuple enum - ignored_any - } - } - - impl de::MapVisitor for IsizeDeserializer { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(State::Value(value)); - self.stack.push(State::Key(key)); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self) - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } - -/* - impl Iterator for IsizeDeserializer { - type Item = Result; - - #[inline] - fn next(&mut self) -> Option> { - match self.stack.pop() { - Some(State::StartState) => { - self.stack.push(KeyOrEndState); - Some(Ok(de::Token::MapStart(self.len))) - } - Some(State::KeyOrEndState) => { - match self.iter.next() { - Some((key, value)) => { - self.stack.push(Value(value)); - Some(Ok(de::Token::String(key))) - } - None => { - self.stack.push(EndState); - Some(Ok(de::Token::End)) - } - } - } - Some(State::Value(x)) => { - self.stack.push(KeyOrEndState); - Some(Ok(de::Token::Isize(x))) - } - Some(EndState) => { - None - } - None => { - None - } - } - } - } - - impl de::Deserializer for IsizeDeserializer { - #[inline] - fn end_of_stream(&mut self) -> Error { - EndOfStream - } - - #[inline] - fn syntax(&mut self, _token: de::Token, _expected: &[de::TokenKind]) -> Error { - Syntax - } - - #[inline] - fn unexpected_name(&mut self, _token: de::Token) -> Error { - Syntax - } - - #[inline] - fn conversion_error(&mut self, _token: de::Token) -> Error { - Syntax - } - - #[inline] - fn missing_field< - T: de::Deserialize - >(&mut self, _field: &'static str) -> Result { - Err(Error::Syntax) - } - } -*/ -} - -////////////////////////////////////////////////////////////////////////////// - -fn run_decoder< - D: Decoder, - T: Clone + PartialEq + Debug + Decodable ->(mut d: D, value: T) { - let v = Decodable::decode(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_decoder_000(b: &mut Bencher) { - b.iter(|| { - let m: HashMap = HashMap::new(); - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -#[bench] -fn bench_decoder_003(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 3 { - m.insert(i.to_string(), i); - } - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -#[bench] -fn bench_decoder_100(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 100 { - m.insert(i.to_string(), i); - } - run_decoder(decoder::IsizeDecoder::new(m.clone()), m) - }) -} - -fn run_deserializer(mut d: D, value: T) - where D: Deserializer, - D::Error: Debug + PartialEq, - T: Clone + PartialEq + Debug + Deserialize -{ - let v = T::deserialize(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_deserializer_000(b: &mut Bencher) { - b.iter(|| { - let m: HashMap = HashMap::new(); - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} - -#[bench] -fn bench_deserializer_003(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 3 { - m.insert(i.to_string(), i); - } - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} - -#[bench] -fn bench_deserializer_100(b: &mut Bencher) { - b.iter(|| { - let mut m: HashMap = HashMap::new(); - for i in 0 .. 100 { - m.insert(i.to_string(), i); - } - run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m) - }) -} diff --git a/testing/benches/bench_struct.rs b/testing/benches/bench_struct.rs deleted file mode 100644 index 305de666..00000000 --- a/testing/benches/bench_struct.rs +++ /dev/null @@ -1,751 +0,0 @@ -use std::collections::HashMap; -use test::Bencher; -use std::fmt; -use std::error; - -use rustc_serialize::Decodable; - -use serde; -use serde::de::Deserialize; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub struct Inner { - a: (), - b: usize, - c: HashMap>, -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] -pub struct Outer { - inner: Vec, -} - -////////////////////////////////////////////////////////////////////////////// - -#[derive(Debug, PartialEq)] -pub enum Error { - EndOfStream, - Syntax, - MissingField, - OtherError, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { - Error::MissingField - } -} - -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; - - use super::{Outer, Inner, Error}; - - #[derive(Debug)] - enum State { - Outer(Outer), - Inner(Inner), - Null, - Usize(usize), - Char(char), - String(String), - Field(&'static str), - Vec(Vec), - Map(HashMap>), - Option(bool), - } - - pub struct OuterDecoder { - stack: Vec, - - } - - impl OuterDecoder { - #[inline] - pub fn new(animal: Outer) -> OuterDecoder { - OuterDecoder { - stack: vec!(State::Outer(animal)), - } - } - } - - impl Decoder for OuterDecoder { - type Error = Error; - - fn error(&mut self, _msg: &str) -> Error { - Error::OtherError - } - - // Primitive types: - #[inline] - fn read_nil(&mut self) -> Result<(), Error> { - match self.stack.pop() { - Some(State::Null) => Ok(()), - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_usize(&mut self) -> Result { - match self.stack.pop() { - Some(State::Usize(value)) => Ok(value), - _ => Err(Error::Syntax), - } - } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_char(&mut self) -> Result { - match self.stack.pop() { - Some(State::Char(c)) => Ok(c), - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_str(&mut self) -> Result { - match self.stack.pop() { - Some(State::String(value)) => Ok(value), - _ => Err(Error::Syntax), - } - } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_struct(&mut self, s_name: &str, _len: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Outer(Outer { inner })) => { - if s_name == "Outer" { - self.stack.push(State::Vec(inner)); - self.stack.push(State::Field("inner")); - f(self) - } else { - Err(Error::Syntax) - } - } - Some(State::Inner(Inner { a: (), b, c })) => { - if s_name == "Inner" { - self.stack.push(State::Map(c)); - self.stack.push(State::Field("c")); - - self.stack.push(State::Usize(b)); - self.stack.push(State::Field("b")); - - self.stack.push(State::Null); - self.stack.push(State::Field("a")); - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_struct_field(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - match self.stack.pop() { - Some(State::Field(name)) => { - if f_name == name { - f(self) - } else { - Err(Error::Syntax) - } - } - _ => Err(Error::Syntax) - } - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - #[inline] - fn read_option(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, bool) -> Result, - { - match self.stack.pop() { - Some(State::Option(b)) => f(self, b), - _ => Err(Error::Syntax), - } - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - match self.stack.pop() { - Some(State::Vec(value)) => { - let len = value.len(); - for inner in value.into_iter().rev() { - self.stack.push(State::Inner(inner)); - } - f(self, len) - } - _ => Err(Error::Syntax) - } - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - - #[inline] - fn read_map(&mut self, f: F) -> Result where - F: FnOnce(&mut OuterDecoder, usize) -> Result, - { - match self.stack.pop() { - Some(State::Map(map)) => { - let len = map.len(); - for (key, value) in map { - match value { - Some(c) => { - self.stack.push(State::Char(c)); - self.stack.push(State::Option(true)); - } - None => { - self.stack.push(State::Option(false)); - } - } - self.stack.push(State::String(key)); - } - f(self, len) - } - _ => Err(Error::Syntax), - } - } - #[inline] - fn read_map_elt_key(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - - #[inline] - fn read_map_elt_val(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut OuterDecoder) -> Result, - { - f(self) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - use std::collections::HashMap; - use std::collections::hash_map; - use std::vec; - use super::{Outer, Inner}; - use super::Error; - use serde::de; - - #[derive(Debug)] - enum State { - Outer(Outer), - Inner(Inner), - Str(&'static str), - Null, - Usize(usize), - Char(char), - String(String), - Option(bool), - Vec(Vec), - Map(HashMap>), - } - - pub struct OuterDeserializer { - stack: Vec, - } - - impl OuterDeserializer { - #[inline] - pub fn new(outer: Outer) -> OuterDeserializer { - OuterDeserializer { - stack: vec!(State::Outer(outer)), - } - } - } - - impl de::Deserializer for OuterDeserializer { - type Error = Error; - - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Vec(value)) => { - visitor.visit_seq(OuterSeqVisitor { - de: self, - iter: value.into_iter(), - }) - } - Some(State::Map(value)) => { - visitor.visit_map(MapVisitor { - de: self, - iter: value.into_iter(), - }) - } - Some(State::Null) => { - visitor.visit_unit() - } - Some(State::Usize(x)) => { - visitor.visit_usize(x) - } - Some(State::Char(x)) => { - visitor.visit_char(x) - } - Some(State::Str(x)) => { - visitor.visit_str(x) - } - Some(State::String(x)) => { - visitor.visit_string(x) - } - Some(State::Option(false)) => { - visitor.visit_none() - } - Some(State::Option(true)) => { - visitor.visit_some(self) - } - Some(_) => Err(Error::Syntax), - None => Err(Error::EndOfStream), - } - } - - fn deserialize_struct(&mut self, - name: &str, - _fields: &'static [&'static str], - mut visitor: V) -> Result - where V: de::Visitor, - { - match self.stack.pop() { - Some(State::Outer(Outer { inner })) => { - if name != "Outer" { - return Err(Error::Syntax); - } - - self.stack.push(State::Vec(inner)); - self.stack.push(State::Str("inner")); - - visitor.visit_map(OuterMapVisitor { - de: self, - state: 0, - }) - } - Some(State::Inner(Inner { a: (), b, c })) => { - if name != "Inner" { - return Err(Error::Syntax); - } - - self.stack.push(State::Map(c)); - self.stack.push(State::Str("c")); - - self.stack.push(State::Usize(b)); - self.stack.push(State::Str("b")); - - self.stack.push(State::Null); - self.stack.push(State::Str("a")); - - visitor.visit_map(InnerMapVisitor { - de: self, - state: 0, - }) - } - _ => { - Err(Error::Syntax) - } - } - } - - forward_to_deserialize! { - bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str - string unit option seq seq_fixed_size bytes map unit_struct - newtype_struct tuple_struct struct_field tuple enum ignored_any - } - } - - struct OuterMapVisitor<'a> { - de: &'a mut OuterDeserializer, - state: usize, - } - - impl<'a> de::MapVisitor for OuterMapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.state { - 0 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 1 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 1 - self.state; - (len, Some(len)) - } - } - - struct OuterSeqVisitor<'a> { - de: &'a mut OuterDeserializer, - iter: vec::IntoIter, - } - - impl<'a> de::SeqVisitor for OuterSeqVisitor<'a> { - type Error = Error; - - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.de.stack.push(State::Inner(value)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - None => { - Ok(None) - } - } - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } - - struct InnerMapVisitor<'a> { - de: &'a mut OuterDeserializer, - state: usize, - } - - impl<'a> de::MapVisitor for InnerMapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.state { - 0 ... 2 => { - self.state += 1; - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - _ => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - if self.state == 3 { - Ok(()) - } else { - Err(Error::Syntax) - } - } - - fn size_hint(&self) -> (usize, Option) { - let len = 1 - self.state; - (len, Some(len)) - } - } - - struct MapVisitor<'a> { - de: &'a mut OuterDeserializer, - iter: hash_map::IntoIter>, - } - - impl<'a> de::MapVisitor for MapVisitor<'a> { - type Error = Error; - - fn visit_key(&mut self) -> Result, Error> - where K: de::Deserialize, - { - match self.iter.next() { - Some((key, Some(value))) => { - self.de.stack.push(State::Char(value)); - self.de.stack.push(State::Option(true)); - self.de.stack.push(State::String(key)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - Some((key, None)) => { - self.de.stack.push(State::Option(false)); - self.de.stack.push(State::String(key)); - Ok(Some(try!(de::Deserialize::deserialize(self.de)))) - } - None => { - Ok(None) - } - } - } - - fn visit_value(&mut self) -> Result - where V: de::Deserialize, - { - de::Deserialize::deserialize(self.de) - } - - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => Ok(()), - } - } - - fn size_hint(&self) -> (usize, Option) { - self.iter.size_hint() - } - } -} - -#[bench] -fn bench_decoder_0_0(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("abc".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!(), - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_decoder_1_0(b: &mut Bencher) { - b.iter(|| { - let map = HashMap::new(); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_decoder_1_5(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("1".to_owned(), Some('a')); - map.insert("2".to_owned(), None); - map.insert("3".to_owned(), Some('b')); - map.insert("4".to_owned(), None); - map.insert("5".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = decoder::OuterDecoder::new(outer.clone()); - let value: Result = Decodable::decode(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_0_0(b: &mut Bencher) { - b.iter(|| { - let outer = Outer { - inner: vec!(), - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_1_0(b: &mut Bencher) { - b.iter(|| { - let map = HashMap::new(); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} - -#[bench] -fn bench_deserializer_1_5(b: &mut Bencher) { - b.iter(|| { - let mut map = HashMap::new(); - map.insert("1".to_owned(), Some('a')); - map.insert("2".to_owned(), None); - map.insert("3".to_owned(), Some('b')); - map.insert("4".to_owned(), None); - map.insert("5".to_owned(), Some('c')); - - let outer = Outer { - inner: vec!( - Inner { - a: (), - b: 5, - c: map, - }, - ) - }; - - let mut d = deserializer::OuterDeserializer::new(outer.clone()); - let value: Result = Deserialize::deserialize(&mut d); - - assert_eq!(value, Ok(outer)); - }) -} diff --git a/testing/benches/bench_vec.rs b/testing/benches/bench_vec.rs deleted file mode 100644 index eb71fae9..00000000 --- a/testing/benches/bench_vec.rs +++ /dev/null @@ -1,642 +0,0 @@ -use std::fmt::Debug; -use std::fmt; -use std::error; -use test::Bencher; - -use rustc_serialize::{Decoder, Decodable}; - -use serde; -use serde::de::{Deserializer, Deserialize}; - -////////////////////////////////////////////////////////////////////////////// - -#[derive(PartialEq, Debug)] -pub enum Error { - EndOfStream, - Syntax, -} - -impl serde::de::Error for Error { - fn custom>(_: T) -> Error { Error::Syntax } - - fn end_of_stream() -> Error { Error::EndOfStream } - - fn unknown_field(_: &str) -> Error { Error::Syntax } - - fn missing_field(_: &'static str) -> Error { Error::Syntax } -} - -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::vec; - use rustc_serialize; - - use super::Error; - - pub struct UsizeDecoder { - len: usize, - iter: vec::IntoIter, - } - - impl UsizeDecoder { - #[inline] - pub fn new(values: Vec) -> UsizeDecoder { - UsizeDecoder { - len: values.len(), - iter: values.into_iter(), - } - } - } - - impl rustc_serialize::Decoder for UsizeDecoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - #[inline] - fn read_usize(&mut self) -> Result { - match self.iter.next() { - Some(value) => Ok(value), - None => Err(Error::EndOfStream), - } - } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - fn read_u8(&mut self) -> Result { Err(Error::Syntax) } - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - fn read_str(&mut self) -> Result { Err(Error::Syntax) } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut UsizeDecoder) -> Result, - { - Err(Error::Syntax) - } - } - - - pub struct U8Decoder { - len: usize, - iter: vec::IntoIter, - } - - impl U8Decoder { - #[inline] - pub fn new(values: Vec) -> U8Decoder { - U8Decoder { - len: values.len(), - iter: values.into_iter(), - } - } - } - - impl rustc_serialize::Decoder for U8Decoder { - type Error = Error; - - fn error(&mut self, _: &str) -> Error { Error::Syntax } - - // Primitive types: - fn read_nil(&mut self) -> Result<(), Error> { Err(Error::Syntax) } - fn read_usize(&mut self) -> Result { Err(Error::Syntax) } - fn read_u64(&mut self) -> Result { Err(Error::Syntax) } - fn read_u32(&mut self) -> Result { Err(Error::Syntax) } - fn read_u16(&mut self) -> Result { Err(Error::Syntax) } - #[inline] - fn read_u8(&mut self) -> Result { - match self.iter.next() { - Some(value) => Ok(value), - None => Err(Error::EndOfStream), - } - } - #[inline] - fn read_isize(&mut self) -> Result { Err(Error::Syntax) } - fn read_i64(&mut self) -> Result { Err(Error::Syntax) } - fn read_i32(&mut self) -> Result { Err(Error::Syntax) } - fn read_i16(&mut self) -> Result { Err(Error::Syntax) } - fn read_i8(&mut self) -> Result { Err(Error::Syntax) } - fn read_bool(&mut self) -> Result { Err(Error::Syntax) } - fn read_f64(&mut self) -> Result { Err(Error::Syntax) } - fn read_f32(&mut self) -> Result { Err(Error::Syntax) } - fn read_char(&mut self) -> Result { Err(Error::Syntax) } - fn read_str(&mut self) -> Result { Err(Error::Syntax) } - - // Compound types: - fn read_enum(&mut self, _name: &str, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_variant_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant(&mut self, _names: &[&str], _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_enum_struct_variant_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_struct_field(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple(&mut self, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct(&mut self, _s_name: &str, _len: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_tuple_struct_arg(&mut self, _a_idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - // Specialized types: - fn read_option(&mut self, _f: F) -> Result where - F: FnOnce(&mut U8Decoder, bool) -> Result, - { - Err(Error::Syntax) - } - - #[inline] - fn read_seq(&mut self, f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - let len = self.len; - f(self, len) - } - #[inline] - fn read_seq_elt(&mut self, _idx: usize, f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - f(self) - } - - fn read_map(&mut self, _f: F) -> Result where - F: FnOnce(&mut U8Decoder, usize) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_key(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - - fn read_map_elt_val(&mut self, _idx: usize, _f: F) -> Result where - F: FnOnce(&mut U8Decoder) -> Result, - { - Err(Error::Syntax) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -mod deserializer { - //use std::num; - use std::vec; - - use super::Error; - - use serde::de; - - #[derive(PartialEq, Debug)] - enum State { - Start, - SepOrEnd, - End, - } - - pub struct Deserializer { - state: State, - iter: vec::IntoIter, - len: usize, - value: Option, - } - - impl Deserializer { - #[inline] - pub fn new(values: Vec) -> Deserializer { - let len = values.len(); - Deserializer { - state: State::Start, - iter: values.into_iter(), - len: len, - value: None, - } - } - } - - impl de::Deserializer for Deserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.state { - State::Start => { - self.state = State::SepOrEnd; - visitor.visit_seq(self) - } - State::SepOrEnd => { - visitor.visit_usize(self.value.take().unwrap()) - } - State::End => { - Err(Error::EndOfStream) - } - } - } - - forward_to_deserialize! { - bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str - string unit option seq seq_fixed_size bytes map unit_struct - newtype_struct tuple_struct struct struct_field tuple enum - ignored_any - } - } - - impl de::SeqVisitor for Deserializer { - type Error = Error; - - #[inline] - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.len -= 1; - self.value = Some(value); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - self.state = State::End; - Ok(None) - } - } - } - - #[inline] - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => { - self.state = State::End; - Ok(()) - } - } - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) - } - } - - impl de::Deserializer for Deserializer { - type Error = Error; - - #[inline] - fn deserialize(&mut self, mut visitor: V) -> Result - where V: de::Visitor, - { - match self.state { - State::Start => { - self.state = State::SepOrEnd; - visitor.visit_seq(self) - } - State::SepOrEnd => { - visitor.visit_u8(self.value.take().unwrap()) - } - State::End => { - Err(Error::EndOfStream) - } - } - } - - forward_to_deserialize! { - bool usize u8 u16 u32 u64 isize i8 i16 i32 i64 f32 f64 char str - string unit option seq seq_fixed_size bytes map unit_struct - newtype_struct tuple_struct struct struct_field tuple enum - ignored_any - } - } - - impl de::SeqVisitor for Deserializer { - type Error = Error; - - #[inline] - fn visit(&mut self) -> Result, Error> - where T: de::Deserialize, - { - match self.iter.next() { - Some(value) => { - self.len -= 1; - self.value = Some(value); - Ok(Some(try!(de::Deserialize::deserialize(self)))) - } - None => { - self.state = State::End; - Ok(None) - } - } - } - - #[inline] - fn end(&mut self) -> Result<(), Error> { - match self.iter.next() { - Some(_) => Err(Error::Syntax), - None => { - self.state = State::End; - Ok(()) - } - } - } - - #[inline] - fn size_hint(&self) -> (usize, Option) { - (self.len, Some(self.len)) - } - } -} - -////////////////////////////////////////////////////////////////////////////// - -fn run_decoder< - D: Decoder, - T: Clone + PartialEq + Debug + Decodable ->(mut d: D, value: T) { - let v = Decodable::decode(&mut d); - - assert_eq!(Ok(value), v); -} - -fn run_deserializer(mut d: D, value: T) - where D: Deserializer, - D::Error: Debug + PartialEq, - T: Clone + PartialEq + Debug + Deserialize -{ - let v = T::deserialize(&mut d); - - assert_eq!(Ok(value), v); -} - -#[bench] -fn bench_decoder_usize_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_usize_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_usize_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_decoder(decoder::UsizeDecoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_decoder_u8_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_decoder(decoder::U8Decoder::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_usize_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_000(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_003(b: &mut Bencher) { - b.iter(|| { - let v: Vec = vec!(1, 2, 3); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} - -#[bench] -fn bench_deserializer_u8_100(b: &mut Bencher) { - b.iter(|| { - let v: Vec = (0 .. 100).collect(); - run_deserializer(deserializer::Deserializer::new(v.clone()), v) - }) -} diff --git a/testing/build.rs b/testing/build.rs index ad175e85..bf4a763b 100644 --- a/testing/build.rs +++ b/testing/build.rs @@ -5,13 +5,7 @@ use std::path::Path; fn main() { let out_dir = env::var_os("OUT_DIR").unwrap(); - - for &(src, dst) in &[ - ("tests/test.rs.in", "test.rs"), - ("benches/bench.rs.in", "bench.rs"), - ] { - let src = Path::new(src); - let dst = Path::new(&out_dir).join(dst); - serde_codegen::expand(&src, &dst).unwrap(); - } + let src = Path::new("tests/test.rs.in"); + let dst = Path::new(&out_dir).join("test.rs"); + serde_codegen::expand(&src, &dst).unwrap(); } From bb5370b74659490326609032f1d6f5c0be8f93d2 Mon Sep 17 00:00:00 2001 From: David Tolnay Date: Wed, 19 Oct 2016 00:30:23 -0700 Subject: [PATCH 5/5] No longer need `e!` --- serde/src/ser/impls.rs | 7 +------ 1 file changed, 1 insertion(+), 6 deletions(-) diff --git a/serde/src/ser/impls.rs b/serde/src/ser/impls.rs index 58a1683e..5653a717 100644 --- a/serde/src/ser/impls.rs +++ b/serde/src/ser/impls.rs @@ -313,11 +313,6 @@ impl Serialize for () { /////////////////////////////////////////////////////////////////////////////// -// FIXME(rust #19630) Remove this work-around -macro_rules! e { - ($e:expr) => { $e } -} - macro_rules! tuple_impls { ($( $TupleVisitor:ident ($len:expr, $($T:ident),+) { @@ -334,7 +329,7 @@ macro_rules! tuple_impls { { let mut state = try!(serializer.serialize_tuple($len)); $( - try!(serializer.serialize_tuple_elt(&mut state, &e!(self.$idx))); + try!(serializer.serialize_tuple_elt(&mut state, &self.$idx)); )+ serializer.serialize_tuple_end(state) }