Release 0.8.6

Macros 1.1

README.md

@@ -1,4 +1,4 @@
-# Serde   [![Build Status](https://api.travis-ci.org/serde-rs/serde.svg?branch=master)](https://travis-ci.org/serde-rs/serde) [![Coverage Status](https://coveralls.io/repos/serde-rs/serde/badge.svg?branch=master&service=github)](https://coveralls.io/github/serde-rs/serde?branch=master) [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde) [![Clippy Linting Result](https://clippy.bashy.io/github/serde-rs/serde/master/badge.svg)](https://clippy.bashy.io/github/serde-rs/serde/master/log)
+# Serde   [![Build Status](https://api.travis-ci.org/serde-rs/serde.svg?branch=master)](https://travis-ci.org/serde-rs/serde) [![Latest Version](https://img.shields.io/crates/v/serde.svg)](https://crates.io/crates/serde)
 
 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
 

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.8.3"
+version = "0.8.6"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/de/value.rs

@@ -12,6 +12,8 @@ use std::collections::{
     hash_set,
 };
 #[cfg(feature = "std")]
+use std::borrow::Cow;
+#[cfg(feature = "std")]
 use std::vec;
 
 #[cfg(all(feature = "collections", not(feature = "std")))]
@@ -24,6 +26,8 @@ use collections::{
     btree_set,
     vec,
 };
+#[cfg(all(feature = "collections", not(feature = "std")))]
+use collections::borrow::Cow;
 
 #[cfg(all(feature = "unstable", feature = "collections"))]
 use collections::borrow::ToOwned;
@@ -463,6 +467,105 @@ impl<'a, E> de::VariantVisitor for StringDeserializer<E>
 
 ///////////////////////////////////////////////////////////////////////////////
 
