Release 1.0.67

Format with rustfmt 0.8.2
Merge pull request #1323 from dtolnay/format-args
2026-04-23 10:38:02 +00:00 · 2018-06-27 00:18:03 -07:00 · 2018-06-27 00:16:06 -07:00 · 2018-06-27 00:15:55 -07:00 · 2018-06-26 23:58:16 -07:00 · 2018-06-26 23:58:02 -07:00
97 changed files with 1064 additions and 358 deletions
@@ -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:
@@ -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
@@ -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.
@@ -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"
-include = ["Cargo.toml", "build.rs", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+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
-# intended for library crates that provide optional Serde impls behind a Cargo
-# cfg of their own. All other crates should depend on serde_derive directly.
+# Re-export the derive(Serialize, Deserialize) macros. This is intended for
+# library crates that provide optional Serde impls behind a Cargo cfg of their
+# 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>.
@@ -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") {
-        Some(rustc) => rustc,
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
        None => return,
    };

-    let output = match Command::new(rustc).arg("--version").output() {
-        Ok(output) => output,
-        Err(_) => return,
-    };
-
-    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;
+    // CString::into_boxed_c_str stabilized in Rust 1.20:
+    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
+    if minor >= 20 {
+        println!("cargo:rustc-cfg=de_boxed_c_str");
    }

-    let next = match pieces.next() {
-        Some(next) => next,
-        None => return,
-    };
+    // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
+    // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
+    // 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) {
-        Ok(minor) => minor,
-        Err(_) => return,
-    };
+    // Duration available in core since Rust 1.25:
+    // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
+    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()
+}
@@ -0,0 +1 @@
+../crates-io.md
@@ -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));
-                    s.parse().map_err(Error::custom)
+                    struct IpAddrVisitor;
+
+                    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));
-            s.parse().map_err(Error::custom)
+            struct IpAddrVisitor;
+
+            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));
-                    s.parse().map_err(Error::custom)
+                    struct SocketAddrVisitor;
+
+                    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));
-            s.parse().map_err(Error::custom)
+            struct SocketAddrVisitor;
+
+            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))
                            }
                        }
@@ -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
-where
-    T: for<'de> Deserialize<'de>,
-{
-}
+impl<T> DeserializeOwned for T 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
-/// data model, which is a way to categorize every Rust data type into one of 29
-/// possible types. Each method of the `Serializer` trait corresponds to one of
-/// the types of the data model.
+/// 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 possible types. Each method of the `Serializer` trait corresponds to one
+/// 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;
@@ -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> {
@@ -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;
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -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>)>>,
-    pending_content: Option<Content<'de>>,
-    fields: Option<&'static [&'static str]>,
+    iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
+    pending_content: Option<&'a Content<'de>>,
    _marker: PhantomData<E>,
 }

 #[cfg(any(feature = "std", feature = "alloc"))]
 impl<'a, 'de, E> FlatMapAccess<'a, 'de, E> {
    fn new(
-        iter: slice::IterMut<'a, Option<(Content<'de>, Content<'de>)>>,
-        fields: Option<&'static [&'static str]>,
+        iter: slice::Iter<'a, Option<(Content<'de>, Content<'de>)>>,
    ) -> 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| {
-                    match self.fields {
-                        None => true,
-                        Some(fields) if fields.contains(&key) => true,
-                        _ => false,
-                    }
-                }),
+                Some((ref c, _)) => c.as_str().map_or(false, |key| self.fields.contains(&key)),
            };

            if use_item {
@@ -8,10 +8,7 @@

 use lib::*;

-use ser::{Serialize, SerializeTuple, Serializer};
-
-#[cfg(feature = "std")]
-use ser::Error;
+use ser::{Error, Serialize, SerializeTuple, Serializer};

 ////////////////////////////////////////////////////////////////////////////////

@@ -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
@@ -55,8 +55,8 @@
 //!    - str
 //!    - &T and &mut T
 //!  - **Compound types**:
-//!    - [T]
-//!    - [T; 0] through [T; 32]
+//!    - \[T\]
+//!    - \[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
-/// model, which is a way to categorize every Rust data structure into one of 29
-/// possible types. Each method of the `Serializer` trait corresponds to one of
-/// the types of the data model.
+/// The role of this trait is to define the serialization half of the [Serde
+/// data model], which is a way to categorize every Rust data structure into one
+/// of 29 possible types. Each method of the `Serializer` trait corresponds to
+/// 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;
@@ -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"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]

 [badges]
 travis-ci = { repository = "serde-rs/serde" }
@@ -0,0 +1 @@
+../crates-io.md
@@ -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()
@@ -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) {
-        Ok(expanded) => expanded.into(),
-        Err(msg) => panic!(msg),
-    }
+    ser::expand_derive_serialize(&input)
+        .unwrap_or_else(compile_error)
+        .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) {
-        Ok(expanded) => expanded.into(),
-        Err(msg) => panic!(msg),
+    de::expand_derive_deserialize(&input)
+        .unwrap_or_else(compile_error)
+        .into()
+}
+
+fn compile_error(message: String) -> proc_macro2::TokenStream {
+    quote! {
+        compile_error!(#message);
    }
 }
@@ -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"
-include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]

 [lib]
 path = "lib.rs"
