Release 1.0.45

Pretend remote derives are not dead code

.travis.yml

@@ -5,6 +5,7 @@ cache: cargo
 # run builds for all the trains (and more)
 rust:
   - 1.13.0
+  - 1.15.0
   - stable
   - beta
   - nightly

README.md

@@ -1,9 +1,11 @@
-# Serde   [![Build Status]][travis] [![Latest Version]][crates.io]
+# Serde   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.13+]][rustc]
 
 [Build Status]: https://api.travis-ci.org/serde-rs/serde.svg?branch=master
 [travis]: https://travis-ci.org/serde-rs/serde
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
+[Rustc Version 1.13+]: https://img.shields.io/badge/rustc-1.13+-lightgray.svg
+[rustc]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
 
 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
 

appveyor.yml

@@ -5,7 +5,7 @@ environment:
 
 install:
   # Install rust, x86_64-pc-windows-msvc host
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
   - rustup-init.exe -y --default-host x86_64-pc-windows-msvc --default-toolchain %APPVEYOR_RUST_CHANNEL%
   - set PATH=C:\msys64\usr\bin;%PATH%;C:\Users\appveyor\.cargo\bin
   - rustc -vV

rustfmt.toml

@@ -1,2 +1 @@
 error_on_line_overflow = false
-same_line_attributes = false

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.27" # remember to update html_root_url
+version = "1.0.45" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/de/from_primitive.rs

@@ -9,33 +9,33 @@
 use lib::*;
 
 macro_rules! int_to_int {
-    ($dst:ident, $n:ident) => (
-        if $dst::MIN as i64 <= $n as i64 && $n as i64 <= $dst::MAX as i64 {
+    ($dst:ident, $n:ident) => {
+        if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 macro_rules! int_to_uint {
-    ($dst:ident, $n:ident) => (
-        if 0 <= $n && $n as u64 <= $dst::MAX as u64 {
+    ($dst:ident, $n:ident) => {
+        if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 macro_rules! uint_to {
-    ($dst:ident, $n:ident) => (
-        if $n as u64 <= $dst::MAX as u64 {
+    ($dst:ident, $n:ident) => {
+        if $n as u64 <= $dst::max_value() as u64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 pub trait FromPrimitive: Sized {
@@ -52,54 +52,144 @@ pub trait FromPrimitive: Sized {
 }
 
 macro_rules! impl_from_primitive_for_int {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { uint_to!($t, n) }
+            #[inline]
+            fn from_isize(n: isize) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_usize(n: usize) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                uint_to!($t, n)
+            }
         }
-    )
+    };
 }
 
 macro_rules! impl_from_primitive_for_uint {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { uint_to!($t, n) }
+            #[inline]
+            fn from_isize(n: isize) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_usize(n: usize) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                uint_to!($t, n)
+            }
         }
-    )
+    };
 }
 
 macro_rules! impl_from_primitive_for_float {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { Some(n as Self) }
+            #[inline]
+            fn from_isize(n: isize) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_usize(n: usize) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                Some(n as Self)
+            }
         }
-    )
+    };
 }
 
 impl_from_primitive_for_int!(isize);

serde/src/de/impls.rs

@@ -470,7 +470,11 @@ impl<'de> Deserialize<'de> for CString {
 }
 
 macro_rules! forwarded_impl {
-    (( $($id: ident),* ), $ty: ty, $func: expr) => {
+    (
+        $(#[doc = $doc:tt])*
+        ( $($id: ident),* ), $ty: ty, $func: expr
+    ) => {
+        $(#[doc = $doc])*
         impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1073,7 +1077,7 @@ map_impl!(
 
 #[cfg(feature = "std")]
 macro_rules! parse_ip_impl {
-    ($ty:ty; $size: expr) => {
+    ($ty:ty; $size:expr) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1087,7 +1091,7 @@ macro_rules! parse_ip_impl {
                 }
             }
         }
-    }
+    };
 }
 
 #[cfg(feature = "std")]
@@ -1230,7 +1234,7 @@ parse_ip_impl!(net::Ipv6Addr; 16);
 
 #[cfg(feature = "std")]
 macro_rules! parse_socket_impl {
-    ($ty:ty, $new: expr) => {
+    ($ty:ty, $new:expr) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1244,7 +1248,7 @@ macro_rules! parse_socket_impl {
                 }
             }
         }
-    }
+    };
 }
 
 #[cfg(feature = "std")]
@@ -1272,10 +1276,7 @@ parse_socket_impl!(net::SocketAddrV4, net::SocketAddrV4::new);
 
 #[cfg(feature = "std")]
 parse_socket_impl!(net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
-    ip,
-    port,
-    0,
-    0
+    ip, port, 0, 0
 ));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1432,10 +1433,28 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
 #[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
-forwarded_impl!((T), Arc<T>, Arc::new);
+forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Arc` will not attempt to
+    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    (T), Arc<T>, Arc::new
+}
 
 #[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
-forwarded_impl!((T), Rc<T>, Rc::new);
+forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Rc` will not attempt to
+    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    (T), Rc<T>, Rc::new
+}
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
@@ -1456,7 +1475,11 @@ where
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
 macro_rules! box_forwarded_impl {
-    ($t:ident) => {
+    (
+        $(#[doc = $doc:tt])*
+        $t:ident
+    ) => {
+        $(#[doc = $doc])*
         impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
         where
             Box<T>: Deserialize<'de>,
@@ -1468,14 +1491,32 @@ macro_rules! box_forwarded_impl {
                 Box::deserialize(deserializer).map(Into::into)
             }
         }
-    }
+    };
 }
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl!(Rc);
+box_forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Rc` will not attempt to
+    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    Rc
+}
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl!(Arc);
+box_forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Arc` will not attempt to
+    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    Arc
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -1918,6 +1959,7 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "unstable")]
+#[allow(deprecated)]
 impl<'de, T> Deserialize<'de> for NonZero<T>
 where
     T: Deserialize<'de> + Zeroable,
@@ -1934,6 +1976,36 @@ where
     }
 }
 
