Release 1.0.67

Implement Serialize for core::fmt::Arguments

.travis.yml

@@ -4,11 +4,15 @@ cache: cargo
 
 # run builds for all the trains (and more)
 rust:
-  - 1.13.0
-  - 1.15.0
   - stable
   - beta
   - nightly
+  - 1.13.0
+  - 1.15.0
+  - 1.20.0
+  - 1.21.0
+  - 1.25.0
+  - 1.26.0
 
 matrix:
   include:

README.md

@@ -25,7 +25,7 @@ You may be looking for:
 <details>
 <summary>
 Click to show Cargo.toml.
-<a href="http://play.integer32.com/?gist=9003c5b88c1f4989941925d7190c6eec" target="_blank">Run this code in the playground.</a>
+<a href="https://play.rust-lang.org/?gist=9003c5b88c1f4989941925d7190c6eec" target="_blank">Run this code in the playground.</a>
 </summary>
 
 ```toml

crates-io.md

@@ -0,0 +1,55 @@
+<!-- Serde readme rendered on crates.io -->
+
+**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
+
+---
+
+You may be looking for:
+
+- [An overview of Serde](https://serde.rs/)
+- [Data formats supported by Serde](https://serde.rs/#data-formats)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Examples](https://serde.rs/examples.html)
+- [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)
+
+## Serde in action
+
+```rust
+#[macro_use]
+extern crate serde_derive;
+
+extern crate serde;
+extern crate serde_json;
+
+#[derive(Serialize, Deserialize, Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+
+    // Convert the Point to a JSON string.
+    let serialized = serde_json::to_string(&point).unwrap();
+
+    // Prints serialized = {"x":1,"y":2}
+    println!("serialized = {}", serialized);
+
+    // Convert the JSON string back to a Point.
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    // Prints deserialized = Point { x: 1, y: 2 }
+    println!("deserialized = {:?}", deserialized);
+}
+```
+
+## Getting help
+
+Serde developers live in the #serde channel on
+[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
+good resource with generally faster response time but less specific knowledge
+about Serde. If IRC is not your thing or you don't get a good response, we are
+happy to respond to [GitHub issues](https://github.com/serde-rs/serde/issues/new)
+as well.

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.60" # remember to update html_root_url
+version = "1.0.67" # 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"
@@ -9,8 +9,8 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde/"
 keywords = ["serde", "serialization", "no_std"]
 categories = ["encoding"]
-readme = "README.md"
+readme = "crates-io.md"
-include = ["Cargo.toml", "build.rs", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["Cargo.toml", "build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"
 
 [badges]
@@ -29,14 +29,30 @@ serde_derive = { version = "1.0", path = "../serde_derive" }
 [features]
 default = ["std"]
 
-# Re-export the derive(Serialize, Deserialize) macros. This is specifically
+# Re-export the derive(Serialize, Deserialize) macros. This is intended for
-# intended for library crates that provide optional Serde impls behind a Cargo
+# library crates that provide optional Serde impls behind a Cargo cfg of their
-# cfg of their own. All other crates should depend on serde_derive directly.
+# own.
+#
+# Mainly this is a workaround for limitations associated with
+# rust-lang/cargo#1286 in which a library crate cannot use one "serde" cfg in
+# Cargo to enable dependencies on both serde and serde_derive crates.
+#
+# The recommended way to provide optional Serde support that requires derive is
+# as follows. In particular, please do not name your library's Serde feature
+# anything other than "serde".
+#
+#     [dependencies]
+#     serde = { version = "1.0", optional = true, features = ["derive"] }
+#
+# Within the library, these optional Serde derives would be written like this.
+#
+#     #[cfg(feature = "serde")]
+#     #[macro_use]
+#     extern crate serde;
+#
+#     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#     struct ...
 #
-# Please refer to the long comment above the line `pub use serde_derive::*` in
-# src/lib.rs before enabling this feature. If you think you need this feature
-# and your use case does not precisely match the one described in the comment,
-# please open an issue to let us know about your use case.
 derive = ["serde_derive"]
 
 # Provide impls for common standard library types like Vec<T> and HashMap<K, V>.

serde/build.rs

@@ -2,36 +2,33 @@ use std::env;
 use std::process::Command;
 use std::str::{self, FromStr};
 
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
 fn main() {
-    let rustc = match env::var_os("RUSTC") {
+    let minor = match rustc_minor_version() {
-        Some(rustc) => rustc,
+        Some(minor) => minor,
         None => return,
     };
 
-    let output = match Command::new(rustc).arg("--version").output() {
+    // CString::into_boxed_c_str stabilized in Rust 1.20:
-        Ok(output) => output,
+    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
-        Err(_) => return,
+    if minor >= 20 {
-    };
+        println!("cargo:rustc-cfg=de_boxed_c_str");
-
-    let version = match str::from_utf8(&output.stdout) {
-        Ok(version) => version,
-        Err(_) => return,
-    };
-
-    let mut pieces = version.split('.');
-    if pieces.next() != Some("rustc 1") {
-        return;
     }
 
-    let next = match pieces.next() {
+    // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
-        Some(next) => next,
+    // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
-        None => return,
+    // https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-From<Box<T>>
-    };
+    if minor >= 21 {
+        println!("cargo:rustc-cfg=de_rc_dst");
+    }
 
-    let minor = match u32::from_str(next) {
+    // Duration available in core since Rust 1.25:
-        Ok(minor) => minor,
+    // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
-        Err(_) => return,
+    if minor >= 25 {
-    };
+        println!("cargo:rustc-cfg=core_duration");
+    }
 
     // 128-bit integers stabilized in Rust 1.26:
     // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
@@ -45,3 +42,37 @@ fn main() {
         println!("cargo:rustc-cfg=num_nonzero");
     }
 }
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
+    // Temporary workaround to support the old 1.26-dev compiler on docs.rs.
+    if version.contains("0eb87c9bf") {
+        return Some(25);
+    }
+
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
+}

serde/crates-io.md

@@ -0,0 +1 @@
+../crates-io.md

serde/src/de/impls.rs

@@ -12,7 +12,7 @@ use de::{
     Deserialize, Deserializer, EnumAccess, Error, SeqAccess, Unexpected, VariantAccess, Visitor,
 };
 
-#[cfg(any(feature = "std", feature = "alloc"))]
+#[cfg(any(core_duration, feature = "std", feature = "alloc"))]
 use de::MapAccess;
 
 use de::from_primitive::FromPrimitive;
@@ -49,6 +49,16 @@ impl<'de> Deserialize<'de> for () {
     }
 }
 
+#[cfg(feature = "unstable")]
+impl<'de> Deserialize<'de> for ! {
+    fn deserialize<D>(_deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        Err(Error::custom("cannot deserialize `!`"))
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 struct BoolVisitor;
@@ -573,7 +583,7 @@ macro_rules! forwarded_impl {
     }
 }
 
-#[cfg(all(feature = "std", feature = "unstable"))]
+#[cfg(all(feature = "std", de_boxed_c_str))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1172,15 +1182,31 @@ map_impl!(
 
 #[cfg(feature = "std")]
 macro_rules! parse_ip_impl {
-    ($ty:ty; $size:expr) => {
+    ($expecting:tt $ty:ty; $size:tt) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
                 D: Deserializer<'de>,
             {
                 if deserializer.is_human_readable() {
-                    let s = try!(String::deserialize(deserializer));
+                    struct IpAddrVisitor;
-                    s.parse().map_err(Error::custom)
+
+                    impl<'de> Visitor<'de> for IpAddrVisitor {
+                        type Value = $ty;
+
+                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                            formatter.write_str($expecting)
+                        }
+
+                        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                        where
+                            E: Error,
+                        {
+                            s.parse().map_err(Error::custom)
+                        }
+                    }
+
+                    deserializer.deserialize_str(IpAddrVisitor)
                 } else {
                     <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
                 }
@@ -1308,8 +1334,24 @@ impl<'de> Deserialize<'de> for net::IpAddr {
         D: Deserializer<'de>,
     {
         if deserializer.is_human_readable() {
-            let s = try!(String::deserialize(deserializer));
+            struct IpAddrVisitor;
-            s.parse().map_err(Error::custom)
+
+            impl<'de> Visitor<'de> for IpAddrVisitor {
+                type Value = net::IpAddr;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("IP address")
+                }
+
+                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    s.parse().map_err(Error::custom)
+                }
+            }
+
+            deserializer.deserialize_str(IpAddrVisitor)
         } else {
             use lib::net::IpAddr;
             deserialize_enum!{
@@ -1322,22 +1364,38 @@ impl<'de> Deserialize<'de> for net::IpAddr {
 }
 
 #[cfg(feature = "std")]
-parse_ip_impl!(net::Ipv4Addr; 4);
+parse_ip_impl!("IPv4 address" net::Ipv4Addr; 4);
 
 #[cfg(feature = "std")]
-parse_ip_impl!(net::Ipv6Addr; 16);
+parse_ip_impl!("IPv6 address" net::Ipv6Addr; 16);
 
 #[cfg(feature = "std")]
 macro_rules! parse_socket_impl {
-    ($ty:ty, $new:expr) => {
+    ($expecting:tt $ty:ty, $new:expr) => {
         impl<'de> Deserialize<'de> for $ty {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
                 D: Deserializer<'de>,
             {
                 if deserializer.is_human_readable() {
-                    let s = try!(String::deserialize(deserializer));
+                    struct SocketAddrVisitor;
-                    s.parse().map_err(Error::custom)
+
+                    impl<'de> Visitor<'de> for SocketAddrVisitor {
+                        type Value = $ty;
+
+                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                            formatter.write_str($expecting)
+                        }
+
+                        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                        where
+                            E: Error,
+                        {
+                            s.parse().map_err(Error::custom)
+                        }
+                    }
+
+                    deserializer.deserialize_str(SocketAddrVisitor)
                 } else {
                     <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
                 }
@@ -1353,8 +1411,24 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
         D: Deserializer<'de>,
     {
         if deserializer.is_human_readable() {
-            let s = try!(String::deserialize(deserializer));
+            struct SocketAddrVisitor;
-            s.parse().map_err(Error::custom)
+
+            impl<'de> Visitor<'de> for SocketAddrVisitor {
+                type Value = net::SocketAddr;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("socket address")
+                }
+
+                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    s.parse().map_err(Error::custom)
+                }
+            }
+
+            deserializer.deserialize_str(SocketAddrVisitor)
         } else {
             use lib::net::SocketAddr;
             deserialize_enum!{
@@ -1367,10 +1441,10 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
 }
 
 #[cfg(feature = "std")]
-parse_socket_impl!(net::SocketAddrV4, net::SocketAddrV4::new);
+parse_socket_impl!("IPv4 socket address" net::SocketAddrV4, net::SocketAddrV4::new);
 
 #[cfg(feature = "std")]
-parse_socket_impl!(net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
+parse_socket_impl!("IPv6 socket address" net::SocketAddrV6, |ip, port| net::SocketAddrV6::new(
     ip, port, 0, 0
 ));
 
@@ -1528,7 +1602,7 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 #[cfg(any(feature = "std", feature = "alloc"))]
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
-#[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(not(de_rc_dst), feature = "rc", any(feature = "std", feature = "alloc")))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1540,7 +1614,7 @@ forwarded_impl! {
     (T), Arc<T>, Arc::new
 }
 
-#[cfg(all(not(feature = "unstable"), feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(not(de_rc_dst), feature = "rc", any(feature = "std", feature = "alloc")))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1607,7 +1681,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
 macro_rules! box_forwarded_impl {
     (
         $(#[doc = $doc:tt])*
@@ -1628,7 +1702,7 @@ macro_rules! box_forwarded_impl {
     };
 }
 
-#[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
 box_forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1640,7 +1714,7 @@ box_forwarded_impl! {
     Rc
 }
 
-#[cfg(all(feature = "unstable", feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(de_rc_dst, feature = "rc", any(feature = "std", feature = "alloc")))]
 box_forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1684,7 +1758,7 @@ forwarded_impl!((T), RwLock<T>, RwLock::new);
 //         secs: u64,
 //         nanos: u32,
 //     }
-#[cfg(feature = "std")]
+#[cfg(any(core_duration, feature = "std"))]
 impl<'de> Deserialize<'de> for Duration {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
@@ -1732,7 +1806,7 @@ impl<'de> Deserialize<'de> for Duration {
                             b"secs" => Ok(Field::Secs),
                             b"nanos" => Ok(Field::Nanos),
                             _ => {
-                                let value = String::from_utf8_lossy(value);
+                                let value = ::export::from_utf8_lossy(value);
                                 Err(Error::unknown_field(&value, FIELDS))
                             }
                         }

serde/src/de/mod.rs

@@ -57,7 +57,7 @@
 //!    - f32, f64
 //!    - char
 //!  - **Compound types**:
-//!    - [T; 0] through [T; 32]
+//!    - \[T; 0\] through \[T; 32\]
 //!    - tuples up to size 16
 //!  - **Common standard library types**:
 //!    - String
@@ -66,7 +66,7 @@
 //!    - PhantomData\<T\>
 //!  - **Wrapper types**:
 //!    - Box\<T\>
-//!    - Box\<[T]\>
+//!    - Box\<\[T\]\>
 //!    - Box\<str\>
 //!    - Rc\<T\>
 //!    - Arc\<T\>
@@ -86,7 +86,7 @@
 //!    - Vec\<T\>
 //!  - **Zero-copy types**:
 //!    - &str
-//!    - &[u8]
+//!    - &\[u8\]
 //!  - **FFI types**:
 //!    - CString
 //!    - Box\<CStr\>
@@ -97,7 +97,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - num::NonZero* (unstable)
+//!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -148,6 +149,13 @@ macro_rules! declare_error_trait {
         ///
         /// Most deserializers should only need to provide the `Error::custom` method
         /// and inherit the default behavior for the other methods.
+        ///
+        /// # Example implementation
+        ///
+        /// The [example data format] presented on the website shows an error
+        /// type appropriate for a basic JSON data format.
+        ///
+        /// [example data format]: https://serde.rs/data-format.html
         pub trait Error: Sized $(+ $($supertrait)::+)* {
             /// Raised when there is general error when deserializing a type.
             ///
@@ -504,6 +512,14 @@ impl<'a> Display for Expected + 'a {
 /// [de]: https://docs.serde.rs/serde/de/index.html
 /// [codegen]: https://serde.rs/codegen.html
 /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by `Self` when deserialized. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
 pub trait Deserialize<'de>: Sized {
     /// Deserialize this value from the given Serde deserializer.
     ///
@@ -568,12 +584,16 @@ pub trait Deserialize<'de>: Sized {
 ///     T: DeserializeOwned;
 /// # }
 /// ```
