Release 0.9.2

SerializeMap::serialize_entry

.travis.yml

@@ -1,27 +1,28 @@
 sudo: false
 language: rust
+
+# run builds for all the trains (and more)
 rust:
-- 1.13.0
-- stable
-- beta
-- nightly
+  - 1.13.0
+  - stable
+  - beta
+  - nightly
+
 before_script:
-- pip install 'travis-cargo<0.2' --user
-- export PATH=$HOME/.local/bin:$PATH
+  - pip install 'travis-cargo<0.2' --user
+  - export PATH=$HOME/.local/bin:$PATH
+
 script:
-- (cd serde && travis-cargo build)
-- (cd serde && travis-cargo --only beta test)
-- (cd serde && travis-cargo --only nightly test -- --features unstable-testing)
-- (cd serde && travis-cargo build -- --no-default-features)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features --features alloc)
-- (cd serde && travis-cargo --only nightly build -- --no-default-features --features collections)
-- (cd testing && travis-cargo --skip nightly test)
-- (cd testing && travis-cargo --only nightly test -- --features unstable-testing)
-- (cd serde_derive && travis-cargo --only nightly test)
-- (cd serde_derive/no-std-tests && travis-cargo --only nightly build)
-#- (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)
+  - (cd serde && travis-cargo build)
+  - (cd serde && travis-cargo --only beta test)
+  - (cd serde && travis-cargo --only nightly test -- --features unstable-testing)
+  - (cd serde && travis-cargo build -- --no-default-features)
+  - (cd serde && travis-cargo --only nightly build -- --no-default-features --features alloc)
+  - (cd serde && travis-cargo --only nightly build -- --no-default-features --features collections)
+  - (cd test_suite && travis-cargo --only beta test)
+  - (cd test_suite/deps && travis-cargo --only nightly build && cd .. && travis-cargo --only nightly test -- --features unstable-testing)
+  - (cd test_suite/no_std && travis-cargo --only nightly build)
+
 env:
   global:
-  - TRAVIS_CARGO_NIGHTLY_FEATURE=""
+    - TRAVIS_CARGO_NIGHTLY_FEATURE=""

examples/serde-syntex-example/.gitignore

@@ -1,2 +0,0 @@
-target
-Cargo.lock

examples/serde-syntex-example/Cargo.toml

@@ -1,18 +0,0 @@
-[package]
-name = "serde-syntex-example"
-version = "0.1.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-build = "build.rs"
-publish = false
-
-[features]
-default = ["serde_codegen"]
-unstable = ["serde_derive"]
-
-[build-dependencies]
-serde_codegen = { version = "^0.8", optional = true, path = "../../serde_codegen" }
-
-[dependencies]
-serde = "^0.8"
-serde_derive = { version = "^0.8", optional = true, path = "../../serde_derive" }
-serde_json = "^0.8"

examples/serde-syntex-example/README.md

@@ -1,20 +0,0 @@
-This example demonstrates how to use Serde with Syntex. On stable or nightly
-with Syntex, it can be built with:
-
-```
-% rustup run stable cargo run
-     Running `target/debug/serde-syntex-example`
-{"x":1,"y":2}
-Point { x: 1, y: 2 }
-
-% rustup run nightly cargo run
-     Running `target/debug/serde-syntex-example`
-{"x":1,"y":2}
-Point { x: 1, y: 2 }
-```
-
-On nightly, it can use a plugin with:
-
-```
-% rustup run nightly cargo run --features unstable --no-default-features
-```

examples/serde-syntex-example/build.rs

@@ -1,25 +0,0 @@
-#[cfg(not(feature = "serde_derive"))]
-mod inner {
-    extern crate serde_codegen;
-
-    use std::env;
-    use std::path::Path;
-
-    pub fn main() {
-        let out_dir = env::var_os("OUT_DIR").unwrap();
-
-        let src = Path::new("src/main.rs.in");
-        let dst = Path::new(&out_dir).join("main.rs");
-
-        serde_codegen::expand(&src, &dst).unwrap();
-    }
-}
-
-#[cfg(feature = "serde_derive")]
-mod inner {
-    pub fn main() {}
-}
-
-fn main() {
-    inner::main();
-}

