Release 0.8.23

Add categories to Cargo.toml
Release 0.8.22
2026-04-23 09:28:04 +00:00 · 2017-01-20 15:25:57 -08:00 · 2017-01-20 15:09:11 -08:00 · 2017-01-10 17:10:26 -08:00 · 2017-01-08 00:18:37 -08:00 · 2017-01-08 00:11:11 -08:00
40 changed files with 373 additions and 2913 deletions
@@ -1,17 +1,11 @@
 sudo: false
 language: rust
 rust:
+- 1.12.0
+- 1.13.0
 - stable
- nightly
- 1.8.0
- 1.9.0
 - beta
-addons:
-  apt:
-    packages:
-    - libcurl4-openssl-dev
-    - libelf-dev
-    - libdw-dev
+- nightly
 before_script:
 - pip install 'travis-cargo<0.2' --user
 - export PATH=$HOME/.local/bin:$PATH
@@ -28,8 +22,6 @@ script:
 - (cd examples/serde-syntex-example && travis-cargo --skip nightly run)
 - (cd examples/serde-syntex-example && travis-cargo --only nightly run -- --no-default-features --features unstable)
 - (cd serde && travis-cargo --only stable doc)
-after_success:
- (cd testing && travis-cargo --only stable coveralls --no-sudo)
 env:
  global:
  - TRAVIS_CARGO_NIGHTLY_FEATURE=""