+///
+/// # Lifetime
+///
+/// The relationship between `Deserialize` and `DeserializeOwned` in trait
+/// bounds is explained in more detail on the page [Understanding deserializer
+/// lifetimes].
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
 pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
-impl<T> DeserializeOwned for T
+impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
-where
-    T: for<'de> Deserialize<'de>,
-{
-}
 
 /// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
 /// ever find yourself looking for a way to pass data into a `Deserialize` impl,
@@ -618,6 +638,14 @@ where
 /// seed can be appeased by passing `std::marker::PhantomData` as a seed in the
 /// case of stateless deserialization.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by `Self::Value` when deserialized. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
 /// # Example
 ///
 /// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need
@@ -756,10 +784,10 @@ where
 /// A **data format** that can deserialize any data structure supported by
 /// Serde.
 ///
-/// The role of this trait is to define the deserialization half of the Serde
+/// The role of this trait is to define the deserialization half of the [Serde
-/// data model, which is a way to categorize every Rust data type into one of 29
+/// data model], which is a way to categorize every Rust data type into one of
-/// possible types. Each method of the `Serializer` trait corresponds to one of
+/// 29 possible types. Each method of the `Serializer` trait corresponds to one
-/// the types of the data model.
+/// of the types of the data model.
 ///
 /// Implementations of `Deserialize` map themselves into this data model by
 /// passing to the `Deserializer` a `Visitor` implementation that can receive
@@ -777,7 +805,7 @@ where
 ///    - UTF-8 bytes with a length and no null terminator.
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - [u8]
+///  - **byte array** - \[u8\]
 ///    - Similar to strings, during deserialization byte arrays can be transient,
 ///      owned, or borrowed.
 ///  - **option**
@@ -841,6 +869,23 @@ where
 /// what type is in the input. Know that relying on `Deserializer::deserialize_any`
 /// means your data type will be able to deserialize from self-describing
 /// formats only, ruling out Bincode and many others.