@@ -0,0 +1 @@
+../crates-io.md
@@ -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"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+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]
@@ -0,0 +1 @@
+../crates-io.md
@@ -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))]
@@ -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"]
-#[no_mangle]
-pub extern "C" fn rust_begin_panic(
-    _msg: core::fmt::Arguments,
-    _file: &'static str,
-    _line: u32,
-) -> ! {
+#[panic_implementation]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
    unsafe {
        libc::abort();
    }
@@ -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,
 }

@@ -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,
 }

@@ -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`
-    S(#[serde(borrow)] Str<'a>)
+    #[serde(borrow)]
+    //~^^^ ERROR: duplicate serde attribute `borrow`
+    S(#[serde(borrow)] Str<'a>),
 }

 fn main() {}
@@ -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,
 }

@@ -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,
 }

@@ -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
-    S { s: Str<'a> }
+    #[serde(borrow)]
+    //~^^^ ERROR: #[serde(borrow)] may only be used on newtype variants
+    S { s: Str<'a> },
 }

 fn main() {}
@@ -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,
 }

@@ -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,
@@ -9,8 +9,8 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten)] cannot be used on newtype structs
+#[derive(Serialize)]
 struct Foo(#[serde(flatten)] HashMap<String, String>);
+//~^^ ERROR: #[serde(flatten)] cannot be used on newtype structs

 fn main() {}
@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
+#[derive(Deserialize)]
 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() {}
@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
+#[derive(Serialize)]
 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() {}
@@ -9,16 +9,16 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
+#[derive(Serialize)]
 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() {}
@@ -9,8 +9,8 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: #[serde(flatten)] cannot be used on tuple structs
+#[derive(Serialize)]
 struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
+//~^^ ERROR: #[serde(flatten)] cannot be used on tuple structs

 fn main() {}
@@ -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")]
@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

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

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(default)] //~^ HELP: #[serde(default)] can only be used on structs
+#[derive(Deserialize)]
+#[serde(default)]
+//~^^ ERROR: #[serde(default)] can only be used on structs
 struct T(u8, u8);

-fn main() { }
+fn main() {}
@@ -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: (),
 }

@@ -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(deserialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename = "x")]
+    #[serde(rename(deserialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
    x: (),
 }

@@ -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: (),
 }

@@ -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="y")] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"))]
+    #[serde(rename = "y")]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
    x: (),
 }

@@ -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: (),
 }

@@ -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="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"))]
+    #[serde(rename(serialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
    x: (),
 }

@@ -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: (),
 }

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

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

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] can only be used on enums
+#[derive(Serialize)]
+#[serde(tag = "type")]
+//~^^ ERROR: #[serde(tag = "...")] can only be used on enums
 struct S;

 fn main() {}
@@ -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),
@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(untagged)] //~^ HELP: #[serde(untagged)] can only be used on enums
+#[derive(Serialize)]
+#[serde(untagged)]
+//~^^ ERROR: #[serde(untagged)] can only be used on enums
 struct S;

 fn main() {}
@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(field_identifier, variant_identifier)] //~^ HELP: `field_identifier` and `variant_identifier` cannot both be set
+#[derive(Deserialize)]
+#[serde(field_identifier, variant_identifier)]
+//~^^ ERROR: `field_identifier` and `variant_identifier` cannot both be set
 enum F {
    A,
    B,
@@ -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() {}
@@ -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() {}
@@ -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,
 }

@@ -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,
 }

@@ -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),
 }

@@ -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,
 }
@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(field_identifier)] //~^ HELP: field identifiers cannot be serialized
+#[derive(Serialize)]
+#[serde(field_identifier)]
+//~^^ ERROR: field identifiers cannot be serialized
 enum F {
    A,
    B,
@@ -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() {}
@@ -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() {}
@@ -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,
 }
@@ -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
 }
@@ -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,
 }

@@ -15,8 +15,9 @@ mod remote {
    }
 }

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(remote = "~~~")] //~^ HELP: failed to parse path: "~~~"
+#[derive(Serialize)]
+#[serde(remote = "~~~")]
+//~^^ ERROR: failed to parse path: "~~~"
 struct S {
    a: u8,
 }
@@ -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() {}
@@ -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() {}
@@ -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,
 }

@@ -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() {}
@@ -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() {}
@@ -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() {}
@@ -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() {}
@@ -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,
 }
@@ -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)]
@@ -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,
 }
@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;

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

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

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(abc="xyz")] //~^ HELP: unknown serde container attribute `abc`
+#[derive(Serialize)]
+#[serde(abc = "xyz")]
+//~^^ ERROR: unknown serde container attribute `abc`
 struct A {
    x: u32,
 }

-fn main() { }
+fn main() {}
@@ -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() {}
@@ -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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)]
 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() {}
@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(deserialize_with)] and a field `f1` marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)]
 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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(deserialize_with)] and a field 0 marked with #[serde(skip_deserializing)]
+#[derive(Deserialize)]
 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() {}
@@ -9,12 +9,12 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Unit` cannot have both #[serde(deserialize_with)] and #[serde(skip_deserializing)]
+#[derive(Deserialize)]
 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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+#[derive(Serialize)]
 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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Newtype` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)]
 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() {}
@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing)]
+#[derive(Serialize)]
 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() {}
@@ -9,10 +9,10 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Struct` cannot have both #[serde(serialize_with)] and a field `f1` marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)]
 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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing)]
