Release 1.0.37

Produce error message for use of flatten in tuple structs

README.md

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

rustfmt.toml

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

serde/Cargo.toml

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

serde/src/de/from_primitive.rs

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

serde/src/de/impls.rs

@@ -470,7 +470,11 @@ impl<'de> Deserialize<'de> for CString {
 }
 
 macro_rules! forwarded_impl {
-    (( $($id: ident),* ), $ty: ty, $func: expr) => {
+    (
+        $(#[doc = $doc:tt])*
+        ( $($id: ident),* ), $ty: ty, $func: expr
+    ) => {
+        $(#[doc = $doc])*
         impl<'de $(, $id : Deserialize<'de>,)*> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1073,7 +1077,7 @@ map_impl!(
 
 #[cfg(feature = "std")]
 macro_rules! parse_ip_impl {
-    ($ty:ty; $size: expr) => {
+    ($ty:ty; $size:expr) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1087,7 +1091,7 @@ macro_rules! parse_ip_impl {
                 }
             }
         }
-    }
+    };
 }
 
 #[cfg(feature = "std")]
@@ -1230,7 +1234,7 @@ parse_ip_impl!(net::Ipv6Addr; 16);
 
 #[cfg(feature = "std")]
 macro_rules! parse_socket_impl {
-    ($ty:ty, $new: expr) => {
+    ($ty:ty, $new:expr) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
@@ -1244,7 +1248,7 @@ macro_rules! parse_socket_impl {
                 }
             }
         }
-    }
+    };
 }
 
 #[cfg(feature = "std")]
@@ -1432,10 +1436,28 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
 #[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
-forwarded_impl!((T), Arc<T>, Arc::new);
+forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Arc` will not attempt to
+    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    (T), Arc<T>, Arc::new
+}
 
 #[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
-forwarded_impl!((T), Rc<T>, Rc::new);
+forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Rc` will not attempt to
+    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    (T), Rc<T>, Rc::new
+}
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, T: ?Sized> Deserialize<'de> for Cow<'a, T>
@@ -1456,7 +1478,11 @@ where
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
 macro_rules! box_forwarded_impl {
-    ($t:ident) => {
+    (
+        $(#[doc = $doc:tt])*
+        $t:ident
+    ) => {
+        $(#[doc = $doc])*
         impl<'de, T: ?Sized> Deserialize<'de> for $t<T>
         where
             Box<T>: Deserialize<'de>,
@@ -1468,14 +1494,32 @@ macro_rules! box_forwarded_impl {
                 Box::deserialize(deserializer).map(Into::into)
             }
         }
-    }
+    };
 }
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl!(Rc);
+box_forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Rc` will not attempt to
+    /// deduplicate `Rc` references to the same data. Every deserialized `Rc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    Rc
+}
 
 #[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
-box_forwarded_impl!(Arc);
+box_forwarded_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Deserializing a data structure containing `Arc` will not attempt to
+    /// deduplicate `Arc` references to the same data. Every deserialized `Arc`
+    /// will end up with a strong count of 1.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    Arc
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 

serde/src/de/value.rs

@@ -37,10 +37,10 @@
 
 use lib::*;
 
+use self::private::{First, Second};
 use de::{self, Expected, IntoDeserializer, SeqAccess};
 use private::de::size_hint;
 use ser;
-use self::private::{First, Second};
 
 ////////////////////////////////////////////////////////////////////////////////
 

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.35")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.37")]
 // 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