examples/serde-syntex-example/src/main.rs

@@ -1,12 +0,0 @@
-#[cfg(feature = "serde_derive")]
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-extern crate serde_json;
-
-#[cfg(feature = "serde_derive")]
-include!("main.rs.in");
-
-#[cfg(not(feature = "serde_derive"))]
-include!(concat!(env!("OUT_DIR"), "/main.rs"));

examples/serde-syntex-example/src/main.rs.in

@@ -1,16 +0,0 @@
-#[derive(Serialize, Deserialize, Debug)]
-struct Point {
-    x: i32,
-    y: i32,
-}
-
-fn main() {
-    let point = Point { x: 1, y: 2 };
-    let serialized = serde_json::to_string(&point).unwrap();
-
-    println!("{}", serialized);
-
-    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
-
-    println!("{:?}", deserialized);
-}

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.9.0"
+version = "0.9.2"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -25,7 +25,7 @@ collections = ["alloc"]
 unstable-testing = ["clippy", "unstable", "std"]
 
 [dependencies]
-clippy = { version = "^0.*", optional = true }
+clippy = { version = "0.*", optional = true }
 
 [dev-dependencies]
-serde_derive = "0.9.0-rc4"
+serde_derive = "0.9"

serde/src/de/mod.rs

@@ -150,10 +150,7 @@ pub trait Error: Sized + error::Error {
     ///         where D: Deserializer
     ///     {
     ///         let s = try!(String::deserialize(deserializer));
-    ///         match s.parse() {
-    ///             Ok(s) => Ok(s),
-    ///             Err(err) => Err(Error::custom(err)),
-    ///         }
+    ///         s.parse().map_err(Error::custom)
     ///     }
     /// }
     /// ```

serde/src/lib.rs

@@ -66,7 +66,7 @@
 #![cfg_attr(feature = "collections", feature(collections, enumset))]
 #![cfg_attr(feature = "clippy", feature(plugin))]
 #![cfg_attr(feature = "clippy", plugin(clippy))]
-#![cfg_attr(feature = "clippy", allow(linkedlist, type_complexity))]
+#![cfg_attr(feature = "clippy", allow(linkedlist, type_complexity, doc_markdown))]
 #![deny(missing_docs)]
 
 #[cfg(feature = "collections")]

serde/src/ser/impls.rs

@@ -568,8 +568,7 @@ macro_rules! serialize_map {
             use super::SerializeMap;
             let mut map = try!(serializer.serialize_map(Some(self.len())));
             for (k, v) in self {
-                try!(map.serialize_key(k));
-                try!(map.serialize_value(v));
+                try!(map.serialize_entry(k, v));
             }
             map.end()
         }

serde/src/ser/mod.rs

@@ -546,8 +546,7 @@ pub trait Serializer {
     /// ```rust,ignore
     /// let mut map = serializer.serialize_map(Some(self.len()))?;
     /// for (k, v) in self {
-    ///     map.serialize_key(k)?;
-    ///     map.serialize_value(v)?;
+    ///     map.serialize_entry(k, v)?;
     /// }
     /// map.end()
     /// ```
@@ -705,8 +704,7 @@ pub trait SerializeTupleVariant {
 /// ```rust,ignore
 /// let mut map = serializer.serialize_map(Some(self.len()))?;
 /// for (k, v) in self {
-///     map.serialize_key(k)?;
-///     map.serialize_value(v)?;
+///     map.serialize_entry(k, v)?;
 /// }
 /// map.end()
 /// ```
@@ -723,6 +721,28 @@ pub trait SerializeMap {
     /// Serialize a map value.
     fn serialize_value<T: ?Sized + Serialize>(&mut self, value: &T) -> Result<(), Self::Error>;
 
+    /// Serialize a map entry consisting of a key and a value.
+    ///
+    /// Some `Serialize` types are not able to hold a key and value in memory at
+    /// the same time so `SerializeMap` implementations are required to support
+    /// `serialize_key` and `serialize_value` individually. The
+    /// `serialize_entry` method allows serializers to optimize for the case
+    /// where key and value are both available. `Serialize` implementations are
+    /// encouraged to use `serialize_entry` if possible.
+    ///
+    /// The default implementation delegates to `serialize_key` and
+    /// `serialize_value`. This is appropriate for serializers that do not care
+    /// about performance or are not able to optimize `serialize_entry` any
+    /// better than this.
+    fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<(), Self::Error> {
+        try!(self.serialize_key(key));
+        self.serialize_value(value)
+    }
+
     /// Finish serializing a map.
     fn end(self) -> Result<Self::Ok, Self::Error>;
 }

serde_codegen/Cargo.toml

@@ -1,32 +0,0 @@
-[package]
-name = "serde_codegen"
-version = "0.9.0"
-authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
-license = "MIT/Apache-2.0"
-description = "Macros to auto-generate implementations for the serde framework"
-homepage = "https://serde.rs"
-repository = "https://github.com/serde-rs/serde"
-documentation = "https://serde.rs/codegen.html"
-keywords = ["serde", "serialization"]
-include = ["Cargo.toml", "src/**/*.rs"]
-
-[features]
-default = ["with-syntex"]
-unstable = []
-unstable-testing = ["clippy"]
-with-syntex = [
-    "syntex",
-    "syntex_syntax",
-]
-with-syn = []
-
-[dependencies]
-clippy = { version = "^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 }
-
-[badges]
-travis-ci = { repository = "serde-rs/serde" }

serde_codegen/src/lib.rs

@@ -1,171 +0,0 @@
-#![cfg_attr(feature = "clippy", plugin(clippy))]
-#![cfg_attr(feature = "clippy", feature(plugin))]
-#![cfg_attr(feature = "clippy", allow(too_many_arguments))]
-#![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
-
-// The `quote!` macro requires deep recursion.
-#![recursion_limit = "192"]
-
-extern crate serde_codegen_internals as internals;
-
-#[cfg(feature = "with-syntex")]
-extern crate syntex;
-
-#[cfg(feature = "with-syntex")]
-extern crate syntex_syntax as syntax;
-
-extern crate syn;
-#[macro_use]
-extern crate quote;
-
-#[cfg(feature = "with-syntex")]
-use std::path::Path;
-
-mod bound;
-mod de;
-mod ser;
-
-#[cfg(feature = "with-syntex")]
-fn syntex_registry() -> syntex::Registry {
-    use syntax::{ast, fold};
-
-    /// Strip the serde attributes from the crate.
-    #[cfg(feature = "with-syntex")]
-    fn strip_attributes(krate: ast::Crate) -> ast::Crate {
-        /// Helper folder that strips the serde attributes after the extensions have been expanded.
-        struct StripAttributeFolder;
-
-        impl fold::Folder for StripAttributeFolder {
-            fn fold_attribute(&mut self, attr: ast::Attribute) -> Option<ast::Attribute> {
-                if attr.value.name == "serde" {
-                    if let ast::MetaItemKind::List(..) = attr.value.node {
-                        return None;
-                    }
-                }
-                Some(attr)
-            }
-
-            fn fold_mac(&mut self, mac: ast::Mac) -> ast::Mac {
-                fold::noop_fold_mac(mac, self)
-            }
-        }
-
-        fold::Folder::fold_crate(&mut StripAttributeFolder, krate)
-    }
-
-    let mut reg = syntex::Registry::new();
-
-    reg.add_attr("feature(custom_derive)");
-    reg.add_attr("feature(custom_attribute)");
-
-    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);
-
-    reg
-}
-
-#[cfg(feature = "with-syntex")]
-pub fn expand_str(src: &str) -> Result<String, syntex::Error> {
-    let src = src.to_owned();
-
-    let expand_thread = move || {
-        syntex_registry().expand_str("", "", &src)
-    };
-
-    syntex::with_extra_stack(expand_thread)
-}
-
-#[cfg(feature = "with-syntex")]
-pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
-    where S: AsRef<Path>,
-          D: AsRef<Path>,
-{
-    let src = src.as_ref().to_owned();
-    let dst = dst.as_ref().to_owned();
-
-    let expand_thread = move || {
-        syntex_registry().expand("", src, dst)
-    };
-
-    syntex::with_extra_stack(expand_thread)
-}
-
-macro_rules! shim {
-    ($name:ident $pkg:ident :: $func:ident) => {
-        pub fn $func(
-            cx: &mut ::syntax::ext::base::ExtCtxt,
-            span: ::syntax::codemap::Span,
-            meta_item: &::syntax::ast::MetaItem,
-            annotatable: &::syntax::ext::base::Annotatable,
-            push: &mut FnMut(::syntax::ext::base::Annotatable)
-        ) {
-            let item = match *annotatable {
-                ::syntax::ext::base::Annotatable::Item(ref item) => item,
-                _ => {
-                    cx.span_err(
-                        meta_item.span,
-                        concat!("`#[derive(",
-                                stringify!($name),
-                                ")]` may only be applied to structs and enums"));
-                    return;
-                }
-            };
-
-            use syntax::{attr, ast, visit};
-            struct MarkSerdeAttributesUsed;
-            impl<'a> visit::Visitor<'a> for MarkSerdeAttributesUsed {
-                fn visit_attribute(&mut self, attr: &ast::Attribute) {
-                    if attr.value.name == "serde" {
-                        if let ast::MetaItemKind::List(..) = attr.value.node {
-                            attr::mark_used(attr);
-                        }
-                    }
-                }
-            }
-            visit::walk_item(&mut MarkSerdeAttributesUsed, item);
-
-            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(),
-                Err(msg) => {
-                    cx.span_err(span, &msg);
-                    return;
-                }
-            };
-
-            use syntax::parse;
-            let name = stringify!($name).to_string();
-            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()));
-        }
-    };
-}
-
-#[cfg(feature = "with-syntex")]
-mod shim {
-    shim!(Serialize ser::expand_derive_serialize);
-    shim!(Deserialize de::expand_derive_deserialize);
-}
-
-#[cfg(feature = "with-syn")]
-#[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();
-    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)
-}

