From 5378d22708eb19cd9b111266fe3a681d427993cc Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 19 Mar 2015 07:49:42 -0700 Subject: [PATCH] Switch to the new custom_deserialize syntax --- benches/bench_enum.rs | 3 +-- benches/bench_log.rs | 12 +++--------- benches/bench_struct.rs | 6 ++---- serde_macros/src/de.rs | 4 ++-- serde_macros/src/lib.rs | 4 ++-- serde_macros/src/ser.rs | 4 ++-- src/json/mod.rs | 5 ++--- tests/test_de.rs | 12 ++++-------- tests/test_json.rs | 19 +++++-------------- tests/test_macros.rs | 22 +++++++--------------- tests/test_ser.rs | 8 ++++---- 11 files changed, 34 insertions(+), 65 deletions(-) diff --git a/benches/bench_enum.rs b/benches/bench_enum.rs index 3381404b..1a6e0150 100644 --- a/benches/bench_enum.rs +++ b/benches/bench_enum.rs @@ -15,8 +15,7 @@ use Animal::{Dog, Frog}; ////////////////////////////////////////////////////////////////////////////// -#[derive(Clone, PartialEq, Debug, RustcDecodable)] -#[derive_deserialize] +#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] pub enum Animal { Dog, Frog(String, isize) diff --git a/benches/bench_log.rs b/benches/bench_log.rs index 65796ca2..eb4b8f1a 100644 --- a/benches/bench_log.rs +++ b/benches/bench_log.rs @@ -17,9 +17,7 @@ use serde::ser::{self, Serialize, Serializer}; use rustc_serialize::Encodable; -#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)] struct Http { protocol: HttpProtocol, status: u32, @@ -161,9 +159,7 @@ impl de::Deserialize for CacheStatus { } } -#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)] struct Origin { ip: String, port: u32, @@ -546,9 +542,7 @@ impl de::Deserialize for Country { } } -#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Debug, PartialEq, RustcEncodable, RustcDecodable, Serialize, Deserialize)] struct Log { timestamp: i64, zone_id: u32, diff --git a/benches/bench_struct.rs b/benches/bench_struct.rs index 4000227a..c625a555 100644 --- a/benches/bench_struct.rs +++ b/benches/bench_struct.rs @@ -14,8 +14,7 @@ use serde::de::{Deserializer, Deserialize}; ////////////////////////////////////////////////////////////////////////////// -#[derive(Clone, PartialEq, Debug, RustcDecodable)] -#[derive_deserialize] +#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] pub struct Inner { a: (), b: usize, @@ -24,8 +23,7 @@ pub struct Inner { ////////////////////////////////////////////////////////////////////////////// -#[derive(Clone, PartialEq, Debug, RustcDecodable)] -#[derive_deserialize] +#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)] pub struct Outer { inner: Vec, } diff --git a/serde_macros/src/de.rs b/serde_macros/src/de.rs index ff512979..ecbfc95d 100644 --- a/serde_macros/src/de.rs +++ b/serde_macros/src/de.rs @@ -28,7 +28,7 @@ pub fn expand_derive_deserialize( let generics = match item.node { ast::ItemStruct(_, ref generics) => generics, ast::ItemEnum(_, ref generics) => generics, - _ => cx.bug("expected ItemStruct or ItemEnum in #[derive_deserialize]") + _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Deserialize)]") }; let impl_generics = builder.from_generics(generics.clone()) @@ -93,7 +93,7 @@ fn deserialize_body( enum_def, ) } - _ => cx.bug("expected ItemStruct or ItemEnum in #[derive_deserialize]") + _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Deserialize)]") } } diff --git a/serde_macros/src/lib.rs b/serde_macros/src/lib.rs index 7c7f6569..6af23dde 100644 --- a/serde_macros/src/lib.rs +++ b/serde_macros/src/lib.rs @@ -18,10 +18,10 @@ mod field; #[doc(hidden)] pub fn plugin_registrar(reg: &mut Registry) { reg.register_syntax_extension( - token::intern("derive_serialize"), + token::intern("derive_Serialize"), Decorator(Box::new(ser::expand_derive_serialize))); reg.register_syntax_extension( - token::intern("derive_deserialize"), + token::intern("derive_Deserialize"), Decorator(Box::new(de::expand_derive_deserialize))); } diff --git a/serde_macros/src/ser.rs b/serde_macros/src/ser.rs index fb6bb9bf..cbc11b0a 100644 --- a/serde_macros/src/ser.rs +++ b/serde_macros/src/ser.rs @@ -27,7 +27,7 @@ pub fn expand_derive_serialize( let generics = match item.node { ast::ItemStruct(_, ref generics) => generics, ast::ItemEnum(_, ref generics) => generics, - _ => cx.bug("expected ItemStruct or ItemEnum in #[derive_serialize]") + _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]") }; let impl_generics = builder.from_generics(generics.clone()) @@ -91,7 +91,7 @@ fn serialize_body( enum_def, ) } - _ => cx.bug("expected ItemStruct or ItemEnum in #[derive_serialize]") + _ => cx.bug("expected ItemStruct or ItemEnum in #[derive(Serialize)]") } } diff --git a/src/json/mod.rs b/src/json/mod.rs index 90220135..4db28916 100644 --- a/src/json/mod.rs +++ b/src/json/mod.rs @@ -46,7 +46,7 @@ //! from JSON via the serialization API. To be able to serialize a piece of data, it must implement //! the `serde::Serialize` trait. To be able to deserialize a piece of data, it must implement the //! `serde::Deserialize` trait. Serde provides provides an annotation to automatically generate -//! the code for these traits: `#[derive_serialize]` and `#[derive_deserialize]`. +//! the code for these traits: `#[derive(Serialize, Deserialize)]`. //! //! The JSON API also provides an enum `serde::json::Value` and a method `to_value` to serialize //! objects. A `serde::json::Value` value can be serialized as a string or buffer using the @@ -70,8 +70,7 @@ //! use serde::json; //! //! // Automatically generate `Serialize` and `Deserialize` trait implementations -//! #[derive_serialize] -//! #[derive_deserialize] +//! #[derive(Serialize, Deserialize)] //! pub struct TestStruct { //! data_int: u8, //! data_str: String, diff --git a/tests/test_de.rs b/tests/test_de.rs index ee2232f3..53e3a50e 100644 --- a/tests/test_de.rs +++ b/tests/test_de.rs @@ -297,24 +297,20 @@ impl<'a, 'b> de::VariantVisitor for TokenDeserializerVariantVisitor<'a, 'b> { ////////////////////////////////////////////////////////////////////////// -#[derive(Copy, PartialEq, Debug)] -#[derive_deserialize] +#[derive(Copy, PartialEq, Debug, Deserialize)] struct NamedUnit; -#[derive(PartialEq, Debug)] -#[derive_deserialize] +#[derive(PartialEq, Debug, Deserialize)] struct NamedSeq(i32, i32, i32); -#[derive(PartialEq, Debug)] -#[derive_deserialize] +#[derive(PartialEq, Debug, Deserialize)] struct NamedMap { a: i32, b: i32, c: i32, } -#[derive(PartialEq, Debug)] -#[derive_deserialize] +#[derive(PartialEq, Debug, Deserialize)] enum Enum { Unit, Seq(i32, i32, i32), diff --git a/tests/test_json.rs b/tests/test_json.rs index 02381bf1..f3da0078 100644 --- a/tests/test_json.rs +++ b/tests/test_json.rs @@ -28,9 +28,7 @@ macro_rules! treemap { }) } -#[derive(Clone, Debug, PartialEq)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] enum Animal { Dog, Frog(String, Vec), @@ -38,18 +36,14 @@ enum Animal { } -#[derive(Clone, Debug, PartialEq)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] struct Inner { a: (), b: usize, c: Vec, } -#[derive(Clone, Debug, PartialEq)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] struct Outer { inner: Vec, } @@ -903,9 +897,7 @@ fn test_parse_option() { ("\"jodhpurs\"", Some("jodhpurs".to_string())), ]); - #[derive(Clone, Debug, PartialEq)] - #[derive_serialize] - #[derive_deserialize] + #[derive(Clone, Debug, PartialEq, Serialize, Deserialize)] struct Foo { x: Option, } @@ -990,8 +982,7 @@ fn test_multiline_errors() { #[test] fn test_missing_field() { - #[derive(Debug, PartialEq)] - #[derive_deserialize] + #[derive(Debug, PartialEq, Deserialize)] struct Foo { x: Option, } diff --git a/tests/test_macros.rs b/tests/test_macros.rs index 6ee0f780..5f465d11 100644 --- a/tests/test_macros.rs +++ b/tests/test_macros.rs @@ -25,37 +25,30 @@ trait Trait { } */ -#[derive(Debug, PartialEq)] -#[derive_serialize] -#[derive_deserialize] +#[derive(Debug, PartialEq, Serialize, Deserialize)] struct NamedUnit; -#[derive(Debug, PartialEq)] -#[derive_serialize] +#[derive(Debug, PartialEq, Serialize)] struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C); -#[derive(Debug, PartialEq)] -#[derive_deserialize] +#[derive(Debug, PartialEq, Deserialize)] struct DeNamedTuple(A, B, C); -#[derive(Debug, PartialEq)] -#[derive_serialize] +#[derive(Debug, PartialEq, Serialize)] struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> { a: &'a A, b: &'b mut B, c: C, } -#[derive(Debug, PartialEq)] -#[derive_deserialize] +#[derive(Debug, PartialEq, Deserialize)] struct DeNamedMap { a: A, b: B, c: C, } -#[derive(Debug, PartialEq)] -#[derive_serialize] +#[derive(Debug, PartialEq, Serialize)] enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a { Unit, Seq( @@ -95,8 +88,7 @@ enum SerEnum<'a, B: 'a, C: /* Trait + */ 'a, D> where D: /* Trait + */ 'a { }, } -#[derive(Debug, PartialEq)] -#[derive_deserialize] +#[derive(Debug, PartialEq, Deserialize)] enum DeEnum /* where D: Trait */ { Unit, Seq( diff --git a/tests/test_ser.rs b/tests/test_ser.rs index b8979820..787c8ca6 100644 --- a/tests/test_ser.rs +++ b/tests/test_ser.rs @@ -267,20 +267,20 @@ impl<'a> Serializer for AssertSerializer<'a> { ////////////////////////////////////////////////////////////////////////// -#[derive_serialize] +#[derive(Serialize)] struct NamedUnit; -#[derive_serialize] +#[derive(Serialize)] struct NamedSeq(i32, i32, i32); -#[derive_serialize] +#[derive(Serialize)] struct NamedMap { a: i32, b: i32, c: i32, } -#[derive_serialize] +#[derive(Serialize)] enum Enum { Unit, Seq(i32, i32),