Switch to the new custom_deserialize syntax

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)

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,

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<Inner>,
 }

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)]")
     }
 }
 

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)));
 }

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)]")
     }
 }
 

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,

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),

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<isize>),
@@ -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<String>,
 }
 
-#[derive(Clone, Debug, PartialEq)]
-#[derive_serialize]
-#[derive_deserialize]
+#[derive(Clone, Debug, PartialEq, Serialize, Deserialize)]
 struct Outer {
     inner: Vec<Inner>,
 }
@@ -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<isize>,
     }
@@ -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<u32>,
     }

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>(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, B, C> {
     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<B, C: /* Trait */, D> /* where D: Trait */ {
     Unit,
     Seq(

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),