+macro_rules! nonzero_integers {
+    ( $( $T: ty, )+ ) => {
+        $(
+            #[cfg(feature = "unstable")]
+            impl<'de> Deserialize<'de> for $T {
+                fn deserialize<D>(deserializer: D) -> Result<$T, D::Error>
+                where
+                    D: Deserializer<'de>,
+                {
+                    let value = try!(Deserialize::deserialize(deserializer));
+                    match <$T>::new(value) {
+                        Some(nonzero) => Ok(nonzero),
+                        None => Err(Error::custom("expected a non-zero value")),
+                    }
+                }
+            }
+        )+
+    };
+}
+
+nonzero_integers! {
+    // Not including signed NonZeroI* since they might be removed
+    NonZeroU8,
+    NonZeroU16,
+    NonZeroU32,
+    NonZeroU64,
+    // FIXME: https://github.com/serde-rs/serde/issues/1136 NonZeroU128,
+    NonZeroUsize,
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 impl<'de, T, E> Deserialize<'de> for Result<T, E>

serde/src/de/mod.rs

@@ -98,7 +98,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - NonZero\<T\> (unstable)
+//!    - NonZero\<T\> (unstable, deprecated)
+//!    - num::NonZero* (unstable)
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -195,6 +196,7 @@ macro_rules! declare_error_trait {
             /// For example if we try to deserialize a String out of a JSON file
             /// containing an integer, the unexpected type is the integer and the
             /// expected type is the string.
+            #[cold]
             fn invalid_type(unexp: Unexpected, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
             }
@@ -212,6 +214,7 @@ macro_rules! declare_error_trait {
             /// For example if we try to deserialize a String out of some binary data
             /// that is not valid UTF-8, the unexpected value is the bytes and the
             /// expected value is a string.
+            #[cold]
             fn invalid_value(unexp: Unexpected, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid value: {}, expected {}", unexp, exp))
             }
@@ -225,12 +228,14 @@ macro_rules! declare_error_trait {
             /// The `exp` argument provides information about what data was being
             /// expected. For example `exp` might say that a tuple of size 6 was
             /// expected.
+            #[cold]
             fn invalid_length(len: usize, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid length {}, expected {}", len, exp))
             }
 
             /// Raised when a `Deserialize` enum type received a variant with an
             /// unrecognized name.
+            #[cold]
             fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
                 if expected.is_empty() {
                     Error::custom(format_args!("unknown variant `{}`, there are no variants",
@@ -244,6 +249,7 @@ macro_rules! declare_error_trait {
 
             /// Raised when a `Deserialize` struct type received a field with an
             /// unrecognized name.
+            #[cold]
             fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
                 if expected.is_empty() {
                     Error::custom(format_args!("unknown field `{}`, there are no fields",
@@ -258,12 +264,14 @@ macro_rules! declare_error_trait {
             /// Raised when a `Deserialize` struct type expected to receive a required
             /// field with a particular name but that field was not present in the
             /// input.
+            #[cold]
             fn missing_field(field: &'static str) -> Self {
                 Error::custom(format_args!("missing field `{}`", field))
             }
 
             /// Raised when a `Deserialize` struct type received more than one of the
             /// same field.
+            #[cold]
             fn duplicate_field(field: &'static str) -> Self {
                 Error::custom(format_args!("duplicate field `{}`", field))
             }
@@ -513,7 +521,7 @@ pub trait Deserialize<'de>: Sized {
     /// have been overwritten. Although whatever state that is will be
     /// memory-safe.
     ///
-    /// This is generally useful when repeateadly deserializing values that
+    /// This is generally useful when repeatedly deserializing values that
     /// are processed one at a time, where the value of `self` doesn't matter
     /// when the next deserialization occurs.
     ///

serde/src/de/value.rs

@@ -37,10 +37,10 @@
 
 use lib::*;
 
+use self::private::{First, Second};
 use de::{self, Expected, IntoDeserializer, SeqAccess};
 use private::de::size_hint;
 use ser;
-use self::private::{First, Second};
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -58,6 +58,7 @@ type ErrorImpl = ();
 
 impl de::Error for Error {
     #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
@@ -68,6 +69,7 @@ impl de::Error for Error {
     }
 
     #[cfg(not(any(feature = "std", feature = "alloc")))]
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
@@ -78,6 +80,7 @@ impl de::Error for Error {
 }
 
 impl ser::Error for Error {
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
@@ -652,11 +655,8 @@ where
 {
     /// Check for remaining elements after passing a `SeqDeserializer` to
     /// `Visitor::visit_seq`.
-    pub fn end(mut self) -> Result<(), E> {
-        let mut remaining = 0;
-        while self.iter.next().is_some() {
-            remaining += 1;
-        }
+    pub fn end(self) -> Result<(), E> {
+        let remaining = self.iter.count();
         if remaining == 0 {
             Ok(())
         } else {
@@ -849,11 +849,8 @@ where
 {
     /// Check for remaining elements after passing a `MapDeserializer` to
     /// `Visitor::visit_map`.
-    pub fn end(mut self) -> Result<(), E> {
-        let mut remaining = 0;
-        while self.iter.next().is_some() {
-            remaining += 1;
-        }
+    pub fn end(self) -> Result<(), E> {
+        let remaining = self.iter.count();
         if remaining == 0 {
             Ok(())
         } else {

serde/src/export.rs

@@ -16,6 +16,9 @@ pub use lib::result::Result::{self, Err, Ok};
 
 pub use self::string::from_utf8_lossy;
 
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use lib::Vec;
+
 mod string {
     use lib::*;
 

serde/src/lib.rs

@@ -79,7 +79,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.27")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.45")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
@@ -90,10 +90,13 @@
 #![cfg_attr(feature = "alloc", feature(alloc))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
-#![cfg_attr(feature = "cargo-clippy",
-            allow(cast_lossless, const_static_lifetime, doc_markdown, linkedlist,
-                  needless_pass_by_value, type_complexity, unreadable_literal,
-                  zero_prefixed_literal))]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        cast_lossless, const_static_lifetime, doc_markdown, linkedlist, needless_pass_by_value,
+        redundant_field_names, type_complexity, unreadable_literal, zero_prefixed_literal
+    )
+)]
 // Whitelisted clippy_pedantic lints
 #![cfg_attr(feature = "cargo-clippy", allow(
 // integer and float ser/de requires these sorts of casts
@@ -104,6 +107,7 @@
 // simplifies some macros
     invalid_upcast_comparisons,
 // things are often more readable this way
+    decimal_literal_representation,
     option_unwrap_used,
     result_unwrap_used,
     shadow_reuse,
@@ -111,7 +115,9 @@
     stutter,
     use_self,
 // not practical
+    many_single_char_names,
     missing_docs_in_private_items,
+    similar_names,
 // alternative is not stable
     empty_enum,
     use_debug,
@@ -132,16 +138,16 @@ extern crate core;
 /// module.
 mod lib {
     mod core {
-        #[cfg(feature = "std")]
-        pub use std::*;
         #[cfg(not(feature = "std"))]
         pub use core::*;
+        #[cfg(feature = "std")]
+        pub use std::*;
     }
 
     pub use self::core::{cmp, iter, mem, ops, slice, str};
-    pub use self::core::{isize, i16, i32, i64, i8};
-    pub use self::core::{usize, u16, u32, u64, u8};
     pub use self::core::{f32, f64};
+    pub use self::core::{i16, i32, i64, i8, isize};
+    pub use self::core::{u16, u32, u64, u8, usize};
 
     pub use self::core::cell::{Cell, RefCell};
     pub use self::core::clone::{self, Clone};
@@ -152,40 +158,40 @@ mod lib {
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
 
-    #[cfg(feature = "std")]
-    pub use std::borrow::{Cow, ToOwned};
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::borrow::{Cow, ToOwned};
-
     #[cfg(feature = "std")]
-    pub use std::string::String;
+    pub use std::borrow::{Cow, ToOwned};
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::string::{String, ToString};
-
     #[cfg(feature = "std")]
-    pub use std::vec::Vec;
+    pub use std::string::String;
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::vec::Vec;
-
     #[cfg(feature = "std")]
-    pub use std::boxed::Box;
+    pub use std::vec::Vec;
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::boxed::Box;
+    #[cfg(feature = "std")]
+    pub use std::boxed::Box;
 
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::rc::Rc;
     #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
     pub use alloc::rc::Rc;
-
     #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::sync::Arc;
+    pub use std::rc::Rc;
+
     #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
     pub use alloc::arc::Arc;
+    #[cfg(all(feature = "rc", feature = "std"))]
+    pub use std::sync::Arc;
 
-    #[cfg(feature = "std")]
-    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
+    #[cfg(feature = "std")]
+    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
     #[cfg(feature = "std")]
     pub use std::{error, net};
@@ -203,12 +209,16 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::path::{Path, PathBuf};
     #[cfg(feature = "std")]
-    pub use std::time::{Duration, SystemTime, UNIX_EPOCH};
-    #[cfg(feature = "std")]
     pub use std::sync::{Mutex, RwLock};
+    #[cfg(feature = "std")]
+    pub use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
     #[cfg(feature = "unstable")]
+    #[allow(deprecated)]
     pub use core::nonzero::{NonZero, Zeroable};
+
+    #[cfg(feature = "unstable")]
+    pub use core::num::{NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -216,13 +226,13 @@ mod lib {
 #[macro_use]
 mod macros;
 
-pub mod ser;
 pub mod de;
+pub mod ser;
 
-#[doc(inline)]
-pub use ser::{Serialize, Serializer};
 #[doc(inline)]
 pub use de::{Deserialize, Deserializer};
+#[doc(inline)]
+pub use ser::{Serialize, Serializer};
 
 // Generated code uses these to support no_std. Not public API.
 #[doc(hidden)]

serde/src/private/de.rs

@@ -11,10 +11,10 @@ use lib::*;
 use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use de::Unexpected;
+use de::{MapAccess, Unexpected};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer,
+pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
                         InternallyTaggedUnitVisitor, TagContentOtherField,
                         TagContentOtherFieldVisitor, TagOrContentField, TagOrContentFieldVisitor,
                         TaggedContentVisitor, UntaggedUnitVisitor};
@@ -188,7 +188,7 @@ where
         }
     }
 
-    deserializer.deserialize_str(CowBytesVisitor)
+    deserializer.deserialize_bytes(CowBytesVisitor)
 }
 
 pub mod size_hint {
@@ -228,9 +228,9 @@ mod content {
 
     use lib::*;
 
-    use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess,
-             Unexpected, Visitor};
     use super::size_hint;
+    use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, MapAccess,
+             SeqAccess, Unexpected, Visitor};
 
     /// Used from generated code to buffer the contents of the Deserializer when
     /// deserializing untagged enums and internally tagged enums.
@@ -269,6 +269,15 @@ mod content {
     }
 
     impl<'de> Content<'de> {
+        pub fn as_str(&self) -> Option<&str> {
+            match *self {
+                Content::Str(x) => Some(x),
+                Content::String(ref x) => Some(x),
+                _ => None,
+            }
+        }
+
+        #[cold]
         fn unexpected(&self) -> Unexpected {
             match *self {
                 Content::Bool(b) => Unexpected::Bool(b),
@@ -1005,6 +1014,62 @@ mod content {
         err: PhantomData<E>,
     }
 
+    impl<'de, E> ContentDeserializer<'de, E>
+    where
+        E: de::Error,
+    {
+        #[cold]
+        fn invalid_type(self, exp: &Expected) -> E {
+            de::Error::invalid_type(self.content.unexpected(), exp)
+        }
+
+        fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+    }
+
+    fn visit_content_seq<'de, V, E>(content: Vec<Content<'de>>, visitor: V) -> Result<V::Value, E>
+    where
+        V: Visitor<'de>,
+        E: de::Error,
+    {
+        let seq = content.into_iter().map(ContentDeserializer::new);
+        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
+        let value = try!(visitor.visit_seq(&mut seq_visitor));
+        try!(seq_visitor.end());
+        Ok(value)
+    }
+
+    fn visit_content_map<'de, V, E>(
+        content: Vec<(Content<'de>, Content<'de>)>,
+        visitor: V,
+    ) -> Result<V::Value, E>
+    where
+        V: Visitor<'de>,
+        E: de::Error,
+    {
+        let map = content
+            .into_iter()
+            .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
+        let mut map_visitor = de::value::MapDeserializer::new(map);
+        let value = try!(visitor.visit_map(&mut map_visitor));
+        try!(map_visitor.end());
+        Ok(value)
+    }
+
     /// Used when deserializing an internally tagged enum because the content will
     /// be used exactly once.
     impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
@@ -1038,21 +1103,152 @@ mod content {
                 Content::None => visitor.visit_none(),
                 Content::Some(v) => visitor.visit_some(ContentDeserializer::new(*v)),
                 Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
-                Content::Seq(v) => {
-                    let seq = v.into_iter().map(ContentDeserializer::new);
-                    let mut seq_visitor = de::value::SeqDeserializer::new(seq);
-                    let value = try!(visitor.visit_seq(&mut seq_visitor));
-                    try!(seq_visitor.end());
-                    Ok(value)
-                }
-                Content::Map(v) => {
-                    let map = v.into_iter()
-                        .map(|(k, v)| (ContentDeserializer::new(k), ContentDeserializer::new(v)));
-                    let mut map_visitor = de::value::MapDeserializer::new(map);
-                    let value = try!(visitor.visit_map(&mut map_visitor));
-                    try!(map_visitor.end());
-                    Ok(value)
-                }
+                Content::Seq(v) => visit_content_seq(v, visitor),
+                Content::Map(v) => visit_content_map(v, visitor),
+            }
+        }
+
+        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Bool(v) => visitor.visit_bool(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Char(v) => visitor.visit_char(v),
+                Content::String(v) => visitor.visit_string(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_string(visitor)
+        }
+
+        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::String(v) => visitor.visit_string(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_byte_buf(visitor)
+        }
+
+        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::String(v) => visitor.visit_string(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                Content::ByteBuf(v) => visitor.visit_byte_buf(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                Content::Seq(v) => visit_content_seq(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
             }
         }
 
@@ -1068,6 +1264,44 @@ mod content {
             }
         }
 
+        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Unit => visitor.visit_unit(),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_unit_struct<V>(
+            self,
+            _name: &'static str,
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                // As a special case, allow deserializing untagged newtype
+                // variant containing unit struct.
+                //
+                //     #[derive(Deserialize)]
+                //     struct Info;
+                //
+                //     #[derive(Deserialize)]
+                //     #[serde(tag = "topic")]
+                //     enum Message {
+                //         Info(Info),
+                //     }
+                //
+                // We want {"topic":"Info"} to deserialize even though
+                // ordinarily unit structs do not deserialize from empty map.
+                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
+                _ => self.deserialize_any(visitor),
+            }
+        }
+
         fn deserialize_newtype_struct<V>(
             self,
             _name: &str,
@@ -1076,7 +1310,65 @@ mod content {
         where
             V: Visitor<'de>,
         {
-            visitor.visit_newtype_struct(self)
+            match self.content {
+                Content::Newtype(v) => visitor.visit_newtype_struct(ContentDeserializer::new(*v)),
+                _ => visitor.visit_newtype_struct(self),
+            }
+        }
+
+        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Seq(v) => visit_content_seq(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_seq(visitor)
+        }
+
+        fn deserialize_tuple_struct<V>(
+            self,
+            _name: &'static str,
+            _len: usize,
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_seq(visitor)
+        }
+
+        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Map(v) => visit_content_map(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_struct<V>(
+            self,
+            _name: &'static str,
+            _fields: &'static [&'static str],
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::Seq(v) => visit_content_seq(v, visitor),
+                Content::Map(v) => visit_content_map(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
         }
 
         fn deserialize_enum<V>(
@@ -1118,45 +1410,26 @@ mod content {
                 }
             };
 
-            visitor.visit_enum(EnumDeserializer {
-                variant: variant,
-                value: value,
-                err: PhantomData,
-            })
+            visitor.visit_enum(EnumDeserializer::new(variant, value))
         }
 
-        fn deserialize_unit_struct<V>(
-            self,
-            _name: &'static str,
-            visitor: V,
-        ) -> Result<V::Value, Self::Error>
+        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
         where
             V: Visitor<'de>,
         {
             match self.content {
-                // As a special case, allow deserializing untagged newtype
-                // variant containing unit struct.
-                //
-                //     #[derive(Deserialize)]
-                //     struct Info;
-                //
-                //     #[derive(Deserialize)]
-                //     #[serde(tag = "topic")]
-                //     enum Message {
-                //         Info(Info),
-                //     }
-                //
-                // We want {"topic":"Info"} to deserialize even though
-                // ordinarily unit structs do not deserialize from empty map.
-                Content::Map(ref v) if v.is_empty() => visitor.visit_unit(),
-                _ => self.deserialize_any(visitor),
+                Content::String(v) => visitor.visit_string(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                _ => Err(self.invalid_type(&visitor)),
             }
         }
 
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-            byte_buf unit seq tuple tuple_struct map struct identifier
-            ignored_any
+        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            drop(self);
+            visitor.visit_unit()
         }
     }
 
@@ -1170,7 +1443,7 @@ mod content {
         }
     }
 
-    struct EnumDeserializer<'de, E>
+    pub struct EnumDeserializer<'de, E>
     where
         E: de::Error,
     {
@@ -1179,6 +1452,19 @@ mod content {
         err: PhantomData<E>,
     }
 
+    impl<'de, E> EnumDeserializer<'de, E>
+    where
+        E: de::Error,
+    {
+        pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
+            EnumDeserializer {
+                variant: variant,
+                value: value,
+                err: PhantomData,
+            }
+        }
+    }
+
     impl<'de, E> de::EnumAccess<'de> for EnumDeserializer<'de, E>
     where
         E: de::Error,
@@ -1199,7 +1485,7 @@ mod content {
         }
     }
 
-    struct VariantDeserializer<'de, E>
+    pub struct VariantDeserializer<'de, E>
     where
         E: de::Error,
     {
@@ -1435,6 +1721,68 @@ mod content {
         err: PhantomData<E>,
     }
 
+    impl<'a, 'de, E> ContentRefDeserializer<'a, 'de, E>
+    where
+        E: de::Error,
+    {
+        #[cold]
+        fn invalid_type(self, exp: &Expected) -> E {
+            de::Error::invalid_type(self.content.unexpected(), exp)
+        }
+
+        fn deserialize_integer<V>(self, visitor: V) -> Result<V::Value, E>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+    }
+
+    fn visit_content_seq_ref<'a, 'de, V, E>(
+        content: &'a [Content<'de>],
+        visitor: V,
+    ) -> Result<V::Value, E>
+    where
+        V: Visitor<'de>,
+        E: de::Error,
+    {
+        let seq = content.into_iter().map(ContentRefDeserializer::new);
+        let mut seq_visitor = de::value::SeqDeserializer::new(seq);
+        let value = try!(visitor.visit_seq(&mut seq_visitor));
+        try!(seq_visitor.end());
+        Ok(value)
+    }
+
+    fn visit_content_map_ref<'a, 'de, V, E>(
+        content: &'a [(Content<'de>, Content<'de>)],
+        visitor: V,
+    ) -> Result<V::Value, E>
+    where
+        V: Visitor<'de>,
+        E: de::Error,
+    {
+        let map = content.into_iter().map(|&(ref k, ref v)| {
+            (
+                ContentRefDeserializer::new(k),
+                ContentRefDeserializer::new(v),
+            )
+        });
+        let mut map_visitor = de::value::MapDeserializer::new(map);
+        let value = try!(visitor.visit_map(&mut map_visitor));
+        try!(map_visitor.end());
+        Ok(value)
+    }
+
     /// Used when deserializing an untagged enum because the content may need to be
     /// used more than once.
     impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
@@ -1470,28 +1818,155 @@ mod content {
                 Content::Newtype(ref v) => {
                     visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
                 }
-                Content::Seq(ref v) => {
-                    let seq = v.into_iter().map(ContentRefDeserializer::new);
-                    let mut seq_visitor = de::value::SeqDeserializer::new(seq);
-                    let value = try!(visitor.visit_seq(&mut seq_visitor));
-                    try!(seq_visitor.end());
-                    Ok(value)
-                }
-                Content::Map(ref v) => {
-                    let map = v.into_iter().map(|&(ref k, ref v)| {
-                        (
-                            ContentRefDeserializer::new(k),
-                            ContentRefDeserializer::new(v),
-                        )
-                    });
-                    let mut map_visitor = de::value::MapDeserializer::new(map);
-                    let value = try!(visitor.visit_map(&mut map_visitor));
-                    try!(map_visitor.end());
-                    Ok(value)
-                }
+                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
+                Content::Map(ref v) => visit_content_map_ref(v, visitor),
             }
         }
 
+        fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Bool(v) => visitor.visit_bool(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_integer(visitor)
+        }
+
+        fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::F32(v) => visitor.visit_f32(v),
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_f64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::F64(v) => visitor.visit_f64(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_char<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Char(v) => visitor.visit_char(v),
+                Content::String(ref v) => visitor.visit_str(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_str<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::String(ref v) => visitor.visit_str(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_string<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_str(visitor)
+        }
+
+        fn deserialize_bytes<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::String(ref v) => visitor.visit_str(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                Content::ByteBuf(ref v) => visitor.visit_bytes(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_byte_buf<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_bytes(visitor)
+        }
+
         fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
         where
             V: Visitor<'de>,
@@ -1504,11 +1979,92 @@ mod content {
             }
         }
 
+        fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Unit => visitor.visit_unit(),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_unit_struct<V>(
+            self,
+            _name: &'static str,
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_unit(visitor)
+        }
+
         fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
         where
             V: Visitor<'de>,
         {
-            visitor.visit_newtype_struct(self)
+            match *self.content {
+                Content::Newtype(ref v) => {
+                    visitor.visit_newtype_struct(ContentRefDeserializer::new(v))
+                }
+                _ => visitor.visit_newtype_struct(self),
+            }
+        }
+
+        fn deserialize_seq<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_tuple<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_seq(visitor)
+        }
+
+        fn deserialize_tuple_struct<V>(
+            self,
+            _name: &'static str,
+            _len: usize,
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.deserialize_seq(visitor)
+        }
+
+        fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Map(ref v) => visit_content_map_ref(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_struct<V>(
+            self,
+            _name: &'static str,
+            _fields: &'static [&'static str],
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::Seq(ref v) => visit_content_seq_ref(v, visitor),
+                Content::Map(ref v) => visit_content_map_ref(v, visitor),
+                _ => Err(self.invalid_type(&visitor)),
+            }
         }
 
         fn deserialize_enum<V>(
@@ -1557,10 +2113,22 @@ mod content {
             })
         }
 
-        forward_to_deserialize_any! {
-            bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-            byte_buf unit unit_struct seq tuple tuple_struct map struct
-            identifier ignored_any
+        fn deserialize_identifier<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::String(ref v) => visitor.visit_str(v),
+                Content::Str(v) => visitor.visit_borrowed_str(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            visitor.visit_unit()
         }
     }
 
@@ -2062,3 +2630,156 @@ where
         T::deserialize_in_place(deserializer, self.0)
     }
 }
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
+    pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,
+    pub PhantomData<E>,
+);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
+where
+    E: Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        Err(Error::custom("can only flatten structs and maps"))
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &'static str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        for item in self.0.iter_mut() {
+            // items in the vector are nulled out when used.  So we can only use
+            // an item if it's still filled in and if the field is one we care
+            // about.
+            let use_item = match *item {
+                None => false,
+                Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x)),
+            };
+
+            if use_item {
+                let (key, value) = item.take().unwrap();
+                return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
+            }
+        }
+
+        Err(Error::custom(format_args!(
+            "no variant of enum {} not found in flattened data",
+            name
+        )))
+    }
+
+    fn deserialize_map<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(FlatMapAccess::new(self.0.iter_mut(), None))
+    }
+
+    fn deserialize_struct<V>(
+        self,
+        _: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_map(FlatMapAccess::new(self.0.iter_mut(), Some(fields)))
+    }
+
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_newtype_struct(self)
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
+        byte_buf option unit unit_struct seq tuple tuple_struct identifier
+        ignored_any
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapAccess<'a, 'de: 'a, E> {
+    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+    pending_content: Option<Content<'de>>,
+    fields: Option<&'static [&'static str]>,
+    _marker: PhantomData<E>,
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
+    fn new(
+        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+        fields: Option<&'static [&'static str]>,
+    ) -> FlatMapAccess<'a, 'de, E> {
+        FlatMapAccess {
+            iter: iter,
+            pending_content: None,
+            fields: fields,
+            _marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
+where
+    E: Error,
+{
+    type Error = E;
+
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        while let Some(item) = self.iter.next() {
+            // items in the vector are nulled out when used.  So we can only use
+            // an item if it's still filled in and if the field is one we care
+            // about.  In case we do not know which fields we want, we take them all.
+            let use_item = match *item {
+                None => false,
+                Some((ref c, _)) => {
+                    c.as_str()
+                        .map_or(self.fields.is_none(), |key| match self.fields {
+                            None => true,
+                            Some(fields) if fields.contains(&key) => true,
+                            _ => false,
+                        })
+                }
+            };
+
+            if use_item {
+                let (key, content) = item.take().unwrap();
+                self.pending_content = Some(content);
+                return seed.deserialize(ContentDeserializer::new(key)).map(Some);
+            }
+        }
+        Ok(None)
+    }
+
+    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.pending_content.take() {
+            Some(value) => seed.deserialize(ContentDeserializer::new(value)),
+            None => Err(Error::custom("value is missing")),
+        }
+    }
+}

serde/src/private/mod.rs

@@ -8,5 +8,5 @@
 
 mod macros;
 
-pub mod ser;
 pub mod de;
+pub mod ser;

serde/src/private/ser.rs

@@ -11,7 +11,8 @@ use lib::*;
 use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use self::content::{SerializeStructVariantAsMapValue, SerializeTupleVariantAsMapValue};
+use self::content::{Content, ContentSerializer, SerializeStructVariantAsMapValue,
+                    SerializeTupleVariantAsMapValue};
 
 /// Used to check that serde(getter) attributes return the expected type.
 /// Not public API.
@@ -58,10 +59,11 @@ enum Unsupported {
     ByteArray,
     Optional,
     Unit,
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    UnitStruct,
     Sequence,
     Tuple,
     TupleStruct,
-    #[cfg(not(any(feature = "std", feature = "alloc")))]
     Enum,
 }
 
@@ -76,10 +78,11 @@ impl Display for Unsupported {
             Unsupported::ByteArray => formatter.write_str("a byte array"),
             Unsupported::Optional => formatter.write_str("an optional"),
             Unsupported::Unit => formatter.write_str("unit"),
+            #[cfg(any(feature = "std", feature = "alloc"))]
+            Unsupported::UnitStruct => formatter.write_str("unit struct"),
             Unsupported::Sequence => formatter.write_str("a sequence"),
             Unsupported::Tuple => formatter.write_str("a tuple"),
             Unsupported::TupleStruct => formatter.write_str("a tuple struct"),
-            #[cfg(not(any(feature = "std", feature = "alloc")))]
             Unsupported::Enum => formatter.write_str("an enum"),
         }
     }
@@ -459,7 +462,7 @@ mod content {
     }
 
     #[derive(Debug)]
-    enum Content {
+    pub enum Content {
         Bool(bool),
 
         U8(u8),
@@ -584,12 +587,12 @@ mod content {
         }
     }
 
-    struct ContentSerializer<E> {
+    pub struct ContentSerializer<E> {
         error: PhantomData<E>,
     }
 
     impl<E> ContentSerializer<E> {
-        fn new() -> Self {
+        pub fn new() -> Self {
             ContentSerializer { error: PhantomData }
         }
     }
@@ -804,7 +807,7 @@ mod content {
         }
     }
 
-    struct SerializeSeq<E> {
+    pub struct SerializeSeq<E> {
         elements: Vec<Content>,
         error: PhantomData<E>,
     }
@@ -830,7 +833,7 @@ mod content {
         }
     }
 
-    struct SerializeTuple<E> {
+    pub struct SerializeTuple<E> {
         elements: Vec<Content>,
         error: PhantomData<E>,
     }
@@ -856,7 +859,7 @@ mod content {
         }
     }
 
-    struct SerializeTupleStruct<E> {
+    pub struct SerializeTupleStruct<E> {
         name: &'static str,
         fields: Vec<Content>,
         error: PhantomData<E>,
@@ -883,7 +886,7 @@ mod content {
         }
     }
 
-    struct SerializeTupleVariant<E> {
+    pub struct SerializeTupleVariant<E> {
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
@@ -917,7 +920,7 @@ mod content {
         }
     }
 
-    struct SerializeMap<E> {
+    pub struct SerializeMap<E> {
         entries: Vec<(Content, Content)>,
         key: Option<Content>,
         error: PhantomData<E>,
@@ -967,7 +970,7 @@ mod content {
         }
     }
 
-    struct SerializeStruct<E> {
+    pub struct SerializeStruct<E> {
         name: &'static str,
         fields: Vec<(&'static str, Content)>,
         error: PhantomData<E>,
@@ -994,7 +997,7 @@ mod content {
         }
     }
 
-    struct SerializeStructVariant<E> {
+    pub struct SerializeStructVariant<E> {
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
@@ -1028,3 +1031,305 @@ mod content {
         }
     }
 }
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializer<'a, M: 'a>(pub &'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> FlatMapSerializer<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    fn bad_type(self, what: Unsupported) -> M::Error {
+        ser::Error::custom(format_args!(
+            "can only flatten structs and maps (got {})",
+            what
+        ))
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> Serializer for FlatMapSerializer<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    type SerializeSeq = Impossible<Self::Ok, M::Error>;
+    type SerializeTuple = Impossible<Self::Ok, M::Error>;
+    type SerializeTupleStruct = Impossible<Self::Ok, M::Error>;
+    type SerializeMap = FlatMapSerializeMap<'a, M>;
+    type SerializeStruct = FlatMapSerializeStruct<'a, M>;
+    type SerializeTupleVariant = Impossible<Self::Ok, M::Error>;
+    type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
+
+    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Boolean))
+    }
+
+    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Float))
+    }
+
+    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Float))
+    }
+
+    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Char))
+    }
+
+    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::String))
+    }
+
+    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::ByteArray))
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Optional))
+    }
+
+    fn serialize_some<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        Err(self.bad_type(Unsupported::Optional))
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Unit))
+    }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::UnitStruct))
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Enum))
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _: &'static str,
+        _: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        try!(self.0.serialize_key(variant));
+        self.0.serialize_value(value)
+    }
+
+    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Err(self.bad_type(Unsupported::Sequence))
+    }
+
+    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(self.bad_type(Unsupported::Tuple))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(self.bad_type(Unsupported::TupleStruct))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(self.bad_type(Unsupported::Enum))
+    }
+
+    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Ok(FlatMapSerializeMap(self.0))
+    }
+
+    fn serialize_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Ok(FlatMapSerializeStruct(self.0))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        inner_variant: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        try!(self.0.serialize_key(inner_variant));
+        Ok(FlatMapSerializeStructVariantAsMapValue::new(
+            self.0,
+            inner_variant,
+        ))
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeMap<'a, M: 'a>(&'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeMap for FlatMapSerializeMap<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_key(key)
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_value(value)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeStruct<'a, M: 'a>(&'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeStruct for FlatMapSerializeStruct<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_entry(key, value)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
+    map: &'a mut M,
+    name: &'static str,
+    fields: Vec<(&'static str, Content)>,
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> FlatMapSerializeStructVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVariantAsMapValue<'a, M> {
+        FlatMapSerializeStructVariantAsMapValue {
+            map: map,
+            name: name,
+            fields: Vec::new(),
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeStructVariant for FlatMapSerializeStructVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
+        self.fields.push((key, value));
+        Ok(())
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        try!(
+            self.map
+                .serialize_value(&Content::Struct(self.name, self.fields))
+        );
+        Ok(())
+    }
+}

serde/src/ser/impls.rs

@@ -320,8 +320,12 @@ map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! deref_impl {
-    ($($desc:tt)+) => {
-        impl $($desc)+ {
+    (
+        $(#[doc = $doc:tt])*
+        <$($desc:tt)+
+    ) => {
+        $(#[doc = $doc])*
+        impl <$($desc)+ {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where
@@ -340,10 +344,30 @@ deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
 deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T: ?Sized> Serialize for Rc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Rc` will serialize a copy of
+    /// the contents of the `Rc` each time the `Rc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Rc<T> where T: Serialize
+}
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T: ?Sized> Serialize for Arc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Arc` will serialize a copy of
+    /// the contents of the `Arc` each time the `Arc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Arc<T> where T: Serialize
+}
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
@@ -351,6 +375,7 @@ deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwne
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "unstable")]
+#[allow(deprecated)]
 impl<T> Serialize for NonZero<T>
 where
     T: Serialize + Zeroable + Clone,
@@ -363,6 +388,32 @@ where
     }
 }
 
+macro_rules! nonzero_integers {
+    ( $( $T: ident, )+ ) => {
+        $(
+            #[cfg(feature = "unstable")]
+            impl Serialize for $T {
+                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    self.get().serialize(serializer)
+                }
+            }
+        )+
+    }
+}
+
+nonzero_integers! {
+    // Not including signed NonZeroI* since they might be removed
+    NonZeroU8,
+    NonZeroU16,
+    NonZeroU32,
+    NonZeroU64,
+    // FIXME: https://github.com/serde-rs/serde/issues/1136 NonZeroU128,
+    NonZeroUsize,
+}
+
 impl<T> Serialize for Cell<T>
 where
     T: Serialize + Copy,
@@ -494,11 +545,9 @@ macro_rules! serialize_display_bounded_length {
         // write! only provides fmt::Formatter to Display implementations, which
         // has methods write_str and write_char but no method to write arbitrary
         // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = unsafe {
-            str::from_utf8_unchecked(written)
-        };
+        let written_str = unsafe { str::from_utf8_unchecked(written) };
         $serializer.serialize_str(written_str)
-    }}
+    }};
 }
 
 #[cfg(feature = "std")]