serde_codegen_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.11.3"
+version = "0.12.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."
@@ -14,8 +14,8 @@ include = ["Cargo.toml", "src/**/*.rs"]
 unstable-testing = ["clippy"]
 
 [dependencies]
-clippy = { version = "^0.*", optional = true }
-syn = "0.10"
+clippy = { version = "0.*", optional = true }
+syn = "0.11"
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }

serde_codegen_internals/src/attr.rs

@@ -149,7 +149,7 @@ impl Item {
                     }
 
                     Literal(_) => {
-                        cx.error(format!("unexpected literal in serde container attribute"));
+                        cx.error("unexpected literal in serde container attribute");
                     }
                 }
             }
@@ -231,7 +231,7 @@ impl Variant {
                     }
 
                     Literal(_) => {
-                        cx.error(format!("unexpected literal in serde variant attribute"));
+                        cx.error("unexpected literal in serde variant attribute");
                     }
                 }
             }
@@ -390,7 +390,7 @@ impl Field {
                     }
 
                     Literal(_) => {
-                        cx.error(format!("unexpected literal in serde field attribute"));
+                        cx.error("unexpected literal in serde field attribute");
                     }
                 }
             }
@@ -404,7 +404,7 @@ impl Field {
 
         Field {
             name: Name {
-                serialize: ser_name.get().unwrap_or(ident.clone()),
+                serialize: ser_name.get().unwrap_or_else(|| ident.clone()),
                 deserialize: de_name.get().unwrap_or(ident),
             },
             skip_serializing: skip_serializing.get(),

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.9.0"
+version = "0.9.2"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -10,6 +10,10 @@ documentation = "https://serde.rs/codegen.html"
 keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
+[features]
+unstable = []
+unstable-testing = ["clippy", "serde_codegen_internals/unstable-testing"]
+
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
 
@@ -17,14 +21,8 @@ travis-ci = { repository = "serde-rs/serde" }
 name = "serde_derive"
 proc-macro = true
 
-[dependencies.serde_codegen]
-version = "=0.9.0"
-path = "../serde_codegen"
-default-features = false
-features = ["with-syn"]
-
-[dev-dependencies]
-compiletest_rs = "^0.2.0"
-fnv = "1.0"
-serde = { version = "0.9.0", path = "../serde" }
-serde_test = { version = "0.9.0", path = "../serde_test" }
+[dependencies]
+clippy = { version = "0.*", optional = true }
+quote = "0.3.8"
+serde_codegen_internals = { version = "=0.12.0", default-features = false, path = "../serde_codegen_internals" }
+syn = { version = "0.11", features = ["aster", "visit"] }

serde_derive/src/de.rs

@@ -7,7 +7,7 @@ use internals::{self, attr};
 
 use std::iter;
 
-pub fn expand_derive_deserialize(item: &syn::MacroInput) -> Result<Tokens, String> {
+pub fn expand_derive_deserialize(item: &syn::DeriveInput) -> Result<Tokens, String> {
     let item = {
         let ctxt = internals::Ctxt::new();
         let item = Item::from_ast(&ctxt, item);

serde_derive/src/lib.rs

@@ -1,11 +1,28 @@
-extern crate proc_macro;
-extern crate serde_codegen;
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", allow(too_many_arguments))]
+#![cfg_attr(feature = "clippy", allow(used_underscore_binding))]
 
+// The `quote!` macro requires deep recursion.
+#![recursion_limit = "192"]
+
+extern crate syn;
+#[macro_use]
+extern crate quote;
+
+extern crate serde_codegen_internals as internals;
+
+extern crate proc_macro;
 use proc_macro::TokenStream;
 
+mod bound;
+mod de;
+mod ser;
+
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    match serde_codegen::expand_derive_serialize(&input.to_string()) {
+    let input = syn::parse_derive_input(&input.to_string()).unwrap();
+    match ser::expand_derive_serialize(&input) {
         Ok(expanded) => expanded.parse().unwrap(),
         Err(msg) => panic!(msg),
     }
@@ -13,7 +30,8 @@ pub fn derive_serialize(input: TokenStream) -> TokenStream {
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    match serde_codegen::expand_derive_deserialize(&input.to_string()) {
+    let input = syn::parse_derive_input(&input.to_string()).unwrap();
+    match de::expand_derive_deserialize(&input) {
         Ok(expanded) => expanded.parse().unwrap(),
         Err(msg) => panic!(msg),
     }

serde_derive/src/ser.rs

@@ -5,7 +5,7 @@ use bound;
 use internals::ast::{Body, Field, Item, Style, Variant};
 use internals::{self, attr};
 
-pub fn expand_derive_serialize(item: &syn::MacroInput) -> Result<Tokens, String> {
+pub fn expand_derive_serialize(item: &syn::DeriveInput) -> Result<Tokens, String> {
     let ctxt = internals::Ctxt::new();
     let item = Item::from_ast(&ctxt, item);
     try!(ctxt.check());

serde_derive/tests/compile_tests.rs

@@ -1,30 +0,0 @@
-extern crate compiletest_rs as compiletest;
-
-use std::path::PathBuf;
-use std::env::var;
-
-fn run_mode(mode: &'static str) {
-    let mut config = compiletest::default_config();
-
-    let cfg_mode = mode.parse().ok().expect("Invalid mode");
-
-    config.target_rustcflags = Some("-L target/debug/ -L target/debug/deps/".to_owned());
-    if let Ok(name) = var::<&str>("TESTNAME") {
-        let s : String = name.to_owned();
-        config.filter = Some(s)
-    }
-    config.mode = cfg_mode;
-    config.src_base = PathBuf::from(format!("tests/{}", mode));
-
-    compiletest::run_tests(&config);
-}
-
-#[test]
-fn compile_fail() {
-    run_mode("compile-fail");
-}
-
-#[test]
-fn run_pass() {
-    run_mode("run-pass");
-}

serde_derive/tests/test.rs

@@ -1,10 +0,0 @@
-#![feature(test)]
-
-#[macro_use]
-extern crate serde_derive;
-
-extern crate test;
-
-include!("../../testing/tests/test.rs.in");
-
-mod compile_tests;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.9.0"
+version = "0.9.2"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -11,8 +11,12 @@ readme = "../README.md"
 keywords = ["serde", "serialization"]
 include = ["Cargo.toml", "src/**/*.rs"]
 
+[features]
+unstable-testing = ["clippy"]
+
 [dependencies]
-serde = { version = "0.9.0", path = "../serde" }
+clippy = { version = "0.*", optional = true }
+serde = { version = "0.9", path = "../serde" }
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }

serde_test/src/de.rs

@@ -273,7 +273,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
         where V: Visitor,
     {
         match self.tokens.peek() {
-            Some(&Token::Option(false)) => {
+            Some(&Token::Unit) | Some(&Token::Option(false)) => {
                 self.tokens.next();
                 visitor.visit_none()
             }
@@ -281,10 +281,6 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
                 self.tokens.next();
                 visitor.visit_some(self)
             }
-            Some(&Token::Unit) => {
-                self.tokens.next();
-                visitor.visit_none()
-            }
             Some(_) => visitor.visit_some(self),
             None => Err(Error::EndOfTokens),
         }
@@ -316,7 +312,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
                 let token = self.tokens.next().unwrap();
                 Err(Error::UnexpectedToken(token))
             }
-            None => { return Err(Error::EndOfTokens); }
+            None => Err(Error::EndOfTokens),
         }
     }
 
@@ -377,11 +373,7 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
         where V: Visitor,
     {
         match self.tokens.peek() {
-            Some(&Token::Unit) => {
-                self.tokens.next();
-                visitor.visit_unit()
-            }
-            Some(&Token::UnitStruct(_)) => {
+            Some(&Token::Unit) | Some(&Token::UnitStruct(_)) => {
                 self.tokens.next();
                 visitor.visit_unit()
             }

serde_test/src/lib.rs

@@ -1,3 +1,6 @@
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+
 extern crate serde;
 
 mod assert;

test_suite/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
-name = "serde_testing"
-version = "0.9.0"
+name = "serde_test_suite"
+version = "0.0.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -9,23 +9,27 @@ repository = "https://github.com/serde-rs/serde"
 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"]
-
-[build-dependencies]
-serde_codegen = { path = "../serde_codegen", features = ["with-syntex"] }
+unstable-testing = [
+    "clippy",
+    "compiletest_rs",
+    "serde/unstable-testing",
+    "serde_derive/unstable-testing",
+    "serde_test/unstable-testing",
+]
 
 [dev-dependencies]
 fnv = "1.0"
-rustc-serialize = "^0.3.16"
+rustc-serialize = "0.3.16"
 serde = { path = "../serde" }
+serde_derive = { path = "../serde_derive" }
 serde_test = { path = "../serde_test" }
 
 [dependencies]
-clippy = { version = "^0.*", optional = true }
+clippy = { version = "0.*", optional = true }
+compiletest_rs = { version = "0.2", optional = true }
 
 [[test]]
 name = "test"

test_suite/deps/Cargo.toml

@@ -0,0 +1,9 @@
+[package]
+name = "serde_test_suite_deps"
+version = "0.0.0"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+publish = false
+
+[dependencies]
+serde = { path = "../../serde" }
+serde_derive = { path = "../../serde_derive" }

test_suite/no_std/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_derive_tests_no_std"
-version = "0.9.0"
+version = "0.0.0"
 publish = false
 
 [dependencies]
 serde = { path = "../../serde", default-features = false }
-serde_derive = { path = ".." }
+serde_derive = { path = "../../serde_derive" }

test_suite/tests/compiletest.rs

@@ -0,0 +1,26 @@
+extern crate compiletest_rs as compiletest;
+
+use std::env;
+
+fn run_mode(mode: &'static str) {
+    let mut config = compiletest::default_config();
+
+    config.mode = mode.parse().expect("invalid mode");
+    config.target_rustcflags = Some("-L deps/target/debug/deps".to_owned());
+    if let Ok(name) = env::var("TESTNAME") {
+        config.filter = Some(name);
+    }
+    config.src_base = format!("tests/{}", mode).into();
+
+    compiletest::run_tests(&config);
+}
+
+#[test]
+fn compile_fail() {
+    run_mode("compile-fail");
+}
+
+#[test]
+fn run_pass() {
+    run_mode("run-pass");
+}

test_suite/tests/macros.rs

@@ -1,31 +1,3 @@
-#[macro_export]
-macro_rules! declare_ser_tests {
-    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
-        $(
-            #[test]
-            fn $name() {
-                $(
-                    assert_ser_tokens(&$value, $tokens);
-                )+
-            }
-        )+
-    }
-}
-
-#[macro_export]
-macro_rules! btreemap {
-    () => {
-        BTreeMap::new()
-    };
-    ($($key:expr => $value:expr),+) => {
-        {
-            let mut map = BTreeMap::new();
-            $(map.insert($key, $value);)+
-            map
-        }
-    }
-}
-
 macro_rules! btreeset {
     () => {
         BTreeSet::new()

test_suite/tests/test.rs

@@ -0,0 +1,26 @@
+#![cfg_attr(feature = "clippy", feature(plugin))]
+#![cfg_attr(feature = "clippy", plugin(clippy))]
+
+#![cfg_attr(feature = "unstable-testing", feature(test, non_ascii_idents))]
+
+#[cfg(feature = "unstable-testing")]
+extern crate test;
+
+#[macro_use]
+extern crate serde_derive;
+
+extern crate serde;
+extern crate serde_test;
+
+#[macro_use]
+mod macros;
+
+mod test_annotations;
+mod test_bytes;
+mod test_de;
+mod test_gen;
+mod test_macros;
+mod test_ser;
+
+#[cfg(feature = "unstable-testing")]
+mod compiletest;

test_suite/tests/test_ser.rs

@@ -51,7 +51,20 @@ enum Enum {
 
 //////////////////////////////////////////////////////////////////////////
 
-declare_ser_tests! {
+macro_rules! declare_tests {
+    ($($name:ident { $($value:expr => $tokens:expr,)+ })+) => {
+        $(
+            #[test]
+            fn $name() {
+                $(
+                    assert_ser_tokens(&$value, $tokens);
+                )+
+            }
+        )+
+    }
+}
+
+declare_tests! {
     test_unit {
         () => &[Token::Unit],
     }

testing/build.rs

@@ -1,11 +0,0 @@
-extern crate serde_codegen;
-
-use std::env;
-use std::path::Path;
-
-fn main() {
-    let out_dir = env::var_os("OUT_DIR").unwrap();
-    let src = Path::new("tests/test.rs.in");
-    let dst = Path::new(&out_dir).join("test.rs");
-    serde_codegen::expand(&src, &dst).unwrap();
-}

testing/tests/test.rs

@@ -1,6 +0,0 @@
-#![cfg_attr(feature = "clippy", feature(plugin))]
-#![cfg_attr(feature = "clippy", plugin(clippy))]
-
-#![cfg_attr(feature = "unstable-testing", feature(non_ascii_idents))]
-
-include!(concat!(env!("OUT_DIR"), "/test.rs"));

testing/tests/test.rs.in

@@ -1,12 +0,0 @@
-extern crate serde;
-extern crate serde_test;
-
-#[macro_use]
-mod macros;
-
-mod test_annotations;
-mod test_bytes;
-mod test_de;
-mod test_gen;
-mod test_macros;
-mod test_ser;