+#[derive(Serialize)]
 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() {}
@@ -9,11 +9,11 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Tuple` cannot have both #[serde(serialize_with)] and a field 0 marked with #[serde(skip_serializing_if)]
+#[derive(Serialize)]
 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() {}
@@ -9,12 +9,12 @@
 #[macro_use]
 extern crate serde_derive;

-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-//~^ HELP: variant `Unit` cannot have both #[serde(serialize_with)] and #[serde(skip_serializing)]
+#[derive(Serialize)]
 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() {}
@@ -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() {}
@@ -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)]
@@ -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 {
-        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_never_result {
+        Ok::<u8, !>(0) => &[
+            Token::NewtypeVariant { name: "Result", variant: "Ok" },
+            Token::U8(0),
        ],
    }
 }
@@ -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> {
        &[
@@ -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 {
@@ -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 {
-        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_never_result {
+        Ok::<u8, !>(0) => &[
+            Token::NewtypeVariant { name: "Result", variant: "Ok" },
+            Token::U8(0),
        ],
    }
 }
@@ -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(
@@ -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());
+}
@@ -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
Author	SHA1	Message	Date
David Tolnay	ce17301b8b	Release 1.0.67	2018-06-27 00:18:03 -07:00
David Tolnay	b0e78c6be4	Format with rustfmt 0.8.2	2018-06-27 00:16:06 -07:00
David Tolnay	898f65fa46	Merge pull request #1323 from dtolnay/format-args Implement Serialize for core::fmt::Arguments	2018-06-27 00:15:55 -07:00
David Tolnay	84e384196d	Implement Serialize for core::fmt::Arguments	2018-06-26 23:58:16 -07:00
David Tolnay	d827b101d9	Resolve default_trait_access lint	2018-06-26 23:58:02 -07:00
David Tolnay	c45ab6b304	Ignore indexing_slicing pedantic lint	2018-06-26 23:56:39 -07:00
David Tolnay	cc9d85b293	Work around unused_imports rustdoc bug	2018-06-26 23:54:32 -07:00
David Tolnay	02493d83be	Ignore indexing_slicing pedantic lint	2018-06-26 23:39:26 -07:00
David Tolnay	a1280c672a	Switch no-std panic to #[panic_implementation]	2018-06-04 10:13:29 -07:00
David Tolnay	a740f76772	Update no-std panic signature for nightly-2018-06-03	2018-06-03 23:15:16 -07:00
David Tolnay	a887db398b	Release 1.0.66	2018-06-03 11:45:20 -07:00
Oliver Schneider	e1ae3c71f3	Merge pull request #1304 from dtolnay/ci CI builders for all versions mentioned in the build script	2018-06-03 10:44:32 +02:00
David Tolnay	d094209774	CI builders for all versions mentioned in the build script This should prevent accidentally inserting something under one of these cfgs that is available only on a newer rustc. For example if something is changed in the Duration serialization, but that change works only on a recent rustc, our test suite will not have caught it before.	2018-06-03 01:26:58 -07:00
David Tolnay	485a64aaf9	Visitor for types that parse from a string	2018-06-03 01:19:46 -07:00
David Tolnay	3e57cd5917	Merge pull request #1303 from dtolnay/duration Support Duration in no-std mode on new compilers	2018-06-03 01:05:39 -07:00
David Tolnay	b6c4cfec37	Support Duration in no-std mode on new compilers	2018-06-03 00:55:58 -07:00
David Tolnay	94853752a1	Stabilize some unstable tests in test suite	2018-06-03 00:31:20 -07:00
David Tolnay	bd366f675e	Merge pull request #1302 from dtolnay/never Implement traits for `!`	2018-06-03 00:30:19 -07:00
David Tolnay	22b1af7eb3	Test never_type	2018-06-03 00:22:11 -07:00
David Tolnay	fd6178cad6	IntoDeserializer for `!`	2018-06-03 00:12:02 -07:00
David Tolnay	338fb67853	Implement traits for `!`	2018-06-03 00:02:29 -07:00
David Tolnay	0a71fe329c	Format the compile-test sources with rustfmt 0.8.2	2018-06-02 22:30:55 -07:00
David Tolnay	a4acc83282	Place compile-fail expected errors on their own line	2018-06-02 22:28:05 -07:00
David Tolnay	57de28744c	These match-expressions are implementing unwrap_or_else	2018-06-02 22:09:04 -07:00
David Tolnay	6d31ec521b	Remove leftover import from compile_error change	2018-06-02 22:01:45 -07:00
David Tolnay	7ad3d17e59	Merge pull request #1297 from adamcrume/master Use compile_error! instead of panicking	2018-06-02 22:00:24 -07:00
Adam Crume	05e931b9a5	Update tests and use quote! macro	2018-06-02 21:11:42 -07:00
David Tolnay	2db2b53bbf	Release 1.0.65	2018-06-01 13:00:58 -07:00
David Tolnay	d5ec3efe49	Merge pull request #1299 from dtolnay/flattenmap Allow multiple flattened maps to see the same fields	2018-06-01 13:00:45 -07:00
David Tolnay	71fc318474	Merge pull request #1300 from dtolnay/refcell Use try_borrow for serializing RefCell	2018-06-01 12:58:03 -07:00
David Tolnay	5ee2fc0562	Allow multiple flattened maps to see the same fields Before this change, flattening anything after a flattened map was nonsensical because the later flattened field would always observe no input fields. #[derive(Deserialize)] struct S { #[serde(flatten)] map: Map<K, V>, #[serde(flatten)] other: Other, // always empty } This change makes a flattened map not consume any of the input fields, leaving them available to later flattened fields in the same struct. The new behavior is useful when two flattened fields that both use deserialize_map care about disjoint subsets of the fields in the input. #[derive(Deserialize)] struct S { // Looks at fields with a "player1_" prefix. #[serde(flatten, with = "prefix_player1")] player1: Player, // Looks at fields with a "player2_" prefix. #[serde(flatten, with = "prefix_player2")] player2: Player, }	2018-06-01 12:50:23 -07:00
David Tolnay	ca53daf697	Fix RefCell serialize impl to work with no-std	2018-06-01 12:47:10 -07:00
Konrad Borowski	c3b9ee314b	Use try_borrow for serializing RefCell	2018-06-01 09:09:40 +02:00
Adam Crume	993710eb16	Use compile_error! instead of panicking Fixes #1168	2018-05-31 19:57:23 -07:00
David Tolnay	dbaf2893e3	Release 1.0.64	2018-05-30 00:17:45 -07:00
David Tolnay	34a7108b73	Second attempt at workaround for docs.rs compiler	2018-05-30 00:17:02 -07:00
David Tolnay	db2bafd3f3	Revert "Work around docs.rs using an old 1.26-dev compiler" This reverts commit `c81bab18ad`.	2018-05-30 00:13:20 -07:00
David Tolnay	1b6fbf1023	Release 1.0.63	2018-05-28 20:12:08 -07:00
David Tolnay	c81bab18ad	Work around docs.rs using an old 1.26-dev compiler	2018-05-28 19:58:27 -07:00
David Tolnay	a39199e9f7	Reword Avro blurb - Emphasize the association with Apache Hadoop, - Rephrase "schematized data" because that term returns not many Google results, doesn't seem widely recognized.	2018-05-27 19:39:50 -07:00
David Tolnay	b0ad1e56e8	Move Avro above deserialization-only formats	2018-05-27 19:31:05 -07:00
David Tolnay	ab53448bc3	Merge pull request #1260 from flavray/master Add Avro to the list of supported data formats	2018-05-27 19:29:19 -07:00
David Tolnay	c50c9d8862	Simplify readme as rendered on crates.io	2018-05-27 19:18:30 -07:00
David Tolnay	cc4f289758	Link from readme to new playground	2018-05-27 19:07:46 -07:00
David Tolnay	a2a9041549	Fix warning about unresolved [u8] and [T] links	2018-05-27 14:35:55 -07:00
David Tolnay	a65950acca	Link to more complete explanation of the data model	2018-05-27 14:11:02 -07:00
David Tolnay	0fbf4d0c5d	Link to example data format from trait rustdocs	2018-05-27 14:05:50 -07:00
David Tolnay	983bf8c090	Release 1.0.62	2018-05-26 18:59:03 -07:00
David Tolnay	f2afa89ff1	Explain the pattern for optional Serde derives	2018-05-26 17:59:53 -07:00
David Tolnay	8b4f9c47c4	Build script rustc-cfg strings are not public API	2018-05-26 17:23:09 -07:00
David Tolnay	06d8a44f18	Move unimportant code out of build script main	2018-05-26 17:18:14 -07:00
David Tolnay	fffdceca95	Link to "Understanding deserializer lifetimes"	2018-05-26 17:08:46 -07:00
David Tolnay	794b769e6b	Merge pull request #1288 from dtolnay/copy Implement Copy for value deserializers of primitive types	2018-05-26 16:05:12 -07:00
David Tolnay	927ec7d38e	Implement Copy for value deserializers of primitive types	2018-05-26 15:56:57 -07:00
David Tolnay	cd0b2d312c	Merge pull request #1286 from dtolnay/into128 Implement IntoDeserializer for i128 and u128	2018-05-26 15:36:46 -07:00
David Tolnay	ea118e11a0	Test the 128-bit IntoDeserializer impls	2018-05-26 15:21:37 -07:00
David Tolnay	0ff4882cab	Implement IntoDeserializer for i128 and u128	2018-05-26 15:15:07 -07:00
David Tolnay	7407d71417	Release 1.0.61	2018-05-26 10:38:18 -07:00
David Tolnay	9faa11fd9a	Update list of impls to show NonZero* stable	2018-05-26 10:37:08 -07:00
David Tolnay	5310bd87ae	Remove unneeded core import This was previously used by the unstable nonzero impls. #[cfg(feature = "unstable")] use core::num::{NonZeroU16, NonZeroU32, NonZeroU64, NonZeroU8, NonZeroUsize};	2018-05-26 10:37:06 -07:00
David Tolnay	99091d5925	Merge pull request #1285 from dtolnay/rcdst Stabilize impls for dynamically sized Rc / Arc	2018-05-26 10:36:52 -07:00
David Tolnay	320a059e4b	Stabilize impls for dynamically sized Rc / Arc	2018-05-26 10:06:29 -07:00
David Tolnay	8a596951bf	Merge pull request #1284 from serde-rs/boxcstr Stabilize Deserialize for Box<CStr>	2018-05-26 10:06:14 -07:00
David Tolnay	350406e827	Merge pull request #1283 from serde-rs/dep Specify serde version required by serde_test	2018-05-26 09:53:47 -07:00
David Tolnay	7ec3cac7d6	Stabilize Deserialize for Box<CStr>	2018-05-26 09:48:50 -07:00
David Tolnay	ad47bd132b	Specify serde version required by serde_test	2018-05-26 09:42:31 -07:00
Flavien Raynaud	38d4f0e06c	Add Avro to the list of supported data formats	2018-05-16 16:22:25 +01:00