@@ -135,16 +135,16 @@ extern crate core;
 /// module.
 mod lib {
     mod core {
-        #[cfg(feature = "std")]
-        pub use std::*;
         #[cfg(not(feature = "std"))]
         pub use core::*;
+        #[cfg(feature = "std")]
+        pub use std::*;
     }
 
     pub use self::core::{cmp, iter, mem, ops, slice, str};
+    pub use self::core::{f32, f64};
     pub use self::core::{isize, i16, i32, i64, i8};
     pub use self::core::{usize, u16, u32, u64, u8};
-    pub use self::core::{f32, f64};
 
     pub use self::core::cell::{Cell, RefCell};
     pub use self::core::clone::{self, Clone};
@@ -155,40 +155,40 @@ mod lib {
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
 
-    #[cfg(feature = "std")]
-    pub use std::borrow::{Cow, ToOwned};
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::borrow::{Cow, ToOwned};
-
     #[cfg(feature = "std")]
-    pub use std::string::String;
+    pub use std::borrow::{Cow, ToOwned};
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::string::{String, ToString};
-
     #[cfg(feature = "std")]
-    pub use std::vec::Vec;
+    pub use std::string::String;
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::vec::Vec;
-
     #[cfg(feature = "std")]
-    pub use std::boxed::Box;
+    pub use std::vec::Vec;
+
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::boxed::Box;
+    #[cfg(feature = "std")]
+    pub use std::boxed::Box;
 
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::rc::Rc;
     #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
     pub use alloc::rc::Rc;
-
     #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::sync::Arc;
+    pub use std::rc::Rc;
+
     #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
     pub use alloc::arc::Arc;
+    #[cfg(all(feature = "rc", feature = "std"))]
+    pub use std::sync::Arc;
 
-    #[cfg(feature = "std")]
-    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
+    #[cfg(feature = "std")]
+    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
     #[cfg(feature = "std")]
     pub use std::{error, net};
@@ -206,16 +206,16 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::path::{Path, PathBuf};
     #[cfg(feature = "std")]
-    pub use std::time::{Duration, SystemTime, UNIX_EPOCH};
-    #[cfg(feature = "std")]
     pub use std::sync::{Mutex, RwLock};
+    #[cfg(feature = "std")]
+    pub use std::time::{Duration, SystemTime, UNIX_EPOCH};
 
     #[cfg(feature = "unstable")]
     #[allow(deprecated)]
     pub use core::nonzero::{NonZero, Zeroable};
 
     #[cfg(feature = "unstable")]
-    pub use core::num::{NonZeroU8, NonZeroU16, NonZeroU32, NonZeroU64, NonZeroUsize};
+    pub use core::num::{NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -223,13 +223,13 @@ mod lib {
 #[macro_use]
 mod macros;
 
-pub mod ser;
 pub mod de;
+pub mod ser;
 
-#[doc(inline)]
-pub use ser::{Serialize, Serializer};
 #[doc(inline)]
 pub use de::{Deserialize, Deserializer};
+#[doc(inline)]
+pub use ser::{Serialize, Serializer};
 
 // Generated code uses these to support no_std. Not public API.
 #[doc(hidden)]

serde/src/private/de.rs

@@ -11,13 +11,13 @@ use lib::*;
 use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use de::{Unexpected, MapAccess};
+use de::{MapAccess, Unexpected};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer,
+pub use self::content::{Content, ContentDeserializer, ContentRefDeserializer, EnumDeserializer,
                         InternallyTaggedUnitVisitor, TagContentOtherField,
                         TagContentOtherFieldVisitor, TagOrContentField, TagOrContentFieldVisitor,
-                        TaggedContentVisitor, UntaggedUnitVisitor, EnumDeserializer};
+                        TaggedContentVisitor, UntaggedUnitVisitor};
 
 /// If the missing field is of type `Option<T>` then treat is as `None`,
 /// otherwise it is an error.
@@ -228,9 +228,9 @@ mod content {
 
     use lib::*;
 
+    use super::size_hint;
     use de::{self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, MapAccess, SeqAccess,
              Unexpected, Visitor};
-    use super::size_hint;
 
     /// Used from generated code to buffer the contents of the Deserializer when
     /// deserializing untagged enums and internally tagged enums.
@@ -1184,7 +1184,8 @@ mod content {
     }
 
     impl<'de, E> EnumDeserializer<'de, E>
-        where E: de::Error
+    where
+        E: de::Error,
     {
         pub fn new(variant: Content<'de>, value: Option<Content<'de>>) -> EnumDeserializer<'de, E> {
             EnumDeserializer {
@@ -2082,12 +2083,13 @@ where
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub struct FlatMapDeserializer<'a, 'de: 'a, E>(
     pub &'a mut Vec<Option<(Content<'de>, Content<'de>)>>,
-    pub PhantomData<E>
+    pub PhantomData<E>,
 );
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
-    where E: Error
+where
+    E: Error,
 {
     type Error = E;
 
@@ -2102,7 +2104,7 @@ impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
         self,
         name: &'static str,
         variants: &'static [&'static str],
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -2113,15 +2115,12 @@ impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
             // about.
             let use_item = match *item {
                 None => false,
-                Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x))
+                Some((ref c, _)) => c.as_str().map_or(false, |x| variants.contains(&x)),
             };
 
             if use_item {
                 let (key, value) = item.take().unwrap();
-                return visitor.visit_enum(EnumDeserializer::new(
-                    key,
-                    Some(value)
-                ));
+                return visitor.visit_enum(EnumDeserializer::new(key, Some(value)));
             }
         }
 
@@ -2142,7 +2141,7 @@ impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
         self,
         _: &'static str,
         fields: &'static [&'static str],
-        visitor: V
+        visitor: V,
     ) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