+///
+/// [Serde data model]: https://serde.rs/data-model.html
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed from the input when deserializing. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website contains example code for
+/// a basic JSON `Deserializer`.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait Deserializer<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1164,6 +1209,16 @@ pub trait Deserializer<'de>: Sized {
 
 /// This trait represents a visitor that walks through a deserializer.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the requirement for lifetime of data
+/// that may be borrowed by `Self::Value`. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example
+///
 /// ```rust
 /// # use std::fmt;
 /// #
@@ -1600,6 +1655,21 @@ pub trait Visitor<'de>: Sized {
 ///
 /// This is a trait that a `Deserializer` passes to a `Visitor` implementation,
 /// which deserializes each item in a sequence.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by deserialized sequence elements. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SeqAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SeqAccess<'de> {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1667,6 +1737,21 @@ where
 /// Provides a `Visitor` access to each entry of a map in the input.
 ///
 /// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by deserialized map entries. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `MapAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait MapAccess<'de> {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1844,6 +1929,21 @@ where
 ///
 /// `EnumAccess` is created by the `Deserializer` and passed to the
 /// `Visitor` in order to identify which variant of an enum to deserialize.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by the deserialized enum variant. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `EnumAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait EnumAccess<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1876,6 +1976,21 @@ pub trait EnumAccess<'de>: Sized {
 /// `VariantAccess` is a visitor that is created by the `Deserializer` and
 /// passed to the `Deserialize` to deserialize the content of a particular enum
 /// variant.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by the deserialized enum variant. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `VariantAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait VariantAccess<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization. Must match the error type of our `EnumAccess`.
@@ -2079,6 +2194,16 @@ pub trait VariantAccess<'de>: Sized {
 /// Converts an existing value into a `Deserializer` from which other values can
 /// be deserialized.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed from the resulting `Deserializer`. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example
+///
 /// ```rust
 /// #[macro_use]
 /// extern crate serde_derive;

serde/src/de/value.rs

@@ -44,6 +44,22 @@ use ser;
 
 ////////////////////////////////////////////////////////////////////////////////
 
+// For structs that contain a PhantomData. We do not want the trait
+// bound `E: Clone` inferred by derive(Clone).
+macro_rules! impl_copy_clone {
+    ($ty:ident $(<$lifetime:tt>)*) => {
+        impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
+
+        impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
+            fn clone(&self) -> Self {
+                *self
+            }
+        }
+    };
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 /// A minimal representation of all possible errors that can occur using the
 /// `IntoDeserializer` trait.
 #[derive(Clone, Debug, PartialEq)]
@@ -124,11 +140,13 @@ where
 }
 
 /// A deserializer holding a `()`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct UnitDeserializer<E> {
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(UnitDeserializer);
+
 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
 where
     E: de::Error,