+/// A helper deserializer that deserializes a `String`.
+#[cfg(any(feature = "std", feature = "collections"))]
+pub struct CowStrDeserializer<'a, E>(Option<Cow<'a, str>>, PhantomData<E>);
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> ValueDeserializer<E> for Cow<'a, str>
+    where E: de::Error,
+{
+    type Deserializer = CowStrDeserializer<'a, E>;
+
+    fn into_deserializer(self) -> CowStrDeserializer<'a, E> {
+        CowStrDeserializer(Some(self), PhantomData)
+    }
+}
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> de::Deserializer for CowStrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize<V>(&mut self, mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        match self.0.take() {
+            Some(Cow::Borrowed(string)) => visitor.visit_str(string),
+            Some(Cow::Owned(string)) => visitor.visit_string(string),
+            None => Err(de::Error::end_of_stream()),
+        }
+    }
+
+    fn deserialize_enum<V>(&mut self,
+                     _name: &str,
+                     _variants: &'static [&'static str],
+                     mut visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::EnumVisitor,
+    {
+        visitor.visit(self)
+    }
+
+    de_forward_to_deserialize!{
+        deserialize_bool,
+        deserialize_f64, deserialize_f32,
+        deserialize_u8, deserialize_u16, deserialize_u32, deserialize_u64, deserialize_usize,
+        deserialize_i8, deserialize_i16, deserialize_i32, deserialize_i64, deserialize_isize,
+        deserialize_char, deserialize_str, deserialize_string,
+        deserialize_ignored_any,
+        deserialize_bytes,
+        deserialize_unit_struct, deserialize_unit,
+        deserialize_seq, deserialize_seq_fixed_size,
+        deserialize_map, deserialize_newtype_struct, deserialize_struct_field,
+        deserialize_tuple,
+        deserialize_struct, deserialize_tuple_struct,
+        deserialize_option
+    }
+}
+
+#[cfg(any(feature = "std", feature = "collections"))]
+impl<'a, E> de::VariantVisitor for CowStrDeserializer<'a, E>
+    where E: de::Error,
+{
+    type Error = E;
+
+    fn visit_variant<T>(&mut self) -> Result<T, Self::Error>
+        where T: de::Deserialize,
+    {
+        de::Deserialize::deserialize(self)
+    }
+
+    fn visit_unit(&mut self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn visit_newtype<T>(&mut self) -> Result<T, Self::Error>
+        where T: super::Deserialize,
+    {
+        let (value,) = try!(self.visit_tuple(1, super::impls::TupleVisitor1::new()));
+        Ok(value)
+    }
+
+    fn visit_tuple<V>(&mut self,
+                      _len: usize,
+                      _visitor: V) -> Result<V::Value, Self::Error>
+        where V: super::Visitor
+    {
+        Err(super::Error::invalid_type(super::Type::TupleVariant))
+    }
+
+    fn visit_struct<V>(&mut self,
+                       _fields: &'static [&'static str],
+                       _visitor: V) -> Result<V::Value, Self::Error>
+        where V: super::Visitor
+    {
+        Err(super::Error::invalid_type(super::Type::StructVariant))
+    }
+}
+
+///////////////////////////////////////////////////////////////////////////////
+
 /// A helper deserializer that deserializes a sequence.
 pub struct SeqDeserializer<I, E> {
     iter: I,
@@ -648,7 +751,7 @@ pub struct MapDeserializer<I, K, V, E>
 {
     iter: I,
     value: Option<V>,
-    len: usize,
+    len: Option<usize>,
     marker: PhantomData<E>,
 }
 
@@ -658,12 +761,23 @@ impl<I, K, V, E> MapDeserializer<I, K, V, E>
           V: ValueDeserializer<E>,
           E: de::Error,
 {
-    /// Construct a new `MapDeserializer<I, K, V>`.
+    /// Construct a new `MapDeserializer<I, K, V, E>` with a specific length.
     pub fn new(iter: I, len: usize) -> Self {
         MapDeserializer {
             iter: iter,
             value: None,
-            len: len,
+            len: Some(len),
+            marker: PhantomData,
+        }
+    }
+
+    /// Construct a new `MapDeserializer<I, K, V, E>` that is not bounded
+    /// by a specific length and that delegates to `iter` for its size hint.
+    pub fn unbounded(iter: I) -> Self {
+        MapDeserializer {
+            iter: iter,
+            value: None,
+            len: None,
             marker: PhantomData,
         }
     }
@@ -714,7 +828,9 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
     {
         match self.iter.next() {
             Some((key, value)) => {
-                self.len -= 1;
+                if let Some(len) = self.len.as_mut() {
+                    *len -= 1;
+                }
                 self.value = Some(value);
                 let mut de = key.into_deserializer();
                 Ok(Some(try!(de::Deserialize::deserialize(&mut de))))
@@ -738,15 +854,16 @@ impl<I, K, V, E> de::MapVisitor for MapDeserializer<I, K, V, E>
     }
 
     fn end(&mut self) -> Result<(), Self::Error> {
-        if self.len == 0 {
+        match self.len {
-            Ok(())
+            Some(len) if len > 0 => Err(de::Error::invalid_length(len)),
-        } else {
+            _ => Ok(())
-            Err(de::Error::invalid_length(self.len))
         }
     }
 
     fn size_hint(&self) -> (usize, Option<usize>) {
-        (self.len, Some(self.len))
+        self.len.map_or_else(
+            || self.iter.size_hint(),
+            |len| (len, Some(len)))
     }
 }
 

serde_codegen/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen"
-version = "0.8.3"
+version = "0.8.6"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -25,14 +25,14 @@ with-syntex = [
 ]
 
 [build-dependencies]
-quasi_codegen = { version = "^0.17.0", optional = true }
+quasi_codegen = { version = "^0.19.0", optional = true }
-syntex = { version = "^0.41.0", optional = true }
+syntex = { version = "^0.43.0", optional = true }
 
 [dependencies]
-aster = { version = "^0.24.0", default-features = false }
+aster = { version = "^0.26.0", default-features = false }
 clippy = { version = "^0.*", optional = true }
-quasi = { version = "^0.17.0", default-features = false }
+quasi = { version = "^0.19.0", default-features = false }
-quasi_macros = { version = "^0.17.0", optional = true }
+quasi_macros = { version = "^0.19.0", optional = true }
-serde_codegen_internals = { version = "=0.6.1", default-features = false, path = "../serde_codegen_internals" }
+serde_codegen_internals = { version = "=0.8.0", default-features = false, path = "../serde_codegen_internals" }
-syntex = { version = "^0.41.0", optional = true }
+syntex = { version = "^0.43.0", optional = true }
-syntex_syntax = { version = "^0.41.0", optional = true }
+syntex_syntax = { version = "^0.43.0", optional = true }

serde_codegen/src/env.rs

@@ -1,36 +0,0 @@
-use std::env;
-use std::ffi::OsStr;
-use std::ops::Drop;
-
-pub fn set_if_unset<K, V>(k: K, v: V) -> TmpEnv<K>
-    where K: AsRef<OsStr>,
-          V: AsRef<OsStr>,
-{
-    match env::var(&k) {
-        Ok(_) => TmpEnv::WasAlreadySet,
-        Err(_) => {
-            env::set_var(&k, v);
-            TmpEnv::WasNotSet { k: k }
-        }
-    }
-}
-
-#[must_use]
-pub enum TmpEnv<K>
-    where K: AsRef<OsStr>,
-{
-    WasAlreadySet,
-    WasNotSet {
-        k: K,
-    }
-}
-
-impl<K> Drop for TmpEnv<K>
-    where K: AsRef<OsStr>,
-{
-    fn drop(&mut self) {
-        if let TmpEnv::WasNotSet { ref k } = *self {
-            env::remove_var(k);
-        }
-    }
-}

serde_codegen/src/lib.rs

@@ -36,7 +36,56 @@ include!(concat!(env!("OUT_DIR"), "/lib.rs"));
 include!("lib.rs.in");
 
 #[cfg(feature = "with-syntex")]
-mod env;
+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> {
+                match attr.node.value.node {
+                    ast::MetaItemKind::List(ref n, _) if n == &"serde" => { 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", ser::expand_derive_serialize);
+    reg.add_decorator("derive_Deserialize", de::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>
@@ -47,50 +96,10 @@ pub fn expand<S, D>(src: S, dst: D) -> Result<(), syntex::Error>
     let dst = dst.as_ref().to_owned();
 
     let expand_thread = move || {
-        use syntax::{ast, fold};
+        syntex_registry().expand("", src, dst)
-
-        /// 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> {
-                    match attr.node.value.node {
-                        ast::MetaItemKind::List(ref n, _) if n == &"serde" => { 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", ser::expand_derive_serialize);
-        reg.add_decorator("derive_Deserialize", de::expand_derive_deserialize);
-
-        reg.add_post_expansion_pass(strip_attributes);
-
-        reg.expand("", src, dst)
     };
 
-    // 16 MB stack unless otherwise specified
+    syntex::with_extra_stack(expand_thread)
-    let _tmp_env = env::set_if_unset("RUST_MIN_STACK", "16777216");
-
-    use std::thread;
-    thread::spawn(expand_thread).join().unwrap()
 }
 
 #[cfg(not(feature = "with-syntex"))]

serde_codegen_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_codegen_internals"
-version = "0.6.1"
+version = "0.8.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde codegen. Unstable."
@@ -17,5 +17,5 @@ with-syntex = ["syntex_syntax", "syntex_errors"]
 
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-syntex_syntax = { version = "^0.41.0", optional = true }
+syntex_syntax = { version = "^0.43.0", optional = true }
-syntex_errors = { version = "^0.41.0", optional = true }
+syntex_errors = { version = "^0.43.0", optional = true }

serde_codegen_internals/src/attr.rs

@@ -8,8 +8,7 @@ use syntax::fold::Folder;
 use syntax::parse::parser::{Parser, PathStyle};
 use syntax::parse::token::{self, InternedString};
 use syntax::parse;
-use syntax::print::pprust::{lit_to_string, meta_item_to_string};
+use syntax::print::pprust::{lit_to_string, meta_item_to_string, meta_list_item_to_string};
-use syntax::ptr::P;
 use syntax::tokenstream::{self, TokenTree};
 
 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
@@ -165,7 +164,7 @@ impl Item {
                         cx.span_err(
                             meta_item.span,
                             &format!("unknown serde container attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                     }
                 }
             }
@@ -236,7 +235,7 @@ impl Variant {
                         cx.span_err(
                             meta_item.span,
                             &format!("unknown serde variant attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                     }
                 }
             }
@@ -384,7 +383,7 @@ impl Field {
                         cx.span_err(
                             meta_item.span,
                             &format!("unknown serde field attribute `{}`",
-                                     meta_item_to_string(meta_item)));
+                                     meta_item_to_string(&meta_item)));
                     }
                 }
             }
@@ -454,7 +453,7 @@ type SerAndDe<T> = (Option<Spanned<T>>, Option<Spanned<T>>);
 fn get_ser_and_de<T, F>(
     cx: &ExtCtxt,
     attribute: &'static str,
-    items: &[P<ast::MetaItem>],
+    items: &[ast::NestedMetaItem],
     f: F
 ) -> Result<SerAndDe<T>, ()>
     where F: Fn(&ExtCtxt, &str, &ast::Lit) -> Result<T, ()>,
@@ -464,15 +463,29 @@ fn get_ser_and_de<T, F>(
 
     for item in items {
         match item.node {
-            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize" => {
+            ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
-                if let Ok(v) = f(cx, name, lit) {
+                match meta_item.node {
-                    ser_item.set(item.span, v);
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize" => {
-                }
+                        if let Ok(v) = f(cx, name, lit) {
-            }
+                            ser_item.set(item.span, v);
+                        }
+                    }
 
-            ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
+                    ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"deserialize" => {
-                if let Ok(v) = f(cx, name, lit) {
+                        if let Ok(v) = f(cx, name, lit) {
-                    de_item.set(item.span, v);
+                            de_item.set(item.span, v);
+                        }
+                    }
+
+                    _ => {
+                        cx.span_err(
+                            item.span,
+                            &format!("unknown {} attribute `{}`",
+                                    attribute,
+                                    meta_item_to_string(meta_item)));
+
+                        return Err(());
+                    }
                 }
             }
 
@@ -481,7 +494,7 @@ fn get_ser_and_de<T, F>(
                     item.span,
                     &format!("unknown {} attribute `{}`",
                              attribute,
-                             meta_item_to_string(item)));
+                             meta_list_item_to_string(item)));
 
                 return Err(());
             }
@@ -493,23 +506,30 @@ fn get_ser_and_de<T, F>(
 
 fn get_renames(
     cx: &ExtCtxt,
-    items: &[P<ast::MetaItem>],
+    items: &[ast::NestedMetaItem],
 ) -> Result<SerAndDe<InternedString>, ()> {
     get_ser_and_de(cx, "rename", items, get_str_from_lit)
 }
 
 fn get_where_predicates(
     cx: &ExtCtxt,
-    items: &[P<ast::MetaItem>],
+    items: &[ast::NestedMetaItem],
 ) -> Result<SerAndDe<Vec<ast::WherePredicate>>, ()> {
     get_ser_and_de(cx, "bound", items, parse_lit_into_where)
 }
 
-pub fn get_serde_meta_items(attr: &ast::Attribute) -> Option<&[P<ast::MetaItem>]> {
+pub fn get_serde_meta_items(attr: &ast::Attribute) -> Option<Vec<ast::MetaItem>> {
     match attr.node.value.node {
         ast::MetaItemKind::List(ref name, ref items) if name == &"serde" => {
             attr::mark_used(attr);
-            Some(items)
+            Some(items.iter().filter_map(|item| {
+                match item.node {
+                    ast::NestedMetaItemKind::MetaItem(ref meta_item) => {
+                        Some((*meta_item.clone()).clone())
+                    }
+                    _ => None,
+                }
+            }).collect())
         }
         _ => None
     }

serde_derive/Cargo.toml

@@ -0,0 +1,23 @@
+[package]
+name = "serde_derive"
+version = "0.8.6"
+authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
+license = "MIT/Apache-2.0"
+description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
+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"]
+
+[lib]
+name = "serde_derive"
+rustc-macro = true
+
+[dependencies]
+serde_codegen = { version = "=0.8.6", path = "../serde_codegen" }
+
+[dev-dependencies]
+fnv = "1.0"
+serde = { version = "0.8.6", path = "../serde" }
+serde_test = { version = "0.8.6", path = "../serde_test" }

serde_derive/src/lib.rs

@@ -0,0 +1,21 @@
+#![feature(rustc_macro, rustc_macro_lib)]
+#![cfg(not(test))]
+
+extern crate rustc_macro;
+extern crate serde_codegen;
+
+use rustc_macro::TokenStream;
+
+#[rustc_macro_derive(Serialize)]
+pub fn derive_serialize(input: TokenStream) -> TokenStream {
+    let item = format!("#[derive(Serialize)]\n{}", input);
+    let expanded = serde_codegen::expand_str(&item).unwrap();
+    expanded.parse().unwrap()
+}
+
+#[rustc_macro_derive(Deserialize)]
+pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+    let item = format!("#[derive(Deserialize)]\n{}", input);
+    let expanded = serde_codegen::expand_str(&item).unwrap();
+    expanded.parse().unwrap()
+}

serde_derive/tests/test.rs

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

serde_macros/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_macros"
-version = "0.8.3"
+version = "0.8.6"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros to auto-generate implementations for the serde framework"
@@ -8,8 +8,7 @@ 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", "build.rs"]
+include = ["Cargo.toml", "src/**/*.rs"]
-build = "build.rs"
 
 [lib]
 name = "serde_macros"
@@ -18,36 +17,25 @@ plugin = true
 [features]
 unstable-testing = [
     "clippy",
-    "skeptic",
-    "serde_json",
     "serde/unstable-testing",
     "serde_codegen/unstable-testing"
 ]
 
-[build-dependencies]
-skeptic = { version = "^0.6.0", optional = true }
-
 [dependencies]
 clippy = { version = "^0.*", optional = true }
-serde_codegen = { version = "=0.8.3", default-features = false, features = ["unstable"], path = "../serde_codegen" }
+serde_codegen = { version = "=0.8.6", default-features = false, features = ["unstable"], path = "../serde_codegen" }
-skeptic = { version = "^0.6.0", optional = true }
-serde_json = { version = "0.8.0", optional = true }
 
 [dev-dependencies]
 compiletest_rs = "^0.2.0"
 fnv = "1.0"
 rustc-serialize = "^0.3.16"
-serde = { version = "0.8.3", path = "../serde" }
+serde = { version = "0.8.6", path = "../serde" }
-serde_test = { version = "0.8.3", path = "../serde_test" }
+serde_test = { version = "0.8.6", path = "../serde_test" }
 
 [[test]]
 name = "test"
 path = "tests/test.rs"
 
-[[test]]
-name = "skeptic"
-path = "tests/skeptic.rs"
-
 [[bench]]
 name = "bench"
 path = "benches/bench.rs"

serde_macros/build.rs

@@ -1,18 +0,0 @@
-#[cfg(feature = "unstable-testing")]
-mod inner {
-    extern crate skeptic;
-
-    pub fn main() {
-        println!("cargo:rerun-if-changed=../README.md");
-        skeptic::generate_doc_tests(&["../README.md"]);
-    }
-}
-
-#[cfg(not(feature = "unstable-testing"))]
-mod inner {
-    pub fn main() {}
-}
-
-fn main() {
-    inner::main()
-}

serde_macros/tests/skeptic.rs

@@ -1,3 +0,0 @@
-#![cfg(feature = "unstable-testing")]
-
-include!(concat!(env!("OUT_DIR"), "/skeptic-tests.rs"));

serde_macros/tests/test.rs

@@ -6,4 +6,3 @@ extern crate test;
 include!("../../testing/tests/test.rs.in");
 
 mod compile_tests;
-mod skeptic;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.8.3"
+version = "0.8.6"
 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.3", path = "../serde" }
+serde = { version = "0.8.6", path = "../serde" }

testing/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_testing"
-version = "0.8.3"
+version = "0.8.6"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"