@@ -2150,11 +2149,7 @@ impl<'a, 'de, E> Deserializer<'de> for FlatMapDeserializer<'a, 'de, E>
         visitor.visit_map(FlatMapAccess::new(self.0.iter_mut(), Some(fields)))
     }
 
-    fn deserialize_newtype_struct<V>(
-        self,
-        _name: &str,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>,
     {
@@ -2180,7 +2175,7 @@ pub struct FlatMapAccess<'a, 'de: 'a, E> {
 impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
     fn new(
         iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-        fields: Option<&'static [&'static str]>
+        fields: Option<&'static [&'static str]>,
     ) -> FlatMapAccess<'a, 'de, E> {
         FlatMapAccess {
             iter: iter,
@@ -2193,7 +2188,8 @@ impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
-    where E: Error
+where
+    E: Error,
 {
     type Error = E;
 
@@ -2208,13 +2204,12 @@ impl<'a, 'de, E> MapAccess<'de> for FlatMapAccess<'a, 'de, E>
             let use_item = match *item {
                 None => false,
                 Some((ref c, _)) => {
-                    c.as_str().map_or(self.fields.is_none(), |key| {
-                        match self.fields {
+                    c.as_str()
+                        .map_or(self.fields.is_none(), |key| match self.fields {
                             None => true,
                             Some(fields) if fields.contains(&key) => true,
-                            _ => false
-                        }
-                    })
+                            _ => false,
+                        })
                 }
             };
 

serde/src/private/mod.rs

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

serde/src/private/ser.rs

@@ -11,12 +11,8 @@ use lib::*;
 use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use self::content::{
-    SerializeStructVariantAsMapValue,
-    SerializeTupleVariantAsMapValue,
-    ContentSerializer,
-    Content,
-};
+use self::content::{Content, ContentSerializer, SerializeStructVariantAsMapValue,
+                    SerializeTupleVariantAsMapValue};
 
 /// Used to check that serde(getter) attributes return the expected type.
 /// Not public API.
@@ -1042,16 +1038,20 @@ pub struct FlatMapSerializer<'a, M: 'a>(pub &'a mut M);
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> FlatMapSerializer<'a, M>
 where
-    M: SerializeMap + 'a
+    M: SerializeMap + 'a,
 {
     fn bad_type(self, what: Unsupported) -> M::Error {
-        ser::Error::custom(format_args!("can only flatten structs and maps (got {})", what))
+        ser::Error::custom(format_args!(
+            "can only flatten structs and maps (got {})",
+            what
+        ))
     }
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> Serializer for FlatMapSerializer<'a, M>
-    where M: SerializeMap + 'a
+where
+    M: SerializeMap + 'a,
 {
     type Ok = ();
     type Error = M::Error;
@@ -1219,7 +1219,10 @@ impl<'a, M> Serializer for FlatMapSerializer<'a, M>
         _: usize,
     ) -> Result<Self::SerializeStructVariant, Self::Error> {
         try!(self.0.serialize_key(inner_variant));
-        Ok(FlatMapSerializeStructVariantAsMapValue::new(self.0, inner_variant))
+        Ok(FlatMapSerializeStructVariantAsMapValue::new(
+            self.0,
+            inner_variant,
+        ))
     }
 }
 
@@ -1228,7 +1231,8 @@ pub struct FlatMapSerializeMap<'a, M: 'a>(&'a mut M);
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> ser::SerializeMap for FlatMapSerializeMap<'a, M>
-    where M: SerializeMap + 'a
+where
+    M: SerializeMap + 'a,
 {
     type Ok = ();
     type Error = M::Error;
@@ -1257,12 +1261,17 @@ pub struct FlatMapSerializeStruct<'a, M: 'a>(&'a mut M);
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> ser::SerializeStruct for FlatMapSerializeStruct<'a, M>
-    where M: SerializeMap + 'a
+where
+    M: SerializeMap + 'a,
 {
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
     where
         T: Serialize,
     {
@@ -1283,7 +1292,8 @@ pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> FlatMapSerializeStructVariantAsMapValue<'a, M>
-    where M: SerializeMap + 'a
+where
+    M: SerializeMap + 'a,
 {
     fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVariantAsMapValue<'a, M> {
         FlatMapSerializeStructVariantAsMapValue {
@@ -1296,12 +1306,17 @@ impl<'a, M> FlatMapSerializeStructVariantAsMapValue<'a, M>
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, M> ser::SerializeStructVariant for FlatMapSerializeStructVariantAsMapValue<'a, M>
-    where M: SerializeMap + 'a
+where
+    M: SerializeMap + 'a,
 {
     type Ok = ();
     type Error = M::Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
     where
         T: Serialize,
     {
@@ -1311,7 +1326,10 @@ impl<'a, M> ser::SerializeStructVariant for FlatMapSerializeStructVariantAsMapVa
     }
 
     fn end(self) -> Result<(), Self::Error> {
-        try!(self.map.serialize_value(&Content::Struct(self.name, self.fields)));
+        try!(
+            self.map
+                .serialize_value(&Content::Struct(self.name, self.fields))
+        );
         Ok(())
     }
 }

serde/src/ser/impls.rs

@@ -320,8 +320,12 @@ map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! deref_impl {
-    ($($desc:tt)+) => {
-        impl $($desc)+ {
+    (
+        $(#[doc = $doc:tt])*
+        <$($desc:tt)+
+    ) => {
+        $(#[doc = $doc])*
+        impl <$($desc)+ {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where
@@ -340,10 +344,30 @@ deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
 deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T: ?Sized> Serialize for Rc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Rc` will serialize a copy of
+    /// the contents of the `Rc` each time the `Rc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Rc<T> where T: Serialize
+}
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T: ?Sized> Serialize for Arc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Arc` will serialize a copy of
+    /// the contents of the `Arc` each time the `Arc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Arc<T> where T: Serialize
+}
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
@@ -521,11 +545,9 @@ macro_rules! serialize_display_bounded_length {
         // write! only provides fmt::Formatter to Display implementations, which
         // has methods write_str and write_char but no method to write arbitrary
         // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = unsafe {
-            str::from_utf8_unchecked(written)
-        };
+        let written_str = unsafe { str::from_utf8_unchecked(written) };
         $serializer.serialize_str(written_str)
-    }}
+    }};
 }
 
 #[cfg(feature = "std")]

serde_derive/Cargo.toml

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

serde_derive/src/bound.rs

@@ -14,7 +14,7 @@ use syn::punctuated::Punctuated;
 use internals::ast::{Data, Container};
 use internals::attr;
 
-use proc_macro2::{Span, Term};
+use proc_macro2::Span;
 
 // Remove the default from every type parameter because in the generated impls
 // they look like associated types: "error: associated type bindings are not
@@ -44,15 +44,7 @@ pub fn with_where_predicates(
     predicates: &[syn::WherePredicate],
 ) -> syn::Generics {
     let mut generics = generics.clone();
-    if generics.where_clause.is_none() {
-        generics.where_clause = Some(syn::WhereClause {
-            where_token: Default::default(),
-            predicates: Punctuated::new(),
-        });
-    }
-    generics.where_clause
-        .as_mut()
-        .unwrap()
+    generics.make_where_clause()
         .predicates
         .extend(predicates.into_iter().cloned());
     generics
@@ -72,15 +64,7 @@ where
         .flat_map(|predicates| predicates.to_vec());
 
     let mut generics = generics.clone();
-    if generics.where_clause.is_none() {
-        generics.where_clause = Some(syn::WhereClause {
-            where_token: Default::default(),
-            predicates: Punctuated::new(),
-        });
-    }
-    generics.where_clause
-        .as_mut()
-        .unwrap()
+    generics.make_where_clause()
         .predicates
         .extend(predicates);
     generics
@@ -192,6 +176,7 @@ where
                 // the bound e.g. Serialize
                 bounds: vec![
                     syn::TypeParamBound::Trait(syn::TraitBound {
+                        paren_token: None,
                         modifier: syn::TraitBoundModifier::None,
                         lifetimes: None,
                         path: bound.clone(),
@@ -201,15 +186,7 @@ where
         });
 
     let mut generics = generics.clone();
-    if generics.where_clause.is_none() {
-        generics.where_clause = Some(syn::WhereClause {
-            where_token: Default::default(),
-            predicates: Punctuated::new(),
-        });
-    }
-    generics.where_clause
-        .as_mut()
-        .unwrap()
+    generics.make_where_clause()
         .predicates
         .extend(new_predicates);
     generics
@@ -221,15 +198,7 @@ pub fn with_self_bound(
     bound: &syn::Path,
 ) -> syn::Generics {
     let mut generics = generics.clone();
-    if generics.where_clause.is_none() {
-        generics.where_clause = Some(syn::WhereClause {
-            where_token: Default::default(),
-            predicates: Punctuated::new(),
-        });
-    }
-    generics.where_clause
-        .as_mut()
-        .unwrap()
+    generics.make_where_clause()
         .predicates
         .push(syn::WherePredicate::Type(syn::PredicateType {
             lifetimes: None,
@@ -239,6 +208,7 @@ pub fn with_self_bound(
             // the bound e.g. Default
             bounds: vec![
                 syn::TypeParamBound::Trait(syn::TraitBound {
+                    paren_token: None,
                     modifier: syn::TraitBoundModifier::None,
                     lifetimes: None,
                     path: bound.clone(),
@@ -249,7 +219,7 @@ pub fn with_self_bound(
 }
 
 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
-    let bound = syn::Lifetime::new(Term::intern(lifetime), Span::def_site());
+    let bound = syn::Lifetime::new(lifetime, Span::call_site());
     let def = syn::LifetimeDef {
         attrs: Vec::new(),
         lifetime: bound,

serde_derive/src/de.rs

@@ -10,7 +10,7 @@ use syn::{self, Ident, Index, Member};
 use syn::punctuated::Punctuated;
 use syn::spanned::Spanned;
 use quote::{ToTokens, Tokens};
-use proc_macro2::{Literal, Span, Term};
+use proc_macro2::{Literal, Span};
 
 use bound;
 use fragment::{Expr, Fragment, Match, Stmts};
@@ -27,7 +27,7 @@ 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::def_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();
 
@@ -181,8 +181,8 @@ enum BorrowedLifetimes {
 impl BorrowedLifetimes {
     fn de_lifetime(&self) -> syn::Lifetime {
         match *self {
-            BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new(Term::intern("'de"), Span::def_site()),
-            BorrowedLifetimes::Static => syn::Lifetime::new(Term::intern("'static"), Span::def_site()),
+            BorrowedLifetimes::Borrowed(_) => syn::Lifetime::new("'de", Span::call_site()),
+            BorrowedLifetimes::Static => syn::Lifetime::new("'static", Span::call_site()),
         }
     }
 
@@ -190,7 +190,7 @@ impl BorrowedLifetimes {
         match *self {
             BorrowedLifetimes::Borrowed(ref bounds) => Some(syn::LifetimeDef {
                 attrs: Vec::new(),
-                lifetime: syn::Lifetime::new(Term::intern("'de"), Span::def_site()),
+                lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
                 bounds: bounds.iter().cloned().collect(),
             }),
@@ -549,7 +549,7 @@ fn deserialize_seq(
             let visit = match field.attrs.deserialize_with() {
                 None => {
                     let field_ty = &field.ty;
-                    let span = Span::def_site().located_at(field.original.span());
+                    let span = field.original.span();
                     let func = quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
                     quote!(try!(#func(&mut __seq)))
                 }
@@ -2193,7 +2193,7 @@ fn deserialize_map(
             let visit = match field.attrs.deserialize_with() {
                 None => {
                     let field_ty = &field.ty;
-                    let span = Span::def_site().located_at(field.original.span());
+                    let span = field.original.span();
                     let func = quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
                     quote! {
                         try!(#func(&mut __map))
@@ -2522,7 +2522,7 @@ fn deserialize_map_in_place(
 }
 
 fn field_i(i: usize) -> Ident {
-    Ident::new(&format!("__field{}", i), Span::def_site())
+    Ident::new(&format!("__field{}", i), Span::call_site())
 }
 
 /// This function wraps the expression in `#[serde(deserialize_with = "...")]`
@@ -2638,7 +2638,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
     let name = field.attrs.name().deserialize_name();
     match field.attrs.deserialize_with() {
         None => {
-            let span = Span::def_site().located_at(field.original.span());
+            let span = field.original.span();
             let func = quote_spanned!(span=> _serde::private::de::missing_field);
             quote_expr! {
                 try!(#func(#name))
@@ -2721,7 +2721,7 @@ impl<'a> ToTokens for DeTypeGenerics<'a> {
         if self.0.borrowed.de_lifetime_def().is_some() {
             let def = syn::LifetimeDef {
                 attrs: Vec::new(),
-                lifetime: syn::Lifetime::new(Term::intern("'de"), Span::def_site()),
+                lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
                 bounds: Punctuated::new(),
             };
@@ -2747,7 +2747,7 @@ impl<'a> ToTokens for InPlaceTypeGenerics<'a> {
         if self.0.borrowed.de_lifetime_def().is_some() {
             let def = syn::LifetimeDef {
                 attrs: Vec::new(),
-                lifetime: syn::Lifetime::new(Term::intern("'de"), Span::def_site()),
+                lifetime: syn::Lifetime::new("'de", Span::call_site()),
                 colon_token: None,
                 bounds: Punctuated::new(),
             };
@@ -2772,7 +2772,7 @@ impl<'a> DeTypeGenerics<'a> {
 fn place_lifetime() -> syn::LifetimeDef {
     syn::LifetimeDef {
         attrs: Vec::new(),
-        lifetime: syn::Lifetime::new(Term::intern("'place"), Span::def_site()),
+        lifetime: syn::Lifetime::new("'place", Span::call_site()),
         colon_token: None,
         bounds: Punctuated::new(),
     }

serde_derive/src/lib.rs

@@ -22,7 +22,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.35")]
+#![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))]
 // The `quote!` macro requires deep recursion.
@@ -41,6 +41,14 @@ extern crate proc_macro2;
 use proc_macro::TokenStream;
 use syn::DeriveInput;
 
+// Quote's default is def_site but it appears call_site is likely to stabilize
+// before def_site. Thus we try to use only call_site.
+macro_rules! quote {
+    ($($tt:tt)*) => {
+        quote_spanned!($crate::proc_macro2::Span::call_site()=> $($tt)*)
+    }
+}
+
 #[macro_use]
 mod bound;
 #[macro_use]

serde_derive/src/ser.rs

@@ -27,7 +27,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<Tokens, Strin
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
-    let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", ident), Span::def_site());
+    let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", ident), Span::call_site());
     let body = Stmts(serialize_body(&cont, &params));
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
@@ -98,9 +98,9 @@ impl Parameters {
     fn new(cont: &Container) -> Self {
         let is_remote = cont.attrs.remote().is_some();
         let self_var = if is_remote {
-            Ident::new("__self", Span::def_site())
+            Ident::new("__self", Span::call_site())
         } else {
-            Ident::new("self", Span::def_site())
+            Ident::new("self", Span::call_site())
         };
 
         let this = match cont.attrs.remote() {
@@ -212,7 +212,7 @@ fn serialize_newtype_struct(
         field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
     }
 
-    let span = Span::def_site().located_at(field.original.span());
+    let span = field.original.span();
     let func = quote_spanned!(span=> _serde::Serializer::serialize_newtype_struct);
     quote_expr! {
         #func(__serializer, #type_name, #field_expr)
@@ -386,7 +386,7 @@ fn serialize_variant(
             }
             Style::Tuple => {
                 let field_names =
-                    (0..variant.fields.len()).map(|i| Ident::new(&format!("__field{}", i), Span::def_site()));
+                    (0..variant.fields.len()).map(|i| Ident::new(&format!("__field{}", i), Span::call_site()));
                 quote! {
                     #this::#variant_ident(#(ref #field_names),*)
                 }
@@ -619,9 +619,9 @@ fn serialize_adjacently_tagged_variant(
                 unreachable!()
             }
         }
-        Style::Newtype => vec![Ident::new("__field0", Span::def_site())],
+        Style::Newtype => vec![Ident::new("__field0", Span::call_site())],
         Style::Tuple => (0..variant.fields.len())
-            .map(|i| Ident::new(&format!("__field{}", i), Span::def_site()))
+            .map(|i| Ident::new(&format!("__field{}", i), Span::call_site()))
             .collect(),
         Style::Struct => variant
             .fields
@@ -862,7 +862,7 @@ fn serialize_tuple_struct_visitor(
         .enumerate()
         .map(|(i, field)| {
             let mut field_expr = if is_enum {
-                let id = Ident::new(&format!("__field{}", i), Span::def_site());
+                let id = Ident::new(&format!("__field{}", i), Span::call_site());
                 quote!(#id)
             } else {
                 get_member(params, field, &Member::Unnamed(Index {
@@ -880,7 +880,7 @@ fn serialize_tuple_struct_visitor(
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
-            let span = Span::def_site().located_at(field.original.span());
+            let span = field.original.span();
             let func = tuple_trait.serialize_element(span);
             let ser = quote! {
                 try!(#func(&mut __serde_state, #field_expr));
@@ -923,7 +923,7 @@ fn serialize_struct_visitor(
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
-            let span = Span::def_site().located_at(field.original.span());
+            let span = field.original.span();
             let ser = if field.attrs.flatten() {
                 quote! {
                     try!(_serde::Serialize::serialize(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
@@ -981,7 +981,7 @@ fn wrap_serialize_variant_with(
         .map(|(i, field)| {
             let id = field
                 .ident
-                .unwrap_or_else(|| Ident::new(&format!("__field{}", i), Span::def_site()));
+                .unwrap_or_else(|| Ident::new(&format!("__field{}", i), Span::call_site()));
             quote!(#id)
         })
         .collect();

serde_derive_internals/Cargo.toml

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

serde_derive_internals/src/ast.rs

@@ -68,6 +68,9 @@ impl<'a> Container<'a> {
             Data::Enum(ref mut variants) => for variant in variants {
                 variant.attrs.rename_by_rule(attrs.rename_all());
                 for field in &mut variant.fields {
+                    if field.attrs.flatten() {
+                        has_flatten = true;
+                    }
                     field.attrs.rename_by_rule(variant.attrs.rename_all());
                 }
             },

serde_derive_internals/src/attr.rs

@@ -15,7 +15,7 @@ use syn::punctuated::Punctuated;
 use syn::synom::{Synom, ParseError};
 use std::collections::BTreeSet;
 use std::str::FromStr;
-use proc_macro2::{Span, TokenStream, TokenNode, TokenTree};
+use proc_macro2::{Span, TokenStream, TokenTree, Group};
 
 // This module handles parsing of `#[serde(...)]` attributes. The entrypoints
 // are `attr::Container::from_ast`, `attr::Variant::from_ast`, and
@@ -332,7 +332,11 @@ impl Container {
                     // Parse `#[serde(remote = "...")]`
                     Meta(NameValue(ref m)) if m.ident == "remote" => {
                         if let Ok(path) = parse_lit_into_path(cx, m.ident.as_ref(), &m.lit) {
-                            remote.set(path);
+                            if is_primitive_path(&path, "Self") {
+                                remote.set(item.ident.into());
+                            } else {
+                                remote.set(path);
+                            }
                         }
                     }
 
@@ -935,10 +939,10 @@ impl Field {
                     leading_colon: None,
                     segments: Punctuated::new(),
                 };
-                path.segments.push(Ident::new("_serde", Span::def_site()).into());
-                path.segments.push(Ident::new("private", Span::def_site()).into());
-                path.segments.push(Ident::new("de", Span::def_site()).into());
-                path.segments.push(Ident::new("borrow_cow_str", Span::def_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,
@@ -950,10 +954,10 @@ impl Field {
                     leading_colon: None,
                     segments: Punctuated::new(),
                 };
-                path.segments.push(Ident::new("_serde", Span::def_site()).into());
-                path.segments.push(Ident::new("private", Span::def_site()).into());
-                path.segments.push(Ident::new("de", Span::def_site()).into());
-                path.segments.push(Ident::new("borrow_cow_bytes", Span::def_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,
@@ -1156,7 +1160,7 @@ fn parse_lit_into_where(
         return Ok(Vec::new());
     }
 
-    let where_string = syn::LitStr::new(&format!("where {}", string.value()), string.span);
+    let where_string = syn::LitStr::new(&format!("where {}", string.value()), string.span());
 
     parse_lit_str::<syn::WhereClause>(&where_string)
         .map(|wh| wh.predicates.into_iter().collect())
@@ -1291,29 +1295,32 @@ fn is_rptr(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
 }
 
 fn is_str(ty: &syn::Type) -> bool {
-    is_primitive_path(ty, "str")
+    is_primitive_type(ty, "str")
 }
 
 fn is_slice_u8(ty: &syn::Type) -> bool {
     match *ty {
-        syn::Type::Slice(ref ty) => is_primitive_path(&ty.elem, "u8"),
+        syn::Type::Slice(ref ty) => is_primitive_type(&ty.elem, "u8"),
         _ => false,
     }
 }
 
-fn is_primitive_path(ty: &syn::Type, primitive: &str) -> bool {
+fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
     match *ty {
         syn::Type::Path(ref ty) => {
-            ty.qself.is_none()
-                && ty.path.leading_colon.is_none()
-                && ty.path.segments.len() == 1
-                && ty.path.segments[0].ident == primitive
-                && ty.path.segments[0].arguments.is_empty()
+            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.segments[0].arguments.is_empty()
+}
+
 // All lifetimes that this type could borrow from a Deserializer.
 //
 // For example a type `S<'a, 'b>` could borrow `'a` and `'b`. On the other hand
@@ -1403,21 +1410,17 @@ where
 
 fn spanned_tokens(s: &syn::LitStr) -> Result<TokenStream, ParseError> {
     let stream = try!(syn::parse_str(&s.value()));
-    Ok(respan_token_stream(stream, s.span))
+    Ok(respan_token_stream(stream, s.span()))
 }
 
 fn respan_token_stream(stream: TokenStream, span: Span) -> TokenStream {
     stream.into_iter().map(|token| respan_token_tree(token, span)).collect()
 }
 
-fn respan_token_tree(token: TokenTree, span: Span) -> TokenTree {
-    TokenTree {
-        span: span,
-        kind: match token.kind {
-            TokenNode::Group(delimiter, nested) => {
-                TokenNode::Group(delimiter, respan_token_stream(nested, span))
-            }
-            other => other,
-        },
+fn respan_token_tree(mut token: TokenTree, span: Span) -> TokenTree {
+    if let TokenTree::Group(ref mut g) = token {
+        *g = Group::new(g.delimiter(), respan_token_stream(g.stream().clone(), span));
     }
+    token.set_span(span);
+    token
 }

serde_derive_internals/src/check.rs

@@ -45,13 +45,24 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
 fn check_flatten(cx: &Ctxt, cont: &Container) {
     match cont.data {
         Data::Enum(_) => {
-            assert!(!cont.attrs.has_flatten());
+            if cont.attrs.has_flatten() {
+                cx.error("#[serde(flatten)] cannot be used within enums");
+            }
         }
-        Data::Struct(_, _) => {
+        Data::Struct(style, _) => {
             for field in cont.data.all_fields() {
                 if !field.attrs.flatten() {
                     continue;
                 }
+                match style {
+                    Style::Tuple => {
+                        cx.error("#[serde(flatten)] cannot be used on tuple structs");
+                    }
+                    Style::Newtype => {
+                        cx.error("#[serde(flatten)] cannot be used on newtype structs");
+                    }
+                    _ => {}
+                }
                 if field.attrs.skip_serializing() {
                     cx.error(
                         "#[serde(flatten] can not be combined with \

serde_derive_internals/src/lib.rs

@@ -6,7 +6,7 @@
 // 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.22.1")]
+#![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))]
 

serde_test/Cargo.toml

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

@@ -155,7 +155,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.35")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.37")]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]

test_suite/Cargo.toml

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

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

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

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

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

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

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

test_suite/tests/test_gen.rs

@@ -385,6 +385,10 @@ fn test_gen() {
         s: vis::S,
     }
 
+    #[derive(Serialize, Deserialize)]
+    #[serde(remote = "Self")]
+    struct RemoteSelf;
+
     #[derive(Serialize, Deserialize)]
     enum ExternallyTaggedVariantWith {
         #[allow(dead_code)]