@@ -158,16 +176,60 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer that cannot be instantiated.
+#[cfg(feature = "unstable")]
+pub struct NeverDeserializer<E> {
+    never: !,
+    marker: PhantomData<E>,
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> IntoDeserializer<'de, E> for !
+where
+    E: de::Error,
+{
+    type Deserializer = NeverDeserializer<E>;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        self
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.never
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 macro_rules! primitive_deserializer {
     ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
         #[doc = "A deserializer holding"]
         #[doc = $doc]
-        #[derive(Clone, Debug)]
+        #[derive(Debug)]
         pub struct $name<E> {
             value: $ty,
             marker: PhantomData<E>
         }
 
+        impl_copy_clone!($name);
+
         impl<'de, E> IntoDeserializer<'de, E> for $ty
         where
             E: de::Error,
@@ -218,13 +280,20 @@ primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
 
+serde_if_integer128! {
+    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
+    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
+}
+
 /// A deserializer holding a `u32`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct U32Deserializer<E> {
     value: u32,
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(U32Deserializer);
+
 impl<'de, E> IntoDeserializer<'de, E> for u32
 where
     E: de::Error,
@@ -291,12 +360,14 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `&str`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct StrDeserializer<'a, E> {
     value: &'a str,
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(StrDeserializer<'de>);
+
 impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
 where
     E: de::Error,
@@ -364,12 +435,14 @@ where
 
 /// A deserializer holding a `&str` with a lifetime tied to another
 /// deserializer.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct BorrowedStrDeserializer<'de, E> {
     value: &'de str,
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(BorrowedStrDeserializer<'de>);
+
 impl<'de, E> BorrowedStrDeserializer<'de, E> {
     /// Create a new borrowed deserializer from the given string.
     pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
@@ -433,12 +506,22 @@ where
 
 /// A deserializer holding a `String`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct StringDeserializer<E> {
     value: String,
     marker: PhantomData<E>,
 }
 
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> Clone for StringDeserializer<E> {
+    fn clone(&self) -> Self {
+        StringDeserializer {
+            value: self.value.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, E> IntoDeserializer<'de, E> for String
 where
@@ -509,12 +592,22 @@ where
 
 /// A deserializer holding a `Cow<str>`.
 #[cfg(any(feature = "std", feature = "alloc"))]
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct CowStrDeserializer<'a, E> {
     value: Cow<'a, str>,
     marker: PhantomData<E>,
 }
 
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> Clone for CowStrDeserializer<'a, E> {
+    fn clone(&self) -> Self {
+        CowStrDeserializer {
+            value: self.value.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
 where
@@ -588,12 +681,14 @@ where
 
 /// A deserializer holding a `&[u8]` with a lifetime tied to another
 /// deserializer.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct BorrowedBytesDeserializer<'de, E> {
     value: &'de [u8],
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
 impl<'de, E> BorrowedBytesDeserializer<'de, E> {
     /// Create a new borrowed deserializer from the given byte slice.
     pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {

serde/src/lib.rs

@@ -52,6 +52,8 @@
 //! - [Pickle], a format common in the Python world.
 //! - [Hjson], a variant of JSON designed to be readable and writable by humans.
 //! - [BSON], the data storage and network transfer format used by MongoDB.
+//! - [Avro], a binary format used within Apache Hadoop, with support for schema
+//!   definition.
 //! - [URL], the x-www-form-urlencoded format.
 //! - [XML], the flexible machine-friendly W3C standard.
 //!   *(deserialization only)*
@@ -69,6 +71,7 @@
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [Hjson]: https://github.com/laktak/hjson-rust
 //! [BSON]: https://github.com/zonyitoo/bson-rs
+//! [Avro]: https://github.com/flavray/avro-rs
 //! [URL]: https://github.com/nox/serde_urlencoded
 //! [XML]: https://github.com/RReverser/serde-xml-rs
 //! [Envy]: https://github.com/softprops/envy
@@ -79,14 +82,14 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.60")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.67")]
 // 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
 // discussion of these features please refer to this issue:
 //
 //    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(specialization))]
+#![cfg_attr(feature = "unstable", feature(specialization, never_type))]
 #![cfg_attr(feature = "alloc", feature(alloc))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
@@ -115,6 +118,7 @@
     stutter,
     use_self,
 // not practical
+    indexing_slicing,
     many_single_char_names,
     missing_docs_in_private_items,
     similar_names,
@@ -123,16 +127,16 @@
     use_debug,
 ))]
 // Blacklisted Rust lints.
-#![deny(missing_docs, unused_imports)]
+//
+// Compiler bug involving unused_imports:
+// https://github.com/rust-lang/rust/issues/51661
+#![deny(missing_docs, /*unused_imports*/)]
 
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
-#[cfg(all(feature = "unstable", feature = "std"))]
-extern crate core;
-
 /// A facade around all the types we need from the `std`, `core`, and `alloc`
 /// crates. This avoids elaborate import wrangling having to happen in every
 /// module.
@@ -211,7 +215,10 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::sync::{Mutex, RwLock};
     #[cfg(feature = "std")]
-    pub use std::time::{Duration, SystemTime, UNIX_EPOCH};
+    pub use std::time::{SystemTime, UNIX_EPOCH};
+
+    #[cfg(any(core_duration, feature = "std"))]
+    pub use self::core::time::Duration;
 }
 
 ////////////////////////////////////////////////////////////////////////////////

serde/src/private/de.rs

@@ -2723,7 +2723,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_map(FlatMapAccess::new(self.0.iter_mut(), None))
+        visitor.visit_map(FlatMapAccess::new(self.0.iter()))
     }
 
     fn deserialize_struct<V>(
@@ -2735,7 +2735,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_map(FlatMapAccess::new(self.0.iter_mut(), Some(fields)))
+        visitor.visit_map(FlatStructAccess::new(self.0.iter_mut(), fields))
     }
 
     fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
@@ -2784,22 +2784,19 @@ where
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 pub struct FlatMapAccess<'a, 'de: 'a, E> {
-    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+    iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
-    pending_content: Option<Content<'de>>,
+    pending_content: Option<&'a Content<'de>>,
-    fields: Option<&'static [&'static str]>,
     _marker: PhantomData<E>,
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
     fn new(
-        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+        iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
-        fields: Option<&'static [&'static str]>,
     ) -> FlatMapAccess<'a, 'de, E> {
         FlatMapAccess {
             iter: iter,
             pending_content: None,
-            fields: fields,
             _marker: PhantomData,
         }
     }
@@ -2812,6 +2809,61 @@ where
 {
     type Error = E;
 
+    fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        while let Some(item) = self.iter.next() {
+            // Items in the vector are nulled out when used by a struct.
+            if let Some((ref key, ref content)) = *item {
+                self.pending_content = Some(content);
+                return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
+            }
+        }
+        Ok(None)
+    }
+
+    fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        match self.pending_content.take() {
+            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
+            None => Err(Error::custom("value is missing")),
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatStructAccess<'a, 'de: 'a, E> {
+    iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+    pending_content: Option<Content<'de>>,
+    fields: &'static [&'static str],
+    _marker: PhantomData<E>,
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, 'de, E> FlatStructAccess<'a, 'de, E> {
+    fn new(
+        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
+        fields: &'static [&'static str],
+    ) -> FlatStructAccess<'a, 'de, E> {
+        FlatStructAccess {
+            iter: iter,
+            pending_content: None,
+            fields: fields,
+            _marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, 'de, E> MapAccess<'de> for FlatStructAccess<'a, 'de, E>
+where
+    E: Error,
+{
+    type Error = E;
+
     fn next_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
     where
         T: DeserializeSeed<'de>,
@@ -2822,13 +2874,7 @@ where
             // about.  In case we do not know which fields we want, we take them all.
             let use_item = match *item {
                 None => false,
-                Some((ref c, _)) => c.as_str().map_or(self.fields.is_none(), |key| {
+                Some((ref c, _)) => c.as_str().map_or(false, |key| self.fields.contains(&key)),
-                    match self.fields {
-                        None => true,
-                        Some(fields) if fields.contains(&key) => true,
-                        _ => false,
-                    }
-                }),
             };
 
             if use_item {

serde/src/ser/impls.rs

@@ -8,10 +8,7 @@
 
 use lib::*;
 
-use ser::{Serialize, SerializeTuple, Serializer};
+use ser::{Error, Serialize, SerializeTuple, Serializer};
-
-#[cfg(feature = "std")]
-use ser::Error;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -72,6 +69,15 @@ impl Serialize for String {
     }
 }
 
+impl<'a> Serialize for fmt::Arguments<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_str(self)
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "std")]
@@ -250,6 +256,16 @@ impl Serialize for () {
     }
 }
 
+#[cfg(feature = "unstable")]
+impl Serialize for ! {
+    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        *self
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! tuple_impls {
@@ -459,7 +475,10 @@ where
     where
         S: Serializer,
     {
-        self.borrow().serialize(serializer)
+        match self.try_borrow() {
+            Ok(value) => value.serialize(serializer),
+            Err(_) => Err(S::Error::custom("already mutably borrowed")),
+        }
     }
 }
 
@@ -517,7 +536,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(core_duration, feature = "std"))]
 impl Serialize for Duration {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where

serde/src/ser/mod.rs

@@ -55,8 +55,8 @@
 //!    - str
 //!    - &T and &mut T
 //!  - **Compound types**:
-//!    - [T]
+//!    - \[T\]
-//!    - [T; 0] through [T; 32]
+//!    - \[T; 0\] through \[T; 32\]
 //!    - tuples up to size 16
 //!  - **Common standard library types**:
 //!    - String
@@ -92,7 +92,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - num::NonZero* (unstable)
+//!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -127,6 +128,13 @@ macro_rules! declare_error_trait {
         /// Trait used by `Serialize` implementations to generically construct
         /// errors belonging to the `Serializer` against which they are
         /// currently running.
+        ///
+        /// # Example implementation
+        ///
+        /// The [example data format] presented on the website shows an error
+        /// type appropriate for a basic JSON data format.
+        ///
+        /// [example data format]: https://serde.rs/data-format.html
         pub trait Error: Sized $(+ $($supertrait)::+)* {
             /// Used when a [`Serialize`] implementation encounters any error
             /// while serializing a type.
@@ -244,10 +252,10 @@ pub trait Serialize {
 
 /// A **data format** that can serialize any data structure supported by Serde.
 ///
-/// The role of this trait is to define the serialization half of the Serde data
+/// The role of this trait is to define the serialization half of the [Serde
-/// model, which is a way to categorize every Rust data structure into one of 29
+/// data model], which is a way to categorize every Rust data structure into one
-/// possible types. Each method of the `Serializer` trait corresponds to one of
+/// of 29 possible types. Each method of the `Serializer` trait corresponds to
-/// the types of the data model.
+/// one of the types of the data model.
 ///
 /// Implementations of `Serialize` map themselves into this data model by
 /// invoking exactly one of the `Serializer` methods.
@@ -264,7 +272,7 @@ pub trait Serialize {
 ///    - UTF-8 bytes with a length and no null terminator.
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - [u8]
+///  - **byte array** - \[u8\]
 ///    - Similar to strings, during deserialization byte arrays can be transient,
 ///      owned, or borrowed.
 ///  - **option**
@@ -309,6 +317,15 @@ pub trait Serialize {
 /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
 /// serializer) that produces a `serde_json::Value` data structure in memory as
 /// output.
+///
+/// [Serde data model]: https://serde.rs/data-model.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website contains example code for
+/// a basic JSON `Serializer`.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait Serializer: Sized {
     /// The output type produced by this `Serializer` during successful
     /// serialization. Most serializers that produce text or binary output
@@ -1520,6 +1537,8 @@ pub trait Serializer: Sized {
 
 /// Returned from `Serializer::serialize_seq`.
 ///
+/// # Example use
+///
 /// ```rust
 /// # use std::marker::PhantomData;
 /// #
@@ -1557,6 +1576,13 @@ pub trait Serializer: Sized {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeSeq` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeSeq {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1575,6 +1601,8 @@ pub trait SerializeSeq {
 
 /// Returned from `Serializer::serialize_tuple`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTuple};
 ///
@@ -1648,6 +1676,13 @@ pub trait SerializeSeq {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTuple` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTuple {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1666,6 +1701,8 @@ pub trait SerializeTuple {
 
 /// Returned from `Serializer::serialize_tuple_struct`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTupleStruct};
 ///
@@ -1684,6 +1721,13 @@ pub trait SerializeTuple {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTupleStruct` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTupleStruct {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1702,6 +1746,8 @@ pub trait SerializeTupleStruct {
 
 /// Returned from `Serializer::serialize_tuple_variant`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTupleVariant};
 ///
@@ -1733,6 +1779,13 @@ pub trait SerializeTupleStruct {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTupleVariant` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTupleVariant {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1751,6 +1804,8 @@ pub trait SerializeTupleVariant {
 
 /// Returned from `Serializer::serialize_map`.
 ///
+/// # Example use
+///
 /// ```rust
 /// # use std::marker::PhantomData;
 /// #
@@ -1790,6 +1845,13 @@ pub trait SerializeTupleVariant {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeMap` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeMap {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1853,6 +1915,8 @@ pub trait SerializeMap {
 
 /// Returned from `Serializer::serialize_struct`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeStruct};
 ///
@@ -1875,6 +1939,13 @@ pub trait SerializeMap {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeStruct` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeStruct {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1904,6 +1975,8 @@ pub trait SerializeStruct {
 
 /// Returned from `Serializer::serialize_struct_variant`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeStructVariant};
 ///
@@ -1928,6 +2001,13 @@ pub trait SerializeStruct {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeStructVariant` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeStructVariant {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.60" # remember to update html_root_url
+version = "1.0.67" # 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)]"
@@ -8,8 +8,8 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/codegen.html"
 keywords = ["serde", "serialization", "no_std"]
-readme = "README.md"
+readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }

serde_derive/crates-io.md

@@ -0,0 +1 @@
+../crates-io.md

serde_derive/src/bound.rs

@@ -200,7 +200,7 @@ pub fn with_bound(
                 lifetimes: None,
                 // the type parameter that is being bounded e.g. T
                 bounded_ty: syn::Type::Path(bounded_ty),
-                colon_token: Default::default(),
+                colon_token: <Token![:]>::default(),
                 // the bound e.g. Serialize
                 bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
                     paren_token: None,
@@ -233,7 +233,7 @@ pub fn with_self_bound(
             lifetimes: None,
             // the type that is being bounded e.g. MyStruct<'a, T>
             bounded_ty: type_of_item(cont),
-            colon_token: Default::default(),
+            colon_token: <Token![:]>::default(),
             // the bound e.g. Default
             bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
                 paren_token: None,
@@ -289,7 +289,7 @@ fn type_of_item(cont: &Container) -> syn::Type {
                 arguments: syn::PathArguments::AngleBracketed(
                     syn::AngleBracketedGenericArguments {
                         colon2_token: None,
-                        lt_token: Default::default(),
+                        lt_token: <Token![<]>::default(),
                         args: cont
                             .generics
                             .params
@@ -309,7 +309,7 @@ fn type_of_item(cont: &Container) -> syn::Type {
                                 }
                             })
                             .collect(),
-                        gt_token: Default::default(),
+                        gt_token: <Token![>]>::default(),
                     },
                 ),
             }].into_iter()

serde_derive/src/lib.rs

@@ -22,14 +22,14 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.60")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.67")]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
         enum_variant_names, redundant_field_names, too_many_arguments, used_underscore_binding,
-        cyclomatic_complexity
+        cyclomatic_complexity, needless_pass_by_value
     )
 )]
 // Whitelisted clippy_pedantic lints
@@ -37,7 +37,7 @@
     feature = "cargo-clippy",
     allow(
         items_after_statements, doc_markdown, stutter, similar_names, use_self, single_match_else,
-        enum_glob_use, match_same_arms, filter_map, cast_possible_truncation
+        enum_glob_use, match_same_arms, filter_map, cast_possible_truncation, indexing_slicing,
     )
 )]
 // The `quote!` macro requires deep recursion.
@@ -69,17 +69,21 @@ mod try;
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
     let input: DeriveInput = syn::parse(input).unwrap();
-    match ser::expand_derive_serialize(&input) {
+    ser::expand_derive_serialize(&input)
-        Ok(expanded) => expanded.into(),
+        .unwrap_or_else(compile_error)
-        Err(msg) => panic!(msg),
+        .into()
-    }
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
     let input: DeriveInput = syn::parse(input).unwrap();
-    match de::expand_derive_deserialize(&input) {
+    de::expand_derive_deserialize(&input)
-        Ok(expanded) => expanded.into(),
+        .unwrap_or_else(compile_error)
-        Err(msg) => panic!(msg),
+        .into()
+}
+
+fn compile_error(message: String) -> proc_macro2::TokenStream {
+    quote! {
+        compile_error!(#message);
     }
 }

serde_derive_internals/Cargo.toml

@@ -8,8 +8,8 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_derive_internals/"
 keywords = ["serde", "serialization"]
-readme = "README.md"
+readme = "crates-io.md"
-include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [lib]
 path = "lib.rs"

serde_derive_internals/crates-io.md

@@ -0,0 +1 @@
+../crates-io.md

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.60" # remember to update html_root_url
+version = "1.0.67" # 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"
@@ -8,14 +8,14 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_test/"
 keywords = ["serde", "serialization"]
-readme = "README.md"
+readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [dependencies]
-serde = { version = "1.0.16", path = "../serde" }
+serde = { version = "1.0.60", path = "../serde" }
 
 [dev-dependencies]
-serde = { version = "1.0.16", path = "../serde", features = ["rc"] }
+serde = { version = "1.0", path = "../serde", features = ["rc"] }
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
 [badges]

serde_test/crates-io.md

@@ -0,0 +1 @@
+../crates-io.md

serde_test/src/lib.rs

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

test_suite/no_std/src/main.rs

@@ -6,7 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-#![feature(lang_items, start)]
+#![feature(lang_items, start, panic_implementation)]
 #![no_std]
 
 extern crate libc;
@@ -20,13 +20,8 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
 #[no_mangle]
 pub extern "C" fn rust_eh_personality() {}
 
-#[lang = "panic_fmt"]
+#[panic_implementation]
-#[no_mangle]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
-pub extern "C" fn rust_begin_panic(
-    _msg: core::fmt::Arguments,
-    _file: &'static str,
-    _line: u32,
-) -> ! {
     unsafe {
         libc::abort();
     }

test_suite/tests/compile-fail/borrow/bad_lifetimes.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "zzz")] //~^^ HELP: failed to parse borrowed lifetimes: "zzz"
+    #[serde(borrow = "zzz")]
+    //~^^^ ERROR: failed to parse borrowed lifetimes: "zzz"
     s: &'a str,
 }
 

test_suite/tests/compile-fail/borrow/duplicate_lifetime.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "'a + 'a")] //~^^ HELP: duplicate borrowed lifetime `'a`
+    #[serde(borrow = "'a + 'a")]
+    //~^^^ ERROR: duplicate borrowed lifetime `'a`
     s: &'a str,
 }
 

test_suite/tests/compile-fail/borrow/duplicate_variant.rs

@@ -12,10 +12,11 @@ extern crate serde_derive;
 #[derive(Deserialize)]
 struct Str<'a>(&'a str);
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 enum Test<'a> {
-    #[serde(borrow)] //~^^ HELP: duplicate serde attribute `borrow`
+    #[serde(borrow)]
-    S(#[serde(borrow)] Str<'a>)
+    //~^^^ ERROR: duplicate serde attribute `borrow`
+    S(#[serde(borrow)] Str<'a>),
 }
 
 fn main() {}

test_suite/tests/compile-fail/borrow/empty_lifetimes.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "")] //~^^ HELP: at least one lifetime must be borrowed
+    #[serde(borrow = "")]
+    //~^^^ ERROR: at least one lifetime must be borrowed
     s: &'a str,
 }
 

test_suite/tests/compile-fail/borrow/no_lifetimes.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test {
-    #[serde(borrow)] //~^^ HELP: field `s` has no lifetimes to borrow
+    #[serde(borrow)]
+    //~^^^ ERROR: field `s` has no lifetimes to borrow
     s: String,
 }
 

test_suite/tests/compile-fail/borrow/struct_variant.rs

@@ -12,10 +12,11 @@ extern crate serde_derive;
 #[derive(Deserialize)]
 struct Str<'a>(&'a str);
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 enum Test<'a> {
-    #[serde(borrow)] //~^^ HELP: #[serde(borrow)] may only be used on newtype variants
+    #[serde(borrow)]
-    S { s: Str<'a> }
+    //~^^^ ERROR: #[serde(borrow)] may only be used on newtype variants
+    S { s: Str<'a> },
 }
 
 fn main() {}

test_suite/tests/compile-fail/borrow/wrong_lifetime.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "'b")] //~^^ HELP: field `s` does not have lifetime 'b
+    #[serde(borrow = "'b")]
+    //~^^^ ERROR: field `s` does not have lifetime 'b
     s: &'a str,
 }
 

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

@@ -9,9 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(tag = "conflict", content = "conflict")]
-//~^^ HELP: enum tags `conflict` for type and content conflict with each other
+//~^^ ERROR: enum tags `conflict` for type and content conflict with each other
 enum E {
     A,
     B,

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

@@ -9,8 +9,8 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: #[serde(flatten)] cannot be used on newtype structs
 struct Foo(#[serde(flatten)] HashMap<String, String>);
+//~^^ ERROR: #[serde(flatten)] cannot be used on newtype structs
 
 fn main() {}

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

@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
 struct Foo {
     #[serde(flatten, skip_deserializing)]
+    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
     other: Other,
 }
 
 #[derive(Deserialize)]
 struct Other {
-    x: u32
+    x: u32,
 }
 
 fn main() {}

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

@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
 struct Foo {
-    #[serde(flatten, skip_serializing_if="Option::is_none")]
+    #[serde(flatten, skip_serializing_if = "Option::is_none")]
+    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
     other: Option<Other>,
 }
 
 #[derive(Serialize)]
 struct Other {
-    x: u32
+    x: u32,
 }
 
 fn main() {}

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

@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
 struct Foo {
     #[serde(flatten, skip_serializing)]
+    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
     other: Other,
 }
 
 #[derive(Serialize)]
 struct Other {
-    x: u32
+    x: u32,
 }
 
 fn main() {}

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

@@ -9,8 +9,8 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: #[serde(flatten)] cannot be used on tuple structs
 struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
+//~^^ ERROR: #[serde(flatten)] cannot be used on tuple structs
 
 fn main() {}

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

@@ -9,9 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(tag = "conflict")]
-//~^^ HELP: variant field name `conflict` conflicts with internal tag
+//~^^ ERROR: variant field name `conflict` conflicts with internal tag
 enum E {
     A {
         #[serde(rename = "conflict")]

test_suite/tests/compile-fail/default-attribute/enum.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-#[serde(default)] //~^ HELP: #[serde(default)] can only be used on structs
+#[serde(default)]
+//~^^ ERROR: #[serde(default)] can only be used on structs
 enum E {
     S { f: u8 },
 }

test_suite/tests/compile-fail/default-attribute/nameless_struct_fields.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-#[serde(default)] //~^ HELP: #[serde(default)] can only be used on structs
+#[serde(default)]
+//~^^ ERROR: #[serde(default)] can only be used on structs
 struct T(u8, u8);
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/duplicate-attribute/rename-and-ser.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename="x", serialize="y")] //~^^ HELP: unknown serde field attribute `serialize`
+    #[serde(rename = "x", serialize = "y")]
+    //~^^^ ERROR: unknown serde field attribute `serialize`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/rename-rename-de.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename="x")]
+    #[serde(rename = "x")]
-    #[serde(rename(deserialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(deserialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename-ser.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"), rename(serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"), rename(serialize = "y"))]
+    //~^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-rename.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"))]
+    #[serde(rename(serialize = "x"))]
-    #[serde(rename="y")] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename = "y")]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/rename-ser-ser.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x", serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x", serialize = "y"))]
+    //~^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/two-rename-ser.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"))]
+    #[serde(rename(serialize = "x"))]
-    #[serde(rename(serialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

test_suite/tests/compile-fail/duplicate-attribute/with-and-serialize-with.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(with = "w", serialize_with = "s")] //~^^ HELP: duplicate serde attribute `serialize_with`
+    #[serde(with = "w", serialize_with = "s")]
+    //~^^^ ERROR: duplicate serde attribute `serialize_with`
     x: (),
 }
 

test_suite/tests/compile-fail/enum-representation/internal-tuple-variant.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] cannot be used with tuple variants
+#[serde(tag = "type")]
+//~^^ ERROR: #[serde(tag = "...")] cannot be used with tuple variants
 enum E {
     Tuple(u8, u8),
 }

test_suite/tests/compile-fail/enum-representation/internally-tagged-struct.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] can only be used on enums
+#[serde(tag = "type")]
+//~^^ ERROR: #[serde(tag = "...")] can only be used on enums
 struct S;
 
 fn main() {}

test_suite/tests/compile-fail/enum-representation/untagged-and-internal.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(untagged)]
-#[serde(tag = "type")] //~^^ HELP: enum cannot be both untagged and internally tagged
+#[serde(tag = "type")]
+//~^^^ ERROR: enum cannot be both untagged and internally tagged
 enum E {
     A(u8),
     B(String),

test_suite/tests/compile-fail/enum-representation/untagged-struct.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(untagged)] //~^ HELP: #[serde(untagged)] can only be used on enums
+#[serde(untagged)]
+//~^^ ERROR: #[serde(untagged)] can only be used on enums
 struct S;
 
 fn main() {}

test_suite/tests/compile-fail/identifier/both.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-#[serde(field_identifier, variant_identifier)] //~^ HELP: `field_identifier` and `variant_identifier` cannot both be set
+#[serde(field_identifier, variant_identifier)]
+//~^^ ERROR: `field_identifier` and `variant_identifier` cannot both be set
 enum F {
     A,
     B,

test_suite/tests/compile-fail/identifier/field_struct.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
-struct S; //~^^ HELP: `field_identifier` can only be used on an enum
+//~^^ ERROR: `field_identifier` can only be used on an enum
+struct S;
 
 fn main() {}

test_suite/tests/compile-fail/identifier/field_tuple.rs

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    B(u8, u8), //~^^^^ HELP: field_identifier may only contain unit variants
+    B(u8, u8),
+    //~^^^^^ ERROR: field_identifier may only contain unit variants
 }
 
 fn main() {}

test_suite/tests/compile-fail/identifier/newtype_not_last.rs

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    Other(String), //~^^^^ HELP: `Other` must be the last variant
+    Other(String),
+    //~^^^^^ ERROR: `Other` must be the last variant
     B,
 }
 

test_suite/tests/compile-fail/identifier/not_identifier.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 enum F {
     A,
-    #[serde(other)] //~^^^ HELP: #[serde(other)] may only be used inside a field_identifier
+    #[serde(other)]
+    //~^^^^ ERROR: #[serde(other)] may only be used inside a field_identifier
     B,
 }
 

test_suite/tests/compile-fail/identifier/not_unit.rs

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    #[serde(other)] //~^^^^ HELP: #[serde(other)] must be on a unit variant
+    #[serde(other)]
+    //~^^^^^ ERROR: #[serde(other)] must be on a unit variant
     Other(u8, u8),
 }
 

test_suite/tests/compile-fail/identifier/other_not_last.rs

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    #[serde(other)] //~^^^^ HELP: #[serde(other)] must be the last variant
+    #[serde(other)]
+    //~^^^^^ ERROR: #[serde(other)] must be the last variant
     Other,
     B,
 }

test_suite/tests/compile-fail/identifier/serialize.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(field_identifier)] //~^ HELP: field identifiers cannot be serialized
+#[serde(field_identifier)]
+//~^^ ERROR: field identifiers cannot be serialized
 enum F {
     A,
     B,

test_suite/tests/compile-fail/identifier/variant_struct.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(variant_identifier)]
-struct S; //~^^ HELP: `variant_identifier` can only be used on an enum
+//~^^ ERROR: `variant_identifier` can only be used on an enum
+struct S;
 
 fn main() {}