@@ -11,12 +11,11 @@ You may be looking for:
 - [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)

 ## Serde in action

 ```rust
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -3,6 +3,7 @@ name = "serde-syntex-example"
 version = "0.1.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 build = "build.rs"
+publish = false

 [features]
 default = ["serde_codegen"]
@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.8.12"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -9,6 +9,7 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde/"
 readme = "../README.md"
 keywords = ["serde", "serialization"]
+categories = ["encoding"]
 include = ["Cargo.toml", "src/**/*.rs"]

 [features]
@@ -84,7 +84,7 @@ mod bytebuf {
    use de;

    #[cfg(feature = "collections")]
-    use collections::Vec;
+    use collections::{String, Vec};

    /// `ByteBuf` wraps a `Vec<u8>` and serializes as a byte array.
    #[derive(Clone, Default, Eq, Hash, PartialEq, PartialOrd, Ord)]
@@ -208,7 +208,7 @@ mod bytebuf {
        fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<ByteBuf, E>
            where E: de::Error,
        {
-            self.visit_byte_buf(v.to_vec())
+            Ok(ByteBuf::from(v))
        }

        #[inline]
@@ -217,6 +217,18 @@ mod bytebuf {
        {
            Ok(ByteBuf::from(v))
        }
+
+        fn visit_str<E>(&mut self, v: &str) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
+
+        fn visit_string<E>(&mut self, v: String) -> Result<ByteBuf, E>
+            where E: de::Error,
+        {
+            Ok(ByteBuf::from(v))
+        }
    }

    impl de::Deserialize for ByteBuf {
@@ -283,6 +283,12 @@ impl Visitor for StringVisitor {
        Ok(v)
    }

+    fn visit_unit<E>(&mut self) -> Result<String, E>
+        where E: Error,
+    {
+        Ok(String::new())
+    }
+
    fn visit_bytes<E>(&mut self, v: &[u8]) -> Result<String, E>
        where E: Error,
    {
@@ -512,27 +518,26 @@ seq_impl!(

 ///////////////////////////////////////////////////////////////////////////////

-struct ArrayVisitor0<T> {
-    marker: PhantomData<T>,
+struct ArrayVisitor<A> {
+    marker: PhantomData<A>,
 }

-impl<T> ArrayVisitor0<T> {
-    /// Construct a `ArrayVisitor0<T>`.
+impl<A> ArrayVisitor<A> {
    pub fn new() -> Self {
-        ArrayVisitor0 {
+        ArrayVisitor {
            marker: PhantomData,
        }
    }
 }

-impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
+impl<T> Visitor for ArrayVisitor<[T; 0]> where T: Deserialize {
    type Value = [T; 0];

    #[inline]
    fn visit_unit<E>(&mut self) -> Result<[T; 0], E>
        where E: Error,
    {
-        Ok([T::default(); 0])
+        Ok([])
    }

    #[inline]
@@ -540,37 +545,24 @@ impl<T> Visitor for ArrayVisitor0<T> where T: Deserialize + Default {
        where V: SeqVisitor,
    {
        try!(visitor.end());
-        Ok([T::default(); 0])
+        Ok([])
    }
 }

 impl<T> Deserialize for [T; 0]
-    where T: Deserialize + Default
+    where T: Deserialize
 {
    fn deserialize<D>(deserializer: &mut D) -> Result<[T; 0], D::Error>
        where D: Deserializer,
    {
-        deserializer.deserialize_seq(ArrayVisitor0::new())
+        deserializer.deserialize_seq_fixed_size(0, ArrayVisitor::<[T; 0]>::new())
    }
 }

 macro_rules! array_impls {
-    ($($visitor:ident, $len:expr => ($($name:ident),+),)+) => {
+    ($($len:expr => ($($name:ident)+))+) => {
        $(
-            struct $visitor<T> {
-                marker: PhantomData<T>,
-            }
-
-            impl<T> $visitor<T> {
-                /// Construct a `ArrayVisitor*<T>`.
-                pub fn new() -> Self {
-                    $visitor {
-                        marker: PhantomData
-                    }
-                }
-            }
-
-            impl<T> Visitor for $visitor<T> where T: Deserialize {
+            impl<T> Visitor for ArrayVisitor<[T; $len]> where T: Deserialize {
                type Value = [T; $len];

                #[inline]
@@ -580,13 +572,13 @@ macro_rules! array_impls {
                    $(
                        let $name = match try!(visitor.visit()) {
                            Some(val) => val,
-                            None => { return Err(Error::end_of_stream()); }
+                            None => return Err(Error::end_of_stream()),
                        };
-                    )+;
+                    )+

                    try!(visitor.end());

-                    Ok([$($name,)+])
+                    Ok([$($name),+])
                }
            }

@@ -596,7 +588,7 @@ macro_rules! array_impls {
                fn deserialize<D>(deserializer: &mut D) -> Result<[T; $len], D::Error>
                    where D: Deserializer,
                {
-                    deserializer.deserialize_seq_fixed_size($len, $visitor::new())
+                    deserializer.deserialize_seq_fixed_size($len, ArrayVisitor::<[T; $len]>::new())
                }
            }
        )+
@@ -604,71 +596,58 @@ macro_rules! array_impls {
 }

 array_impls! {
-    ArrayVisitor1, 1 => (a),
-    ArrayVisitor2, 2 => (a, b),
-    ArrayVisitor3, 3 => (a, b, c),
-    ArrayVisitor4, 4 => (a, b, c, d),
-    ArrayVisitor5, 5 => (a, b, c, d, e),
-    ArrayVisitor6, 6 => (a, b, c, d, e, f),
-    ArrayVisitor7, 7 => (a, b, c, d, e, f, g),
-    ArrayVisitor8, 8 => (a, b, c, d, e, f, g, h),
-    ArrayVisitor9, 9 => (a, b, c, d, e, f, g, h, i),
-    ArrayVisitor10, 10 => (a, b, c, d, e, f, g, h, i, j),
-    ArrayVisitor11, 11 => (a, b, c, d, e, f, g, h, i, j, k),
-    ArrayVisitor12, 12 => (a, b, c, d, e, f, g, h, i, j, k, l),
-    ArrayVisitor13, 13 => (a, b, c, d, e, f, g, h, i, j, k, l, m),
-    ArrayVisitor14, 14 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n),
-    ArrayVisitor15, 15 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o),
-    ArrayVisitor16, 16 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p),
-    ArrayVisitor17, 17 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q),
-    ArrayVisitor18, 18 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r),
-    ArrayVisitor19, 19 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s),
-    ArrayVisitor20, 20 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s ,t),
-    ArrayVisitor21, 21 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u),
-    ArrayVisitor22, 22 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v),
-    ArrayVisitor23, 23 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w),
-    ArrayVisitor24, 24 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x),
-    ArrayVisitor25, 25 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y),
-    ArrayVisitor26, 26 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z),
-    ArrayVisitor27, 27 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa),
-    ArrayVisitor28, 28 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa, ab),
-    ArrayVisitor29, 29 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa, ab, ac),
-    ArrayVisitor30, 30 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa, ab, ac, ad),
-    ArrayVisitor31, 31 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa, ab, ac, ad, ae),
-    ArrayVisitor32, 32 => (a, b, c, d, e, f, g, h, i, j, k, l, m, n, o, p, q, r, s, t, u, v, w, x,
-                           y, z, aa, ab, ac, ad, ae, af),
+    1 => (a)
+    2 => (a b)
+    3 => (a b c)
+    4 => (a b c d)
+    5 => (a b c d e)
+    6 => (a b c d e f)
+    7 => (a b c d e f g)
+    8 => (a b c d e f g h)
+    9 => (a b c d e f g h i)
+    10 => (a b c d e f g h i j)
+    11 => (a b c d e f g h i j k)
+    12 => (a b c d e f g h i j k l)
+    13 => (a b c d e f g h i j k l m)
+    14 => (a b c d e f g h i j k l m n)
+    15 => (a b c d e f g h i j k l m n o)
+    16 => (a b c d e f g h i j k l m n o p)
+    17 => (a b c d e f g h i j k l m n o p q)
+    18 => (a b c d e f g h i j k l m n o p q r)
+    19 => (a b c d e f g h i j k l m n o p q r s)
+    20 => (a b c d e f g h i j k l m n o p q r s t)
+    21 => (a b c d e f g h i j k l m n o p q r s t u)
+    22 => (a b c d e f g h i j k l m n o p q r s t u v)
+    23 => (a b c d e f g h i j k l m n o p q r s t u v w)
+    24 => (a b c d e f g h i j k l m n o p q r s t u v w x)
+    25 => (a b c d e f g h i j k l m n o p q r s t u v w x y)
+    26 => (a b c d e f g h i j k l m n o p q r s t u v w x y z)
+    27 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa)
+    28 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab)
+    29 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac)
+    30 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad)
+    31 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae)
+    32 => (a b c d e f g h i j k l m n o p q r s t u v w x y z aa ab ac ad ae af)
 }

 ///////////////////////////////////////////////////////////////////////////////

 macro_rules! tuple_impls {
-    ($($len:expr => $visitor:ident => ($($name:ident),+),)+) => {
+    ($($len:expr => $visitor:ident => ($($name:ident)+))+) => {
        $(
            /// Construct a tuple visitor.
            pub struct $visitor<$($name,)+> {
                marker: PhantomData<($($name,)+)>,
            }

-            impl<
-                $($name: Deserialize,)+
-            > $visitor<$($name,)+> {
+            impl<$($name: Deserialize,)+> $visitor<$($name,)+> {
                /// Construct a `TupleVisitor*<T>`.
                pub fn new() -> Self {
                    $visitor { marker: PhantomData }
                }
            }

-
-            impl<
-                $($name: Deserialize,)+
-            > Visitor for $visitor<$($name,)+> {
+            impl<$($name: Deserialize),+> Visitor for $visitor<$($name,)+> {
                type Value = ($($name,)+);

                #[inline]
@@ -679,9 +658,9 @@ macro_rules! tuple_impls {
                    $(
                        let $name = match try!(visitor.visit()) {
                            Some(value) => value,
-                            None => { return Err(Error::end_of_stream()); }
+                            None => return Err(Error::end_of_stream()),
                        };
-                     )+;
+                    )+

                    try!(visitor.end());

@@ -689,9 +668,7 @@ macro_rules! tuple_impls {
                }
            }

-            impl<
-                $($name: Deserialize),+
-            > Deserialize for ($($name,)+) {
+            impl<$($name: Deserialize),+> Deserialize for ($($name,)+) {
                #[inline]
                fn deserialize<D>(deserializer: &mut D) -> Result<($($name,)+), D::Error>
                    where D: Deserializer,
@@ -704,22 +681,22 @@ macro_rules! tuple_impls {
 }

 tuple_impls! {
-    1 => TupleVisitor1 => (T0),
-    2 => TupleVisitor2 => (T0, T1),
-    3 => TupleVisitor3 => (T0, T1, T2),
-    4 => TupleVisitor4 => (T0, T1, T2, T3),
-    5 => TupleVisitor5 => (T0, T1, T2, T3, T4),
-    6 => TupleVisitor6 => (T0, T1, T2, T3, T4, T5),
-    7 => TupleVisitor7 => (T0, T1, T2, T3, T4, T5, T6),
-    8 => TupleVisitor8 => (T0, T1, T2, T3, T4, T5, T6, T7),
-    9 => TupleVisitor9 => (T0, T1, T2, T3, T4, T5, T6, T7, T8),
-    10 => TupleVisitor10 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9),
-    11 => TupleVisitor11 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10),
-    12 => TupleVisitor12 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11),
-    13 => TupleVisitor13 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12),
-    14 => TupleVisitor14 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13),
-    15 => TupleVisitor15 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14),
-    16 => TupleVisitor16 => (T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15),
+    1 => TupleVisitor1 => (T0)
+    2 => TupleVisitor2 => (T0 T1)
+    3 => TupleVisitor3 => (T0 T1 T2)
+    4 => TupleVisitor4 => (T0 T1 T2 T3)
+    5 => TupleVisitor5 => (T0 T1 T2 T3 T4)
+    6 => TupleVisitor6 => (T0 T1 T2 T3 T4 T5)
+    7 => TupleVisitor7 => (T0 T1 T2 T3 T4 T5 T6)
+    8 => TupleVisitor8 => (T0 T1 T2 T3 T4 T5 T6 T7)
+    9 => TupleVisitor9 => (T0 T1 T2 T3 T4 T5 T6 T7 T8)
+    10 => TupleVisitor10 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9)
+    11 => TupleVisitor11 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10)
+    12 => TupleVisitor12 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11)
+    13 => TupleVisitor13 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12)
+    14 => TupleVisitor14 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13)
+    15 => TupleVisitor15 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14)
+    16 => TupleVisitor16 => (T0 T1 T2 T3 T4 T5 T6 T7 T8 T9 T10 T11 T12 T13 T14 T15)
 }

 ///////////////////////////////////////////////////////////////////////////////
@@ -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)
                }
@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.8.12"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -22,8 +22,8 @@ with-syn = []

 [dependencies]
 clippy = { version = "^0.*", optional = true }
-quote = "0.3"
-serde_codegen_internals = { version = "=0.10.0", default-features = false, path = "../serde_codegen_internals" }
-syn = { version = "0.9", features = ["aster", "visit"] }
-syntex = { version = "^0.44.0", optional = true }
-syntex_syntax = { version = "^0.44.0", optional = true }
+quote = "0.3.8"
+serde_codegen_internals = { version = "=0.11.3", default-features = false, path = "../serde_codegen_internals" }
+syn = { version = "0.10", features = ["aster", "visit"] }
+syntex = { version = "^0.54.0", optional = true }
+syntex_syntax = { version = "^0.54.0", optional = true }
@@ -496,6 +496,7 @@ fn deserialize_item_enum(

    let variant_visitor = deserialize_field_visitor(
        variants.iter()
+            .filter(|variant| !variant.attrs.skip_deserializing())
            .map(|variant| variant.attrs.name().deserialize_name())
            .collect(),
        item_attrs,
@@ -518,7 +519,7 @@ fn deserialize_item_enum(

    // Match arms to extract a variant from a string
    let mut variant_arms = vec![];
-    for (i, variant) in variants.iter().enumerate() {
+    for (i, variant) in variants.iter().filter(|variant| !variant.attrs.skip_deserializing()).enumerate() {
        let variant_name = aster::id(format!("__field{}", i));
        let variant_name = quote!(__Field::#variant_name);

@@ -881,7 +882,7 @@ fn deserialize_map(
        .map(|&(_, ref name)| {
            quote! {
                __Field::#name => {
-                    try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>());
+                    let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>());
                }
            }
        })
@@ -892,7 +893,7 @@ fn deserialize_map(
        None
    } else {
        Some(quote! {
-            _ => { try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); }
+            _ => { let _ = try!(visitor.visit_value::<_serde::de::impls::IgnoredAny>()); }
        })
    };

@@ -2,7 +2,6 @@
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", allow(too_many_arguments))]
 #![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
-#![cfg_attr(not(feature = "with-syntex"), feature(rustc_private, plugin))]

 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "192"]
@@ -16,13 +15,6 @@ extern crate syntex;
 #[macro_use]
 extern crate syntex_syntax as syntax;

-#[cfg(not(feature = "with-syntex"))]
-#[macro_use]
-extern crate syntax;
-
-#[cfg(not(feature = "with-syntex"))]
-extern crate rustc_plugin;
-
 extern crate syn;
 #[macro_use]
 extern crate quote;
@@ -30,9 +22,6 @@ extern crate quote;
 #[cfg(feature = "with-syntex")]
 use std::path::Path;

-#[cfg(not(feature = "with-syntex"))]
-use syntax::feature_gate::AttributeType;
-
 mod bound;
 mod de;
 mod ser;
@@ -49,11 +38,11 @@ fn syntex_registry() -> syntex::Registry {

        impl fold::Folder for StripAttributeFolder {
            fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-                match attr.node.value.node {
-                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { return None; }
-                    _ => {}
+                if attr.value.name == "serde" {
+                    if let ast::MetaItemKind::List(..) = attr.value.node {
+                        return None;
+                    }
                }
-
                Some(attr)
            }

@@ -70,8 +59,8 @@ fn syntex_registry() -> syntex::Registry {
    reg.add_attr("feature(custom_derive)");
    reg.add_attr("feature(custom_attribute)");

-    reg.add_decorator("derive_Serialize", expand_derive_serialize);
-    reg.add_decorator("derive_Deserialize", expand_derive_deserialize);
+    reg.add_decorator("derive_Serialize", shim::expand_derive_serialize);
+    reg.add_decorator("derive_Deserialize", shim::expand_derive_deserialize);

    reg.add_post_expansion_pass(strip_attributes);

@@ -104,24 +93,9 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
    syntex::with_extra_stack(expand_thread)
 }

-#[cfg(not(feature = "with-syntex"))]
-pub fn register(reg: &mut rustc_plugin::Registry) {
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Serialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(expand_derive_serialize)));
-
-    reg.register_syntax_extension(
-        syntax::parse::token::intern("derive_Deserialize"),
-        syntax::ext::base::MultiDecorator(
-            Box::new(expand_derive_deserialize)));
-
-    reg.register_attribute("serde".to_owned(), AttributeType::Normal);
-}
-
 macro_rules! shim {
    ($name:ident $pkg:ident :: $func:ident) => {
-        fn $func(
+        pub fn $func(
            cx: &mut ::syntax::ext::base::ExtCtxt,
            span: ::syntax::codemap::Span,
            meta_item: &::syntax::ast::MetaItem,
@@ -142,13 +116,12 @@ macro_rules! shim {

            use syntax::{attr, ast, visit};
            struct MarkSerdeAttributesUsed;
-            impl visit::Visitor for MarkSerdeAttributesUsed {
+            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
                fn visit_attribute(&mut self, attr: &ast::Attribute) {
-                    match attr.node.value.node {
-                        ast::MetaItemKind::List(ref name, _) if name == "serde" => {
+                    if attr.value.name == "serde" {
+                        if let ast::MetaItemKind::List(..) = attr.value.node {
                            attr::mark_used(attr);
                        }
-                        _ => {}
                    }
                }
            }
@@ -157,6 +130,7 @@ macro_rules! shim {
            use syntax::print::pprust;
            let s = pprust::item_to_string(item);

+            use {syn, $pkg};
            let syn_item = syn::parse_macro_input(&s).unwrap();
            let expanded = match $pkg::$func(&syn_item) {
                Ok(expanded) => expanded.to_string(),
@@ -168,128 +142,31 @@ 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, sess);
            push(::syntax::ext::base::Annotatable::Item(impl_item.unwrap().unwrap()));
        }
    };
 }

-shim!(Serialize ser::expand_derive_serialize);
-shim!(Deserialize de::expand_derive_deserialize);
+#[cfg(feature = "with-syntex")]
+mod shim {
+    shim!(Serialize ser::expand_derive_serialize);
+    shim!(Deserialize de::expand_derive_deserialize);
+}

 #[cfg(feature = "with-syn")]
-pub fn expand_single_item(item: &str) -> Result<String, String> {
+#[doc(hidden)]
+/// Not public API. Use the serde_derive crate.
+pub fn expand_derive_serialize(item: &str) -> Result<quote::Tokens, String> {
    let syn_item = syn::parse_macro_input(item).unwrap();
-    let (ser, de, syn_item) = strip_serde_derives(syn_item);
-    let expanded_ser = if ser {
-        Some(try!(ser::expand_derive_serialize(&syn_item)))
-    } else {
-        None
-    };
-    let expanded_de = if de {
-        Some(try!(de::expand_derive_deserialize(&syn_item)))
-    } else {
-        None::<quote::Tokens>
-    };
-    let syn_item = strip_serde_attrs(syn_item);
-    return Ok(quote!(#expanded_ser #expanded_de #syn_item).to_string());
-
-    fn strip_serde_derives(item: syn::MacroInput) -> (bool, bool, syn::MacroInput) {
-        let mut ser = false;
-        let mut de = false;
-        let item = syn::MacroInput {
-            attrs: item.attrs.into_iter().flat_map(|attr| {
-                if attr.is_sugared_doc || attr.style != syn::AttrStyle::Outer {
-                    return Some(attr);
-                }
-                let (name, nested) = match attr.value {
-                    syn::MetaItem::List(name, nested) => (name, nested),
-                    _ => return Some(attr)
-                };
-                if name != "derive" {
-                    return Some(syn::Attribute {
-                        style: syn::AttrStyle::Outer,
-                        value: syn::MetaItem::List(name, nested),
-                        is_sugared_doc: false,
-                    });
-                }
-                let rest: Vec<_> = nested.into_iter().filter(|nested| {
-                    match *nested {
-                        syn::MetaItem::Word(ref word) if word == "Serialize" => {
-                            ser = true;
-                            false
-                        }
-                        syn::MetaItem::Word(ref word) if word == "Deserialize" => {
-                            de = true;
-                            false
-                        }
-                        _ => true,
-                    }
-                }).collect();
-                if rest.is_empty() {
-                    None
-                } else {
-                    Some(syn::Attribute {
-                        style: syn::AttrStyle::Outer,
-                        value: syn::MetaItem::List(name, rest),
-                        is_sugared_doc: false,
-                    })
-                }
-            }).collect(),
-            ..item
-        };
-        (ser, de, item)
-    }
-
-    fn strip_serde_attrs(item: syn::MacroInput) -> syn::MacroInput {
-        syn::MacroInput {
-            attrs: strip_serde_from_attrs(item.attrs),
-            body: match item.body {
-                syn::Body::Enum(variants) => syn::Body::Enum(
-                    variants.into_iter().map(|variant| {
-                        syn::Variant {
-                            ident: variant.ident,
-                            attrs: strip_serde_from_attrs(variant.attrs),
-                            data: strip_serde_from_variant_data(variant.data),
-                            discriminant: variant.discriminant,
-                        }
-                    }).collect()
-                ),
-                syn::Body::Struct(variant_data) => syn::Body::Struct(
-                    strip_serde_from_variant_data(variant_data)
-                ),
-            },
-            ..item
-        }
-    }
-
-    fn strip_serde_from_variant_data(data: syn::VariantData) -> syn::VariantData {
-        match data {
-            syn::VariantData::Struct(fields) => syn::VariantData::Struct(
-                fields.into_iter().map(strip_serde_from_field).collect()
-            ),
-            syn::VariantData::Tuple(fields) => syn::VariantData::Tuple(
-                fields.into_iter().map(strip_serde_from_field).collect()
-            ),
-            syn::VariantData::Unit => syn::VariantData::Unit,
-        }
-    }
-
-    fn strip_serde_from_field(field: syn::Field) -> syn::Field {
-        syn::Field {
-            attrs: strip_serde_from_attrs(field.attrs),
-            ..field
-        }
-    }
-
-    fn strip_serde_from_attrs(attrs: Vec<syn::Attribute>) -> Vec<syn::Attribute> {
-        attrs.into_iter().filter(|attr| {
-            match attr.value {
-                syn::MetaItem::List(ref ident, _) => ident != "serde",
-                _ => true,
-            }
-        }).collect()
-    }
+    ser::expand_derive_serialize(&syn_item)
+}
+
+#[cfg(feature = "with-syn")]
+#[doc(hidden)]
+/// Not public API. Use the serde_derive crate.
+pub fn expand_derive_deserialize(item: &str) -> Result<quote::Tokens, String> {
+    let syn_item = syn::parse_macro_input(item).unwrap();
+    de::expand_derive_deserialize(&syn_item)
 }
@@ -256,76 +256,80 @@ fn serialize_variant(
    let variant_ident = variant.ident.clone();
    let variant_name = variant.attrs.name().serialize_name();

-    match variant.style {
-        Style::Unit => {
-            quote! {
-                #type_ident::#variant_ident =>
-                    _serde::ser::Serializer::serialize_unit_variant(
-                        _serializer,
-                        #type_name,
-                        #variant_index,
-                        #variant_name,
-                    ),
-            }
-        },
-        Style::Newtype => {
-            let block = serialize_newtype_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                ty,
-                generics,
-                &variant.fields[0],
-            );
-
-            quote! {
-                #type_ident::#variant_ident(ref __simple_value) => #block,
-            }
-        },
-        Style::Tuple => {
-            let field_names: Vec<Tokens> = (0 .. variant.fields.len())
-                .map(|i| {
-                    let id = aster::id(format!("__field{}", i));
-                    quote!(ref #id)
-                })
-                .collect();
-
-            let pat = quote!(#type_ident::#variant_ident(#(#field_names),*));
-
-            let block = serialize_tuple_variant(
-                type_name,
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-            );
-
-            quote! {
-                #pat => { #block }
-            }
+    if variant.attrs.skip_serializing() {
+        let skipped_msg = format!("The enum variant {}::{} cannot be serialized",
+                                type_ident, variant_ident);
+        let skipped_err = quote! {
+            Err(_serde::ser::Error::invalid_value(#skipped_msg))
+        };
+        let fields_pat = match variant.style {
+            Style::Unit => quote!(),
+            Style::Newtype | Style::Tuple => quote!( (..) ),
+            Style::Struct => quote!( {..} ),
+        };
+        quote! {
+            #type_ident::#variant_ident #fields_pat => #skipped_err,
        }
-        Style::Struct => {
-            let fields = variant.fields.iter().map(|field| {
-                let id = match field.ident {
-                    Some(ref name) => name.clone(),
-                    None => panic!("struct variant has unnamed fields"),
-                };
-                quote!(ref #id)
-            });
-            let pat = quote!(#type_ident::#variant_ident { #(#fields),* });
+    } else { // variant wasn't skipped
+        match variant.style {
+            Style::Unit => {
+                quote! {
+                    #type_ident::#variant_ident =>
+                        _serde::ser::Serializer::serialize_unit_variant(
+                            _serializer,
+                            #type_name,
+                            #variant_index,
+                            #variant_name,
+                        ),
+                }
+            },
+            Style::Newtype => {
+                let block = serialize_newtype_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    ty,
+                    generics,
+                    &variant.fields[0],
+                );

-            let block = serialize_struct_variant(
-                variant_index,
-                variant_name,
-                generics,
-                ty,
-                &variant.fields,
-                item_attrs,
-            );
+                quote! {
+                    #type_ident::#variant_ident(ref __simple_value) => #block,
+                }
+            },
+            Style::Tuple => {
+                let field_names = (0 .. variant.fields.len())
+                    .map(|i| aster::id(format!("__field{}", i)));

-            quote! {
-                #pat => { #block }
+                let block = serialize_tuple_variant(
+                    type_name,
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident(#(ref #field_names),*) => { #block }
+                }
+            }
+            Style::Struct => {
+                let fields = variant.fields.iter()
+                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
+
+                let block = serialize_struct_variant(
+                    variant_index,
+                    variant_name,
+                    generics,
+                    ty,
+                    &variant.fields,
+                    item_attrs,
+                );
+
+                quote! {
+                    #type_ident::#variant_ident { #(ref #fields),* } => { #block }
+                }
            }
        }
    }
@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.10.0"
+version = "0.11.3"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."
@@ -15,4 +15,4 @@ unstable-testing = ["clippy"]

 [dependencies]
 clippy = { version = "^0.*", optional = true }
-syn = "0.9"
+syn = "0.10"
@@ -1,5 +1,7 @@
 use Ctxt;
 use syn;
+use syn::MetaItem::{List, NameValue, Word};
+use syn::NestedMetaItem::{Literal, MetaItem};

 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
 // are `attr::Item::from_ast`, `attr::Variant::from_ast`, and
@@ -105,7 +107,7 @@ impl Item {
            for meta_item in meta_items {
                match meta_item {
                    // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                        if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                            ser_name.set(s.clone());
                            de_name.set(s);
@@ -113,7 +115,7 @@ impl Item {
                    }

                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                        if let Ok((ser, de)) = get_renames(cx, meta_items) {
                            ser_name.set_opt(ser);
                            de_name.set_opt(de);
@@ -121,12 +123,12 @@ impl Item {
                    }

                    // Parse `#[serde(deny_unknown_fields)]`