serde/src/ser/mod.rs

@@ -93,7 +93,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - NonZero\<T\> (unstable)
+//!    - NonZero\<T\> (unstable, deprecated)
+//!    - num::NonZero* (unstable)
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.27" # remember to update html_root_url
+version = "1.0.45" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -23,9 +23,10 @@ name = "serde_derive"
 proc-macro = true
 
 [dependencies]
-quote = "0.3.8"
-serde_derive_internals = { version = "=0.19.0", default-features = false, path = "../serde_derive_internals" }
-syn = { version = "0.11", features = ["visit"] }
+proc-macro2 = "0.3"
+quote = "0.5.2"
+serde_derive_internals = { version = "=0.23.1", default-features = false, path = "../serde_derive_internals" }
+syn = { version = "0.13", features = ["visit"] }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/src/bound.rs

@@ -8,28 +8,30 @@
 
 use std::collections::HashSet;
 
-use syn::{self, visit};
+use syn;
+use syn::punctuated::{Pair, Punctuated};
+use syn::visit::{self, Visit};
 
-use internals::ast::{Body, Container};
+use internals::ast::{Container, Data};
 use internals::attr;
 
-macro_rules! path {
-    ($($path:tt)+) => {
-        syn::parse_path(quote!($($path)+).as_str()).unwrap()
-    };
-}
+use proc_macro2::Span;
 
 // Remove the default from every type parameter because in the generated impls
 // they look like associated types: "error: associated type bindings are not
 // allowed here".
 pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
     syn::Generics {
-        ty_params: generics
-            .ty_params
+        params: generics
+            .params
             .iter()
-            .map(|ty_param| syn::TyParam {
-                default: None,
-                ..ty_param.clone()
+            .map(|param| match *param {
+                syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
+                    eq_token: None,
+                    default: None,
+                    ..param.clone()
+                }),
+                _ => param.clone(),
             })
             .collect(),
         ..generics.clone()
@@ -42,27 +44,24 @@ pub fn with_where_predicates(
 ) -> syn::Generics {
     let mut generics = generics.clone();
     generics
-        .where_clause
+        .make_where_clause()
         .predicates
-        .extend_from_slice(predicates);
+        .extend(predicates.into_iter().cloned());
     generics
 }
 
-pub fn with_where_predicates_from_fields<F>(
+pub fn with_where_predicates_from_fields(
     cont: &Container,
     generics: &syn::Generics,
-    from_field: F,
-) -> syn::Generics
-where
-    F: Fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
-{
-    let predicates = cont.body
+    from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
+) -> syn::Generics {
+    let predicates = cont.data
         .all_fields()
         .flat_map(|field| from_field(&field.attrs))
         .flat_map(|predicates| predicates.to_vec());
 
     let mut generics = generics.clone();
-    generics.where_clause.predicates.extend(predicates);
+    generics.make_where_clause().predicates.extend(predicates);
     generics
 }
 
@@ -77,40 +76,53 @@ where
 //         #[serde(skip_serializing)]
 //         c: C,
 //     }
-pub fn with_bound<F>(
+pub fn with_bound(
     cont: &Container,
     generics: &syn::Generics,
-    filter: F,
+    filter: fn(&attr::Field, Option<&attr::Variant>) -> bool,
     bound: &syn::Path,
-) -> syn::Generics
-where
-    F: Fn(&attr::Field, Option<&attr::Variant>) -> bool,
-{
-    struct FindTyParams {
+) -> syn::Generics {
+    struct FindTyParams<'ast> {
         // Set of all generic type parameters on the current struct (A, B, C in
         // the example). Initialized up front.
-        all_ty_params: HashSet<syn::Ident>,
+        all_type_params: HashSet<syn::Ident>,
+
         // Set of generic type parameters used in fields for which filter
         // returns true (A and B in the example). Filled in as the visitor sees
         // them.
-        relevant_ty_params: HashSet<syn::Ident>,
+        relevant_type_params: HashSet<syn::Ident>,
+
+        // Fields whose type is an associated type of one of the generic type
+        // parameters.
+        associated_type_usage: Vec<&'ast syn::TypePath>,
     }
-    impl visit::Visitor for FindTyParams {
-        fn visit_path(&mut self, path: &syn::Path) {
+    impl<'ast> Visit<'ast> for FindTyParams<'ast> {
+        fn visit_field(&mut self, field: &'ast syn::Field) {
+            if let syn::Type::Path(ref ty) = field.ty {
+                if let Some(Pair::Punctuated(ref t, _)) = ty.path.segments.first() {
+                    if self.all_type_params.contains(&t.ident) {
+                        self.associated_type_usage.push(ty);
+                    }
+                }
+            }
+            self.visit_type(&field.ty);
+        }
+
+        fn visit_path(&mut self, path: &'ast syn::Path) {
             if let Some(seg) = path.segments.last() {
-                if seg.ident == "PhantomData" {
+                if seg.into_value().ident == "PhantomData" {
                     // Hardcoded exception, because PhantomData<T> implements
                     // Serialize and Deserialize whether or not T implements it.
                     return;
                 }
             }
-            if !path.global && path.segments.len() == 1 {
-                let id = path.segments[0].ident.clone();
-                if self.all_ty_params.contains(&id) {
-                    self.relevant_ty_params.insert(id);
+            if path.leading_colon.is_none() && path.segments.len() == 1 {
+                let id = path.segments[0].ident;
+                if self.all_type_params.contains(&id) {
+                    self.relevant_type_params.insert(id);
                 }
             }
-            visit::walk_path(self, path);
+            visit::visit_path(self, path);
         }
 
         // Type parameter should not be considered used by a macro path.
@@ -119,61 +131,66 @@ where
         //         mac: T!(),
         //         marker: PhantomData<T>,
         //     }
-        fn visit_mac(&mut self, _mac: &syn::Mac) {}
+        fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
     }
 
-    let all_ty_params: HashSet<_> = generics
-        .ty_params
-        .iter()
-        .map(|ty_param| ty_param.ident.clone())
-        .collect();
+    let all_type_params = generics.type_params().map(|param| param.ident).collect();
 
     let mut visitor = FindTyParams {
-        all_ty_params: all_ty_params,
-        relevant_ty_params: HashSet::new(),
+        all_type_params: all_type_params,
+        relevant_type_params: HashSet::new(),
+        associated_type_usage: Vec::new(),
     };
-    match cont.body {
-        Body::Enum(ref variants) => for variant in variants.iter() {
+    match cont.data {
+        Data::Enum(ref variants) => for variant in variants.iter() {
             let relevant_fields = variant
                 .fields
                 .iter()
                 .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
             for field in relevant_fields {
-                visit::walk_ty(&mut visitor, field.ty);
+                visitor.visit_field(field.original);
             }
         },
-        Body::Struct(_, ref fields) => {
+        Data::Struct(_, ref fields) => {
             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
-                visit::walk_ty(&mut visitor, field.ty);
+                visitor.visit_field(field.original);
             }
         }
     }
 
+    let relevant_type_params = visitor.relevant_type_params;
+    let associated_type_usage = visitor.associated_type_usage;
     let new_predicates = generics
-        .ty_params
-        .iter()
-        .map(|ty_param| ty_param.ident.clone())
-        .filter(|id| visitor.relevant_ty_params.contains(id))
-        .map(|id| {
-            syn::WherePredicate::BoundPredicate(syn::WhereBoundPredicate {
-                bound_lifetimes: Vec::new(),
+        .type_params()
+        .map(|param| param.ident)
+        .filter(|id| relevant_type_params.contains(id))
+        .map(|id| syn::TypePath {
+            qself: None,
+            path: id.into(),
+        })
+        .chain(associated_type_usage.into_iter().cloned())
+        .map(|bounded_ty| {
+            syn::WherePredicate::Type(syn::PredicateType {
+                lifetimes: None,
                 // the type parameter that is being bounded e.g. T
-                bounded_ty: syn::Ty::Path(None, id.into()),
+                bounded_ty: syn::Type::Path(bounded_ty),
+                colon_token: Default::default(),
                 // the bound e.g. Serialize
-                bounds: vec![
-                    syn::TyParamBound::Trait(
-                        syn::PolyTraitRef {
-                            bound_lifetimes: Vec::new(),
-                            trait_ref: bound.clone(),
-                        },
-                        syn::TraitBoundModifier::None,
-                    ),
-                ],
+                bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+                    paren_token: None,
+                    modifier: syn::TraitBoundModifier::None,
+                    lifetimes: None,
+                    path: bound.clone(),
+                })].into_iter()
+                    .collect(),
             })
         });
 
     let mut generics = generics.clone();
-    generics.where_clause.predicates.extend(new_predicates);
+    generics
+        .make_where_clause()
+        .predicates
+        .extend(new_predicates);
     generics
 }
 
@@ -184,75 +201,90 @@ pub fn with_self_bound(
 ) -> syn::Generics {
     let mut generics = generics.clone();
     generics
-        .where_clause
+        .make_where_clause()
         .predicates
-        .push(syn::WherePredicate::BoundPredicate(
-            syn::WhereBoundPredicate {
-                bound_lifetimes: Vec::new(),
-                // the type that is being bounded e.g. MyStruct<'a, T>
-                bounded_ty: type_of_item(cont),
-                // the bound e.g. Default
-                bounds: vec![
-                    syn::TyParamBound::Trait(
-                        syn::PolyTraitRef {
-                            bound_lifetimes: Vec::new(),
-                            trait_ref: bound.clone(),
-                        },
-                        syn::TraitBoundModifier::None,
-                    ),
-                ],
-            },
-        ));
+        .push(syn::WherePredicate::Type(syn::PredicateType {
+            lifetimes: None,
+            // the type that is being bounded e.g. MyStruct<'a, T>
+            bounded_ty: type_of_item(cont),
+            colon_token: Default::default(),
+            // the bound e.g. Default
+            bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+                paren_token: None,
+                modifier: syn::TraitBoundModifier::None,
+                lifetimes: None,
+                path: bound.clone(),
+            })].into_iter()
+                .collect(),
+        }));
     generics
 }
 
 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
-    let mut generics = generics.clone();
-
-    for lifetime_def in &mut generics.lifetimes {
-        lifetime_def.bounds.push(syn::Lifetime::new(lifetime));
-    }
-
-    for ty_param in &mut generics.ty_params {
-        ty_param
-            .bounds
-            .push(syn::TyParamBound::Region(syn::Lifetime::new(lifetime)));
-    }
-
-    generics.lifetimes.push(syn::LifetimeDef {
+    let bound = syn::Lifetime::new(lifetime, Span::call_site());
+    let def = syn::LifetimeDef {
         attrs: Vec::new(),
-        lifetime: syn::Lifetime::new(lifetime),
-        bounds: Vec::new(),
-    });
+        lifetime: bound,
+        colon_token: None,
+        bounds: Punctuated::new(),
+    };
 
-    generics
+    let params = Some(syn::GenericParam::Lifetime(def))
+        .into_iter()
+        .chain(generics.params.iter().cloned().map(|mut param| {
+            match param {
+                syn::GenericParam::Lifetime(ref mut param) => {
+                    param.bounds.push(bound);
+                }
+                syn::GenericParam::Type(ref mut param) => {
+                    param.bounds.push(syn::TypeParamBound::Lifetime(bound));
+                }
+                syn::GenericParam::Const(_) => {}
+            }
+            param
+        }))
+        .collect();
+
+    syn::Generics {
+        params: params,
+        ..generics.clone()
+    }
 }
 
-fn type_of_item(cont: &Container) -> syn::Ty {
-    syn::Ty::Path(
-        None,
-        syn::Path {
-            global: false,
-            segments: vec![
-                syn::PathSegment {
-                    ident: cont.ident.clone(),
-                    parameters: syn::PathParameters::AngleBracketed(
-                        syn::AngleBracketedParameterData {
-                            lifetimes: cont.generics
-                                .lifetimes
-                                .iter()
-                                .map(|def| def.lifetime.clone())
-                                .collect(),
-                            types: cont.generics
-                                .ty_params
-                                .iter()
-                                .map(|param| syn::Ty::Path(None, param.ident.clone().into()))
-                                .collect(),
-                            bindings: Vec::new(),
-                        },
-                    ),
-                },
-            ],
+fn type_of_item(cont: &Container) -> syn::Type {
+    syn::Type::Path(syn::TypePath {
+        qself: None,
+        path: syn::Path {
+            leading_colon: None,
+            segments: vec![syn::PathSegment {
+                ident: cont.ident,
+                arguments: syn::PathArguments::AngleBracketed(
+                    syn::AngleBracketedGenericArguments {
+                        colon2_token: None,
+                        lt_token: Default::default(),
+                        args: cont.generics
+                            .params
+                            .iter()
+                            .map(|param| match *param {
+                                syn::GenericParam::Type(ref param) => {
+                                    syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
+                                        qself: None,
+                                        path: param.ident.into(),
+                                    }))
+                                }
+                                syn::GenericParam::Lifetime(ref param) => {
+                                    syn::GenericArgument::Lifetime(param.lifetime)
+                                }
+                                syn::GenericParam::Const(_) => {
+                                    panic!("Serde does not support const generics yet");
+                                }
+                            })
+                            .collect(),
+                        gt_token: Default::default(),
+                    },
+                ),
+            }].into_iter()
+                .collect(),
         },
-    )
+    })
 }

serde_derive/src/fragment.rs

@@ -7,6 +7,7 @@
 // except according to those terms.
 
 use quote::{ToTokens, Tokens};
+use syn::token;
 
 pub enum Fragment {
     /// Tokens that can be used as an expression.
@@ -36,9 +37,7 @@ impl ToTokens for Expr {
         match self.0 {
             Fragment::Expr(ref expr) => expr.to_tokens(out),
             Fragment::Block(ref block) => {
-                out.append("{");
-                block.to_tokens(out);
-                out.append("}");
+                token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
     }
@@ -63,12 +62,10 @@ impl ToTokens for Match {
         match self.0 {
             Fragment::Expr(ref expr) => {
                 expr.to_tokens(out);
-                out.append(",");
+                <Token![,]>::default().to_tokens(out);
             }
             Fragment::Block(ref block) => {
-                out.append("{");
-                block.to_tokens(out);
-                out.append("}");
+                token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
     }

serde_derive/src/lib.rs

@@ -22,43 +22,51 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.27")]
-#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
-#![cfg_attr(feature = "cargo-clippy", allow(used_underscore_binding))]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.45")]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(enum_variant_names, redundant_field_names, too_many_arguments, used_underscore_binding)
+)]
 // The `quote!` macro requires deep recursion.
-#![recursion_limit = "192"]
+#![recursion_limit = "512"]
 
 #[macro_use]
 extern crate quote;
+#[macro_use]
 extern crate syn;
 
 extern crate serde_derive_internals as internals;
 
 extern crate proc_macro;
+extern crate proc_macro2;
+
 use proc_macro::TokenStream;
+use syn::DeriveInput;
 
 #[macro_use]
 mod bound;
 #[macro_use]
 mod fragment;
 
-mod ser;
 mod de;
+mod pretend;
+mod ser;
+mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let input = syn::parse_derive_input(&input.to_string()).unwrap();
+    let input: DeriveInput = syn::parse(input).unwrap();
     match ser::expand_derive_serialize(&input) {
-        Ok(expanded) => expanded.parse().unwrap(),
+        Ok(expanded) => expanded.into(),
         Err(msg) => panic!(msg),
     }
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input = syn::parse_derive_input(&input.to_string()).unwrap();
+    let input: DeriveInput = syn::parse(input).unwrap();
     match de::expand_derive_deserialize(&input) {
-        Ok(expanded) => expanded.parse().unwrap(),
+        Ok(expanded) => expanded.into(),
         Err(msg) => panic!(msg),
     }
 }

serde_derive/src/pretend.rs

@@ -0,0 +1,145 @@
+use proc_macro2::Span;
+use quote::Tokens;
+use syn::Ident;
+
+use internals::ast::{Container, Data, Field, Style};
+
+// Suppress dead_code warnings that would otherwise appear when using a remote
+// derive. Other than this pretend code, a struct annotated with remote derive
+// never has its fields referenced and an enum annotated with remote derive
+// never has its variants constructed.
+//
+//     warning: field is never used: `i`
+//      --> src/main.rs:4:20
+//       |
+//     4 | struct StructDef { i: i32 }
+//       |                    ^^^^^^
+//
+//     warning: variant is never constructed: `V`
+//      --> src/main.rs:8:16
+//       |
+//     8 | enum EnumDef { V }
+//       |                ^
+//
+pub fn pretend_used(cont: &Container) -> Tokens {
+    let pretend_fields = pretend_fields_used(cont);
+    let pretend_variants = pretend_variants_used(cont);
+
+    quote! {
+        #pretend_fields
+        #pretend_variants
+    }
+}
+
+// For structs with named fields, expands to:
+//
+//     match None::<T> {
+//         Some(T { a: ref __v0, b: ref __v1 }) => {}
+//         _ => {}
+//     }
+//
+// For enums, expands to the following but only including struct variants:
+//
+//     match None::<T> {
+//         Some(T::A { a: ref __v0 }) => {}
+//         Some(T::B { b: ref __v0 }) => {}
+//         _ => {}
+//     }
+//
+// The `ref` is important in case the user has written a Drop impl on their
+// type. Rust does not allow destructuring a struct or enum that has a Drop
+// impl.
+fn pretend_fields_used(cont: &Container) -> Tokens {
+    let type_ident = cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let patterns = match cont.data {
+        Data::Enum(ref variants) => {
+            variants.iter()
+                .filter_map(|variant| match variant.style {
+                    Style::Struct => {
+                        let variant_ident = variant.ident;
+                        let pat = struct_pattern(&variant.fields);
+                        Some(quote!(#type_ident::#variant_ident #pat))
+                    }
+                    _ => None,
+                })
+                .collect::<Vec<_>>()
+        }
+        Data::Struct(Style::Struct, ref fields) => {
+            let pat = struct_pattern(fields);
+            vec![quote!(#type_ident #pat)]
+        }
+        Data::Struct(_, _) => {
+            return quote!();
+        }
+    };
+
+    quote! {
+        match _serde::export::None::<#type_ident #ty_generics> {
+            #(
+                _serde::export::Some(#patterns) => {}
+            )*
+            _ => {}
+        }
+    }
+}
+
+// Expands to one of these per enum variant:
+//
+//     match None {
+//         Some((__v0, __v1,)) => {
+//             let _ = E::V { a: __v0, b: __v1 };
+//         }
+//         _ => {}
+//     }
+//
+fn pretend_variants_used(cont: &Container) -> Tokens {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
+            return quote!();
+        }
+    };
+
+    let type_ident = cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+    let turbofish = ty_generics.as_turbofish();
+
+    let cases = variants.iter()
+        .map(|variant| {
+            let variant_ident = variant.ident;
+            let ref placeholders = (0..variant.fields.len())
+                .map(|i| Ident::new(&format!("__v{}", i), Span::call_site()))
+                .collect::<Vec<_>>();
+
+            let pat = match variant.style {
+                Style::Struct => {
+                    let names = variant.fields.iter().map(|field| field.ident);
+                    quote!({ #(#names: #placeholders),* })
+                }
+                Style::Tuple | Style::Newtype => {
+                    quote!(( #(#placeholders),* ))
+                }
+                Style::Unit => quote!(),
+            };
+
+            quote! {
+                match _serde::export::None {
+                    _serde::export::Some((#(#placeholders,)*)) => {
+                        let _ = #type_ident::#variant_ident #turbofish #pat;
+                    }
+                    _ => {}
+                }
+            }
+        });
+
+    quote!(#(#cases)*)
+}
+
+fn struct_pattern(fields: &[Field]) -> Tokens {
+    let names = fields.iter().map(|field| field.ident);
+    let placeholders = (0..fields.len())
+        .map(|i| Ident::new(&format!("__v{}", i), Span::call_site()));
+    quote!({ #(#names: ref #placeholders),* })
+}

serde_derive/src/ser.rs

@@ -6,13 +6,17 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn::{self, Ident};
+use proc_macro2::Span;
 use quote::Tokens;
+use syn::spanned::Spanned;
+use syn::{self, Ident, Index, Member};
 
 use bound;
 use fragment::{Fragment, Match, Stmts};
-use internals::ast::{Body, Container, Field, Style, Variant};
+use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, Ctxt};
+use pretend;
+use try;
 
 use std::u32;
 
@@ -25,16 +29,18 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<Tokens, Strin
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
-    let dummy_const = Ident::new(format!("_IMPL_SERIALIZE_FOR_{}", ident));
+    let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", ident), Span::call_site());
     let body = Stmts(serialize_body(&cont, &params));
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;
+        let used = pretend::pretend_used(&cont);
         quote! {
             impl #impl_generics #ident #ty_generics #where_clause {
                 #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
                     where __S: _serde::Serializer
                 {
+                    #used
                     #body
                 }
             }
@@ -52,10 +58,12 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<Tokens, Strin
         }
     };
 
+    let try_replacement = try::replacement();
     let generated = quote! {
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const #dummy_const: () = {
             extern crate serde as _serde;
+            #try_replacement
             #impl_block
         };
     };
@@ -95,14 +103,14 @@ impl Parameters {
     fn new(cont: &Container) -> Self {
         let is_remote = cont.attrs.remote().is_some();
         let self_var = if is_remote {
-            Ident::new("__self")
+            Ident::new("__self", Span::call_site())
         } else {
-            Ident::new("self")
+            Ident::new("self", Span::call_site())
         };
 
         let this = match cont.attrs.remote() {
             Some(remote) => remote.clone(),
-            None => cont.ident.clone().into(),
+            None => cont.ident.into(),
         };
 
         let generics = build_generics(cont);
@@ -118,7 +126,7 @@ impl Parameters {
     /// Type name to use in error messages and `&'static str` arguments to
     /// various Serializer methods.
     fn type_name(&self) -> &str {
-        self.this.segments.last().unwrap().ident.as_ref()
+        self.this.segments.last().unwrap().value().ident.as_ref()
     }
 }
 
@@ -136,7 +144,7 @@ fn build_generics(cont: &Container) -> syn::Generics {
             cont,
             &generics,
             needs_serialize_bound,
-            &path!(_serde::Serialize),
+            &parse_quote!(_serde::Serialize),
         ),
     }
 }
@@ -152,36 +160,36 @@ fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -
 }
 
 fn serialize_body(cont: &Container, params: &Parameters) -> Fragment {
-    if let Some(into_type) = cont.attrs.into_type() {
-        serialize_into(params, into_type)
+    if let Some(type_into) = cont.attrs.type_into() {
+        serialize_into(params, type_into)
     } else {
-        match cont.body {
-            Body::Enum(ref variants) => serialize_enum(params, variants, &cont.attrs),
-            Body::Struct(Style::Struct, ref fields) => {
+        match cont.data {
+            Data::Enum(ref variants) => serialize_enum(params, variants, &cont.attrs),
+            Data::Struct(Style::Struct, ref fields) => {
                 if fields.iter().any(|field| field.ident.is_none()) {
                     panic!("struct has unnamed fields");
                 }
                 serialize_struct(params, fields, &cont.attrs)
             }
-            Body::Struct(Style::Tuple, ref fields) => {
+            Data::Struct(Style::Tuple, ref fields) => {
                 if fields.iter().any(|field| field.ident.is_some()) {
                     panic!("tuple struct has named fields");
                 }
                 serialize_tuple_struct(params, fields, &cont.attrs)
             }
-            Body::Struct(Style::Newtype, ref fields) => {
+            Data::Struct(Style::Newtype, ref fields) => {
                 serialize_newtype_struct(params, &fields[0], &cont.attrs)
             }
-            Body::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
+            Data::Struct(Style::Unit, _) => serialize_unit_struct(&cont.attrs),
         }
     }
 }
 
-fn serialize_into(params: &Parameters, into_type: &syn::Ty) -> Fragment {
+fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
     let self_var = &params.self_var;
     quote_block! {
         _serde::Serialize::serialize(
-            &_serde::export::Into::<#into_type>::into(_serde::export::Clone::clone(#self_var)),
+            &_serde::export::Into::<#type_into>::into(_serde::export::Clone::clone(#self_var)),
             __serializer)
     }
 }
@@ -201,13 +209,22 @@ fn serialize_newtype_struct(
 ) -> Fragment {
     let type_name = cattrs.name().serialize_name();
 
-    let mut field_expr = get_field(params, field, 0);
+    let mut field_expr = get_member(
+        params,
+        field,
+        &Member::Unnamed(Index {
+            index: 0,
+            span: Span::call_site(),
+        }),
+    );
     if let Some(path) = field.attrs.serialize_with() {
-        field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+        field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
     }
 
+    let span = field.original.span();
+    let func = quote_spanned!(span=> _serde::Serializer::serialize_newtype_struct);
     quote_expr! {
-        _serde::Serializer::serialize_newtype_struct(__serializer, #type_name, #field_expr)
+        #func(__serializer, #type_name, #field_expr)
     }
 }
 
@@ -216,12 +233,8 @@ fn serialize_tuple_struct(
     fields: &[Field],
     cattrs: &attr::Container,
 ) -> Fragment {
-    let serialize_stmts = serialize_tuple_struct_visitor(
-        fields,
-        params,
-        false,
-        quote!(_serde::ser::SerializeTupleStruct::serialize_field),
-    );
+    let serialize_stmts =
+        serialize_tuple_struct_visitor(fields, params, false, &TupleTrait::SerializeTupleStruct);
 
     let type_name = cattrs.name().serialize_name();
     let len = serialize_stmts.len();
@@ -235,15 +248,22 @@ fn serialize_tuple_struct(
 }
 
 fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    assert!(fields.len() as u64 <= u32::MAX as u64);
+    assert!(fields.len() as u64 <= u64::from(u32::MAX));
 
-    let serialize_fields = serialize_struct_visitor(
-        fields,
-        params,
-        false,
-        quote!(_serde::ser::SerializeStruct::serialize_field),
-        quote!(_serde::ser::SerializeStruct::skip_field),
-    );
+    if cattrs.has_flatten() {
+        serialize_struct_as_map(params, fields, cattrs)
+    } else {
+        serialize_struct_as_struct(params, fields, cattrs)
+    }
+}
+
+fn serialize_struct_as_struct(
+    params: &Parameters,
+    fields: &[Field],
+    cattrs: &attr::Container,
+) -> Fragment {
+    let serialize_fields =
+        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeStruct);
 
     let type_name = cattrs.name().serialize_name();
 
@@ -258,8 +278,8 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
         .map(|field| match field.attrs.skip_serializing_if() {
             None => quote!(1),
             Some(path) => {
-                let ident = field.ident.clone().expect("struct has unnamed fields");
-                let field_expr = get_field(params, field, ident);
+                let ident = field.ident.expect("struct has unnamed fields");
+                let field_expr = get_member(params, field, &Member::Named(ident));
                 quote!(if #path(#field_expr) { 0 } else { 1 })
             }
         })
@@ -272,8 +292,46 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
     }
 }
 
+fn serialize_struct_as_map(
+    params: &Parameters,
+    fields: &[Field],
+    cattrs: &attr::Container,
+) -> Fragment {
+    let serialize_fields =
+        serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);
+
+    let mut serialized_fields = fields
+        .iter()
+        .filter(|&field| !field.attrs.skip_serializing())
+        .peekable();
+
+    let let_mut = mut_if(serialized_fields.peek().is_some());
+
+    let len = if cattrs.has_flatten() {
+        quote!(_serde::export::None)
+    } else {
+        let len = serialized_fields
+            .map(|field| match field.attrs.skip_serializing_if() {
+                None => quote!(1),
+                Some(path) => {
+                    let ident = field.ident.expect("struct has unnamed fields");
+                    let field_expr = get_member(params, field, &Member::Named(ident));
+                    quote!(if #path(#field_expr) { 0 } else { 1 })
+                }
+            })
+            .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+        quote!(_serde::export::Some(#len))
+    };
+
+    quote_block! {
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
+        #(#serialize_fields)*
+        _serde::ser::SerializeMap::end(__serde_state)
+    }
+}
+
 fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Container) -> Fragment {
-    assert!(variants.len() as u64 <= u32::MAX as u64);
+    assert!(variants.len() as u64 <= u64::from(u32::MAX));
 
     let self_var = &params.self_var;
 
@@ -299,7 +357,7 @@ fn serialize_variant(
     cattrs: &attr::Container,
 ) -> Tokens {
     let this = &params.this;
-    let variant_ident = variant.ident.clone();
+    let variant_ident = variant.ident;
 
     if variant.attrs.skip_serializing() {
         let skipped_msg = format!(
@@ -332,8 +390,8 @@ fn serialize_variant(
                 }
             }
             Style::Tuple => {
-                let field_names =
-                    (0..variant.fields.len()).map(|i| Ident::new(format!("__field{}", i)));
+                let field_names = (0..variant.fields.len())
+                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                 quote! {
                     #this::#variant_ident(#(ref #field_names),*)
                 }
@@ -342,7 +400,7 @@ fn serialize_variant(
                 let fields = variant
                     .fields
                     .iter()
-                    .map(|f| f.ident.clone().expect("struct variant has unnamed fields"));
+                    .map(|f| f.ident.expect("struct variant has unnamed fields"));
                 quote! {
                     #this::#variant_ident { #(ref #fields),* }
                 }
@@ -379,7 +437,7 @@ fn serialize_externally_tagged_variant(
     let variant_name = variant.attrs.name().serialize_name();
 
     if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, &variant);
+        let ser = wrap_serialize_variant_with(params, path, variant);
         return quote_expr! {
             _serde::Serializer::serialize_newtype_variant(
                 __serializer,
@@ -406,7 +464,7 @@ fn serialize_externally_tagged_variant(
             let field = &variant.fields[0];
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
             quote_expr! {
@@ -453,7 +511,7 @@ fn serialize_internally_tagged_variant(
     let variant_ident_str = variant.ident.as_ref();
 
     if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, &variant);
+        let ser = wrap_serialize_variant_with(params, path, variant);
         return quote_expr! {
             _serde::private::ser::serialize_tagged_newtype(
                 __serializer,
@@ -480,7 +538,7 @@ fn serialize_internally_tagged_variant(
             let field = &variant.fields[0];
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
             quote_expr! {
@@ -519,7 +577,7 @@ fn serialize_adjacently_tagged_variant(
     let variant_name = variant.attrs.name().serialize_name();
 
     let inner = Stmts(if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, &variant);
+        let ser = wrap_serialize_variant_with(params, path, variant);
         quote_expr! {
             _serde::Serialize::serialize(#ser, __serializer)
         }
@@ -538,12 +596,18 @@ fn serialize_adjacently_tagged_variant(
                 let field = &variant.fields[0];
                 let mut field_expr = quote!(__field0);
                 if let Some(path) = field.attrs.serialize_with() {
-                    field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                    field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
                 }
 
-                quote_expr! {
-                    _serde::Serialize::serialize(#field_expr, __serializer)
-                }
+                return quote_block! {
+                    let mut __struct = try!(_serde::Serializer::serialize_struct(
+                        __serializer, #type_name, 2));
+                    try!(_serde::ser::SerializeStruct::serialize_field(
+                        &mut __struct, #tag, #variant_name));
+                    try!(_serde::ser::SerializeStruct::serialize_field(
+                        &mut __struct, #content, #field_expr));
+                    _serde::ser::SerializeStruct::end(__struct)
+                };
             }
             Style::Tuple => {
                 serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields)
@@ -558,7 +622,7 @@ fn serialize_adjacently_tagged_variant(
     });
 
     let fields_ty = variant.fields.iter().map(|f| &f.ty);
-    let ref fields_ident: Vec<_> = match variant.style {
+    let fields_ident: &Vec<_> = &match variant.style {
         Style::Unit => {
             if variant.attrs.serialize_with().is_some() {
                 vec![]
@@ -566,14 +630,14 @@ fn serialize_adjacently_tagged_variant(
                 unreachable!()
             }
         }
-        Style::Newtype => vec![Ident::new("__field0")],
+        Style::Newtype => vec![Ident::new("__field0", Span::call_site())],
         Style::Tuple => (0..variant.fields.len())
-            .map(|i| Ident::new(format!("__field{}", i)))
+            .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()))
             .collect(),
         Style::Struct => variant
             .fields
             .iter()
-            .map(|f| f.ident.clone().expect("struct variant has unnamed fields"))
+            .map(|f| f.ident.expect("struct variant has unnamed fields"))
             .collect(),
     };
 
@@ -620,7 +684,7 @@ fn serialize_untagged_variant(
     cattrs: &attr::Container,
 ) -> Fragment {
     if let Some(path) = variant.attrs.serialize_with() {
-        let ser = wrap_serialize_variant_with(params, path, &variant);
+        let ser = wrap_serialize_variant_with(params, path, variant);
         return quote_expr! {
             _serde::Serialize::serialize(#ser, __serializer)
         };
@@ -636,7 +700,7 @@ fn serialize_untagged_variant(
             let field = &variant.fields[0];
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
             quote_expr! {
@@ -665,14 +729,12 @@ fn serialize_tuple_variant(
     params: &Parameters,
     fields: &[Field],
 ) -> Fragment {
-    let method = match context {
-        TupleVariant::ExternallyTagged { .. } => {
-            quote!(_serde::ser::SerializeTupleVariant::serialize_field)
-        }
-        TupleVariant::Untagged => quote!(_serde::ser::SerializeTuple::serialize_element),
+    let tuple_trait = match context {
+        TupleVariant::ExternallyTagged { .. } => TupleTrait::SerializeTupleVariant,
+        TupleVariant::Untagged => TupleTrait::SerializeTuple,
     };
 
-    let serialize_stmts = serialize_tuple_struct_visitor(fields, params, true, method);
+    let serialize_stmts = serialize_tuple_struct_visitor(fields, params, true, &tuple_trait);
 
     let len = serialize_stmts.len();
     let let_mut = mut_if(len > 0);
@@ -724,18 +786,14 @@ fn serialize_struct_variant<'a>(
     fields: &[Field],
     name: &str,
 ) -> Fragment {
-    let (method, skip_method) = match context {
-        StructVariant::ExternallyTagged { .. } => (
-            quote!(_serde::ser::SerializeStructVariant::serialize_field),
-            quote!(_serde::ser::SerializeStructVariant::skip_field),
-        ),
-        StructVariant::InternallyTagged { .. } | StructVariant::Untagged => (
-            quote!(_serde::ser::SerializeStruct::serialize_field),
-            quote!(_serde::ser::SerializeStruct::skip_field),
-        ),
+    let struct_trait = match context {
+        StructVariant::ExternallyTagged { .. } => (StructTrait::SerializeStructVariant),
+        StructVariant::InternallyTagged { .. } | StructVariant::Untagged => {
+            (StructTrait::SerializeStruct)
+        }
     };
 
-    let serialize_fields = serialize_struct_visitor(fields, params, true, method, skip_method);
+    let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
 
     let mut serialized_fields = fields
         .iter()
@@ -746,7 +804,7 @@ fn serialize_struct_variant<'a>(
 
     let len = serialized_fields
         .map(|field| {
-            let ident = field.ident.clone().expect("struct has unnamed fields");
+            let ident = field.ident.expect("struct has unnamed fields");
 
             match field.attrs.skip_serializing_if() {
                 Some(path) => quote!(if #path(#ident) { 0 } else { 1 }),
@@ -806,17 +864,24 @@ fn serialize_tuple_struct_visitor(
     fields: &[Field],
     params: &Parameters,
     is_enum: bool,
-    func: Tokens,
+    tuple_trait: &TupleTrait,
 ) -> Vec<Tokens> {
     fields
         .iter()
         .enumerate()
         .map(|(i, field)| {
             let mut field_expr = if is_enum {
-                let id = Ident::new(format!("__field{}", i));
+                let id = Ident::new(&format!("__field{}", i), Span::call_site());
                 quote!(#id)
             } else {
-                get_field(params, field, i)
+                get_member(
+                    params,
+                    field,
+                    &Member::Unnamed(Index {
+                        index: i as u32,
+                        span: Span::call_site(),
+                    }),
+                )
             };
 
             let skip = field
@@ -825,9 +890,11 @@ fn serialize_tuple_struct_visitor(
                 .map(|path| quote!(#path(#field_expr)));
 
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
+            let span = field.original.span();
+            let func = tuple_trait.serialize_element(span);
             let ser = quote! {
                 try!(#func(&mut __serde_state, #field_expr));
             };
@@ -844,18 +911,18 @@ fn serialize_struct_visitor(
     fields: &[Field],
     params: &Parameters,
     is_enum: bool,
-    func: Tokens,
-    skip_func: Tokens,
+    struct_trait: &StructTrait,
 ) -> Vec<Tokens> {
     fields
         .iter()
         .filter(|&field| !field.attrs.skip_serializing())
         .map(|field| {
-            let field_ident = field.ident.clone().expect("struct has unnamed field");
+            let field_ident = field.ident.expect("struct has unnamed field");
+
             let mut field_expr = if is_enum {
                 quote!(#field_ident)
             } else {
-                get_field(params, field, field_ident)
+                get_member(params, field, &Member::Named(field_ident))
             };
 
             let key_expr = field.attrs.name().serialize_name();
@@ -866,21 +933,37 @@ fn serialize_struct_visitor(
                 .map(|path| quote!(#path(#field_expr)));
 
             if let Some(path) = field.attrs.serialize_with() {
-                field_expr = wrap_serialize_field_with(params, field.ty, path, field_expr);
+                field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
-            let ser = quote! {
-                try!(#func(&mut __serde_state, #key_expr, #field_expr));
+            let span = field.original.span();
+            let ser = if field.attrs.flatten() {
+                quote! {
+                    try!(_serde::Serialize::serialize(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+                }
+            } else {
+                let func = struct_trait.serialize_field(span);
+                quote! {
+                    try!(#func(&mut __serde_state, #key_expr, #field_expr));
+                }
             };
 
             match skip {
                 None => ser,
                 Some(skip) => {
-                    quote! {
-                        if !#skip {
-                            #ser
-                        } else {
-                            try!(#skip_func(&mut __serde_state, #key_expr));
+                    if let Some(skip_func) = struct_trait.skip_field(span) {
+                        quote! {
+                            if !#skip {
+                                #ser
+                            } else {
+                                try!(#skip_func(&mut __serde_state, #key_expr));
+                            }
+                        }
+                    } else {
+                        quote! {
+                            if !#skip {
+                                #ser
+                            }
                         }
                     }
                 }
@@ -891,16 +974,16 @@ fn serialize_struct_visitor(
 
 fn wrap_serialize_field_with(
     params: &Parameters,
-    field_ty: &syn::Ty,
-    serialize_with: &syn::Path,
-    field_expr: Tokens,
+    field_ty: &syn::Type,
+    serialize_with: &syn::ExprPath,
+    field_expr: &Tokens,
 ) -> Tokens {
     wrap_serialize_with(params, serialize_with, &[field_ty], &[quote!(#field_expr)])
 }
 
 fn wrap_serialize_variant_with(
     params: &Parameters,
-    serialize_with: &syn::Path,
+    serialize_with: &syn::ExprPath,
     variant: &Variant,
 ) -> Tokens {
     let field_tys: Vec<_> = variant.fields.iter().map(|field| field.ty).collect();
@@ -911,8 +994,7 @@ fn wrap_serialize_variant_with(
         .map(|(i, field)| {
             let id = field
                 .ident
-                .as_ref()
-                .map_or_else(|| Ident::new(format!("__field{}", i)), |id| id.clone());
+                .unwrap_or_else(|| Ident::new(&format!("__field{}", i), Span::call_site()));
             quote!(#id)
         })
         .collect();
@@ -926,21 +1008,26 @@ fn wrap_serialize_variant_with(
 
 fn wrap_serialize_with(
     params: &Parameters,
-    serialize_with: &syn::Path,
-    field_tys: &[&syn::Ty],
+    serialize_with: &syn::ExprPath,
+    field_tys: &[&syn::Type],
     field_exprs: &[Tokens],
 ) -> Tokens {
     let this = &params.this;
     let (_, ty_generics, where_clause) = params.generics.split_for_impl();
 
-    let wrapper_generics = if field_exprs.len() == 0 {
+    let wrapper_generics = if field_exprs.is_empty() {
         params.generics.clone()
     } else {
         bound::with_lifetime_bound(&params.generics, "'__a")
     };
     let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
 
-    let field_access = (0..field_exprs.len()).map(|n| Ident::new(format!("{}", n)));
+    let field_access = (0..field_exprs.len()).map(|n| {
+        Member::Unnamed(Index {
+            index: n as u32,
+            span: Span::call_site(),
+        })
+    });
 
     quote!({
         struct __SerializeWith #wrapper_impl_generics #where_clause {
@@ -977,20 +1064,14 @@ fn mut_if(is_mut: bool) -> Option<Tokens> {
     }
 }
 
-fn get_field<I>(params: &Parameters, field: &Field, ident: I) -> Tokens
-where
-    I: Into<Ident>,
-{
+fn get_member(params: &Parameters, field: &Field, member: &Member) -> Tokens {
     let self_var = &params.self_var;
     match (params.is_remote, field.attrs.getter()) {
-        (false, None) => {
-            let ident = ident.into();
-            quote!(&#self_var.#ident)
-        }
+        (false, None) => quote!(&#self_var.#member),
         (true, None) => {
+            let inner = quote!(&#self_var.#member);
             let ty = field.ty;
-            let ident = ident.into();
-            quote!(_serde::private::ser::constrain::<#ty>(&#self_var.#ident))
+            quote!(_serde::private::ser::constrain::<#ty>(#inner))
         }
         (true, Some(getter)) => {
             let ty = field.ty;
@@ -1001,3 +1082,59 @@ where
         }
     }
 }
+
+enum StructTrait {
+    SerializeMap,
+    SerializeStruct,
+    SerializeStructVariant,
+}
+
+impl StructTrait {
+    fn serialize_field(&self, span: Span) -> Tokens {
+        match *self {
+            StructTrait::SerializeMap => {
+                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry)
+            }
+            StructTrait::SerializeStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field)
+            }
+            StructTrait::SerializeStructVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeStructVariant::serialize_field)
+            }
+        }
+    }
+
+    fn skip_field(&self, span: Span) -> Option<Tokens> {
+        match *self {
+            StructTrait::SerializeMap => None,
+            StructTrait::SerializeStruct => {
+                Some(quote_spanned!(span=> _serde::ser::SerializeStruct::skip_field))
+            }
+            StructTrait::SerializeStructVariant => {
+                Some(quote_spanned!(span=> _serde::ser::SerializeStructVariant::skip_field))
+            }
+        }
+    }
+}
+
+enum TupleTrait {
+    SerializeTuple,
+    SerializeTupleStruct,
+    SerializeTupleVariant,
+}
+
+impl TupleTrait {
+    fn serialize_element(&self, span: Span) -> Tokens {
+        match *self {
+            TupleTrait::SerializeTuple => {
+                quote_spanned!(span=> _serde::ser::SerializeTuple::serialize_element)
+            }
+            TupleTrait::SerializeTupleStruct => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleStruct::serialize_field)
+            }
+            TupleTrait::SerializeTupleVariant => {
+                quote_spanned!(span=> _serde::ser::SerializeTupleVariant::serialize_field)
+            }
+        }
+    }
+}

serde_derive/src/try.rs

@@ -0,0 +1,25 @@
+use proc_macro2::{Op, Spacing};
+use quote::Tokens;
+
+// None of our generated code requires the `From::from` error conversion
+// performed by the standard library's `try!` macro. With this simplified macro
+// we see a significant improvement in type checking and borrow checking time of
+// the generated code and a slight improvement in binary size.
+pub fn replacement() -> Tokens {
+    // Cannot pass `$expr` to `quote!` prior to Rust 1.17.0 so interpolate it.
+    let dollar = Op::new('$', Spacing::Alone);
+
+    quote! {
+        #[allow(unused_macros)]
+        macro_rules! try {
+            (#dollar __expr:expr) => {
+                match #dollar __expr {
+                    _serde::export::Ok(__val) => __val,
+                    _serde::export::Err(__err) => {
+                        return _serde::export::Err(__err);
+                    }
+                }
+            }
+        }
+    }
+}

serde_derive_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive_internals"
-version = "0.19.0" # remember to update html_root_url
+version = "0.23.1" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
@@ -12,8 +12,8 @@ readme = "README.md"
 include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [dependencies]
-syn = { version = "0.11.10", default-features = false, features = ["parsing"] }
-synom = "0.11"
+proc-macro2 = "0.3"
+syn = { version = "0.13", default-features = false, features = ["derive", "parsing", "clone-impls"] }
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }

serde_derive_internals/src/ast.rs

@@ -6,19 +6,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn;
 use attr;
 use check;
+use syn;
+use syn::punctuated::Punctuated;
 use Ctxt;
 
 pub struct Container<'a> {
     pub ident: syn::Ident,
     pub attrs: attr::Container,
-    pub body: Body<'a>,
+    pub data: Data<'a>,
     pub generics: &'a syn::Generics,
 }
 
-pub enum Body<'a> {
+pub enum Data<'a> {
     Enum(Vec<Variant<'a>>),
     Struct(Style, Vec<Field<'a>>),
 }
@@ -33,7 +34,8 @@ pub struct Variant<'a> {
 pub struct Field<'a> {
     pub ident: Option<syn::Ident>,
     pub attrs: attr::Field,
-    pub ty: &'a syn::Ty,
+    pub ty: &'a syn::Type,
+    pub original: &'a syn::Field,
 }
 
 #[derive(Copy, Clone)]
@@ -46,34 +48,48 @@ pub enum Style {
 
 impl<'a> Container<'a> {
     pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput) -> Container<'a> {
-        let attrs = attr::Container::from_ast(cx, item);
+        let mut attrs = attr::Container::from_ast(cx, item);
 
-        let mut body = match item.body {
-            syn::Body::Enum(ref variants) => {
-                Body::Enum(enum_from_ast(cx, variants, &attrs.default()))
+        let mut data = match item.data {
+            syn::Data::Enum(ref data) => {
+                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default()))
             }
-            syn::Body::Struct(ref variant_data) => {
-                let (style, fields) = struct_from_ast(cx, variant_data, None, &attrs.default());
-                Body::Struct(style, fields)
+            syn::Data::Struct(ref data) => {
+                let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
+                Data::Struct(style, fields)
+            }
+            syn::Data::Union(_) => {
+                panic!("Serde does not support derive for unions");
             }
         };
 
-        match body {
-            Body::Enum(ref mut variants) => for ref mut variant in variants {
+        let mut has_flatten = false;
+        match data {
+            Data::Enum(ref mut variants) => for variant in variants {
                 variant.attrs.rename_by_rule(attrs.rename_all());
-                for ref mut field in &mut variant.fields {
+                for field in &mut variant.fields {
+                    if field.attrs.flatten() {
+                        has_flatten = true;
+                    }
                     field.attrs.rename_by_rule(variant.attrs.rename_all());
                 }
             },
-            Body::Struct(_, ref mut fields) => for field in fields {
+            Data::Struct(_, ref mut fields) => for field in fields {
+                if field.attrs.flatten() {
+                    has_flatten = true;
+                }
                 field.attrs.rename_by_rule(attrs.rename_all());
             },
         }
 
+        if has_flatten {
+            attrs.mark_has_flatten();
+        }
+
         let item = Container {
-            ident: item.ident.clone(),
+            ident: item.ident,
             attrs: attrs,
-            body: body,
+            data: data,
             generics: &item.generics,
         };
         check::check(cx, &item);
@@ -81,13 +97,13 @@ impl<'a> Container<'a> {
     }
 }
 
-impl<'a> Body<'a> {
+impl<'a> Data<'a> {
     pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
         match *self {
-            Body::Enum(ref variants) => {
+            Data::Enum(ref variants) => {
                 Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
             }
-            Body::Struct(_, ref fields) => Box::new(fields.iter()),
+            Data::Struct(_, ref fields) => Box::new(fields.iter()),
         }
     }
 
@@ -98,7 +114,7 @@ impl<'a> Body<'a> {
 
 fn enum_from_ast<'a>(
     cx: &Ctxt,
-    variants: &'a [syn::Variant],
+    variants: &'a Punctuated<syn::Variant, Token![,]>,
     container_default: &attr::Default,
 ) -> Vec<Variant<'a>> {
     variants
@@ -106,9 +122,9 @@ fn enum_from_ast<'a>(
         .map(|variant| {
             let attrs = attr::Variant::from_ast(cx, variant);
             let (style, fields) =
-                struct_from_ast(cx, &variant.data, Some(&attrs), container_default);
+                struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
             Variant {
-                ident: variant.ident.clone(),
+                ident: variant.ident,
                 attrs: attrs,
                 style: style,
                 fields: fields,
@@ -119,30 +135,30 @@ fn enum_from_ast<'a>(
 
 fn struct_from_ast<'a>(
     cx: &Ctxt,
-    data: &'a syn::VariantData,
+    fields: &'a syn::Fields,
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
 ) -> (Style, Vec<Field<'a>>) {
-    match *data {
-        syn::VariantData::Struct(ref fields) => (
+    match *fields {
+        syn::Fields::Named(ref fields) => (
             Style::Struct,
-            fields_from_ast(cx, fields, attrs, container_default),
+            fields_from_ast(cx, &fields.named, attrs, container_default),
         ),
-        syn::VariantData::Tuple(ref fields) if fields.len() == 1 => (
+        syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => (
             Style::Newtype,
-            fields_from_ast(cx, fields, attrs, container_default),
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
-        syn::VariantData::Tuple(ref fields) => (
+        syn::Fields::Unnamed(ref fields) => (
             Style::Tuple,
-            fields_from_ast(cx, fields, attrs, container_default),
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
         ),
-        syn::VariantData::Unit => (Style::Unit, Vec::new()),
+        syn::Fields::Unit => (Style::Unit, Vec::new()),
     }
 }
 
 fn fields_from_ast<'a>(
     cx: &Ctxt,
-    fields: &'a [syn::Field],
+    fields: &'a Punctuated<syn::Field, Token![,]>,
     attrs: Option<&attr::Variant>,
     container_default: &attr::Default,
 ) -> Vec<Field<'a>> {
@@ -150,9 +166,10 @@ fn fields_from_ast<'a>(
         .iter()
         .enumerate()
         .map(|(i, field)| Field {
-            ident: field.ident.clone(),
+            ident: field.ident,
             attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
             ty: &field.ty,
+            original: field,
         })
         .collect()
 }

serde_derive_internals/src/case.rs

@@ -7,14 +7,14 @@
 // except according to those terms.
 
 // See https://users.rust-lang.org/t/psa-dealing-with-warning-unused-import-std-ascii-asciiext-in-today-s-nightly/13726
-#[allow(unused_imports)]
+#[allow(deprecated, unused_imports)]
 use std::ascii::AsciiExt;
 
 use std::str::FromStr;
 
 use self::RenameRule::*;
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 pub enum RenameRule {
     /// Don't apply a default rename rule.
     None,
@@ -113,14 +113,7 @@ impl FromStr for RenameRule {
 fn rename_variants() {
     for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[
         (
-            "Outcome",
-            "outcome",
-            "OUTCOME",
-            "outcome",
-            "outcome",
-            "OUTCOME",
-            "outcome",
-            "OUTCOME",
+            "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
         ),
         (
             "VeryTasty",
@@ -154,13 +147,7 @@ fn rename_variants() {
 fn rename_fields() {
     for &(original, upper, pascal, camel, screaming, kebab, screaming_kebab) in &[
         (
-            "outcome",
-            "OUTCOME",
-            "Outcome",
-            "outcome",
-            "OUTCOME",
-            "outcome",
-            "OUTCOME",
+            "outcome", "OUTCOME", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
         ),
         (
             "very_tasty",

serde_derive_internals/src/check.rs

@@ -6,29 +6,32 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{Body, Container, Style};
-use attr::Identifier;
+use ast::{Container, Data, Style};
+use attr::{EnumTag, Identifier};
 use Ctxt;
 
 /// Cross-cutting checks that require looking at more than a single attrs
 /// object. Simpler checks should happen when parsing and building the attrs.
 pub fn check(cx: &Ctxt, cont: &Container) {
     check_getter(cx, cont);
+    check_flatten(cx, cont);
     check_identifier(cx, cont);
     check_variant_skip_attrs(cx, cont);
+    check_internal_tag_field_name_conflict(cx, cont);
+    check_adjacent_tag_conflict(cx, cont);
 }
 
 /// Getters are only allowed inside structs (not enums) with the `remote`
 /// attribute.
 fn check_getter(cx: &Ctxt, cont: &Container) {
-    match cont.body {
-        Body::Enum(_) => {
-            if cont.body.has_getter() {
+    match cont.data {
+        Data::Enum(_) => {
+            if cont.data.has_getter() {
                 cx.error("#[serde(getter = \"...\")] is not allowed in an enum");
             }
         }
-        Body::Struct(_, _) => {
-            if cont.body.has_getter() && cont.attrs.remote().is_none() {
+        Data::Struct(_, _) => {
+            if cont.data.has_getter() && cont.attrs.remote().is_none() {
                 cx.error(
                     "#[serde(getter = \"...\")] can only be used in structs \
                      that have #[serde(remote = \"...\")]",
@@ -38,6 +41,49 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
     }
 }
 
+/// Flattening has some restrictions we can test.
+fn check_flatten(cx: &Ctxt, cont: &Container) {
+    match cont.data {
+        Data::Enum(_) => {
+            if cont.attrs.has_flatten() {
+                cx.error("#[serde(flatten)] cannot be used within enums");
+            }
+        }
+        Data::Struct(style, _) => {
+            for field in cont.data.all_fields() {
+                if !field.attrs.flatten() {
+                    continue;
+                }
+                match style {
+                    Style::Tuple => {
+                        cx.error("#[serde(flatten)] cannot be used on tuple structs");
+                    }
+                    Style::Newtype => {
+                        cx.error("#[serde(flatten)] cannot be used on newtype structs");
+                    }
+                    _ => {}
+                }
+                if field.attrs.skip_serializing() {
+                    cx.error(
+                        "#[serde(flatten] can not be combined with \
+                         #[serde(skip_serializing)]",
+                    );
+                } else if field.attrs.skip_serializing_if().is_some() {
+                    cx.error(
+                        "#[serde(flatten] can not be combined with \
+                         #[serde(skip_serializing_if = \"...\")]",
+                    );
+                } else if field.attrs.skip_deserializing() {
+                    cx.error(
+                        "#[serde(flatten] can not be combined with \
+                         #[serde(skip_deserializing)]",
+                    );
+                }
+            }
+        }
+    }
+}
+
 /// The `other` attribute must be used at most once and it must be the last
 /// variant of an enum that has the `field_identifier` attribute.
 ///
@@ -45,9 +91,9 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
 /// `field_identifier` all but possibly one variant must be unit variants. The
 /// last variant may be a newtype variant which is an implicit "other" case.
 fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.body {
-        Body::Enum(ref variants) => variants,
-        Body::Struct(_, _) => {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
             return;
         }
     };
@@ -102,9 +148,9 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
 /// Skip-(de)serializing attributes are not allowed on variants marked
 /// (de)serialize_with.
 fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.body {
-        Body::Enum(ref variants) => variants,
-        Body::Struct(_, _) => {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
             return;
         }
     };
@@ -169,3 +215,64 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
         }
     }
 }
+
+/// The tag of an internally-tagged struct variant must not be
+/// the same as either one of its fields, as this would result in
+/// duplicate keys in the serialized output and/or ambiguity in
+/// the to-be-deserialized input.
+fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => return,
+    };
+
+    let tag = match *cont.attrs.tag() {
+        EnumTag::Internal { ref tag } => tag.as_str(),
+        EnumTag::External | EnumTag::Adjacent { .. } | EnumTag::None => return,
+    };
+
+    let diagnose_conflict = || {
+        let message = format!("variant field name `{}` conflicts with internal tag", tag);
+        cx.error(message);
+    };
+
+    for variant in variants {
+        match variant.style {
+            Style::Struct => {
+                for field in &variant.fields {
+                    let check_ser = !field.attrs.skip_serializing();
+                    let check_de = !field.attrs.skip_deserializing();
+                    let name = field.attrs.name();
+                    let ser_name = name.serialize_name();
+                    let de_name = name.deserialize_name();
+
+                    if check_ser && ser_name == tag || check_de && de_name == tag {
+                        diagnose_conflict();
+                        return;
+                    }
+                }
+            }
+            Style::Unit | Style::Newtype | Style::Tuple => {}
+        }
+    }
+}
+
+/// In the case of adjacently-tagged enums, the type and the
+/// contents tag must differ, for the same reason.
+fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
+    let (type_tag, content_tag) = match *cont.attrs.tag() {
+        EnumTag::Adjacent {
+            ref tag,
+            ref content,
+        } => (tag, content),
+        EnumTag::Internal { .. } | EnumTag::External | EnumTag::None => return,
+    };
+
+    if type_tag == content_tag {
+        let message = format!(
+            "enum tags `{}` for type and content conflict with each other",
+            type_tag
+        );
+        cx.error(message);
+    }
+}

serde_derive_internals/src/ctxt.rs

@@ -6,8 +6,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fmt::Display;
 use std::cell::RefCell;
+use std::fmt::Display;
+use std::thread;
 
 #[derive(Default)]
 pub struct Ctxt {
@@ -48,7 +49,7 @@ impl Ctxt {
 
 impl Drop for Ctxt {
     fn drop(&mut self) {
-        if self.errors.borrow().is_some() {
+        if !thread::panicking() && self.errors.borrow().is_some() {
             panic!("forgot to check for errors");
         }
     }

serde_derive_internals/src/lib.rs

@@ -6,11 +6,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.19.0")]
+#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.23.1")]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(cyclomatic_complexity, doc_markdown, match_same_arms, redundant_field_names)
+)]
 
-extern crate syn;
 #[macro_use]
-extern crate synom;
+extern crate syn;
+
+extern crate proc_macro2;
 
 pub mod ast;
 pub mod attr;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.27" # remember to update html_root_url
+version = "1.0.45" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"

serde_test/src/de.rs

@@ -6,9 +6,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
 use serde::de::{self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess,
                 SeqAccess, VariantAccess, Visitor};
-use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
 
 use error::Error;
 use token::Token;
@@ -22,28 +22,28 @@ macro_rules! assert_next_token {
     ($de:expr, $expected:expr) => {
         match $de.next_token_opt() {
             Some(token) if token == $expected => {}
-            Some(other) => {
-                panic!("expected Token::{} but deserialization wants Token::{}",
-                       other, $expected)
-            }
-            None => {
-                panic!("end of tokens but deserialization wants Token::{}",
-                       $expected)
-            }
+            Some(other) => panic!(
+                "expected Token::{} but deserialization wants Token::{}",
+                other, $expected
+            ),
+            None => panic!(
+                "end of tokens but deserialization wants Token::{}",
+                $expected
+            ),
         }
-    }
+    };
 }
 
 macro_rules! unexpected {
     ($token:expr) => {
         panic!("deserialization did not expect this token: {}", $token)
-    }
+    };
 }
 
 macro_rules! end_of_tokens {
     () => {
         panic!("ran out of tokens to deserialize")
-    }
+    };
 }
 
 impl<'de> Deserializer<'de> {

serde_test/src/lib.rs

@@ -53,7 +53,7 @@
 //! # use serde::ser::{Serialize, Serializer, SerializeMap};
 //! # use serde::de::{Deserialize, Deserializer, Visitor, MapAccess};
 //! #
-//! # // Dumb immitation of LinkedHashMap.
+//! # // Dumb imitation of LinkedHashMap.
 //! # #[derive(PartialEq, Debug)]
 //! # struct LinkedHashMap<K, V>(Vec<(K, V)>);
 //! #
@@ -155,28 +155,33 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.27")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.45")]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
 // Whitelisted clippy_pedantic lints
-#![cfg_attr(feature = "cargo-clippy",
-            allow(missing_docs_in_private_items, stutter, use_debug, use_self))]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        empty_line_after_outer_attr, missing_docs_in_private_items, redundant_field_names, stutter,
+        use_debug, use_self
+    )
+)]
 
 #[macro_use]
 extern crate serde;
 
-mod ser;
 mod de;
 mod error;
+mod ser;
 
+mod assert;
 mod configure;
 mod token;
-mod assert;
 
-pub use token::Token;
 pub use assert::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens,
                  assert_ser_tokens_error, assert_tokens};
+pub use token::Token;
 
 pub use configure::{Compact, Configure, Readable};
 

serde_test/src/ser.rs

@@ -45,7 +45,7 @@ macro_rules! assert_next_token {
     ($ser:expr, $expected:ident($v:expr)) => {
         assert_next_token!(
             $ser,
-            format_args!("{}({:?})", stringify!($expected), $v),
+            format_args!(concat!(stringify!($expected), "({:?})"), $v),
             Token::$expected(v),
             v == $v
         );
@@ -56,13 +56,13 @@ macro_rules! assert_next_token {
             use std::fmt::Write;
             let mut buffer = String::new();
             $(
-                write!(&mut buffer, "{}: {:?}, ", stringify!($k), $k).unwrap();
+                write!(&mut buffer, concat!(stringify!($k), ": {:?}, "), $k).unwrap();
             )*
             buffer
         };
         assert_next_token!(
             $ser,
-            format_args!("{} {{ {}}}", stringify!($expected), field_format()),
+            format_args!(concat!(stringify!($expected), " {{ {}}}"), field_format()),
             Token::$expected { $($k),* },
             ($($k,)*) == compare
         );

test_suite/Cargo.toml

@@ -9,6 +9,7 @@ unstable = ["serde/unstable", "compiletest_rs"]
 
 [dev-dependencies]
 fnv = "1.0"
+proc-macro2 = "0.3"
 rustc-serialize = "0.3.16"
 serde = { path = "../serde", features = ["rc"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }

test_suite/no_std/src/main.rs

@@ -6,11 +6,10 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(lang_items, start, compiler_builtins_lib)]
+#![feature(lang_items, start)]
 #![no_std]
 
 extern crate libc;
-extern crate compiler_builtins;
 
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {
@@ -19,19 +18,17 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
 
 #[lang = "eh_personality"]
 #[no_mangle]
-pub extern fn rust_eh_personality() {}
-
-#[lang = "eh_unwind_resume"]
-#[no_mangle]
-pub extern fn rust_eh_unwind_resume() {}
+pub extern "C" fn rust_eh_personality() {}
 
 #[lang = "panic_fmt"]
 #[no_mangle]
-pub extern fn rust_begin_panic(_msg: core::fmt::Arguments,
-                               _file: &'static str,
-                               _line: u32) -> ! {
+pub extern "C" fn rust_begin_panic(
+    _msg: core::fmt::Arguments,
+    _file: &'static str,
+    _line: u32,
+) -> ! {
     unsafe {
-        libc::abort()
+        libc::abort();
     }
 }
 
@@ -50,7 +47,9 @@ struct Newtype(u8);
 struct Tuple(u8, u8);
 
 #[derive(Serialize, Deserialize)]
-struct Struct { f: u8 }
+struct Struct {
+    f: u8,
+}
 
 #[derive(Serialize, Deserialize)]
 enum Enum {

test_suite/tests/bytes/mod.rs

@@ -0,0 +1,58 @@
+use serde::de::{Deserializer, Error, SeqAccess, Visitor};
+use std::fmt;
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserializer.deserialize_byte_buf(ByteBufVisitor)
+}
+
+struct ByteBufVisitor;
+
+impl<'de> Visitor<'de> for ByteBufVisitor {
+    type Value = Vec<u8>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("byte array")
+    }
+
+    fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut values = Vec::new();
+        while let Some(value) = try!(visitor.next_element()) {
+            values.push(value);
+        }
+        Ok(values)
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.to_vec())
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.as_bytes().to_vec())
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.into_bytes())
+    }
+}

test_suite/tests/compile-fail/conflict/adjacent-tag.rs

@@ -0,0 +1,20 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[serde(tag = "conflict", content = "conflict")]
+//~^^ HELP: enum tags `conflict` for type and content conflict with each other
+enum E {
+    A,
+    B,
+}
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-newtype-struct.rs

@@ -0,0 +1,16 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten)] cannot be used on newtype structs
+struct Foo(#[serde(flatten)] HashMap<String, String>);
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-skip-deserializing.rs

@@ -0,0 +1,24 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
+struct Foo {
+    #[serde(flatten, skip_deserializing)]
+    other: Other,
+}
+
+#[derive(Deserialize)]
+struct Other {
+    x: u32
+}
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-skip-serializing-if.rs

@@ -0,0 +1,24 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
+struct Foo {
+    #[serde(flatten, skip_serializing_if="Option::is_none")]
+    other: Option<Other>,
+}
+
+#[derive(Serialize)]
+struct Other {
+    x: u32
+}
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-skip-serializing.rs

@@ -0,0 +1,24 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
+struct Foo {
+    #[serde(flatten, skip_serializing)]
+    other: Other,
+}
+
+#[derive(Serialize)]
+struct Other {
+    x: u32
+}
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-tuple-struct.rs

@@ -0,0 +1,16 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten)] cannot be used on tuple structs
+struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
+
+fn main() {}

test_suite/tests/compile-fail/conflict/flatten-within-enum.rs

@@ -0,0 +1,21 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+//~^ HELP: #[serde(flatten)] cannot be used within enums
+enum Foo {
+    A {
+        #[serde(flatten)]
+        fields: HashMap<String, String>,
+    }
+}
+
+fn main() {}

test_suite/tests/compile-fail/conflict/internal-tag.rs

@@ -0,0 +1,22 @@
+// Copyright 2018 Serde Developers
+//
+// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
+// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
+// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
+// option. This file may not be copied, modified, or distributed
+// except according to those terms.
+
+#[macro_use]
+extern crate serde_derive;
+
+#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[serde(tag = "conflict")]
+//~^^ HELP: variant field name `conflict` conflicts with internal tag
+enum E {
+    A {
+        #[serde(rename = "conflict")]
+        x: (),
+    },
+}
+
+fn main() {}

test_suite/tests/test_annotations.rs

@@ -12,12 +12,13 @@
 extern crate serde_derive;
 
 extern crate serde;
-use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
 use self::serde::de::{self, Unexpected};
+use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
+use std::collections::HashMap;
 
 extern crate serde_test;
-use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens,
-                       Token};
+use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens,
+                       assert_ser_tokens_error, assert_tokens, Token};
 
 trait MyDefault: Sized {
     fn my_default() -> Self;
@@ -94,6 +95,50 @@ where
     a5: E,
 }
 
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct CollectOther {
+    a: u32,
+    b: u32,
+    #[serde(flatten)]
+    extra: HashMap<String, u32>,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct FlattenStructEnumWrapper {
+    #[serde(flatten)]
+    data: FlattenStructEnum,
+    #[serde(flatten)]
+    extra: HashMap<String, String>,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case")]
+enum FlattenStructEnum {
+    InsertInteger { index: u32, value: u32 },
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct FlattenStructTagContentEnumWrapper {
+    outer: u32,
+    #[serde(flatten)]
+    data: FlattenStructTagContentEnumNewtype,
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct FlattenStructTagContentEnumNewtype(pub FlattenStructTagContentEnum);
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+#[serde(rename_all = "snake_case", tag = "type", content = "value")]
+enum FlattenStructTagContentEnum {
+    InsertInteger { index: u32, value: u32 },
+    NewtypeVariant(FlattenStructTagContentEnumNewtypeVariant),
+}
+
+#[derive(Debug, PartialEq, Serialize, Deserialize)]
+struct FlattenStructTagContentEnumNewtypeVariant {
+    value: u32,
+}
+
 #[test]
 fn test_default_struct() {
     assert_de_tokens(
@@ -478,12 +523,10 @@ enum RenameEnumSerializeDeserialize<A> {
 fn test_rename_enum() {
     assert_tokens(
         &RenameEnum::Batman,
-        &[
-            Token::UnitVariant {
-                name: "Superhero",
-                variant: "bruce_wayne",
-            },
-        ],
+        &[Token::UnitVariant {
+            name: "Superhero",
+            variant: "bruce_wayne",
+        }],
     );
 
     assert_tokens(
@@ -1170,12 +1213,7 @@ fn test_missing_renamed_field_enum() {
 #[derive(Debug, PartialEq, Deserialize)]
 enum InvalidLengthEnum {
     A(i32, i32, i32),
-    B(
-        #[serde(skip_deserializing)]
-        i32,
-        i32,
-        i32,
-    ),
+    B(#[serde(skip_deserializing)] i32, i32, i32),
 }
 
 #[test]
@@ -1267,3 +1305,489 @@ fn test_from_into_traits() {
     assert_ser_tokens::<StructFromEnum>(&StructFromEnum(None), &[Token::None]);
     assert_de_tokens::<StructFromEnum>(&StructFromEnum(Some(2)), &[Token::Some, Token::U32(2)]);
 }
+
+#[test]
+fn test_collect_other() {
+    let mut extra = HashMap::new();
+    extra.insert("c".into(), 3);
+    assert_tokens(
+        &CollectOther { a: 1, b: 2, extra },
+        &[
+            Token::Map { len: None },
+            Token::Str("a"),
+            Token::U32(1),
+            Token::Str("b"),
+            Token::U32(2),
+            Token::Str("c"),
+            Token::U32(3),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_flatten_struct_enum() {
+    let mut extra = HashMap::new();
+    extra.insert("extra_key".into(), "extra value".into());
+    let change_request = FlattenStructEnumWrapper {
+        data: FlattenStructEnum::InsertInteger {
+            index: 0,
+            value: 42,
+        },
+        extra,
+    };
+    assert_de_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("insert_integer"),
+            Token::Map { len: None },
+            Token::Str("index"),
+            Token::U32(0),
+            Token::Str("value"),
+            Token::U32(42),
+            Token::MapEnd,
+            Token::Str("extra_key"),
+            Token::Str("extra value"),
+            Token::MapEnd,
+        ],
+    );
+    assert_ser_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("insert_integer"),
+            Token::Struct {
+                len: 2,
+                name: "insert_integer",
+            },
+            Token::Str("index"),
+            Token::U32(0),
+            Token::Str("value"),
+            Token::U32(42),
+            Token::StructEnd,
+            Token::Str("extra_key"),
+            Token::Str("extra value"),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_flatten_struct_tag_content_enum() {
+    let change_request = FlattenStructTagContentEnumWrapper {
+        outer: 42,
+        data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::InsertInteger {
+            index: 0,
+            value: 42,
+        }),
+    };
+    assert_de_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::U32(42),
+            Token::Str("type"),
+            Token::Str("insert_integer"),
+            Token::Str("value"),
+            Token::Map { len: None },
+            Token::Str("index"),
+            Token::U32(0),
+            Token::Str("value"),
+            Token::U32(42),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+    assert_ser_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::U32(42),
+            Token::Str("type"),
+            Token::Str("insert_integer"),
+            Token::Str("value"),
+            Token::Struct {
+                len: 2,
+                name: "insert_integer",
+            },
+            Token::Str("index"),
+            Token::U32(0),
+            Token::Str("value"),
+            Token::U32(42),
+            Token::StructEnd,
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_flatten_struct_tag_content_enum_newtype() {
+    let change_request = FlattenStructTagContentEnumWrapper {
+        outer: 42,
+        data: FlattenStructTagContentEnumNewtype(FlattenStructTagContentEnum::NewtypeVariant(
+            FlattenStructTagContentEnumNewtypeVariant { value: 23 },
+        )),
+    };
+    assert_de_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::U32(42),
+            Token::Str("type"),
+            Token::Str("newtype_variant"),
+            Token::Str("value"),
+            Token::Map { len: None },
+            Token::Str("value"),
+            Token::U32(23),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+    assert_ser_tokens(
+        &change_request,
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::U32(42),
+            Token::Str("type"),
+            Token::Str("newtype_variant"),
+            Token::Str("value"),
+            Token::Struct {
+                len: 1,
+                name: "FlattenStructTagContentEnumNewtypeVariant",
+            },
+            Token::Str("value"),
+            Token::U32(23),
+            Token::StructEnd,
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_unknown_field_in_flatten() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct Outer {
+        dummy: String,
+        #[serde(flatten)]
+        inner: Inner,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Inner {
+        foo: HashMap<String, u32>,
+    }
+
+    assert_de_tokens_error::<Outer>(
+        &[
+            Token::Struct {
+                name: "Outer",
+                len: 1,
+            },
+            Token::Str("dummy"),
+            Token::Str("23"),
+            Token::Str("foo"),
+            Token::Map { len: None },
+            Token::Str("a"),
+            Token::U32(1),
+            Token::Str("b"),
+            Token::U32(2),
+            Token::MapEnd,
+            Token::Str("bar"),
+            Token::U32(23),
+            Token::StructEnd,
+        ],
+        "unknown field `bar`",
+    );
+}
+
+#[test]
+fn test_complex_flatten() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Outer {
+        y: u32,
+        #[serde(flatten)]
+        first: First,
+        #[serde(flatten)]
+        second: Second,
+        z: u32,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct First {
+        a: u32,
+        b: bool,
+        c: Vec<String>,
+        d: String,
+        e: Option<u64>,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Second {
+        f: u32,
+    }
+
+    assert_de_tokens(
+        &Outer {
+            y: 0,
+            first: First {
+                a: 1,
+                b: true,
+                c: vec!["a".into(), "b".into()],
+                d: "c".into(),
+                e: Some(2),
+            },
+            second: Second { f: 3 },
+            z: 4,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("y"),
+            Token::U32(0),
+            Token::Str("a"),
+            Token::U32(1),
+            Token::Str("b"),
+            Token::Bool(true),
+            Token::Str("c"),
+            Token::Seq { len: Some(2) },
+            Token::Str("a"),
+            Token::Str("b"),
+            Token::SeqEnd,
+            Token::Str("d"),
+            Token::Str("c"),
+            Token::Str("e"),
+            Token::U64(2),
+            Token::Str("f"),
+            Token::U32(3),
+            Token::Str("z"),
+            Token::U32(4),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_ser_tokens(
+        &Outer {
+            y: 0,
+            first: First {
+                a: 1,
+                b: true,
+                c: vec!["a".into(), "b".into()],
+                d: "c".into(),
+                e: Some(2),
+            },
+            second: Second { f: 3 },
+            z: 4,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("y"),
+            Token::U32(0),
+            Token::Str("a"),
+            Token::U32(1),
+            Token::Str("b"),
+            Token::Bool(true),
+            Token::Str("c"),
+            Token::Seq { len: Some(2) },
+            Token::Str("a"),
+            Token::Str("b"),
+            Token::SeqEnd,
+            Token::Str("d"),
+            Token::Str("c"),
+            Token::Str("e"),
+            Token::Some,
+            Token::U64(2),
+            Token::Str("f"),
+            Token::U32(3),
+            Token::Str("z"),
+            Token::U32(4),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_flatten_unsupported_type() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Outer {
+        outer: String,
+        #[serde(flatten)]
+        inner: String,
+    }
+
+    assert_ser_tokens_error(
+        &Outer {
+            outer: "foo".into(),
+            inner: "bar".into(),
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::Str("foo"),
+        ],
+        "can only flatten structs and maps (got a string)",
+    );
+    assert_de_tokens_error::<Outer>(
+        &[
+            Token::Map { len: None },
+            Token::Str("outer"),
+            Token::Str("foo"),
+            Token::Str("a"),
+            Token::Str("b"),
+            Token::MapEnd,
+        ],
+        "can only flatten structs and maps",
+    );
+}
+
+#[test]
+fn test_non_string_keys() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct TestStruct {
+        name: String,
+        age: u32,
+        #[serde(flatten)]
+        mapping: HashMap<u32, u32>,
+    }
+
+    let mut mapping = HashMap::new();
+    mapping.insert(0, 42);
+    assert_tokens(
+        &TestStruct {
+            name: "peter".into(),
+            age: 3,
+            mapping,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("name"),
+            Token::Str("peter"),
+            Token::Str("age"),
+            Token::U32(3),
+            Token::U32(0),
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_lifetime_propagation_for_flatten() {
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
+    struct A<T> {
+        #[serde(flatten)]
+        t: T,
+    }
+
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
+    struct B<'a> {
+        #[serde(flatten, borrow)]
+        t: HashMap<&'a str, u32>,
+    }
+
+    #[derive(Deserialize, Serialize, Debug, PartialEq)]
+    struct C<'a> {
+        #[serde(flatten, borrow)]
+        t: HashMap<&'a [u8], u32>,
+    }
+
+    let mut owned_map = HashMap::new();
+    owned_map.insert("x".to_string(), 42u32);
+    assert_tokens(
+        &A { t: owned_map },
+        &[
+            Token::Map { len: None },
+            Token::Str("x"),
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+
+    let mut borrowed_map = HashMap::new();
+    borrowed_map.insert("x", 42u32);
+    assert_ser_tokens(
+        &B {
+            t: borrowed_map.clone(),
+        },
+        &[
+            Token::Map { len: None },
+            Token::BorrowedStr("x"),
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &B { t: borrowed_map },
+        &[
+            Token::Map { len: None },
+            Token::BorrowedStr("x"),
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+
+    let mut borrowed_map = HashMap::new();
+    borrowed_map.insert(&b"x"[..], 42u32);
+    assert_ser_tokens(
+        &C {
+            t: borrowed_map.clone(),
+        },
+        &[
+            Token::Map { len: None },
+            Token::Seq { len: Some(1) },
+            Token::U8(120),
+            Token::SeqEnd,
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &C { t: borrowed_map },
+        &[
+            Token::Map { len: None },
+            Token::BorrowedBytes(b"x"),
+            Token::U32(42),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_flatten_enum_newtype() {
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    struct S {
+        #[serde(flatten)]
+        flat: E,
+    }
+
+    #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    enum E {
+        Q(HashMap<String, String>),
+    }
+
+    let e = E::Q({
+        let mut map = HashMap::new();
+        map.insert("k".to_owned(), "v".to_owned());
+        map
+    });
+    let s = S { flat: e };
+
+    assert_tokens(
+        &s,
+        &[
+            Token::Map { len: None },
+            Token::Str("Q"),
+            Token::Map { len: Some(1) },
+            Token::Str("k"),
+            Token::Str("v"),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+}

test_suite/tests/test_de.rs

@@ -6,18 +6,20 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![cfg_attr(feature = "cargo-clippy", allow(decimal_literal_representation))]
+
 #[macro_use]
 extern crate serde_derive;
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::net;
-use std::path::{Path, PathBuf};
-use std::time::{Duration, UNIX_EPOCH};
 use std::default::Default;
 use std::ffi::{CString, OsString};
+use std::net;
+use std::num::Wrapping;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::Arc;
-use std::num::Wrapping;
+use std::time::{Duration, UNIX_EPOCH};
 
 #[cfg(feature = "unstable")]
 use std::ffi::CStr;

test_suite/tests/test_gen.rs

@@ -17,8 +17,8 @@
 extern crate serde_derive;
 
 extern crate serde;
-use self::serde::ser::{Serialize, Serializer};
 use self::serde::de::{DeserializeOwned, Deserializer};
+use self::serde::ser::{Serialize, Serializer};
 
 use std::borrow::Cow;
 use std::marker::PhantomData;
@@ -92,14 +92,10 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     enum EnumWith<T> {
         Unit,
-        Newtype(
-            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
-            X,
-        ),
+        Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X),
         Tuple(
             T,
-            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
-            X,
+            #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
         ),
         Struct {
             t: T,
@@ -122,17 +118,13 @@ fn test_gen() {
     assert_ser::<MultipleRef<i32>>();
 
     #[derive(Serialize, Deserialize)]
-    struct Newtype(
-        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
-        X,
-    );
+    struct Newtype(#[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X);
     assert::<Newtype>();
 
     #[derive(Serialize, Deserialize)]
     struct Tuple<T>(
         T,
-        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")]
-        X,
+        #[serde(serialize_with = "ser_x", deserialize_with = "de_x")] X,
     );
     assert::<Tuple<i32>>();
 
@@ -191,12 +183,16 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(bound = "D: SerializeWith + DeserializeWith")]
     struct WithTraits1<D, E> {
-        #[serde(serialize_with = "SerializeWith::serialize_with",
-                deserialize_with = "DeserializeWith::deserialize_with")]
+        #[serde(
+            serialize_with = "SerializeWith::serialize_with",
+            deserialize_with = "DeserializeWith::deserialize_with"
+        )]
         d: D,
-        #[serde(serialize_with = "SerializeWith::serialize_with",
-                deserialize_with = "DeserializeWith::deserialize_with",
-                bound = "E: SerializeWith + DeserializeWith")]
+        #[serde(
+            serialize_with = "SerializeWith::serialize_with",
+            deserialize_with = "DeserializeWith::deserialize_with",
+            bound = "E: SerializeWith + DeserializeWith"
+        )]
         e: E,
     }
     assert::<WithTraits1<X, X>>();
@@ -204,13 +200,18 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))]
     struct WithTraits2<D, E> {
-        #[serde(serialize_with = "SerializeWith::serialize_with",
-                deserialize_with = "DeserializeWith::deserialize_with")]
+        #[serde(
+            serialize_with = "SerializeWith::serialize_with",
+            deserialize_with = "DeserializeWith::deserialize_with"
+        )]
         d: D,
-        #[serde(serialize_with = "SerializeWith::serialize_with",
-                bound(serialize = "E: SerializeWith"))]
-        #[serde(deserialize_with = "DeserializeWith::deserialize_with",
-                bound(deserialize = "E: DeserializeWith"))]
+        #[serde(
+            serialize_with = "SerializeWith::serialize_with", bound(serialize = "E: SerializeWith")
+        )]
+        #[serde(
+            deserialize_with = "DeserializeWith::deserialize_with",
+            bound(deserialize = "E: DeserializeWith")
+        )]
         e: E,
     }
     assert::<WithTraits2<X, X>>();
@@ -270,17 +271,11 @@ fn test_gen() {
     struct EmptyTupleDenyUnknown();
 
     #[derive(Serialize, Deserialize)]
-    struct TupleSkipAll(
-        #[serde(skip_deserializing)]
-        u8,
-    );
+    struct TupleSkipAll(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
-    struct TupleSkipAllDenyUnknown(
-        #[serde(skip_deserializing)]
-        u8,
-    );
+    struct TupleSkipAllDenyUnknown(#[serde(skip_deserializing)] u8);
 
     #[derive(Serialize, Deserialize)]
     enum EmptyEnum {}
@@ -305,10 +300,7 @@ fn test_gen() {
             #[serde(skip_deserializing)]
             f: u8,
         },
-        TupleSkip(
-            #[serde(skip_deserializing)]
-            u8,
-        ),
+        TupleSkip(#[serde(skip_deserializing)] u8),
     }
 
     #[cfg(feature = "unstable")]
@@ -321,10 +313,7 @@ fn test_gen() {
             #[serde(skip_deserializing)]
             f: u8,
         },
-        TupleSkip(
-            #[serde(skip_deserializing)]
-            u8,
-        ),
+        TupleSkip(#[serde(skip_deserializing)] u8),
     }
 
     #[derive(Serialize, Deserialize)]
@@ -344,9 +333,7 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(untagged, remote = "Or")]
     enum OrDef<A, B> {
-        #[allow(dead_code)]
         A(A),
-        #[allow(dead_code)]
         B(B),
     }
 
@@ -386,10 +373,11 @@ fn test_gen() {
     }
 
     #[derive(Serialize, Deserialize)]
-    enum ExternallyTaggedVariantWith {
-        #[allow(dead_code)]
-        Normal { f1: String },
+    #[serde(remote = "Self")]
+    struct RemoteSelf;
 
+    #[derive(Serialize, Deserialize)]
+    enum ExternallyTaggedVariantWith {
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         #[allow(dead_code)]
@@ -400,6 +388,11 @@ fn test_gen() {
         #[allow(dead_code)]
         Tuple(String, u8),
 
+        #[serde(serialize_with = "ser_x")]
+        #[serde(deserialize_with = "de_x")]
+        #[allow(dead_code)]
+        Struct1 { x: X },
+
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
@@ -415,14 +408,16 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(tag = "t")]
     enum InternallyTaggedVariantWith {
-        #[allow(dead_code)]
-        Normal { f1: String },
-
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         #[allow(dead_code)]
         Newtype(X),
 
+        #[serde(serialize_with = "ser_x")]
+        #[serde(deserialize_with = "de_x")]
+        #[allow(dead_code)]
+        Struct1 { x: X },
+
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
@@ -438,9 +433,6 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(tag = "t", content = "c")]
     enum AdjacentlyTaggedVariantWith {
-        #[allow(dead_code)]
-        Normal { f1: String },
-
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         #[allow(dead_code)]
@@ -451,6 +443,11 @@ fn test_gen() {
         #[allow(dead_code)]
         Tuple(String, u8),
 
+        #[serde(serialize_with = "ser_x")]
+        #[serde(deserialize_with = "de_x")]
+        #[allow(dead_code)]
+        Struct1 { x: X },
+
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
@@ -466,9 +463,6 @@ fn test_gen() {
     #[derive(Serialize, Deserialize)]
     #[serde(untagged)]
     enum UntaggedVariantWith {
-        #[allow(dead_code)]
-        Normal { f1: String },
-
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         #[allow(dead_code)]
@@ -479,6 +473,11 @@ fn test_gen() {
         #[allow(dead_code)]
         Tuple(String, u8),
 
+        #[serde(serialize_with = "ser_x")]
+        #[serde(deserialize_with = "de_x")]
+        #[allow(dead_code)]
+        Struct1 { x: X },
+
         #[serde(serialize_with = "serialize_some_other_variant")]
         #[serde(deserialize_with = "deserialize_some_other_variant")]
         #[allow(dead_code)]
@@ -491,6 +490,13 @@ fn test_gen() {
     }
     assert_ser::<UntaggedVariantWith>();
 
+    #[derive(Serialize, Deserialize)]
+    struct FlattenWith {
+        #[serde(flatten, serialize_with = "ser_x", deserialize_with = "de_x")]
+        x: X,
+    }
+    assert::<FlattenWith>();
+
     #[derive(Serialize, Deserialize)]
     struct StaticStrStruct<'a> {
         a: &'a str,
@@ -519,7 +525,9 @@ fn test_gen() {
     assert::<SkippedStaticStr>();
 
     macro_rules! T {
-        () => { () }
+        () => {
+            ()
+        };
     }
 
     #[derive(Serialize, Deserialize)]
@@ -528,6 +536,37 @@ fn test_gen() {
         marker: PhantomData<T>,
     }
     assert::<TypeMacro<X>>();
+
+    #[derive(Serialize)]
+    struct BigArray {
+        #[serde(serialize_with = "<[_]>::serialize")]
+        array: [u8; 256],
+    }
+    assert_ser::<BigArray>();
+
+    trait AssocSerde {
+        type Assoc;
+    }
+
+    struct NoSerdeImpl;
+    impl AssocSerde for NoSerdeImpl {
+        type Assoc = u32;
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct AssocDerive<T: AssocSerde> {
+        assoc: T::Assoc,
+    }
+
+    assert::<AssocDerive<NoSerdeImpl>>();
+
+    #[derive(Serialize, Deserialize)]
+    struct AssocDeriveMulti<S, T: AssocSerde> {
+        s: S,
+        assoc: T::Assoc,
+    }
+
+    assert::<AssocDeriveMulti<i32, NoSerdeImpl>>();
 }
 
 //////////////////////////////////////////////////////////////////////////

test_suite/tests/test_macros.rs

@@ -7,11 +7,16 @@
 // except according to those terms.
 
 #![deny(trivial_numeric_casts)]
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
 
 #[macro_use]
 extern crate serde_derive;
 
+extern crate serde;
 extern crate serde_test;
+
+mod bytes;
+
 use self::serde_test::{assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens,
                        Token};
 
@@ -220,12 +225,10 @@ fn test_de_named_map() {
 fn test_ser_enum_unit() {
     assert_ser_tokens(
         &SerEnum::Unit::<u32, u32, u32>,
-        &[
-            Token::UnitVariant {
-                name: "SerEnum",
-                variant: "Unit",
-            },
-        ],
+        &[Token::UnitVariant {
+            name: "SerEnum",
+            variant: "Unit",
+        }],
     );
 }
 
@@ -290,12 +293,10 @@ fn test_ser_enum_map() {
 fn test_de_enum_unit() {
     assert_tokens(
         &DeEnum::Unit::<u32, u32, u32>,
-        &[
-            Token::UnitVariant {
-                name: "DeEnum",
-                variant: "Unit",
-            },
-        ],
+        &[Token::UnitVariant {
+            name: "DeEnum",
+            variant: "Unit",
+        }],
     );
 }
 
@@ -440,6 +441,51 @@ fn test_generic_newtype_struct() {
     );
 }
 
+#[test]
+fn test_untagged_newtype_struct() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(untagged)]
+    enum E {
+        Newtype(GenericNewTypeStruct<u32>),
+        Null,
+    }
+
+    assert_tokens(
+        &E::Newtype(GenericNewTypeStruct(5u32)),
+        &[
+            Token::NewtypeStruct {
+                name: "GenericNewTypeStruct",
+            },
+            Token::U32(5),
+        ],
+    );
+}
+
+#[test]
+fn test_adjacently_tagged_newtype_struct() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "t", content = "c")]
+    enum E {
+        Newtype(GenericNewTypeStruct<u32>),
+        Null,
+    }
+
+    assert_de_tokens(
+        &E::Newtype(GenericNewTypeStruct(5u32)),
+        &[
+            Token::Struct { name: "E", len: 2 },
+            Token::Str("c"),
+            Token::NewtypeStruct {
+                name: "GenericNewTypeStruct",
+            },
+            Token::U32(5),
+            Token::Str("t"),
+            Token::Str("Newtype"),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_generic_tuple_struct() {
     assert_tokens(
@@ -460,12 +506,10 @@ fn test_generic_tuple_struct() {
 fn test_generic_enum_unit() {
     assert_tokens(
         &GenericEnum::Unit::<u32, u32>,
-        &[
-            Token::UnitVariant {
-                name: "GenericEnum",
-                variant: "Unit",
-            },
-        ],
+        &[Token::UnitVariant {
+            name: "GenericEnum",
+            variant: "Unit",
+        }],
     );
 }
 
@@ -777,6 +821,166 @@ fn test_internally_tagged_enum() {
     );
 }
 
+#[test]
+fn test_internally_tagged_bytes() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    #[serde(tag = "type")]
+    enum InternallyTagged {
+        String {
+            string: String,
+        },
+        Bytes {
+            #[serde(with = "bytes")]
+            bytes: Vec<u8>,
+        },
+    }
+
+    assert_de_tokens(
+        &InternallyTagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "String",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("String"),
+            Token::Str("string"),
+            Token::Str("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "String",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("String"),
+            Token::Str("string"),
+            Token::String("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "String",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("String"),
+            Token::Str("string"),
+            Token::Bytes(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "String",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("String"),
+            Token::Str("string"),
+            Token::ByteBuf(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Bytes",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("Bytes"),
+            Token::Str("bytes"),
+            Token::Str("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Bytes",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("Bytes"),
+            Token::Str("bytes"),
+            Token::String("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Bytes",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("Bytes"),
+            Token::Str("bytes"),
+            Token::Bytes(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Bytes",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("Bytes"),
+            Token::Str("bytes"),
+            Token::ByteBuf(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &InternallyTagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Bytes",
+                len: 2,
+            },
+            Token::Str("type"),
+            Token::Str("Bytes"),
+            Token::Str("bytes"),
+            Token::Seq { len: Some(1) },
+            Token::U8(0),
+            Token::SeqEnd,
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_internally_tagged_struct_variant_containing_unit_variant() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -1196,12 +1400,10 @@ fn test_enum_in_untagged_enum() {
 
     assert_tokens(
         &Outer::Inner(Inner::Unit),
-        &[
-            Token::UnitVariant {
-                name: "Inner",
-                variant: "Unit",
-            },
-        ],
+        &[Token::UnitVariant {
+            name: "Inner",
+            variant: "Unit",
+        }],
     );
 
     assert_tokens(
@@ -1244,6 +1446,148 @@ fn test_enum_in_untagged_enum() {
     );
 }
 
+#[test]
+fn test_untagged_bytes() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    #[serde(untagged)]
+    enum Untagged {
+        String {
+            string: String,
+        },
+        Bytes {
+            #[serde(with = "bytes")]
+            bytes: Vec<u8>,
+        },
+    }
+
+    assert_de_tokens(
+        &Untagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("string"),
+            Token::Str("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("string"),
+            Token::String("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("string"),
+            Token::Bytes(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::String {
+            string: "\0".to_owned(),
+        },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("string"),
+            Token::ByteBuf(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("bytes"),
+            Token::Str("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("bytes"),
+            Token::String("\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("bytes"),
+            Token::Bytes(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("bytes"),
+            Token::ByteBuf(b"\0"),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Untagged::Bytes { bytes: vec![0] },
+        &[
+            Token::Struct {
+                name: "Untagged",
+                len: 1,
+            },
+            Token::Str("bytes"),
+            Token::Seq { len: Some(1) },
+            Token::U8(0),
+            Token::SeqEnd,
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_rename_all() {
     #[derive(Serialize, Deserialize, Debug, PartialEq)]

test_suite/tests/test_remote.rs

@@ -6,6 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+
 #[macro_use]
 extern crate serde_derive;
 
@@ -119,10 +121,7 @@ struct UnitDef;
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::PrimitivePriv")]
-struct PrimitivePrivDef(
-    #[serde(getter = "remote::PrimitivePriv::get")]
-    u8,
-);
+struct PrimitivePrivDef(#[serde(getter = "remote::PrimitivePriv::get")] u8);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::PrimitivePub")]
@@ -130,34 +129,22 @@ struct PrimitivePubDef(u8);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::NewtypePriv")]
-struct NewtypePrivDef(
-    #[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")]
-    remote::Unit,
-);
+struct NewtypePrivDef(#[serde(getter = "remote::NewtypePriv::get", with = "UnitDef")] remote::Unit);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::NewtypePub")]
-struct NewtypePubDef(
-    #[serde(with = "UnitDef")]
-    remote::Unit,
-);
+struct NewtypePubDef(#[serde(with = "UnitDef")] remote::Unit);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::TuplePriv")]
 struct TuplePrivDef(
-    #[serde(getter = "remote::TuplePriv::first")]
-    u8,
-    #[serde(getter = "remote::TuplePriv::second", with = "UnitDef")]
-    remote::Unit,
+    #[serde(getter = "remote::TuplePriv::first")] u8,
+    #[serde(getter = "remote::TuplePriv::second", with = "UnitDef")] remote::Unit,
 );
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::TuplePub")]
-struct TuplePubDef(
-    u8,
-    #[serde(with = "UnitDef")]
-    remote::Unit,
-);
+struct TuplePubDef(u8, #[serde(with = "UnitDef")] remote::Unit);
 
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructPriv")]
@@ -173,10 +160,8 @@ struct StructPrivDef {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::StructPub")]
 struct StructPubDef {
-    #[allow(dead_code)]
     a: u8,
 
-    #[allow(dead_code)]
     #[serde(with = "UnitDef")]
     b: remote::Unit,
 }

test_suite/tests/test_roundtrip.rs

@@ -30,7 +30,7 @@ fn ip_addr_roundtrip() {
 }
 
 #[test]
-fn socked_addr_roundtrip() {
+fn socket_addr_roundtrip() {
     assert_tokens(
         &net::SocketAddr::from((*b"1234567890123456", 1234)).compact(),
         &seq![

test_suite/tests/test_ser.rs

@@ -10,13 +10,13 @@
 extern crate serde_derive;
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
-use std::net;
-use std::path::{Path, PathBuf};
-use std::time::{Duration, UNIX_EPOCH};
 use std::ffi::CString;
+use std::net;
+use std::num::Wrapping;
+use std::path::{Path, PathBuf};
 use std::rc::Rc;
 use std::sync::Arc;
-use std::num::Wrapping;
+use std::time::{Duration, UNIX_EPOCH};
 
 #[cfg(unix)]
 use std::str;

test_suite/tests/test_value.rs

@@ -10,8 +10,8 @@
 extern crate serde_derive;
 
 extern crate serde;
-use serde::Deserialize;
 use serde::de::{value, IntoDeserializer};
+use serde::Deserialize;
 
 #[test]
 fn test_u32_to_enum() {

travis.sh

@@ -55,6 +55,7 @@ else
     channel build
     cd "$DIR/test_suite"
     channel test --features unstable
+    channel build --tests --features proc-macro2/nightly
     if [ -z "${APPVEYOR}" ]; then
         cd "$DIR/test_suite/no_std"
         channel build
@@ -86,4 +87,10 @@ else
     channel build --no-default-features
     cd "$DIR/serde_test"
     channel build
+
+    CHANNEL=1.15.0
+    cd "$DIR"
+    cargo clean
+    cd "$DIR/serde_derive"
+    channel build
 fi