test_suite/tests/compile-fail/identifier/variant_tuple.rs

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(variant_identifier)]
 enum F {
     A,
-    B(u8, u8), //~^^^^ HELP: variant_identifier may only contain unit variants
+    B(u8, u8),
+    //~^^^^^ ERROR: variant_identifier may only contain unit variants
 }
 
 fn main() {}

test_suite/tests/compile-fail/precondition/deserialize_de_lifetime.rs

@@ -9,7 +9,8 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct S<'de> {
-    s: &'de str, //~^^ HELP: cannot deserialize when there is a lifetime parameter called 'de
+    //~^^ ERROR: cannot deserialize when there is a lifetime parameter called 'de
+    s: &'de str,
 }

test_suite/tests/compile-fail/precondition/deserialize_dst.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct S {
     string: String,
-    slice: [u8], //~^^^ HELP: cannot deserialize a dynamically sized struct
+    slice: [u8],
+    //~^^^^ ERROR: cannot deserialize a dynamically sized struct
 }

test_suite/tests/compile-fail/remote/bad_getter.rs

@@ -15,10 +15,11 @@ mod remote {
     }
 }
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(remote = "remote::S")]
 struct S {
-    #[serde(getter = "~~~")] //~^^^ HELP: failed to parse path: "~~~"
+    #[serde(getter = "~~~")]
+    //~^^^^ ERROR: failed to parse path: "~~~"
     a: u8,
 }
 