-                    syn::MetaItem::Word(ref name) if name == "deny_unknown_fields" => {
+                    MetaItem(Word(ref name)) if name == "deny_unknown_fields" => {
                        deny_unknown_fields.set_true();
                    }

                    // Parse `#[serde(bound="D: Serialize")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "bound" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
                        if let Ok(where_predicates) = parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
                            ser_bound.set(where_predicates.clone());
                            de_bound.set(where_predicates);
@@ -134,17 +136,21 @@ impl Item {
                    }

                    // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "bound" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "bound" => {
                        if let Ok((ser, de)) = get_where_predicates(cx, meta_items) {
                            ser_bound.set_opt(ser);
                            de_bound.set_opt(de);
                        }
                    }

-                    _ => {
+                    MetaItem(ref meta_item) => {
                        cx.error(format!("unknown serde container attribute `{}`",
                                         meta_item.name()));
                    }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde container attribute"));
+                    }
                }
            }
        }
@@ -181,18 +187,22 @@ impl Item {
 #[derive(Debug)]
 pub struct Variant {
    name: Name,
+    skip_deserializing: bool,
+    skip_serializing: bool,
 }

 impl Variant {
    pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
        let mut ser_name = Attr::none(cx, "rename");
        let mut de_name = Attr::none(cx, "rename");
+        let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
+        let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");

        for meta_items in variant.attrs.iter().filter_map(get_serde_meta_items) {
            for meta_item in meta_items {
                match meta_item {
                    // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                        if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                            ser_name.set(s.clone());
                            de_name.set(s);
@@ -200,17 +210,29 @@ impl Variant {
                    }

                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                        if let Ok((ser, de)) = get_renames(cx, meta_items) {
                            ser_name.set_opt(ser);
                            de_name.set_opt(de);
                        }
                    }
+                    // Parse `#[serde(skip_deserializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_deserializing" => {
+                        skip_deserializing.set_true();
+                    }
+                    // Parse `#[serde(skip_serializing)]`
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
+                        skip_serializing.set_true();
+                    }

-                    _ => {
+                    MetaItem(ref meta_item) => {
                        cx.error(format!("unknown serde variant attribute `{}`",
                                         meta_item.name()));
                    }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde variant attribute"));
+                    }
                }
            }
        }
