Release 1.0.39

Without collect_other_fields, the visit_borrowed_str and
visit_borrowed_bytes implementations that were being generated were
identical to their default implementation of forwarding to visit_str and
visit_bytes.

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.37" # remember to update html_root_url
+version = "1.0.39" # 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/impls.rs

@@ -1276,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
 ));
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/de/value.rs

@@ -652,11 +652,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 +846,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/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.37")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.39")]
 // 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, redundant_field_names, 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
@@ -143,8 +146,8 @@ mod lib {
 
     pub use self::core::{cmp, iter, mem, ops, slice, str};
     pub use self::core::{f32, f64};
-    pub use self::core::{isize, i16, i32, i64, i8};
-    pub use self::core::{usize, u16, u32, u64, u8};
+    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};

serde/src/private/de.rs

@@ -229,8 +229,8 @@ mod content {
     use lib::*;
 
     use super::size_hint;
-    use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess,
-             Unexpected, Visitor};
+    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.
@@ -1013,6 +1013,45 @@ 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 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>
@@ -1046,21 +1085,185 @@ 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>,
+        {
+            match self.content {
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match self.content {
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&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),
+                _ => 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::ByteBuf(v) => visitor.visit_byte_buf(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                _ => Err(self.invalid_type(&visitor)),
             }
         }
 
@@ -1076,6 +1279,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,
@@ -1087,6 +1328,61 @@ mod content {
             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>(
             self,
             _name: &str,
@@ -1129,38 +1425,23 @@ mod content {
             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()
         }
     }
 
@@ -1452,6 +1733,51 @@ 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 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>
@@ -1487,28 +1813,188 @@ 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>,
+        {
+            match *self.content {
+                Content::I8(v) => visitor.visit_i8(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::I16(v) => visitor.visit_i16(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::I32(v) => visitor.visit_i32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_i64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u16<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U16(v) => visitor.visit_u16(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U32(v) => visitor.visit_u32(v),
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&visitor)),
+            }
+        }
+
+        fn deserialize_u64<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            match *self.content {
+                Content::U64(v) => visitor.visit_u64(v),
+                Content::I64(v) => visitor.visit_i64(v),
+                _ => Err(self.invalid_type(&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),
+                _ => 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::ByteBuf(ref v) => visitor.visit_bytes(v),
+                Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                _ => 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>,
@@ -1521,6 +2007,27 @@ 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>,
@@ -1528,6 +2035,61 @@ mod content {
             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>(
             self,
             _name: &str,
@@ -1574,10 +2136,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()
         }
     }
 

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.37" # remember to update html_root_url
+version = "1.0.39" # 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)]"
@@ -25,7 +25,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "0.3"
 quote = "0.5"
-serde_derive_internals = { version = "=0.23.0", default-features = false, path = "../serde_derive_internals" }
+serde_derive_internals = { version = "=0.23.1", default-features = false, path = "../serde_derive_internals" }
 syn = { version = "0.13", features = ["visit"] }
 
 [dev-dependencies]

serde_derive/src/bound.rs

@@ -8,10 +8,11 @@
 
 use std::collections::HashSet;
 
-use syn::{self, visit};
-use syn::punctuated::Punctuated;
+use syn;
+use syn::punctuated::{Pair, Punctuated};
+use syn::visit::{self, Visit};
 
-use internals::ast::{Data, Container};
+use internals::ast::{Container, Data};
 use internals::attr;
 
 use proc_macro2::Span;
@@ -25,13 +26,11 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
             .params
             .iter()
             .map(|param| match *param {
-                syn::GenericParam::Type(ref param) => {
-                    syn::GenericParam::Type(syn::TypeParam {
-                        eq_token: None,
-                        default: None,
-                        ..param.clone()
-                    })
-                }
+                syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
+                    eq_token: None,
+                    default: None,
+                    ..param.clone()
+                }),
                 _ => param.clone(),
             })
             .collect(),
@@ -44,29 +43,25 @@ pub fn with_where_predicates(
     predicates: &[syn::WherePredicate],
 ) -> syn::Generics {
     let mut generics = generics.clone();
-    generics.make_where_clause()
+    generics
+        .make_where_clause()
         .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]>,
-{
+    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.make_where_clause()
-        .predicates
-        .extend(predicates);
+    generics.make_where_clause().predicates.extend(predicates);
     generics
 }
 
@@ -81,26 +76,39 @@ 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<'ast> visit::Visit<'ast> 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.into_value().ident == "PhantomData" {
                     // Hardcoded exception, because PhantomData<T> implements
@@ -110,8 +118,8 @@ where
             }
             if path.leading_colon.is_none() && path.segments.len() == 1 {
                 let id = path.segments[0].ident;
-                if self.all_ty_params.contains(&id) {
-                    self.relevant_ty_params.insert(id);
+                if self.all_type_params.contains(&id) {
+                    self.relevant_type_params.insert(id);
                 }
             }
             visit::visit_path(self, path);
@@ -123,21 +131,15 @@ where
         //         mac: T!(),
         //         marker: PhantomData<T>,
         //     }
-        fn visit_macro(&mut self, _mac: &syn::Macro) {}
+        fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
     }
 
-    let all_ty_params: HashSet<_> = generics
-        .params
-        .iter()
-        .filter_map(|param| match *param {
-            syn::GenericParam::Type(ref param) => Some(param.ident),
-            _ => None,
-        })
-        .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.data {
         Data::Enum(ref variants) => for variant in variants.iter() {
@@ -146,47 +148,47 @@ where
                 .iter()
                 .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
             for field in relevant_fields {
-                visit::visit_type(&mut visitor, field.ty);
+                visitor.visit_field(field.original);
             }
         },
         Data::Struct(_, ref fields) => {
             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
-                visit::visit_type(&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
-        .params
-        .iter()
-        .filter_map(|param| match *param {
-            syn::GenericParam::Type(ref param) => Some(param.ident),
-            _ => None,
+        .type_params()
+        .map(|param| param.ident)
+        .filter(|id| relevant_type_params.contains(id))
+        .map(|id| syn::TypePath {
+            qself: None,
+            path: id.into(),
         })
-        .filter(|id| visitor.relevant_ty_params.contains(id))
-        .map(|id| {
+        .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::Type::Path(syn::TypePath {
-                    qself: None,
-                    path: id.into(),
-                }),
+                bounded_ty: syn::Type::Path(bounded_ty),
                 colon_token: Default::default(),
                 // the bound e.g. Serialize
-                bounds: vec![
-                    syn::TypeParamBound::Trait(syn::TraitBound {
-                        paren_token: None,
-                        modifier: syn::TraitBoundModifier::None,
-                        lifetimes: None,
-                        path: bound.clone(),
-                    }),
-                ].into_iter().collect(),
+                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.make_where_clause()
+    generics
+        .make_where_clause()
         .predicates
         .extend(new_predicates);
     generics
@@ -198,7 +200,8 @@ pub fn with_self_bound(
     bound: &syn::Path,
 ) -> syn::Generics {
     let mut generics = generics.clone();
-    generics.make_where_clause()
+    generics
+        .make_where_clause()
         .predicates
         .push(syn::WherePredicate::Type(syn::PredicateType {
             lifetimes: None,
@@ -206,14 +209,13 @@ pub fn with_self_bound(
             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(),
+            bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+                paren_token: None,
+                modifier: syn::TraitBoundModifier::None,
+                lifetimes: None,
+                path: bound.clone(),
+            })].into_iter()
+                .collect(),
         }));
     generics
 }
@@ -229,21 +231,18 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
 
     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(_) => {}
+        .chain(generics.params.iter().cloned().map(|mut param| {
+            match param {
+                syn::GenericParam::Lifetime(ref mut param) => {
+                    param.bounds.push(bound);
                 }
-                param
-            }))
+                syn::GenericParam::Type(ref mut param) => {
+                    param.bounds.push(syn::TypeParamBound::Lifetime(bound));
+                }
+                syn::GenericParam::Const(_) => {}
+            }
+            param
+        }))
         .collect();
 
     syn::Generics {
@@ -257,36 +256,35 @@ fn type_of_item(cont: &Container) -> syn::Type {
         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(),
+            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/de.rs

@@ -6,15 +6,15 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn::{self, Ident, Index, Member};
+use proc_macro2::{Literal, Span};
+use quote::{ToTokens, Tokens};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
-use quote::{ToTokens, Tokens};
-use proc_macro2::{Literal, Span};
+use syn::{self, Ident, Index, Member};
 
 use bound;
 use fragment::{Expr, Fragment, Match, Stmts};
-use internals::ast::{Data, Container, Field, Style, Variant};
+use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{self, attr};
 
 use std::collections::BTreeSet;
@@ -27,7 +27,10 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<Tokens, Str
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
-    let dummy_const = Ident::new(&format!("_IMPL_DESERIALIZE_FOR_{}", ident), Span::call_site());
+    let dummy_const = Ident::new(
+        &format!("_IMPL_DESERIALIZE_FOR_{}", ident),
+        Span::call_site(),
+    );
     let body = Stmts(deserialize_body(&cont, &params));
     let delife = params.borrowed.de_lifetime();
 
@@ -268,7 +271,8 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
 
     let code = match cont.data {
         Data::Struct(Style::Struct, ref fields) => {
-            if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None) {
+            if let Some(code) = deserialize_struct_in_place(None, params, fields, &cont.attrs, None)
+            {
                 code
             } else {
                 return None;
@@ -321,8 +325,8 @@ fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fra
         impl<'de> _serde::de::Visitor<'de> for __Visitor {
             type Value = #this;
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             #[inline]
@@ -415,8 +419,8 @@ fn deserialize_tuple(
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_newtype_struct
@@ -503,8 +507,8 @@ fn deserialize_tuple_in_place(
         impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
             type Value = ();
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_newtype_struct
@@ -550,7 +554,8 @@ fn deserialize_seq(
                 None => {
                     let field_ty = &field.ty;
                     let span = field.original.span();
-                    let func = quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
+                    let func =
+                        quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
                     quote!(try!(#func(&mut __seq)))
                 }
                 Some(path) => {
@@ -637,13 +642,12 @@ fn deserialize_seq_in_place(
         .enumerate()
         .map(|(field_index, (_, field))| {
             // If there's no field name, assume we're a tuple-struct and use a numeric index
-            let field_name = field
-                .ident
-                .map(Member::Named)
-                .unwrap_or_else(|| Member::Unnamed(Index {
+            let field_name = field.ident.map(Member::Named).unwrap_or_else(|| {
+                Member::Unnamed(Index {
                     index: field_index as u32,
                     span: Span::call_site(),
-                }));
+                })
+            });
 
             let dot = quote_spanned!(Span::call_site()=> .);
             if field.attrs.skip_deserializing() {
@@ -871,8 +875,8 @@ fn deserialize_struct(
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_seq
@@ -919,8 +923,8 @@ fn deserialize_struct_in_place(
 
     let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs));
 
-    let (field_visitor, fields_stmt, visit_map) = deserialize_struct_as_struct_in_place_visitor(
-        params, fields, cattrs);
+    let (field_visitor, fields_stmt, visit_map) =
+        deserialize_struct_as_struct_in_place_visitor(params, fields, cattrs);
 
     let field_visitor = Stmts(field_visitor);
     let fields_stmt = Stmts(fields_stmt);
@@ -978,8 +982,8 @@ fn deserialize_struct_in_place(
         impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
             type Value = ();
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             #visit_seq
@@ -1059,9 +1063,7 @@ fn deserialize_externally_tagged_enum(
             let variant_name = field_i(i);
 
             let block = Match(deserialize_externally_tagged_variant(
-                params,
-                variant,
-                cattrs,
+                params, variant, cattrs,
             ));
 
             quote! {
@@ -1102,8 +1104,8 @@ fn deserialize_externally_tagged_enum(
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             fn visit_enum<__A>(self, __data: __A) -> _serde::export::Result<Self::Value, __A::Error>
@@ -1161,9 +1163,9 @@ fn deserialize_internally_tagged_enum(
                 params,
                 variant,
                 cattrs,
-                quote!(
+                quote! {
                     _serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
-                ),
+                },
             ));
 
             quote! {
@@ -1373,8 +1375,8 @@ fn deserialize_adjacently_tagged_enum(
         impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
             type Value = #this #ty_generics;
 
-            fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-                _serde::export::Formatter::write_str(formatter, #expecting)
+            fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+                _serde::export::Formatter::write_str(__formatter, #expecting)
             }
 
             fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
@@ -1525,8 +1527,7 @@ fn deserialize_externally_tagged_variant(
     cattrs: &attr::Container,
 ) -> Fragment {
     if let Some(path) = variant.attrs.deserialize_with() {
-        let (wrapper, wrapper_ty, unwrap_fn) =
-            wrap_deserialize_variant_with(params, variant, path);
+        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
         return quote_block! {
             #wrapper
             _serde::export::Result::map(
@@ -1608,8 +1609,7 @@ fn deserialize_untagged_variant(
     deserializer: Tokens,
 ) -> Fragment {
     if let Some(path) = variant.attrs.deserialize_with() {
-        let (wrapper, wrapper_ty, unwrap_fn) =
-            wrap_deserialize_variant_with(params, variant, path);
+        let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
         return quote_block! {
             #wrapper
             _serde::export::Result::map(
@@ -1715,7 +1715,7 @@ fn deserialize_untagged_newtype_variant(
 fn deserialize_generated_identifier(
     fields: &[(String, Ident)],
     cattrs: &attr::Container,
-    is_variant: bool
+    is_variant: bool,
 ) -> Fragment {
     let this = quote!(__Field);
     let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect();
@@ -1810,12 +1810,7 @@ fn deserialize_custom_identifier(
 
     let names_idents: Vec<_> = ordinary
         .iter()
-        .map(|variant| {
-            (
-                variant.attrs.name().deserialize_name(),
-                variant.ident,
-            )
-        })
+        .map(|variant| (variant.attrs.name().deserialize_name(), variant.ident))
         .collect();
 
     let names = names_idents.iter().map(|&(ref name, _)| name);
@@ -1872,12 +1867,16 @@ fn deserialize_identifier(
     fields: &[(String, Ident)],
     is_variant: bool,
     fallthrough: Option<Tokens>,
-    collect_other_fields: bool
+    collect_other_fields: bool,
 ) -> Fragment {
     let field_strs = fields.iter().map(|&(ref name, _)| name);
     let field_borrowed_strs = fields.iter().map(|&(ref name, _)| name);
-    let field_bytes = fields.iter().map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
-    let field_borrowed_bytes = fields.iter().map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
+    let field_bytes = fields
+        .iter()
+        .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
+    let field_borrowed_bytes = fields
+        .iter()
+        .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
 
     let constructors: &Vec<_> = &fields
         .iter()
@@ -1892,10 +1891,54 @@ fn deserialize_identifier(
 
     let index_expecting = if is_variant { "variant" } else { "field" };
 
+    let bytes_to_str = if fallthrough.is_some() || collect_other_fields {
+        None
+    } else {
+        Some(quote! {
+            let __value = &_serde::export::from_utf8_lossy(__value);
+        })
+    };
+
+    let (
+        value_as_str_content,
+        value_as_borrowed_str_content,
+        value_as_bytes_content,
+        value_as_borrowed_bytes_content,
+    ) = if !collect_other_fields {
+        (None, None, None, None)
+    } else {
+        (
+            Some(quote! {
+                let __value = _serde::private::de::Content::String(__value.to_string());
+            }),
+            Some(quote! {
+                let __value = _serde::private::de::Content::Str(__value);
+            }),
+            Some(quote! {
+                let __value = _serde::private::de::Content::ByteBuf(__value.to_vec());
+            }),
+            Some(quote! {
+                let __value = _serde::private::de::Content::Bytes(__value);
+            }),
+        )
+    };
+
+    let fallthrough_arm = if let Some(fallthrough) = fallthrough {
+        fallthrough
+    } else if is_variant {
+        quote! {
+            _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
+        }
+    } else {
+        quote! {
+            _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
+        }
+    };
+
     let variant_indices = 0u64..;
     let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
     let visit_other = if collect_other_fields {
-        Some(quote! {
+        quote! {
             fn visit_bool<__E>(self, __value: bool) -> Result<Self::Value, __E>
                 where __E: _serde::de::Error
             {
@@ -1973,9 +2016,38 @@ fn deserialize_identifier(
             {
                 Ok(__Field::__other(_serde::private::de::Content::Unit))
             }
-        })
+
+            fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::export::Result<Self::Value, __E>
+                where __E: _serde::de::Error
+            {
+                match __value {
+                    #(
+                        #field_borrowed_strs => _serde::export::Ok(#constructors),
+                    )*
+                    _ => {
+                        #value_as_borrowed_str_content
+                        #fallthrough_arm
+                    }
+                }
+            }
+
+            fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::export::Result<Self::Value, __E>
+                where __E: _serde::de::Error
+            {
+                match __value {
+                    #(
+                        #field_borrowed_bytes => _serde::export::Ok(#constructors),
+                    )*
+                    _ => {
+                        #bytes_to_str
+                        #value_as_borrowed_bytes_content
+                        #fallthrough_arm
+                    }
+                }
+            }
+        }
     } else {
-        Some(quote! {
+        quote! {
             fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
                 where __E: _serde::de::Error
             {
@@ -1988,52 +2060,12 @@ fn deserialize_identifier(
                                 &#fallthrough_msg))
                 }
             }
-        })
-    };
-
-    let bytes_to_str = if fallthrough.is_some() || collect_other_fields {
-        None
-    } else {
-        Some(quote! {
-            let __value = &_serde::export::from_utf8_lossy(__value);
-        })
-    };
-
-    let (value_as_str_content, value_as_borrowed_str_content,
-         value_as_bytes_content, value_as_borrowed_bytes_content) = if !collect_other_fields {
-        (None, None, None, None)
-    } else {
-        (
-            Some(quote! {
-                let __value = _serde::private::de::Content::String(__value.to_string());
-            }),
-            Some(quote! {
-                let __value = _serde::private::de::Content::Str(__value);
-            }),
-            Some(quote! {
-                let __value = _serde::private::de::Content::ByteBuf(__value.to_vec());
-            }),
-            Some(quote! {
-                let __value = _serde::private::de::Content::Bytes(__value);
-            })
-        )
-    };
-
-    let fallthrough_arm = if let Some(fallthrough) = fallthrough {
-        fallthrough
-    } else if is_variant {
-        quote! {
-            _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
-        }
-    } else {
-        quote! {
-            _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
         }
     };
 
     quote_block! {
-        fn expecting(&self, formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
-            _serde::export::Formatter::write_str(formatter, #expecting)
+        fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
+            _serde::export::Formatter::write_str(__formatter, #expecting)
         }
 
         #visit_other
@@ -2052,35 +2084,6 @@ fn deserialize_identifier(
             }
         }
 
-        fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::export::Result<Self::Value, __E>
-            where __E: _serde::de::Error
-        {
-            match __value {
-                #(
-                    #field_borrowed_strs => _serde::export::Ok(#constructors),
-                )*
-                _ => {
-                    #value_as_borrowed_str_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
-        fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::export::Result<Self::Value, __E>
-            where __E: _serde::de::Error
-        {
-            match __value {
-                #(
-                    #field_borrowed_bytes => _serde::export::Ok(#constructors),
-                )*
-                _ => {
-                    #bytes_to_str
-                    #value_as_borrowed_bytes_content
-                    #fallthrough_arm
-                }
-            }
-        }
-
         fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::export::Result<Self::Value, __E>
             where __E: _serde::de::Error
         {
@@ -2194,7 +2197,8 @@ fn deserialize_map(
                 None => {
                     let field_ty = &field.ty;
                     let span = field.original.span();
-                    let func = quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
+                    let func =
+                        quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
                     quote! {
                         try!(#func(&mut __map))
                     }
@@ -2473,7 +2477,12 @@ fn deserialize_map_in_place(
             // If missing_expr unconditionally returns an error, don't try
             // to assign its value to self.place. Maybe this could be handled
             // more elegantly.
-            if missing_expr.as_ref().into_tokens().to_string().starts_with("return ") {
+            if missing_expr
+                .as_ref()
+                .into_tokens()
+                .to_string()
+                .starts_with("return ")
+            {
                 let missing_expr = Stmts(missing_expr);
                 quote! {
                     if !#name {
@@ -2582,35 +2591,37 @@ fn wrap_deserialize_variant_with(
     let (wrapper, wrapper_ty) =
         wrap_deserialize_with(params, &quote!((#(#field_tys),*)), deserialize_with);
 
-    let field_access = (0..variant.fields.len()).map(|n| Member::Unnamed(Index {
-        index: n as u32,
-        span: Span::call_site(),
-    }));
+    let field_access = (0..variant.fields.len()).map(|n| {
+        Member::Unnamed(Index {
+            index: n as u32,
+            span: Span::call_site(),
+        })
+    });
     let unwrap_fn = match variant.style {
+        Style::Struct if variant.fields.len() == 1 => {
+            let field_ident = variant.fields[0].ident.unwrap();
+            quote! {
+                |__wrap| #this::#variant_ident { #field_ident: __wrap.value }
+            }
+        }
         Style::Struct => {
             let field_idents = variant
                 .fields
                 .iter()
                 .map(|field| field.ident.as_ref().unwrap());
-            quote!({
-                |__wrap| {
-                    #this::#variant_ident { #(#field_idents: __wrap.value.#field_access),* }
-                }
-            })
+            quote! {
+                |__wrap| #this::#variant_ident { #(#field_idents: __wrap.value.#field_access),* }
+            }
         }
-        Style::Tuple => quote!({
-            |__wrap| {
-                #this::#variant_ident(#(__wrap.value.#field_access),*)
-            }
-        }),
-        Style::Newtype => quote!({
-            |__wrap| {
-                #this::#variant_ident(__wrap.value)
-            }
-        }),
-        Style::Unit => quote!({
-            |__wrap| { #this::#variant_ident }
-        }),
+        Style::Tuple => quote! {
+            |__wrap| #this::#variant_ident(#(__wrap.value.#field_access),*)
+        },
+        Style::Newtype => quote! {
+            |__wrap| #this::#variant_ident(__wrap.value)
+        },
+        Style::Unit => quote! {
+            |__wrap| #this::#variant_ident
+        },
     };
 
     (wrapper, wrapper_ty, unwrap_fn)
@@ -2683,7 +2694,8 @@ impl<'a> ToTokens for InPlaceImplGenerics<'a> {
                     param.bounds.push(place_lifetime.lifetime);
                 }
                 syn::GenericParam::Type(ref mut param) => {
-                    param.bounds
+                    param
+                        .bounds
                         .push(syn::TypeParamBound::Lifetime(place_lifetime.lifetime));
                 }
                 syn::GenericParam::Const(_) => {}

serde_derive/src/lib.rs

@@ -22,9 +22,11 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.37")]
-#![cfg_attr(feature = "cargo-clippy", allow(enum_variant_names, redundant_field_names,
-                                            too_many_arguments, used_underscore_binding))]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.39")]
+#![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 = "512"]
 
@@ -54,8 +56,8 @@ mod bound;
 #[macro_use]
 mod fragment;
 
-mod ser;
 mod de;
+mod ser;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {

serde_derive/src/ser.rs

@@ -6,14 +6,14 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn::{self, Ident, Index, Member};
-use syn::spanned::Spanned;
-use quote::Tokens;
 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::{Data, Container, Field, Style, Variant};
+use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, Ctxt};
 
 use std::u32;
@@ -204,10 +204,14 @@ fn serialize_newtype_struct(
 ) -> Fragment {
     let type_name = cattrs.name().serialize_name();
 
-    let mut field_expr = get_member(params, field, &Member::Unnamed(Index {
-        index: 0,
-        span: Span::call_site(),
-    }));
+    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);
     }
@@ -224,12 +228,8 @@ fn serialize_tuple_struct(
     fields: &[Field],
     cattrs: &attr::Container,
 ) -> Fragment {
-    let serialize_stmts = serialize_tuple_struct_visitor(
-        fields,
-        params,
-        false,
-        &TupleTrait::SerializeTupleStruct,
-    );
+    let serialize_stmts =
+        serialize_tuple_struct_visitor(fields, params, false, &TupleTrait::SerializeTupleStruct);
 
     let type_name = cattrs.name().serialize_name();
     let len = serialize_stmts.len();
@@ -252,13 +252,13 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
     }
 }
 
-fn serialize_struct_as_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    let serialize_fields = serialize_struct_visitor(
-        fields,
-        params,
-        false,
-        &StructTrait::SerializeStruct,
-    );
+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();
 
@@ -287,13 +287,13 @@ fn serialize_struct_as_struct(params: &Parameters, fields: &[Field], cattrs: &at
     }
 }
 
-fn serialize_struct_as_map(params: &Parameters, fields: &[Field], cattrs: &attr::Container) -> Fragment {
-    let serialize_fields = serialize_struct_visitor(
-        fields,
-        params,
-        false,
-        &StructTrait::SerializeMap,
-    );
+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()
@@ -385,8 +385,8 @@ fn serialize_variant(
                 }
             }
             Style::Tuple => {
-                let field_names =
-                    (0..variant.fields.len()).map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
+                let field_names = (0..variant.fields.len())
+                    .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                 quote! {
                     #this::#variant_ident(#(ref #field_names),*)
                 }
@@ -776,12 +776,10 @@ fn serialize_struct_variant<'a>(
     name: &str,
 ) -> Fragment {
     let struct_trait = match context {
-        StructVariant::ExternallyTagged { .. } => (
-            StructTrait::SerializeStructVariant
-        ),
-        StructVariant::InternallyTagged { .. } | StructVariant::Untagged => (
-            StructTrait::SerializeStruct
-        ),
+        StructVariant::ExternallyTagged { .. } => (StructTrait::SerializeStructVariant),
+        StructVariant::InternallyTagged { .. } | StructVariant::Untagged => {
+            (StructTrait::SerializeStruct)
+        }
     };
 
     let serialize_fields = serialize_struct_visitor(fields, params, true, &struct_trait);
@@ -865,10 +863,14 @@ fn serialize_tuple_struct_visitor(
                 let id = Ident::new(&format!("__field{}", i), Span::call_site());
                 quote!(#id)
             } else {
-                get_member(params, field, &Member::Unnamed(Index {
-                    index: i as u32,
-                    span: Span::call_site(),
-                }))
+                get_member(
+                    params,
+                    field,
+                    &Member::Unnamed(Index {
+                        index: i as u32,
+                        span: Span::call_site(),
+                    }),
+                )
             };
 
             let skip = field
@@ -1009,10 +1011,12 @@ fn wrap_serialize_with(
     };
     let (wrapper_impl_generics, wrapper_ty_generics, _) = wrapper_generics.split_for_impl();
 
-    let field_access = (0..field_exprs.len()).map(|n| Member::Unnamed(Index {
-        index: n as u32,
-        span: Span::call_site(),
-    }));
+    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 {
@@ -1052,9 +1056,7 @@ fn mut_if(is_mut: bool) -> Option<Tokens> {
 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) => {
-            quote_spanned!(Span::call_site()=> &#self_var.#member)
-        }
+        (false, None) => quote_spanned!(Span::call_site()=> &#self_var.#member),
         (true, None) => {
             let inner = quote_spanned!(Span::call_site()=> &#self_var.#member);
             let ty = field.ty;
@@ -1094,12 +1096,12 @@ impl StructTrait {
     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)
-            })
+            StructTrait::SerializeStruct => {
+                Some(quote_spanned!(span=> _serde::ser::SerializeStruct::skip_field))
+            }
+            StructTrait::SerializeStructVariant => {
+                Some(quote_spanned!(span=> _serde::ser::SerializeStructVariant::skip_field))
+            }
         }
     }
 }

serde_derive_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive_internals"
-version = "0.23.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."

serde_derive_internals/src/ast.rs

@@ -6,11 +6,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use syn;
 use attr;
 use check;
-use Ctxt;
+use syn;
 use syn::punctuated::Punctuated;
+use Ctxt;
 
 pub struct Container<'a> {
     pub ident: syn::Ident,

serde_derive_internals/src/attr.rs

@@ -6,16 +6,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use Ctxt;
+use proc_macro2::{Group, Span, TokenStream, TokenTree};
+use std::collections::BTreeSet;
+use std::str::FromStr;
 use syn;
+use syn::punctuated::Punctuated;
+use syn::synom::{ParseError, Synom};
 use syn::Ident;
 use syn::Meta::{List, NameValue, Word};
 use syn::NestedMeta::{Literal, Meta};
-use syn::punctuated::Punctuated;
-use syn::synom::{Synom, ParseError};
-use std::collections::BTreeSet;
-use std::str::FromStr;
-use proc_macro2::{Span, TokenStream, TokenTree, Group};
+use Ctxt;
 
 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
 // are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
@@ -234,7 +234,10 @@ impl Container {
 
                     // Parse `#[serde(default)]`
                     Meta(Word(word)) if word == "default" => match item.data {
-                        syn::Data::Struct(syn::DataStruct { fields: syn::Fields::Named(_), .. }) => {
+                        syn::Data::Struct(syn::DataStruct {
+                            fields: syn::Fields::Named(_),
+                            ..
+                        }) => {
                             default.set(Default::Default);
                         }
                         _ => cx.error(
@@ -247,7 +250,10 @@ impl Container {
                     Meta(NameValue(ref m)) if m.ident == "default" => {
                         if let Ok(path) = parse_lit_into_expr_path(cx, m.ident.as_ref(), &m.lit) {
                             match item.data {
-                                syn::Data::Struct(syn::DataStruct { fields: syn::Fields::Named(_), .. }) => {
+                                syn::Data::Struct(syn::DataStruct {
+                                    fields: syn::Fields::Named(_),
+                                    ..
+                                }) => {
                                     default.set(Default::Path(path));
                                 }
                                 _ => cx.error(
@@ -503,13 +509,11 @@ fn decide_identifier(
         }
         (&syn::Data::Enum(_), true, false) => Identifier::Field,
         (&syn::Data::Enum(_), false, true) => Identifier::Variant,
-        (&syn::Data::Struct(_), true, false)
-        | (&syn::Data::Union(_), true, false) => {
+        (&syn::Data::Struct(_), true, false) | (&syn::Data::Union(_), true, false) => {
             cx.error("`field_identifier` can only be used on an enum");
             Identifier::No
         }
-        (&syn::Data::Struct(_), false, true)
-        | (&syn::Data::Union(_), false, true) => {
+        (&syn::Data::Struct(_), false, true) | (&syn::Data::Union(_), false, true) => {
             cx.error("`variant_identifier` can only be used on an enum");
             Identifier::No
         }
@@ -594,10 +598,16 @@ impl Variant {
                     Meta(NameValue(ref m)) if m.ident == "with" => {
                         if let Ok(path) = parse_lit_into_expr_path(cx, m.ident.as_ref(), &m.lit) {
                             let mut ser_path = path.clone();
-                            ser_path.path.segments.push(Ident::new("serialize", Span::call_site()).into());
+                            ser_path
+                                .path
+                                .segments
+                                .push(Ident::new("serialize", Span::call_site()).into());
                             serialize_with.set(ser_path);
                             let mut de_path = path;
-                            de_path.path.segments.push(Ident::new("deserialize", Span::call_site()).into());
+                            de_path
+                                .path
+                                .segments
+                                .push(Ident::new("deserialize", Span::call_site()).into());
                             deserialize_with.set(de_path);
                         }
                     }
@@ -838,10 +848,16 @@ impl Field {
                     Meta(NameValue(ref m)) if m.ident == "with" => {
                         if let Ok(path) = parse_lit_into_expr_path(cx, m.ident.as_ref(), &m.lit) {
                             let mut ser_path = path.clone();
-                            ser_path.path.segments.push(Ident::new("serialize", Span::call_site()).into());
+                            ser_path
+                                .path
+                                .segments
+                                .push(Ident::new("serialize", Span::call_site()).into());
                             serialize_with.set(ser_path);
                             let mut de_path = path;
-                            de_path.path.segments.push(Ident::new("deserialize", Span::call_site()).into());
+                            de_path
+                                .path
+                                .segments
+                                .push(Ident::new("deserialize", Span::call_site()).into());
                             deserialize_with.set(de_path);
                         }
                     }
@@ -873,7 +889,9 @@ impl Field {
 
                     // Parse `#[serde(borrow = "'a + 'b")]`
                     Meta(NameValue(ref m)) if m.ident == "borrow" => {
-                        if let Ok(lifetimes) = parse_lit_into_lifetimes(cx, m.ident.as_ref(), &m.lit) {
+                        if let Ok(lifetimes) =
+                            parse_lit_into_lifetimes(cx, m.ident.as_ref(), &m.lit)
+                        {
                             if let Ok(borrowable) = borrowable_lifetimes(cx, &ident, &field.ty) {
                                 for lifetime in &lifetimes {
                                     if !borrowable.contains(lifetime) {
@@ -939,10 +957,14 @@ impl Field {
                     leading_colon: None,
                     segments: Punctuated::new(),
                 };
-                path.segments.push(Ident::new("_serde", Span::call_site()).into());
-                path.segments.push(Ident::new("private", Span::call_site()).into());
-                path.segments.push(Ident::new("de", Span::call_site()).into());
-                path.segments.push(Ident::new("borrow_cow_str", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("_serde", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("private", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("de", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("borrow_cow_str", Span::call_site()).into());
                 let expr = syn::ExprPath {
                     attrs: Vec::new(),
                     qself: None,
@@ -954,10 +976,14 @@ impl Field {
                     leading_colon: None,
                     segments: Punctuated::new(),
                 };
-                path.segments.push(Ident::new("_serde", Span::call_site()).into());
-                path.segments.push(Ident::new("private", Span::call_site()).into());
-                path.segments.push(Ident::new("de", Span::call_site()).into());
-                path.segments.push(Ident::new("borrow_cow_bytes", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("_serde", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("private", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("de", Span::call_site()).into());
+                path.segments
+                    .push(Ident::new("borrow_cow_bytes", Span::call_site()).into());
                 let expr = syn::ExprPath {
                     attrs: Vec::new(),
                     qself: None,
@@ -1097,7 +1123,10 @@ where
     Ok((ser_meta.get(), de_meta.get()))
 }
 
-fn get_renames<'a>(cx: &Ctxt, items: &'a Punctuated<syn::NestedMeta, Token![,]>) -> Result<SerAndDe<&'a syn::LitStr>, ()> {
+fn get_renames<'a>(
+    cx: &Ctxt,
+    items: &'a Punctuated<syn::NestedMeta, Token![,]>,
+) -> Result<SerAndDe<&'a syn::LitStr>, ()> {
     get_ser_and_de(cx, "rename", items, get_lit_str)
 }
 
@@ -1141,12 +1170,18 @@ fn get_lit_str<'a>(
 
 fn parse_lit_into_path(cx: &Ctxt, attr_name: &str, lit: &syn::Lit) -> Result<syn::Path, ()> {
     let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
-    parse_lit_str(string).map_err(|_| cx.error(format!("failed to parse path: {:?}", string.value())))
+    parse_lit_str(string)
+        .map_err(|_| cx.error(format!("failed to parse path: {:?}", string.value())))
 }
 
-fn parse_lit_into_expr_path(cx: &Ctxt, attr_name: &str, lit: &syn::Lit) -> Result<syn::ExprPath, ()> {
+fn parse_lit_into_expr_path(
+    cx: &Ctxt,
+    attr_name: &str,
+    lit: &syn::Lit,
+) -> Result<syn::ExprPath, ()> {
     let string = try!(get_lit_str(cx, attr_name, attr_name, lit));
-    parse_lit_str(string).map_err(|_| cx.error(format!("failed to parse path: {:?}", string.value())))
+    parse_lit_str(string)
+        .map_err(|_| cx.error(format!("failed to parse path: {:?}", string.value())))
 }
 
 fn parse_lit_into_where(
@@ -1173,7 +1208,8 @@ fn parse_lit_into_ty(cx: &Ctxt, attr_name: &str, lit: &syn::Lit) -> Result<syn::
     parse_lit_str(string).map_err(|_| {
         cx.error(format!(
             "failed to parse type: {} = {:?}",
-            attr_name, string.value()
+            attr_name,
+            string.value()
         ))
     })
 }
@@ -1210,7 +1246,10 @@ fn parse_lit_into_lifetimes(
         return Ok(set);
     }
 
-    cx.error(format!("failed to parse borrowed lifetimes: {:?}", string.value()));
+    cx.error(format!(
+        "failed to parse borrowed lifetimes: {:?}",
+        string.value()
+    ));
     Err(())
 }
 
@@ -1255,14 +1294,10 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
             return false;
         }
     };
-    seg.ident == "Cow"
-        && args.len() == 2
-        && match (&args[0], &args[1]) {
-            (&syn::GenericArgument::Lifetime(_), &syn::GenericArgument::Type(ref arg)) => {
-                elem(arg)
-            }
-            _ => false,
-        }
+    seg.ident == "Cow" && args.len() == 2 && match (&args[0], &args[1]) {
+        (&syn::GenericArgument::Lifetime(_), &syn::GenericArgument::Type(ref arg)) => elem(arg),
+        _ => false,
+    }
 }
 
 // Whether the type looks like it might be `&T` where elem="T". This can have
@@ -1287,9 +1322,7 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
 //     }
 fn is_rptr(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
     match *ty {
-        syn::Type::Reference(ref ty) => {
-            ty.mutability.is_none() && elem(&ty.elem)
-        }
+        syn::Type::Reference(ref ty) => ty.mutability.is_none() && elem(&ty.elem),
         _ => false,
     }
 }
@@ -1307,17 +1340,13 @@ fn is_slice_u8(ty: &syn::Type) -> bool {
 
 fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
     match *ty {
-        syn::Type::Path(ref ty) => {
-            ty.qself.is_none() && is_primitive_path(&ty.path, primitive)
-        }
+        syn::Type::Path(ref ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
         _ => false,
     }
 }
 
 fn is_primitive_path(path: &syn::Path, primitive: &str) -> bool {
-    path.leading_colon.is_none()
-        && path.segments.len() == 1
-        && path.segments[0].ident == primitive
+    path.leading_colon.is_none() && path.segments.len() == 1 && path.segments[0].ident == primitive
         && path.segments[0].arguments.is_empty()
 }
 
@@ -1414,7 +1443,10 @@ fn spanned_tokens(s: &syn::LitStr) -> Result<TokenStream, ParseError> {
 }
 
 fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
-    stream.into_iter().map(|token| respan_token_tree(token, span)).collect()
+    stream
+        .into_iter()
+        .map(|token| respan_token_tree(token, span))
+        .collect()
 }
 
 fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {

serde_derive_internals/src/case.rs

@@ -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,8 +6,8 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use ast::{Data, Container, Style};
-use attr::{Identifier, EnumTag};
+use ast::{Container, Data, Style};
+use attr::{EnumTag, Identifier};
 use Ctxt;
 
 /// Cross-cutting checks that require looking at more than a single attrs
@@ -66,17 +66,17 @@ fn check_flatten(cx: &Ctxt, cont: &Container) {
                 if field.attrs.skip_serializing() {
                     cx.error(
                         "#[serde(flatten] can not be combined with \
-                         #[serde(skip_serializing)]"
+                         #[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 = \"...\")]"
+                         #[serde(skip_serializing_if = \"...\")]",
                     );
                 } else if field.attrs.skip_deserializing() {
                     cx.error(
                         "#[serde(flatten] can not be combined with \
-                         #[serde(skip_deserializing)]"
+                         #[serde(skip_deserializing)]",
                     );
                 }
             }
@@ -220,10 +220,7 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
 /// 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,
-) {
+fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     let variants = match cont.data {
         Data::Enum(ref variants) => variants,
         Data::Struct(_, _) => return,
@@ -235,10 +232,7 @@ fn check_internal_tag_field_name_conflict(
     };
 
     let diagnose_conflict = || {
-        let message = format!(
-            "variant field name `{}` conflicts with internal tag",
-            tag
-        );
+        let message = format!("variant field name `{}` conflicts with internal tag", tag);
         cx.error(message);
     };
 
@@ -257,8 +251,8 @@ fn check_internal_tag_field_name_conflict(
                         return;
                     }
                 }
-            },
-            Style::Unit | Style::Newtype | Style::Tuple => {},
+            }
+            Style::Unit | Style::Newtype | Style::Tuple => {}
         }
     }
 }
@@ -267,7 +261,10 @@ fn check_internal_tag_field_name_conflict(
 /// 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::Adjacent {
+            ref tag,
+            ref content,
+        } => (tag, content),
         EnumTag::Internal { .. } | EnumTag::External | EnumTag::None => return,
     };
 

serde_derive_internals/src/ctxt.rs

@@ -6,8 +6,8 @@
 // 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)]

serde_derive_internals/src/lib.rs

@@ -6,9 +6,11 @@
 // 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.23.0")]
-#![cfg_attr(feature = "cargo-clippy", allow(cyclomatic_complexity, doc_markdown, match_same_arms,
-                                            redundant_field_names))]
+#![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)
+)]
 
 #[macro_use]
 extern crate syn;

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.37" # remember to update html_root_url
+version = "1.0.39" # 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

@@ -155,29 +155,33 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.37")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.39")]
 #![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(empty_line_after_outer_attr, missing_docs_in_private_items,
-                  redundant_field_names, 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/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/test_gen.rs

@@ -391,9 +391,6 @@ fn test_gen() {
 
     #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
-        #[allow(dead_code)]
-        Normal { f1: String },
-
         #[serde(serialize_with = "ser_x")]
         #[serde(deserialize_with = "de_x")]
         #[allow(dead_code)]
@@ -404,6 +401,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)]
@@ -419,14 +421,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)]
@@ -442,9 +446,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)]
@@ -455,6 +456,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)]
@@ -470,9 +476,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)]
@@ -483,6 +486,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)]
@@ -539,6 +547,30 @@ fn test_gen() {
         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>>();
 }
 
 //////////////////////////////////////////////////////////////////////////