test_suite/tests/compile-fail/remote/bad_remote.rs

@@ -15,8 +15,9 @@ mod remote {
     }
 }
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(remote = "~~~")] //~^ HELP: failed to parse path: "~~~"
+#[serde(remote = "~~~")]
+//~^^ ERROR: failed to parse path: "~~~"
 struct S {
     a: u8,
 }

test_suite/tests/compile-fail/remote/enum_getter.rs

@@ -11,17 +11,18 @@ extern crate serde_derive;
 
 mod remote {
     pub enum E {
-        A { a: u8 }
+        A { a: u8 },
     }
 }
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(remote = "remote::E")]
 pub enum E {
     A {
-        #[serde(getter = "get_a")] //~^^^^ HELP: #[serde(getter = "...")] is not allowed in an enum
+        #[serde(getter = "get_a")]
+        //~^^^^^ ERROR: #[serde(getter = "...")] is not allowed in an enum
         a: u8,
-    }
+    },
 }
 
 fn main() {}

test_suite/tests/compile-fail/remote/missing_field.rs

@@ -19,7 +19,8 @@ mod remote {
 #[derive(Serialize, Deserialize)]
 #[serde(remote = "remote::S")]
 struct S {
-    a: u8, //~^^^ ERROR: missing field `b` in initializer of `remote::S`
+    a: u8,
+    //~^^^^ ERROR: missing field `b` in initializer of `remote::S`
 }
 
 fn main() {}

test_suite/tests/compile-fail/remote/nonremote_getter.rs

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(getter = "S::get")] //~^^ HELP: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")]
+    #[serde(getter = "S::get")]
+    //~^^^ ERROR: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")]
     a: u8,
 }
 