@@ -220,12 +242,22 @@ impl Variant {
                serialize: ser_name.get().unwrap_or_else(|| variant.ident.to_string()),
                deserialize: de_name.get().unwrap_or_else(|| variant.ident.to_string()),
            },
+            skip_deserializing: skip_deserializing.get(),
+            skip_serializing: skip_serializing.get(),
        }
    }

    pub fn name(&self) -> &Name {
        &self.name
    }
+
+    pub fn skip_deserializing(&self) -> bool {
+        self.skip_deserializing
+    }
+
+    pub fn skip_serializing(&self) -> bool {
+        self.skip_serializing
+    }
 }

 /// Represents field attribute information
@@ -278,7 +310,7 @@ impl Field {
            for meta_item in meta_items {
                match meta_item {
                    // Parse `#[serde(rename="foo")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "rename" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "rename" => {
                        if let Ok(s) = get_string_from_lit(cx, name.as_ref(), name.as_ref(), lit) {
                            ser_name.set(s.clone());
                            de_name.set(s);
@@ -286,7 +318,7 @@ impl Field {
                    }

                    // Parse `#[serde(rename(serialize="foo", deserialize="bar"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "rename" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "rename" => {
                        if let Ok((ser, de)) = get_renames(cx, meta_items) {
                            ser_name.set_opt(ser);
                            de_name.set_opt(de);
@@ -294,50 +326,50 @@ impl Field {
                    }

                    // Parse `#[serde(default)]`
-                    syn::MetaItem::Word(ref name) if name == "default" => {
+                    MetaItem(Word(ref name)) if name == "default" => {
                        default.set(FieldDefault::Default);
                    }

                    // Parse `#[serde(default="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "default" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "default" => {
                        if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                            default.set(FieldDefault::Path(path));
                        }
                    }

                    // Parse `#[serde(skip_serializing)]`
-                    syn::MetaItem::Word(ref name) if name == "skip_serializing" => {
+                    MetaItem(Word(ref name)) if name == "skip_serializing" => {
                        skip_serializing.set_true();
                    }

                    // Parse `#[serde(skip_deserializing)]`
-                    syn::MetaItem::Word(ref name) if name == "skip_deserializing" => {
+                    MetaItem(Word(ref name)) if name == "skip_deserializing" => {
                        skip_deserializing.set_true();
                    }

                    // Parse `#[serde(skip_serializing_if="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "skip_serializing_if" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "skip_serializing_if" => {
                        if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                            skip_serializing_if.set(path);
                        }
                    }

                    // Parse `#[serde(serialize_with="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "serialize_with" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "serialize_with" => {
                        if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                            serialize_with.set(path);
                        }
                    }

                    // Parse `#[serde(deserialize_with="...")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "deserialize_with" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "deserialize_with" => {
                        if let Ok(path) = parse_lit_into_path(cx, name.as_ref(), lit) {
                            deserialize_with.set(path);
                        }
                    }

                    // Parse `#[serde(bound="D: Serialize")]`
-                    syn::MetaItem::NameValue(ref name, ref lit) if name == "bound" => {
+                    MetaItem(NameValue(ref name, ref lit)) if name == "bound" => {
                        if let Ok(where_predicates) = parse_lit_into_where(cx, name.as_ref(), name.as_ref(), lit) {
                            ser_bound.set(where_predicates.clone());
                            de_bound.set(where_predicates);
@@ -345,17 +377,21 @@ impl Field {
                    }

                    // Parse `#[serde(bound(serialize="D: Serialize", deserialize="D: Deserialize"))]`
-                    syn::MetaItem::List(ref name, ref meta_items) if name == "bound" => {
+                    MetaItem(List(ref name, ref meta_items)) if name == "bound" => {
                        if let Ok((ser, de)) = get_where_predicates(cx, meta_items) {
                            ser_bound.set_opt(ser);
                            de_bound.set_opt(de);
                        }
                    }

-                    _ => {
+                    MetaItem(ref meta_item) => {
                        cx.error(format!("unknown serde field attribute `{}`",
                                         meta_item.name()));
                    }
+
+                    Literal(_) => {
+                        cx.error(format!("unexpected literal in serde field attribute"));
+                    }
                }
            }
        }
@@ -424,7 +460,7 @@ type SerAndDe<T> = (Option<T>, Option<T>);
 fn get_ser_and_de<T, F>(
    cx: &Ctxt,
    attr_name: &'static str,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
    f: F
 ) -> Result<SerAndDe<T>, ()>
    where F: Fn(&Ctxt, &str, &str, &syn::Lit) -> Result<T, ()>,
@@ -434,13 +470,13 @@ fn get_ser_and_de<T, F>(

    for item in items {
        match *item {
-            syn::MetaItem::NameValue(ref name, ref lit) if name == "serialize" => {
+            MetaItem(NameValue(ref name, ref lit)) if name == "serialize" => {
                if let Ok(v) = f(cx, attr_name, name.as_ref(), lit) {
                    ser_item.set(v);
                }
            }

-            syn::MetaItem::NameValue(ref name, ref lit) if name == "deserialize" => {
+            MetaItem(NameValue(ref name, ref lit)) if name == "deserialize" => {
                if let Ok(v) = f(cx, attr_name, name.as_ref(), lit) {
                    de_item.set(v);
                }
@@ -459,21 +495,21 @@ fn get_ser_and_de<T, F>(

 fn get_renames(
    cx: &Ctxt,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
 ) -> Result<SerAndDe<String>, ()> {
    get_ser_and_de(cx, "rename", items, get_string_from_lit)
 }

 fn get_where_predicates(
    cx: &Ctxt,
-    items: &[syn::MetaItem],
+    items: &[syn::NestedMetaItem],
 ) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()> {
    get_ser_and_de(cx, "bound", items, parse_lit_into_where)
 }

-pub fn get_serde_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::MetaItem>> {
+pub fn get_serde_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::NestedMetaItem>> {
    match attr.value {
-        syn::MetaItem::List(ref name, ref items) if name == "serde" => {
+        List(ref name, ref items) if name == "serde" => {
            Some(items.iter().cloned().collect())
        }
        _ => None
@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.8.12"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 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.12"
+version = "=0.8.23"
 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.12", path = "../serde" }
-serde_test = { version = "0.8.12", path = "../serde_test" }
+serde = { version = "0.8.23", path = "../serde" }
+serde_test = { version = "0.8.23", path = "../serde_test" }
@@ -1,24 +1,19 @@
-#![feature(proc_macro, proc_macro_lib)]
-#![cfg(not(test))]
-
 extern crate proc_macro;
 extern crate serde_codegen;

 use proc_macro::TokenStream;

-#[proc_macro_derive(Serialize)]
+#[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let item = format!("#[derive(Serialize)]\n{}", input);
-    match serde_codegen::expand_single_item(&item) {
+    match serde_codegen::expand_derive_serialize(&input.to_string()) {
        Ok(expanded) => expanded.parse().unwrap(),
        Err(msg) => panic!(msg),
    }
 }

-#[proc_macro_derive(Deserialize)]
+#[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let item = format!("#[derive(Deserialize)]\n{}", input);
-    match serde_codegen::expand_single_item(&item) {
+    match serde_codegen::expand_derive_deserialize(&input.to_string()) {
        Ok(expanded) => expanded.parse().unwrap(),
        Err(msg) => panic!(msg),
    }
@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,5 +1,3 @@
-#![feature(proc_macro)]
-
 #[macro_use]
 extern crate serde_derive;

@@ -1,4 +1,3 @@
-#![feature(proc_macro)]
 #![deny(identity_op)]

 #[macro_use]
@@ -1,4 +1,4 @@
-#![feature(test, proc_macro)]
+#![feature(test)]

 #[macro_use]
 extern crate serde_derive;
@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.8.12"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 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.12", path = "../serde" }
+serde = { version = "0.8.23", path = "../serde" }
@@ -1,6 +1,6 @@
 [package]
 name = "serde_testing"
-version = "0.8.12"
+version = "0.8.23"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,6 +10,7 @@ documentation = "https://docs.serde.rs/serde/"
 readme = "README.md"
 keywords = ["serialization"]
 build = "build.rs"
+publish = false

 [features]
 unstable-testing = ["clippy", "serde/unstable-testing", "serde_codegen/unstable-testing"]
@@ -29,7 +30,3 @@ clippy = { version = "^0.*", optional = true }
 [[test]]
 name = "test"
 path = "tests/test.rs"
-
-[[bench]]
-name = "bench"
-path = "benches/bench.rs"
@@ -1,9 +0,0 @@
-#![feature(test)]
-#![cfg_attr(feature = "clippy", feature(plugin))]
-#![cfg_attr(feature = "clippy", plugin(clippy))]
-
-extern crate rustc_serialize;
-extern crate serde;
-extern crate test;
-
-include!(concat!(env!("OUT_DIR"), "/bench.rs"));
@@ -1,4 +0,0 @@
-mod bench_enum;
-mod bench_map;
-mod bench_struct;
-mod bench_vec;
@@ -1,466 +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: Into<String>>(_: 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<State>,
-
-    }
-
-    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<usize, Error> { Err(Error::Syntax) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_isize(&mut self) -> Result<isize, Error> {
-            match self.stack.pop() {
-                Some(State::Isize(x)) => Ok(x),
-                _ => Err(Error::Syntax),
-            }
-        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_str(&mut self) -> Result<String, Error> {
-            match self.stack.pop() {
-                Some(State::String(x)) => Ok(x),
-                _ => Err(Error::Syntax),
-            }
-        }
-
-        // Compound types:
-        #[inline]
-        fn read_enum<T, F>(&mut self, name: &str, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, names: &[&str], f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, _a_idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, bool) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        #[inline]
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
-        {
-            f(self, 3)
-        }
-
-        #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut AnimalDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-mod deserializer {
-    use super::{Animal, Error};
-
-    use serde::de;
-
-    #[derive(Debug)]
-    enum State {
-        Animal(Animal),
-        Isize(isize),
-        Str(&'static str),
-        String(String),
-        UnitState,
-    }
-
-    pub struct AnimalDeserializer {
-        stack: Vec<State>,
-    }
-
-    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<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            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<V>(&mut self,
-                         _name: &str,
-                         _variants: &[&str],
-                         mut visitor: V) -> Result<V::Value, Error>
-            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)
-                }
-            }
-        }
-    }
-
-    struct DogVisitor<'a> {
-        de: &'a mut AnimalDeserializer,
-    }
-
-    impl<'a> de::VariantVisitor for DogVisitor<'a> {
-        type Error = Error;
-
-        fn visit_variant<V>(&mut self) -> Result<V, Error>
-            where V: de::Deserialize
-        {
-            de::Deserialize::deserialize(self.de)
-        }
-
-        fn visit_unit(&mut self) -> Result<(), Error> {
-            de::Deserialize::deserialize(self.de)
-        }
-    }
-
-    struct FrogVisitor<'a> {
-        de: &'a mut AnimalDeserializer,
-        state: usize,
-    }
-
-    impl<'a> de::VariantVisitor for FrogVisitor<'a> {
-        type Error = Error;
-
-        fn visit_variant<V>(&mut self) -> Result<V, Error>
-            where V: de::Deserialize
-        {
-            de::Deserialize::deserialize(self.de)
-        }
-
-        fn visit_tuple<V>(&mut self,
-                          _len: usize,
-                          mut visitor: V) -> Result<V::Value, Error>
-            where V: de::Visitor,
-        {
-            visitor.visit_seq(self)
-        }
-    }
-
-    impl<'a> de::SeqVisitor for FrogVisitor<'a> {
-        type Error = Error;
-
-        fn visit<T>(&mut self) -> Result<Option<T>, 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<usize>) {
-            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);
-    })
-}
@@ -1,474 +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: Into<String>>(_: 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<String, isize>,
-        stack: Vec<Value>,
-    }
-
-    impl IsizeDecoder {
-        #[inline]
-        pub fn new(values: HashMap<String, isize>) -> 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<usize, Error> { Err(Error::Syntax) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_isize(&mut self) -> Result<isize, Error> {
-            match self.stack.pop() {
-                Some(Value::Isize(x)) => Ok(x),
-                Some(_) => Err(Error::Syntax),
-                None => Err(Error::EndOfStream),
-            }
-        }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_str(&mut self) -> Result<String, Error> {
-            match self.stack.pop() {
-                Some(Value::String(x)) => Ok(x),
-                Some(_) => Err(Error::Syntax),
-                None => Err(Error::EndOfStream),
-            }
-        }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder, bool) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_seq<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_seq_elt<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        #[inline]
-        fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder, usize) -> Result<T, Error>,
-        {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_map_elt_key<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut IsizeDecoder) -> Result<T, Error>,
-        {
-            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<State>,
-        iter: hash_map::IntoIter<String, isize>,
-    }
-
-    impl IsizeDeserializer {
-        #[inline]
-        pub fn new(values: HashMap<String, isize>) -> IsizeDeserializer {
-            IsizeDeserializer {
-                stack: vec!(State::StartState),
-                iter: values.into_iter(),
-            }
-        }
-    }
-
-    impl de::Deserializer for IsizeDeserializer {
-        type Error = Error;
-
-        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            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)
-                }
-            }
-        }
-    }
-
-    impl de::MapVisitor for IsizeDeserializer {
-        type Error = Error;
-
-        fn visit_key<K>(&mut self) -> Result<Option<K>, 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<V>(&mut self) -> Result<V, Error>
-            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<usize>) {
-            self.iter.size_hint()
-        }
-    }
-
-/*
-    impl Iterator for IsizeDeserializer {
-        type Item = Result<de::Token, Error>;
-
-        #[inline]
-        fn next(&mut self) -> Option<Result<de::Token, Error>> {
-            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<Error> 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<IsizeDeserializer, Error>
-        >(&mut self, _field: &'static str) -> Result<T, Error> {
-            Err(Error::Syntax)
-        }
-    }
-*/
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-fn run_decoder<
-    D: Decoder<Error=Error>,
-    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<String, isize> = HashMap::new();
-        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_decoder_003(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, isize> = 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<String, isize> = HashMap::new();
-        for i in 0 .. 100 {
-            m.insert(i.to_string(), i);
-        }
-        run_decoder(decoder::IsizeDecoder::new(m.clone()), m)
-    })
-}
-
-fn run_deserializer<D, T>(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<String, isize> = HashMap::new();
-        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
-    })
-}
-
-#[bench]
-fn bench_deserializer_003(b: &mut Bencher) {
-    b.iter(|| {
-        let mut m: HashMap<String, isize> = 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<String, isize> = HashMap::new();
-        for i in 0 .. 100 {
-            m.insert(i.to_string(), i);
-        }
-        run_deserializer(deserializer::IsizeDeserializer::new(m.clone()), m)
-    })
-}
@@ -1,745 +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<String, Option<char>>,
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[derive(Clone, PartialEq, Debug, RustcDecodable, Deserialize)]
-pub struct Outer {
-    inner: Vec<Inner>,
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-#[derive(Debug, PartialEq)]
-pub enum Error {
-    EndOfStream,
-    Syntax,
-    MissingField,
-    OtherError,
-}
-
-impl serde::de::Error for Error {
-    fn custom<T: Into<String>>(_: 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<Inner>),
-        Map(HashMap<String, Option<char>>),
-        Option(bool),
-    }
-
-    pub struct OuterDecoder {
-        stack: Vec<State>,
-
-    }
-
-    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<usize, Error> {
-            match self.stack.pop() {
-                Some(State::Usize(value)) => Ok(value),
-                _ => Err(Error::Syntax),
-            }
-        }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_char(&mut self) -> Result<char, Error> {
-            match self.stack.pop() {
-                Some(State::Char(c)) => Ok(c),
-                _ => Err(Error::Syntax),
-            }
-        }
-        #[inline]
-        fn read_str(&mut self) -> Result<String, Error> {
-            match self.stack.pop() {
-                Some(State::String(value)) => Ok(value),
-                _ => Err(Error::Syntax),
-            }
-        }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        #[inline]
-        fn read_struct<T, F>(&mut self, s_name: &str, _len: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, f_name: &str, _f_idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            match self.stack.pop() {
-                Some(State::Field(name)) => {
-                    if f_name == name {
-                        f(self)
-                    } else {
-                        Err(Error::Syntax)
-                    }
-                }
-                _ => Err(Error::Syntax)
-            }
-        }
-
-        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        // Specialized types:
-        #[inline]
-        fn read_option<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, bool) -> Result<T, Error>,
-        {
-            match self.stack.pop() {
-                Some(State::Option(b)) => f(self, b),
-                _ => Err(Error::Syntax),
-            }
-        }
-
-        #[inline]
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        #[inline]
-        fn read_map<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder, usize) -> Result<T, Error>,
-        {
-            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<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        #[inline]
-        fn read_map_elt_val<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut OuterDecoder) -> Result<T, Error>,
-        {
-            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<Inner>),
-        Map(HashMap<String, Option<char>>),
-    }
-
-    pub struct OuterDeserializer {
-        stack: Vec<State>,
-    }
-
-    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<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            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<V>(&mut self,
-                           name: &str,
-                           _fields: &'static [&'static str],
-                           mut visitor: V) -> Result<V::Value, Error>
-            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)
-                }
-            }
-        }
-    }
-
-    struct OuterMapVisitor<'a> {
-        de: &'a mut OuterDeserializer,
-        state: usize,
-    }
-
-    impl<'a> de::MapVisitor for OuterMapVisitor<'a> {
-        type Error = Error;
-
-        fn visit_key<K>(&mut self) -> Result<Option<K>, 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<V>(&mut self) -> Result<V, Error>
-            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<usize>) {
-            let len = 1 - self.state;
-            (len, Some(len))
-        }
-    }
-
-    struct OuterSeqVisitor<'a> {
-        de: &'a mut OuterDeserializer,
-        iter: vec::IntoIter<Inner>,
-    }
-
-    impl<'a> de::SeqVisitor for OuterSeqVisitor<'a> {
-        type Error = Error;
-
-        fn visit<T>(&mut self) -> Result<Option<T>, 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<usize>) {
-            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<K>(&mut self) -> Result<Option<K>, 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<V>(&mut self) -> Result<V, Error>
-            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<usize>) {
-            let len = 1 - self.state;
-            (len, Some(len))
-        }
-    }
-
-    struct MapVisitor<'a> {
-        de: &'a mut OuterDeserializer,
-        iter: hash_map::IntoIter<String, Option<char>>,
-    }
-
-    impl<'a> de::MapVisitor for MapVisitor<'a> {
-        type Error = Error;
-
-        fn visit_key<K>(&mut self) -> Result<Option<K>, 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<V>(&mut self) -> Result<V, Error>
-            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<usize>) {
-            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<Outer, Error> = 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<Outer, Error> = 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<Outer, Error> = 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<Outer, Error> = 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<Outer, Error> = 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<Outer, Error> = Deserialize::deserialize(&mut d);
-
-        assert_eq!(value, Ok(outer));
-    })
-}
@@ -1,628 +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: Into<String>>(_: 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<usize>,
-    }
-
-    impl UsizeDecoder {
-        #[inline]
-        pub fn new(values: Vec<usize>) -> 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<usize, Error> {
-            match self.iter.next() {
-                Some(value) => Ok(value),
-                None => Err(Error::EndOfStream),
-            }
-        }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
-        fn read_u8(&mut self) -> Result<u8, Error> { Err(Error::Syntax) }
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
-        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder, bool) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        #[inline]
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
-        {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut UsizeDecoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-    }
-
-
-    pub struct U8Decoder {
-        len: usize,
-        iter: vec::IntoIter<u8>,
-    }
-
-    impl U8Decoder {
-        #[inline]
-        pub fn new(values: Vec<u8>) -> 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<usize, Error> { Err(Error::Syntax) }
-        fn read_u64(&mut self) -> Result<u64, Error> { Err(Error::Syntax) }
-        fn read_u32(&mut self) -> Result<u32, Error> { Err(Error::Syntax) }
-        fn read_u16(&mut self) -> Result<u16, Error> { Err(Error::Syntax) }
-        #[inline]
-        fn read_u8(&mut self) -> Result<u8, Error> {
-            match self.iter.next() {
-                Some(value) => Ok(value),
-                None => Err(Error::EndOfStream),
-            }
-        }
-        #[inline]
-        fn read_isize(&mut self) -> Result<isize, Error> { Err(Error::Syntax) }
-        fn read_i64(&mut self) -> Result<i64, Error> { Err(Error::Syntax) }
-        fn read_i32(&mut self) -> Result<i32, Error> { Err(Error::Syntax) }
-        fn read_i16(&mut self) -> Result<i16, Error> { Err(Error::Syntax) }
-        fn read_i8(&mut self) -> Result<i8, Error> { Err(Error::Syntax) }
-        fn read_bool(&mut self) -> Result<bool, Error> { Err(Error::Syntax) }
-        fn read_f64(&mut self) -> Result<f64, Error> { Err(Error::Syntax) }
-        fn read_f32(&mut self) -> Result<f32, Error> { Err(Error::Syntax) }
-        fn read_char(&mut self) -> Result<char, Error> { Err(Error::Syntax) }
-        fn read_str(&mut self) -> Result<String, Error> { Err(Error::Syntax) }
-
-        // Compound types:
-        fn read_enum<T, F>(&mut self, _name: &str, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_variant_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant<T, F>(&mut self, _names: &[&str], _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_enum_struct_variant_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_struct_field<T, F>(&mut self, _f_name: &str, _f_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple<T, F>(&mut self, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct<T, F>(&mut self, _s_name: &str, _len: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_tuple_struct_arg<T, F>(&mut self, _a_idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        // Specialized types:
-        fn read_option<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, bool) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        #[inline]
-        fn read_seq<T, F>(&mut self, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
-        {
-            let len = self.len;
-            f(self, len)
-        }
-        #[inline]
-        fn read_seq_elt<T, F>(&mut self, _idx: usize, f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            f(self)
-        }
-
-        fn read_map<T, F>(&mut self, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder, usize) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_key<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            Err(Error::Syntax)
-        }
-
-        fn read_map_elt_val<T, F>(&mut self, _idx: usize, _f: F) -> Result<T, Error> where
-            F: FnOnce(&mut U8Decoder) -> Result<T, Error>,
-        {
-            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<A> {
-        state: State,
-        iter: vec::IntoIter<A>,
-        len: usize,
-        value: Option<A>,
-    }
-
-    impl<A> Deserializer<A> {
-        #[inline]
-        pub fn new(values: Vec<A>) -> Deserializer<A> {
-            let len = values.len();
-            Deserializer {
-                state: State::Start,
-                iter: values.into_iter(),
-                len: len,
-                value: None,
-            }
-        }
-    }
-
-    impl de::Deserializer for Deserializer<usize> {
-        type Error = Error;
-
-        #[inline]
-        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            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)
-                }
-            }
-        }
-    }
-
-    impl de::SeqVisitor for Deserializer<usize> {
-        type Error = Error;
-
-        #[inline]
-        fn visit<T>(&mut self) -> Result<Option<T>, 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<usize>) {
-            (self.len, Some(self.len))
-        }
-    }
-
-    impl de::Deserializer for Deserializer<u8> {
-        type Error = Error;
-
-        #[inline]
-        fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-            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)
-                }
-            }
-        }
-    }
-
-    impl de::SeqVisitor for Deserializer<u8> {
-        type Error = Error;
-
-        #[inline]
-        fn visit<T>(&mut self) -> Result<Option<T>, 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<usize>) {
-            (self.len, Some(self.len))
-        }
-    }
-}
-
-//////////////////////////////////////////////////////////////////////////////
-
-fn run_decoder<
-    D: Decoder<Error=Error>,
-    T: Clone + PartialEq + Debug + Decodable
->(mut d: D, value: T) {
-    let v = Decodable::decode(&mut d);
-
-    assert_eq!(Ok(value), v);
-}
-
-fn run_deserializer<D, T>(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<usize> = vec!();
-        run_decoder(decoder::UsizeDecoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_usize_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<usize> = 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<usize> = (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<u8> = vec!();
-        run_decoder(decoder::U8Decoder::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_decoder_u8_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = 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<u8> = (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<usize> = vec!();
-        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_usize_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<usize> = 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<usize> = (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<u8> = vec!();
-        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
-    })
-}
-
-#[bench]
-fn bench_deserializer_u8_003(b: &mut Bencher) {
-    b.iter(|| {
-        let v: Vec<u8> = 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<u8> = (0 .. 100).collect();
-        run_deserializer(deserializer::Deserializer::new(v.clone()), v)
-    })
-}
@@ -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();
 }
@@ -1,4 +1,5 @@
 extern crate serde;
+extern crate serde_test;

 #[macro_use]
 mod macros;
@@ -1,11 +1,13 @@
 use std::fmt;
 use std::error;

-use serde::{Serialize, Serializer, Deserialize, Deserializer};
+use serde::{Serialize, Serializer};
 use serde::bytes::{ByteBuf, Bytes};
 use serde::ser;
 use serde::de;

+use serde_test::{assert_de_tokens, Token};
+
 ///////////////////////////////////////////////////////////////////////////////

 #[derive(Debug, PartialEq)]
@@ -286,153 +288,6 @@ impl Serializer for BytesSerializer {

 ///////////////////////////////////////////////////////////////////////////////

-struct BytesDeserializer {
-    bytes: Option<Vec<u8>>,
-}
-
-impl BytesDeserializer {
-    fn new(bytes: Vec<u8>) -> Self {
-        BytesDeserializer {
-            bytes: Some(bytes),
-        }
-    }
-}
-
-impl Deserializer for BytesDeserializer {
-    type Error = Error;
-
-    fn deserialize<V>(&mut self, _visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        Err(Error)
-    }
-
-    fn deserialize_bytes<V>(&mut self, mut visitor: V) -> Result<V::Value, Error>
-        where V: de::Visitor,
-    {
-        visitor.visit_byte_buf(self.bytes.take().unwrap())
-    }
-
-    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)
-    }
-}
-
-///////////////////////////////////////////////////////////////////////////////
-
 #[test]
 fn test_bytes_ser_bytes() {
    let buf = vec![];
@@ -449,12 +304,42 @@ fn test_bytes_ser_bytes() {
 ///////////////////////////////////////////////////////////////////////////////

 #[test]
-fn test_byte_buf_de_bytes() {
-    let mut de = BytesDeserializer::new(vec![]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::new()));
+fn test_byte_buf_de() {
+    let empty = ByteBuf::new();
+    assert_de_tokens(&empty, &[Token::Bytes(b""),]);
+    assert_de_tokens(&empty, &[Token::Str("")]);
+    assert_de_tokens(&empty, &[Token::String(String::new())]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(None),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&empty, &[
+        Token::SeqStart(Some(0)),
+        Token::SeqEnd,
+    ]);

-    let mut de = BytesDeserializer::new(vec![1, 2, 3]);
-    let bytes = Deserialize::deserialize(&mut de);
-    assert_eq!(bytes, Ok(ByteBuf::from(vec![1, 2, 3])));
+    let buf = ByteBuf::from(vec![65, 66, 67]);
+    assert_de_tokens(&buf, &[Token::Bytes(b"ABC")]);
+    assert_de_tokens(&buf, &[Token::Str("ABC")]);
+    assert_de_tokens(&buf, &[Token::String("ABC".to_owned())]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(None),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
+    assert_de_tokens(&buf, &[
+        Token::SeqStart(Some(3)),
+        Token::SeqSep,
+        Token::U8(65),
+        Token::SeqSep,
+        Token::U8(66),
+        Token::SeqSep,
+        Token::U8(67),
+        Token::SeqEnd,
+    ]);
 }
@@ -37,7 +37,10 @@ enum Enum {
    Unit,
    Simple(i32),
    Seq(i32, i32, i32),
-    Map { a: i32, b: i32, c: i32 }
+    Map { a: i32, b: i32, c: i32 },
+    #[allow(dead_code)]
+    #[serde(skip_deserializing)]
+    Skipped,
 }

 //////////////////////////////////////////////////////////////////////////
@@ -215,6 +218,9 @@ declare_tests! {
            Token::SeqEnd,
        ],
    }
+    test_unit_string {
+        String::new() => &[Token::Unit],
+    }
    test_tuple_struct {
        TupleStruct(1, 2, 3) => &[
            Token::SeqStart(Some(3)),
@@ -802,6 +808,12 @@ declare_error_tests! {
        ],
        Error::UnknownVariant("Foo".to_owned()),
    }
+    test_enum_skipped_variant<Enum> {
+        &[
+            Token::EnumUnit("Enum", "Skipped"),
+        ],
+        Error::UnknownVariant("Skipped".to_owned()),
+    }
    test_struct_seq_too_long<Struct> {
        &[
            Token::SeqStart(Some(4)),
@@ -30,12 +30,20 @@ struct Struct {
    c: i32,
 }

-#[derive(Serialize)]
+#[derive(Serialize, PartialEq, Debug)]
 enum Enum {
    Unit,
    One(i32),
    Seq(i32, i32),
    Map { a: i32, b: i32 },
+    #[serde(skip_serializing)]
+    SkippedUnit,
+    #[serde(skip_serializing)]
+    SkippedOne(i32),
+    #[serde(skip_serializing)]
+    SkippedSeq(i32, i32),
+    #[serde(skip_serializing)]
+    SkippedMap { _a: i32, _b: i32 },
 }

 //////////////////////////////////////////////////////////////////////////
@@ -388,3 +396,23 @@ fn test_cannot_serialize_paths() {
        &[],
        Error::InvalidValue("Path contains invalid UTF-8 characters".to_owned()));
 }
+
+#[test]
+fn test_enum_skipped() {
+    assert_ser_tokens_error(
+        &Enum::SkippedUnit,
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedUnit cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedOne(42),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedOne cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedSeq(1, 2),
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedSeq cannot be serialized".to_owned()));
+    assert_ser_tokens_error(
+        &Enum::SkippedMap { _a: 1, _b: 2 },
+        &[],
+        Error::InvalidValue("The enum variant Enum::SkippedMap cannot be serialized".to_owned()));
+}
Author	SHA1	Message	Date
David Tolnay	1f65ce75ec	Release 0.8.23	2017-01-20 15:25:57 -08:00
Jake Goulding	9536e52aa6	Add categories to Cargo.toml	2017-01-20 15:09:11 -08:00
David Tolnay	9e45bd8c87	Release 0.8.22	2017-01-10 17:10:26 -08:00
David Tolnay	e461a23798	Not intended to be published	2017-01-08 00:18:37 -08:00
David Tolnay	894a21bc1f	Remove the proc_macro feature gate	2017-01-08 00:11:11 -08:00
David Tolnay	1ecf3730ee	Update to syntex 0.54	2017-01-06 01:26:51 -08:00
Erick Tryzelaar	b6e8b58cb2	Stop testing on 1.11	2017-01-02 14:59:00 -08:00
Oliver Schneider	a3f556959f	Merge pull request #652 from serde-rs/bbstr Support deserializing ByteBuf from string	2016-12-25 01:09:15 +01:00
David Tolnay	9338c4f1b9	Release 0.8.21	2016-12-24 13:10:24 -05:00
David Tolnay	28d67f4172	Format variant-skip message only if variant is skipped	2016-12-24 13:10:06 -05:00
David Tolnay	2401ae61a8	Update to syntex 0.52	2016-12-24 12:42:23 -05:00
David Tolnay	57d3fce0c6	Further simplify variant serialization patterns	2016-12-24 12:28:46 -05:00
David Tolnay	a020cceed8	Simplify variant serialize patterns	2016-12-24 12:22:45 -05:00
David Tolnay	49e985eb90	Update message for skipped enum variant	2016-12-24 12:16:28 -05:00
David Tolnay	63def96c66	Merge pull request #653 from shinglyu/skip_se Implement skip_serializing for enum variant	2016-12-24 11:40:21 -05:00
Shing Lyu	2fea8c9c28	Implement skip_serializing for enum variant	2016-12-24 22:34:22 +08:00
David Tolnay	b7ea213926	Support nostd for ByteBuf from String	2016-12-23 23:30:27 -05:00
David Tolnay	871fb5adee	Support deserializing ByteBuf from string	2016-12-23 23:17:42 -05:00
David Tolnay	2c984980a0	Link to release notes from readme	2016-12-22 21:52:37 -05:00
David Tolnay	36f07912b8	Remove no-longer-necessary cfg This was fixed in Rust, allowing proc macro crates to be tested.	2016-12-17 17:32:11 -08:00
David Tolnay	7222cf7514	Ignore warning from unused enum variant	2016-12-17 17:31:11 -08:00
David Tolnay	08c59a2e0e	Release 0.8.20	2016-12-16 07:58:52 -08:00
David Tolnay	4a0bf4de65	Merge pull request #641 from shinglyu/deser_enum Implemented skip_deserializing for enum	2016-12-16 07:53:34 -08:00
Shing Lyu	95ffca9bbe	Implemented skip_deserializing for enum	2016-12-16 20:29:21 +08:00
David Tolnay	5e47c87ba0	Add test for deserializing unit to string	2016-12-01 04:46:29 -08:00
David Tolnay	c6d5d9be14	Merge pull request #635 from serde-rs/oli-obk-patch-1 Enable deserializing an empty `String` from a unit value	2016-12-01 07:46:07 -05:00
Oliver Schneider	d63d09f4db	Enable deserializing an empty `String` from a unit value	2016-12-01 11:23:12 +01:00
David Tolnay	de6d00c306	Merge pull request #628 from serde-rs/str Do not copy tokens to String after expanding	2016-11-24 17:33:19 -05:00
David Tolnay	5bda95ba81	Do not copy tokens to String after expanding	2016-11-24 13:07:47 -08:00
David Tolnay	36641e7b81	Release 0.8.19	2016-11-23 09:14:03 -08:00
David Tolnay	6eca34c45c	Drop libsyntax	2016-11-23 09:13:21 -08:00
David Tolnay	7efa0153b0	Drop testing on rust 1.10	2016-11-19 15:24:40 -08:00
David Tolnay	8dba87661b	Bump serde_codegen_internals because it failed to publish somehow	2016-11-19 11:47:19 -08:00
David Tolnay	17fb4cb503	Release 0.8.18	2016-11-19 11:40:00 -08:00
David Tolnay	5bd0386b8e	Merge pull request #618 from serde-rs/up Ask proc_macro_derive to ignore serde attributes	2016-11-19 14:19:15 -05:00
David Tolnay	8b484c9703	Hide the serde_codegen functions from docs	2016-11-15 21:37:19 -05:00
David Tolnay	a16f07858b	Ask proc_macro_derive to ignore serde attributes	2016-11-15 21:29:34 -05:00
David Tolnay	133d117bf4	Bump post-expansion dependency	2016-11-07 11:16:14 -08:00
David Tolnay	e7f3a80867	Update serde codegen to syn 0.10	2016-11-02 22:58:55 -07:00
David Tolnay	f8c3d225a3	Shorten the syn meta item matches	2016-11-02 22:56:27 -07:00
David Tolnay	6d40d9e8ec	Update codegen internals to syn 0.10	2016-11-02 22:52:20 -07:00
David Tolnay	c91fca19e1	Release 0.8.17	2016-11-02 09:26:04 -07:00
David Tolnay	f13a805530	Merge pull request #605 from serde-rs/up Bump syntex to 0.48	2016-11-02 09:24:55 -07:00
David Tolnay	54802983b8	Bump syntex to 0.48	2016-11-02 09:12:22 -07:00
David Tolnay	f430d9d1c8	Remove unneeded type ascription	2016-10-23 21:06:50 -07:00
David Tolnay	c9612a2f57	Release 0.8.16	2016-10-22 00:07:27 -07:00
David Tolnay	7ffea5a716	Bump syntex to 0.46	2016-10-21 23:38:27 -07:00
David Tolnay	c8c9f7d96c	Merge pull request #599 from TheCatPlusPlus/master Explictly discard result of visiting IgnoredAny	2016-10-21 23:36:57 -07:00
Cat Plus Plus	f75d286b90	Explictly discard result of visiting IgnoredAny Makes the code generated by `derive(Deserialize)` compile cleanly when `unused_results` lint is enabled.	2016-10-22 08:00:44 +02:00
David Tolnay	9acb17ab54	Release 0.8.15	2016-10-20 08:42:40 -07:00
David Tolnay	f15ff1868e	Merge pull request #597 from serde-rs/cov Drop coveralls	2016-10-20 00:44:19 -07:00
David Tolnay	86f0d0382f	Drop coveralls Has not been uploading for months.	2016-10-20 00:33:03 -07:00
David Tolnay	8595b25763	Merge pull request #592 from serde-rs/post Use post-expansion crate to let other custom derives see serde attrs	2016-10-20 00:18:23 -07:00
David Tolnay	49aca521f1	Bump post-expansion dependency	2016-10-20 00:01:14 -07:00
David Tolnay	4c38bd0180	Merge branch origin/master into origin/post	2016-10-19 23:59:53 -07:00
Homu	02c4ff7b7e	Auto merge of #594 - serde-rs:expr, r=oli-obk No longer need `e!` This compiles all the way back to Rust 1.7.0, and 1.6.0 fails for other reasons so I think we are clear here. The referenced issue https://github.com/rust-lang/rust/issues/19630 is still open so they must have fixed it some other way.	2016-10-19 18:07:10 +09:00
David Tolnay	a8d1c0253a	Merge pull request #593 from serde-rs/rmbench Remove benchmarks	2016-10-19 00:48:05 -07:00
David Tolnay	bb5370b746	No longer need `e!`	2016-10-19 00:30:23 -07:00
David Tolnay	536e78a146	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.	2016-10-18 22:19:10 -07:00
David Tolnay	21c9446890	Update benchmarks to serde 0.8	2016-10-18 22:15:54 -07:00
David Tolnay	1b42f3f594	Release 0.8.14	2016-10-18 21:42:39 -07:00
David Tolnay	cafa02d9b4	Merge pull request #591 from serde-rs/sess Not safe to share Spans from one ParseSess to another	2016-10-18 21:41:05 -07:00
David Tolnay	a9b6cbb8b3	Use post-expansion crate to let other custom derives see serde attrs	2016-10-18 09:00:33 -07:00
David Tolnay	1d719b542c	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	2016-10-17 23:12:32 -07:00
David Tolnay	532b950971	Release 0.8.13	2016-10-16 10:34:26 -07:00
Erick Tryzelaar	f93b4e91e6	Version bump serde_derive to 0.8.13	2016-10-15 15:24:37 -07:00
Erick Tryzelaar	94e2ccc94e	Merge pull request #588 from erickt/master Drop support for rust 1.8.0 and 1.9.0.	2016-10-15 15:12:56 -07:00
Erick Tryzelaar	cbe6b4c97c	Drop support for rust 1.8.0 and 1.9.0.	2016-10-15 14:43:30 -07:00
Erick Tryzelaar	a46a4e27dd	Merge pull request #587 from erickt/master Update syntex version to 0.45.0	2016-10-15 14:43:13 -07:00
Erick Tryzelaar	4919a3184d	Update syntex version to 0.45.0	2016-10-15 14:01:14 -07:00
David Tolnay	0b19608d85	Merge pull request #584 from serde-rs/array-tuple Array and tuple deserialization cleanup	2016-10-14 08:43:08 -07:00
David Tolnay	99bddddd8e	Array and tuple deserialization cleanup	2016-10-14 00:15:24 -07:00