test_suite/tests/compile-fail/remote/unknown_field.rs

@@ -19,7 +19,8 @@ mod remote {
 #[serde(remote = "remote::S")]
 struct S {
     //~^^^ ERROR: struct `remote::S` has no field named `b`
-    b: u8, //~^^^^ ERROR: no field `b` on type `&remote::S`
+    b: u8,
+    //~^^^^^ ERROR: no field `b` on type `&remote::S`
 }
 
 fn main() {}

test_suite/tests/compile-fail/remote/wrong_de.rs

@@ -13,8 +13,10 @@ mod remote {
     pub struct S(pub u16);
 }
 
-#[derive(Deserialize)] //~ ERROR: mismatched types
+#[derive(Deserialize)]
 #[serde(remote = "remote::S")]
-struct S(u8); //~^^ expected u16, found u8
+struct S(u8);
+//~^^^ ERROR: mismatched types
+//~^^^^ expected u16, found u8
 
 fn main() {}

test_suite/tests/compile-fail/remote/wrong_getter.rs

@@ -21,11 +21,13 @@ mod remote {
     }
 }
 
-#[derive(Serialize)] //~ ERROR: mismatched types
+#[derive(Serialize)]
 #[serde(remote = "remote::S")]
 struct S {
     #[serde(getter = "remote::S::get")]
-    a: u8, //~^^^^ expected u8, found u16
+    //~^^^^ ERROR: mismatched types
+    a: u8,
+    //~^^^^^^ expected u8, found u16
 }
 
 fn main() {}

test_suite/tests/compile-fail/remote/wrong_ser.rs

@@ -15,10 +15,12 @@ mod remote {
     }
 }
 
-#[derive(Serialize)] //~ ERROR: mismatched types
+#[derive(Serialize)]
 #[serde(remote = "remote::S")]
 struct S {
-    a: u8, //~^^^ expected u8, found u16
+    a: u8,
+    //~^^^^ ERROR: mismatched types
+    //~^^^^^ expected u8, found u16
 }
 
 fn main() {}

test_suite/tests/compile-fail/transparent/at_most_one.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(transparent)]
+//~^^ ERROR: #[serde(transparent)] requires struct to have at most one transparent field
 struct S {
-    //~^^^ HELP: #[serde(transparent)] requires struct to have at most one transparent field
     a: u8,
     b: u8,
 }

test_suite/tests/compile-fail/transparent/de_at_least_one.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(transparent)]
+//~^^ ERROR: #[serde(transparent)] requires at least one field that is neither skipped nor has a default
 struct S {
-    //~^^^ HELP: #[serde(transparent)] requires at least one field that is neither skipped nor has a default
     #[serde(skip)]
     a: u8,
     #[serde(default)]

test_suite/tests/compile-fail/transparent/ser_at_least_one.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(transparent)]
+//~^^ ERROR: #[serde(transparent)] requires at least one field that is not skipped
 struct S {
-    //~^^^ HELP: #[serde(transparent)] requires at least one field that is not skipped
     #[serde(skip)]
     a: u8,
 }

test_suite/tests/compile-fail/type-attribute/from.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-#[serde(from = "Option<T")] //~^ HELP: failed to parse type: from = "Option<T"
+#[serde(from = "Option<T")]
+//~^^ ERROR: failed to parse type: from = "Option<T"
 enum TestOne {
     Testing,
     One,

test_suite/tests/compile-fail/type-attribute/into.rs

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(into = "Option<T")] //~^ HELP: failed to parse type: into = "Option<T"
+#[serde(into = "Option<T")]
+//~^^ ERROR: failed to parse type: into = "Option<T"
 enum TestOne {
     Testing,
     One,

test_suite/tests/compile-fail/unknown-attribute/container.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-#[serde(abc="xyz")] //~^ HELP: unknown serde container attribute `abc`
+#[serde(abc = "xyz")]
+//~^^ ERROR: unknown serde container attribute `abc`
 struct A {
     x: u32,
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/unknown-attribute/field.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct C {
-    #[serde(abc="xyz")] //~^^ HELP: unknown serde field attribute `abc`
+    #[serde(abc = "xyz")]
+    //~^^^ ERROR: unknown serde field attribute `abc`
     x: u32,
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/unknown-attribute/variant.rs

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 enum E {
-    #[serde(abc="xyz")] //~^^ HELP: unknown serde variant attribute `abc`
+    #[serde(abc = "xyz")]
+    //~^^^ ERROR: unknown serde variant attribute `abc`
     V,
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_de_newtype_field.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-//~^ HELP: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
 enum Enum {
     #[serde(deserialize_with = "deserialize_some_newtype_variant")]
+    //~^^^ ERROR: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
     Newtype(#[serde(skip_deserializing)] String),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_de_struct_field.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-//~^ HELP: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
 enum Enum {
     #[serde(deserialize_with = "deserialize_some_other_variant")]
+    //~^^^ ERROR: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
     Struct {
         #[serde(skip_deserializing)]
         f1: String,
@@ -20,4 +20,4 @@ enum Enum {
     },
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_de_tuple_field.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-//~^ HELP: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
 enum Enum {
     #[serde(deserialize_with = "deserialize_some_other_variant")]
+    //~^^^ ERROR: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
     Tuple(#[serde(skip_deserializing)] String, u8),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_de_whole_variant.rs

@@ -9,12 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
-//~^ HELP: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
 enum Enum {
     #[serde(deserialize_with = "deserialize_some_unit_variant")]
     #[serde(skip_deserializing)]
+    //~^^^^ ERROR: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
     Unit,
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_newtype_variant")]
+    //~^^^ ERROR: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
     Newtype(#[serde(skip_serializing)] String),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_newtype_field_if.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_newtype_variant")]
+    //~^^^ ERROR: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
     Newtype(#[serde(skip_serializing_if = "always")] String),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_struct_field.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_other_variant")]
+    //~^^^ ERROR: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
     Struct {
         #[serde(skip_serializing)]
         f1: String,
@@ -20,4 +20,4 @@ enum Enum {
     },
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_struct_field_if.rs

@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_newtype_variant")]
+    //~^^^ ERROR: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
     Struct {
         #[serde(skip_serializing_if = "always")]
         f1: String,
@@ -20,4 +20,4 @@ enum Enum {
     },
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_other_variant")]
+    //~^^^ ERROR: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
     Tuple(#[serde(skip_serializing)] String, u8),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_tuple_field_if.rs

@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_other_variant")]
+    //~^^^ ERROR: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
     Tuple(#[serde(skip_serializing_if = "always")] String, u8),
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/compile-fail/with-variant/skip_ser_whole_variant.rs

@@ -9,12 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
-//~^ HELP: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
 enum Enum {
     #[serde(serialize_with = "serialize_some_unit_variant")]
     #[serde(skip_serializing)]
+    //~^^^^ ERROR: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
     Unit,
 }
 
-fn main() { }
+fn main() {}

test_suite/tests/run-pass/identity-op.rs

@@ -15,6 +15,8 @@ extern crate serde_derive;
 // serialized, which Clippy warns about. If the expansion info is registered
 // correctly, the Clippy lint is not triggered.
 #[derive(Serialize)]
-struct A { b: u8 }
+struct A {
+    b: u8,
+}
 
 fn main() {}

test_suite/tests/test_annotations.rs

@@ -14,7 +14,7 @@ extern crate serde_derive;
 extern crate serde;
 use self::serde::de::{self, Unexpected};
 use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
-use std::collections::HashMap;
+use std::collections::{BTreeMap, HashMap};
 use std::marker::PhantomData;
 
 extern crate serde_test;
@@ -1683,6 +1683,49 @@ fn test_complex_flatten() {
     );
 }
 
+#[test]
+fn test_flatten_map_twice() {
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct Outer {
+        #[serde(flatten)]
+        first: BTreeMap<String, String>,
+        #[serde(flatten)]
+        between: Inner,
+        #[serde(flatten)]
+        second: BTreeMap<String, String>,
+    }
+
+    #[derive(Debug, PartialEq, Deserialize)]
+    struct Inner {
+        y: String,
+    }
+
+    assert_de_tokens(
+        &Outer {
+            first: {
+                let mut first = BTreeMap::new();
+                first.insert("x".to_owned(), "X".to_owned());
+                first.insert("y".to_owned(), "Y".to_owned());
+                first
+            },
+            between: Inner { y: "Y".to_owned() },
+            second: {
+                let mut second = BTreeMap::new();
+                second.insert("x".to_owned(), "X".to_owned());
+                second
+            },
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("x"),
+            Token::Str("X"),
+            Token::Str("y"),
+            Token::Str("Y"),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_flatten_unsupported_type() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]

test_suite/tests/test_de.rs

@@ -7,13 +7,14 @@
 // except according to those terms.
 
 #![cfg_attr(feature = "cargo-clippy", allow(decimal_literal_representation))]
+#![cfg_attr(feature = "unstable", feature(never_type))]
 
 #[macro_use]
 extern crate serde_derive;
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::default::Default;
-use std::ffi::{CString, OsString};
+use std::ffi::{CStr, CString, OsString};
 use std::net;
 use std::num::Wrapping;
 use std::path::{Path, PathBuf};
@@ -21,9 +22,6 @@ use std::rc::{Rc, Weak as RcWeak};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};
 
-#[cfg(feature = "unstable")]
-use std::ffi::CStr;
-
 extern crate serde;
 use serde::{Deserialize, Deserializer};
 
@@ -865,6 +863,26 @@ declare_tests! {
             Token::U64(1),
         ],
     }
+    test_rc_dst {
+        Rc::<str>::from("s") => &[
+            Token::Str("s"),
+        ],
+        Rc::<[bool]>::from(&[true][..]) => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    }
+    test_arc_dst {
+        Arc::<str>::from("s") => &[
+            Token::Str("s"),
+        ],
+        Arc::<[bool]>::from(&[true][..]) => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    }
 }
 
 declare_tests! {
@@ -962,24 +980,10 @@ declare_tests! {
 
 #[cfg(feature = "unstable")]
 declare_tests! {
-    test_rc_dst {
+    test_never_result {
-        Rc::<str>::from("s") => &[
+        Ok::<u8, !>(0) => &[
-            Token::Str("s"),
+            Token::NewtypeVariant { name: "Result", variant: "Ok" },
-        ],
+            Token::U8(0),
-        Rc::<[bool]>::from(&[true][..]) => &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
-        ],
-    }
-    test_arc_dst {
-        Arc::<str>::from("s") => &[
-            Token::Str("s"),
-        ],
-        Arc::<[bool]>::from(&[true][..]) => &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
         ],
     }
 }
@@ -1024,7 +1028,6 @@ fn test_osstring() {
     assert_de_tokens_ignore(&tokens);
 }
 
-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr() {
     assert_de_tokens::<Box<CStr>>(
@@ -1033,7 +1036,6 @@ fn test_cstr() {
     );
 }
 
-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr_internal_null() {
     assert_de_tokens_error::<Box<CStr>>(
@@ -1042,7 +1044,6 @@ fn test_cstr_internal_null() {
     );
 }
 
-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr_internal_null_end() {
     assert_de_tokens_error::<Box<CStr>>(
@@ -1051,6 +1052,20 @@ fn test_cstr_internal_null_end() {
     );
 }
 
+#[cfg(feature = "unstable")]
+#[test]
+fn test_never_type() {
+    assert_de_tokens_error::<!>(&[], "cannot deserialize `!`");
+
+    assert_de_tokens_error::<Result<u8, !>>(
+        &[Token::NewtypeVariant {
+            name: "Result",
+            variant: "Err",
+        }],
+        "cannot deserialize `!`",
+    );
+}
+
 declare_error_tests! {
     test_unknown_field<StructDenyUnknown> {
         &[

test_suite/tests/test_gen.rs

@@ -297,11 +297,9 @@ fn test_gen() {
         f: u8,
     }
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     struct EmptyTuple();
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
     struct EmptyTupleDenyUnknown();
@@ -327,7 +325,6 @@ fn test_gen() {
         Variant,
     }
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     enum EmptyVariants {
         Braced {},
@@ -339,7 +336,6 @@ fn test_gen() {
         TupleSkip(#[serde(skip_deserializing)] u8),
     }
 
-    #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     #[serde(deny_unknown_fields)]
     enum EmptyVariantsDenyUnknown {

test_suite/tests/test_ser.rs

@@ -6,9 +6,12 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+#![cfg_attr(feature = "unstable", feature(never_type))]
+
 #[macro_use]
 extern crate serde_derive;
 
+use std::cell::RefCell;
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::CString;
 use std::mem;
@@ -439,6 +442,31 @@ declare_tests! {
             Token::U64(1),
         ],
     }
+    test_rc_dst {
+        Rc::<str>::from("s") => &[
+            Token::Str("s"),
+        ],
+        Rc::<[bool]>::from(&[true][..]) => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    }
+    test_arc_dst {
+        Arc::<str>::from("s") => &[
+            Token::Str("s"),
+        ],
+        Arc::<[bool]>::from(&[true][..]) => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+    }
+    test_fmt_arguments {
+        format_args!("{}{}", 1, 'a') => &[
+            Token::Str("1a"),
+        ],
+    }
 }
 
 declare_tests! {
@@ -522,27 +550,12 @@ declare_tests! {
     }
 }
 
-// Serde's implementation is not unstable, but the constructors are.
 #[cfg(feature = "unstable")]
 declare_tests! {
-    test_rc_dst {
+    test_never_result {
-        Rc::<str>::from("s") => &[
+        Ok::<u8, !>(0) => &[
-            Token::Str("s"),
+            Token::NewtypeVariant { name: "Result", variant: "Ok" },
-        ],
+            Token::U8(0),
-        Rc::<[bool]>::from(&[true][..]) => &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
-        ],
-    }
-    test_arc_dst {
-        Arc::<str>::from("s") => &[
-            Token::Str("s"),
-        ],
-        Arc::<[bool]>::from(&[true][..]) => &[
-            Token::Seq { len: Some(1) },
-            Token::Bool(true),
-            Token::SeqEnd,
         ],
     }
 }
@@ -563,6 +576,13 @@ fn test_cannot_serialize_paths() {
     assert_ser_tokens_error(&path_buf, &[], "path contains invalid UTF-8 characters");
 }
 
+#[test]
+fn test_cannot_serialize_mutably_borrowed_ref_cell() {
+    let ref_cell = RefCell::new(42);
+    let _reference = ref_cell.borrow_mut();
+    assert_ser_tokens_error(&ref_cell, &[], "already mutably borrowed");
+}
+
 #[test]
 fn test_enum_skipped() {
     assert_ser_tokens_error(

test_suite/tests/test_value.rs

@@ -25,3 +25,21 @@ fn test_u32_to_enum() {
     let e: E = E::deserialize(deserializer).unwrap();
     assert_eq!(E::B, e);
 }
+
+#[test]
+fn test_integer128() {
+    let de_u128 = IntoDeserializer::<value::Error>::into_deserializer(1u128);
+    let de_i128 = IntoDeserializer::<value::Error>::into_deserializer(1i128);
+
+    // u128 to u128
+    assert_eq!(1u128, u128::deserialize(de_u128).unwrap());
+
+    // u128 to i128
+    assert_eq!(1i128, i128::deserialize(de_u128).unwrap());
+
+    // i128 to u128
+    assert_eq!(1u128, u128::deserialize(de_i128).unwrap());
+
+    // i128 to i128
+    assert_eq!(1i128, i128::deserialize(de_i128).unwrap());
+}

travis.sh

@@ -93,4 +93,12 @@ else
     cargo clean
     cd "$DIR/serde_derive"
     channel build
+
+    for CHANNEL in 1.20.0 1.21.0 1.25.0 1.26.0; do
+        cd "$DIR"
+        cargo clean
+        cd "$DIR/serde"
+        channel build --no-default-features
+        channel build
+    done
 fi