Release 1.0.71

Merge pull request #1349 from dtolnay/range
Share some code between the Range and RangeInclusive impls
2026-04-23 09:28:04 +00:00 · 2018-08-06 23:55:55 -07:00 · 2018-08-06 23:30:03 -07:00 · 2018-08-06 23:16:47 -07:00 · 2018-08-06 23:04:26 -07:00 · 2018-08-06 22:57:46 -07:00
99 changed files with 859 additions and 494 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:
@@ -79,12 +79,13 @@ fn main() {

 ## Getting help

-Serde developers live in the #serde channel on
-[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
-good resource with generally faster response time but less specific knowledge
-about Serde. If IRC is not your thing or you don't get a good response, we are
-happy to respond to [GitHub issues](https://github.com/serde-rs/serde/issues/new)
-as well.
+Serde developers live in the #serde channel on [`irc.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][issues] as well.
+
+[irc]: https://wiki.mozilla.org/IRC
+[issues]: https://github.com/serde-rs/serde/issues/new/choose

 ## License

@@ -47,9 +47,10 @@ fn main() {

 ## Getting help

-Serde developers live in the #serde channel on
-[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
-good resource with generally faster response time but less specific knowledge
-about Serde. If IRC is not your thing or you don't get a good response, we are
-happy to respond to [GitHub issues](https://github.com/serde-rs/serde/issues/new)
-as well.
+Serde developers live in the #serde channel on [`irc.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][issues] as well.
+
+[irc]: https://wiki.mozilla.org/IRC
+[issues]: https://github.com/serde-rs/serde/issues/new/choose
@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.65" # remember to update html_root_url
+version = "1.0.71" # 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"
@@ -24,12 +24,24 @@ fn main() {
        println!("cargo:rustc-cfg=de_rc_dst");
    }

+    // 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
    if minor >= 26 {
        println!("cargo:rustc-cfg=integer128");
    }

+    // Inclusive ranges methods stabilized in Rust 1.27:
+    // https://github.com/rust-lang/rust/pull/50758
+    if minor >= 27 {
+        println!("cargo:rustc-cfg=range_inclusive");
+    }
+
    // Non-zero integers stabilized in Rust 1.28:
    // https://github.com/rust-lang/rust/pull/50808
    if minor >= 28 {
@@ -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;
@@ -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,13 @@ 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(de_rc_dst), 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 +1620,13 @@ forwarded_impl! {
    (T), Arc<T>, Arc::new
 }

-#[cfg(all(not(de_rc_dst), 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 +1693,13 @@ where

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

-#[cfg(all(de_rc_dst, 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 +1720,13 @@ macro_rules! box_forwarded_impl {
    };
 }

-#[cfg(all(de_rc_dst, 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 +1738,13 @@ box_forwarded_impl! {
    Rc
 }

-#[cfg(all(de_rc_dst, 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 +1788,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 +1836,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))
                            }
                        }
@@ -1950,8 +2054,7 @@ impl<'de> Deserialize<'de> for SystemTime {
 //         start: u64,
 //         end: u32,
 //     }
-#[cfg(feature = "std")]
-impl<'de, Idx> Deserialize<'de> for ops::Range<Idx>
+impl<'de, Idx> Deserialize<'de> for Range<Idx>
 where
    Idx: Deserialize<'de>,
 {
@@ -1959,134 +2062,165 @@ where
    where
        D: Deserializer<'de>,
    {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(field_identifier, rename_all = "lowercase")]
-        enum Field {
-            Start,
-            End,
-        };
-
-        impl<'de> Deserialize<'de> for Field {
-            fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            where
-                D: Deserializer<'de>,
-            {
-                struct FieldVisitor;
-
-                impl<'de> Visitor<'de> for FieldVisitor {
-                    type Value = Field;
-
-                    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`start` or `end`")
-                    }
-
-                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            "start" => Ok(Field::Start),
-                            "end" => Ok(Field::End),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
-                        }
-                    }
-
-                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
-                    where
-                        E: Error,
-                    {
-                        match value {
-                            b"start" => Ok(Field::Start),
-                            b"end" => Ok(Field::End),
-                            _ => {
-                                let value = String::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
-                            }
-                        }
-                    }
-                }
-
-                deserializer.deserialize_identifier(FieldVisitor)
-            }
-        }
-
-        struct RangeVisitor<Idx> {
-            phantom: PhantomData<Idx>,
-        }
-
-        impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
-        where
-            Idx: Deserialize<'de>,
-        {
-            type Value = ops::Range<Idx>;
-
-            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct Range")
-            }
-
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-            where
-                A: SeqAccess<'de>,
-            {
-                let start: Idx = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let end: Idx = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                Ok(start..end)
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut start: Option<Idx> = None;
-                let mut end: Option<Idx> = None;
-                while let Some(key) = try!(map.next_key()) {
-                    match key {
-                        Field::Start => {
-                            if start.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("start"));
-                            }
-                            start = Some(try!(map.next_value()));
-                        }
-                        Field::End => {
-                            if end.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("end"));
-                            }
-                            end = Some(try!(map.next_value()));
-                        }
-                    }
-                }
-                let start = match start {
-                    Some(start) => start,
-                    None => return Err(<A::Error as Error>::missing_field("start")),
-                };
-                let end = match end {
-                    Some(end) => end,
-                    None => return Err(<A::Error as Error>::missing_field("end")),
-                };
-                Ok(start..end)
-            }
-        }
-
-        const FIELDS: &'static [&'static str] = &["start", "end"];
-        deserializer.deserialize_struct(
+        let (start, end) = deserializer.deserialize_struct(
            "Range",
-            FIELDS,
-            RangeVisitor {
+            range::FIELDS,
+            range::RangeVisitor {
+                expecting: "struct Range",
                phantom: PhantomData,
            },
-        )
+        )?;
+        Ok(start..end)
+    }
+}
+
+#[cfg(range_inclusive)]
+impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
+where
+    Idx: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (start, end) = deserializer.deserialize_struct(
+            "RangeInclusive",
+            range::FIELDS,
+            range::RangeVisitor {
+                expecting: "struct RangeInclusive",
+                phantom: PhantomData,
+            },
+        )?;
+        Ok(RangeInclusive::new(start, end))
+    }
+}
+
+mod range {
+    use lib::*;
+
+    use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+
+    pub const FIELDS: &'static [&'static str] = &["start", "end"];
+
+    // If this were outside of the serde crate, it would just use:
+    //
+    //    #[derive(Deserialize)]
+    //    #[serde(field_identifier, rename_all = "lowercase")]
+    enum Field {
+        Start,
+        End,
+    }
+
+    impl<'de> Deserialize<'de> for Field {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct FieldVisitor;
+
+            impl<'de> Visitor<'de> for FieldVisitor {
+                type Value = Field;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("`start` or `end`")
+                }
+
+                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        "start" => Ok(Field::Start),
+                        "end" => Ok(Field::End),
+                        _ => Err(Error::unknown_field(value, FIELDS)),
+                    }
+                }
+
+                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        b"start" => Ok(Field::Start),
+                        b"end" => Ok(Field::End),
+                        _ => {
+                            let value = ::export::from_utf8_lossy(value);
+                            Err(Error::unknown_field(&value, FIELDS))
+                        }
+                    }
+                }
+            }
+
+            deserializer.deserialize_identifier(FieldVisitor)
+        }
+    }
+
+    pub struct RangeVisitor<Idx> {
+        pub expecting: &'static str,
+        pub phantom: PhantomData<Idx>,
+    }
+
+    impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
+    where
+        Idx: Deserialize<'de>,
+    {
+        type Value = (Idx, Idx);
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str(self.expecting)
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let start: Idx = match try!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(0, &self));
+                }
+            };
+            let end: Idx = match try!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(1, &self));
+                }
+            };
+            Ok((start, end))
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut start: Option<Idx> = None;
+            let mut end: Option<Idx> = None;
+            while let Some(key) = try!(map.next_key()) {
+                match key {
+                    Field::Start => {
+                        if start.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("start"));
+                        }
+                        start = Some(try!(map.next_value()));
+                    }
+                    Field::End => {
+                        if end.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("end"));
+                        }
+                        end = Some(try!(map.next_value()));
+                    }
+                }
+            }
+            let start = match start {
+                Some(start) => start,
+                None => return Err(<A::Error as Error>::missing_field("start")),
+            };
+            let end = match end {
+                Some(end) => end,
+                None => return Err(<A::Error as Error>::missing_field("end")),
+            };
+            Ok((start, end))
+        }
    }
 }

@@ -97,7 +97,9 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
+//!    - RangeInclusive\<T\>
 //!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -592,11 +594,7 @@ pub trait Deserialize<'de>: Sized {
 ///
 /// [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,
@@ -176,6 +176,48 @@ 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"]
@@ -82,22 +82,29 @@
 ////////////////////////////////////////////////////////////////////////////////

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.65")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.71")]
 // 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
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
-        cast_lossless, const_static_lifetime, doc_markdown, linkedlist, needless_pass_by_value,
-        redundant_field_names, type_complexity, unreadable_literal, zero_prefixed_literal
+        cast_lossless,
+        const_static_lifetime,
+        doc_markdown,
+        linkedlist,
+        needless_pass_by_value,
+        redundant_field_names,
+        type_complexity,
+        unreadable_literal,
+        zero_prefixed_literal
    )
 )]
 // Whitelisted clippy_pedantic lints
@@ -118,6 +125,7 @@
    stutter,
    use_self,
 // not practical
+    indexing_slicing,
    many_single_char_names,
    missing_docs_in_private_items,
    similar_names,
@@ -126,7 +134,10 @@
    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*/)]

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

@@ -144,7 +155,7 @@ mod lib {
        pub use std::*;
    }

-    pub use self::core::{cmp, iter, mem, num, ops, slice, str};
+    pub use self::core::{cmp, iter, mem, num, slice, str};
    pub use self::core::{f32, f64};
    pub use self::core::{i16, i32, i64, i8, isize};
    pub use self::core::{u16, u32, u64, u8, usize};
@@ -155,6 +166,7 @@ mod lib {
    pub use self::core::default::{self, Default};
    pub use self::core::fmt::{self, Debug, Display};
    pub use self::core::marker::{self, PhantomData};
+    pub use self::core::ops::Range;
    pub use self::core::option::{self, Option};
    pub use self::core::result::{self, Result};

@@ -189,7 +201,7 @@ mod lib {
    pub use std::sync::{Arc, Weak as ArcWeak};

    #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
+    pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
    #[cfg(feature = "std")]
    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};

@@ -211,7 +223,13 @@ 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;
+
+    #[cfg(range_inclusive)]
+    pub use self::core::ops::RangeInclusive;
 }

 ////////////////////////////////////////////////////////////////////////////////
@@ -128,7 +128,7 @@
 /// [`Deserializer`]: trait.Deserializer.html
 /// [`Visitor`]: de/trait.Visitor.html
 /// [`Deserializer::deserialize_any`]: trait.Deserializer.html#tymethod.deserialize_any
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! forward_to_deserialize_any {
    (<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => {
        $(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})*
@@ -157,7 +157,7 @@ macro_rules! forward_to_deserialize_any_method {
 }

 #[doc(hidden)]
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! forward_to_deserialize_any_helper {
    (bool<$l:tt, $v:ident>) => {
        forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()}
@@ -32,7 +32,7 @@ macro_rules! __private_deserialize {

 /// Used only by Serde doc tests. Not public API.
 #[doc(hidden)]
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! __serialize_unimplemented {
    ($($func:ident)*) => {
        $(
@@ -52,7 +52,7 @@ macro_rules! __serialize_unimplemented_method {
 }

 #[doc(hidden)]
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! __serialize_unimplemented_helper {
    (bool) => {
        __serialize_unimplemented_method!(serialize_bool(bool) -> Ok);
@@ -69,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")]
@@ -218,8 +227,7 @@ seq_impl!(VecDeque<T>);

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

-#[cfg(feature = "std")]
-impl<Idx> Serialize for ops::Range<Idx>
+impl<Idx> Serialize for Range<Idx>
 where
    Idx: Serialize,
 {
@@ -237,6 +245,25 @@ where

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

+#[cfg(range_inclusive)]
+impl<Idx> Serialize for RangeInclusive<Idx>
+where
+    Idx: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use super::SerializeStruct;
+        let mut state = try!(serializer.serialize_struct("RangeInclusive", 2));
+        try!(state.serialize_field("start", &self.start()));
+        try!(state.serialize_field("end", &self.end()));
+        state.end()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 impl Serialize for () {
    #[inline]
    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -247,6 +274,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 {
@@ -517,7 +554,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
@@ -92,7 +92,9 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
+//!    - RangeInclusive\<T\>
 //!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.65" # remember to update html_root_url
+version = "1.0.71" # 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)]"
@@ -32,8 +32,7 @@ pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
                    ..param.clone()
                }),
                _ => param.clone(),
-            })
-            .collect(),
+            }).collect(),
        ..generics.clone()
    }
 }
@@ -193,14 +192,13 @@ pub fn with_bound(
        .map(|id| syn::TypePath {
            qself: None,
            path: id.into(),
-        })
-        .chain(associated_type_usage.into_iter().cloned())
+        }).chain(associated_type_usage.into_iter().cloned())
        .map(|bounded_ty| {
            syn::WherePredicate::Type(syn::PredicateType {
                lifetimes: None,
                // the type parameter that is being bounded e.g. T
                bounded_ty: syn::Type::Path(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,
@@ -208,7 +206,7 @@ pub fn with_bound(
                    lifetimes: None,
                    path: bound.clone(),
                })].into_iter()
-                    .collect(),
+                .collect(),
            })
        });

@@ -233,7 +231,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,
@@ -241,7 +239,7 @@ pub fn with_self_bound(
                lifetimes: None,
                path: bound.clone(),
            })].into_iter()
-                .collect(),
+            .collect(),
        }));
    generics
 }
@@ -270,8 +268,7 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
                syn::GenericParam::Const(_) => {}
            }
            param
-        }))
-        .collect();
+        })).collect();

    syn::Generics {
        params: params,
@@ -289,7 +286,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
@@ -307,13 +304,12 @@ fn type_of_item(cont: &Container) -> syn::Type {
                                syn::GenericParam::Const(_) => {
                                    panic!("Serde does not support const generics yet");
                                }
-                            })
-                            .collect(),
-                        gt_token: Default::default(),
+                            }).collect(),
+                        gt_token: <Token![>]>::default(),
                    },
                ),
            }].into_iter()
-                .collect(),
+            .collect(),
        },
    })
 }
@@ -73,6 +73,9 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
    let generated = quote! {
        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
        const #dummy_const: () = {
+            #[allow(unknown_lints)]
+            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
+            #[allow(rust_2018_idioms)]
            extern crate serde as _serde;
            #try_replacement
            #impl_block
@@ -201,7 +204,9 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
 // All other fields may need a `T: Deserialize` bound where T is the type of the
 // field.
 fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_deserializing() && field.deserialize_with().is_none() && field.de_bound().is_none()
+    !field.skip_deserializing()
+        && field.deserialize_with().is_none()
+        && field.de_bound().is_none()
        && variant.map_or(true, |variant| {
            !variant.skip_deserializing()
                && variant.deserialize_with().is_none()
@@ -1347,8 +1352,7 @@ fn deserialize_adjacently_tagged_enum(
            quote! {
                __Field::#variant_index => #block
            }
-        })
-        .collect();
+        }).collect();

    let expecting = format!("adjacently tagged enum {}", params.type_name());
    let type_name = cattrs.name().deserialize_name();
@@ -1936,8 +1940,7 @@ fn deserialize_custom_identifier(
                variant.attrs.name().deserialize_name(),
                variant.ident.clone(),
            )
-        })
-        .collect();
+        }).collect();

    let names = names_idents.iter().map(|&(ref name, _)| name);

@@ -129,8 +129,7 @@ fn enum_from_ast<'a>(
                style: style,
                fields: fields,
            }
-        })
-        .collect()
+        }).collect()
 }

 fn struct_from_ast<'a>(
@@ -173,6 +172,5 @@ fn fields_from_ast<'a>(
            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
            ty: &field.ty,
            original: field,
-        })
-        .collect()
+        }).collect()
 }
@@ -22,22 +22,35 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.65")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.71")]
 #![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
+        enum_variant_names,
+        redundant_field_names,
+        too_many_arguments,
+        used_underscore_binding,
+        cyclomatic_complexity,
+        needless_pass_by_value
    )
 )]
 // Whitelisted clippy_pedantic lints
 #![cfg_attr(
    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
+        items_after_statements,
+        doc_markdown,
+        stutter,
+        similar_names,
+        use_self,
+        single_match_else,
+        enum_glob_use,
+        match_same_arms,
+        filter_map,
+        cast_possible_truncation,
+        indexing_slicing,
    )
 )]
 // The `quote!` macro requires deep recursion.
@@ -69,17 +82,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);
    }
 }
@@ -62,8 +62,7 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
                    Some(quote!(#type_ident::#variant_ident #pat))
                }
                _ => None,
-            })
-            .collect::<Vec<_>>(),
+            }).collect::<Vec<_>>(),
        Data::Struct(Style::Struct, ref fields) => {
            let pat = struct_pattern(fields);
            vec![quote!(#type_ident #pat)]
@@ -61,6 +61,9 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
    let generated = quote! {
        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
        const #dummy_const: () = {
+            #[allow(unknown_lints)]
+            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
+            #[allow(rust_2018_idioms)]
            extern crate serde as _serde;
            #try_replacement
            #impl_block
@@ -157,7 +160,9 @@ fn build_generics(cont: &Container) -> syn::Generics {
 // attribute specify their own bound so we do not generate one. All other fields
 // may need a `T: Serialize` bound where T is the type of the field.
 fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_serializing() && field.serialize_with().is_none() && field.ser_bound().is_none()
+    !field.skip_serializing()
+        && field.serialize_with().is_none()
+        && field.ser_bound().is_none()
        && variant.map_or(true, |variant| {
            !variant.skip_serializing()
                && variant.serialize_with().is_none()
@@ -279,8 +284,7 @@ fn serialize_tuple_struct(
                let field_expr = get_member(params, field, &Member::Unnamed(index));
                quote!(if #path(#field_expr) { 0 } else { 1 })
            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+        }).fold(quote!(0), |sum, expr| quote!(#sum + #expr));

    quote_block! {
        let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len));
@@ -323,8 +327,7 @@ fn serialize_struct_as_struct(
                let field_expr = get_member(params, field, &field.member);
                quote!(if #path(#field_expr) { 0 } else { 1 })
            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+        }).fold(quote!(0), |sum, expr| quote!(#sum + #expr));

    quote_block! {
        let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len));
@@ -358,8 +361,7 @@ fn serialize_struct_as_map(
                    let field_expr = get_member(params, field, &field.member);
                    quote!(if #path(#field_expr) { 0 } else { 1 })
                }
-            })
-            .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+            }).fold(quote!(0), |sum, expr| quote!(#sum + #expr));
        quote!(_serde::export::Some(#len))
    };

@@ -380,8 +382,7 @@ fn serialize_enum(params: &Parameters, variants: &[Variant], cattrs: &attr::Cont
        .enumerate()
        .map(|(variant_index, variant)| {
            serialize_variant(params, variant, variant_index as u32, cattrs)
-        })
-        .collect();
+        }).collect();

    quote_expr! {
        match *#self_var {
@@ -785,8 +786,7 @@ fn serialize_tuple_variant(
                let field_expr = Ident::new(&format!("__field{}", i), Span::call_site());
                quote!(if #path(#field_expr) { 0 } else { 1 })
            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+        }).fold(quote!(0), |sum, expr| quote!(#sum + #expr));

    match context {
        TupleVariant::ExternallyTagged {
@@ -863,8 +863,7 @@ fn serialize_struct_variant<'a>(
                Some(path) => quote!(if #path(#member) { 0 } else { 1 }),
                None => quote!(1),
            }
-        })
-        .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+        }).fold(quote!(0), |sum, expr| quote!(#sum + #expr));

    match context {
        StructVariant::ExternallyTagged {
@@ -1043,8 +1042,7 @@ fn serialize_tuple_struct_visitor(
                None => ser,
                Some(skip) => quote!(if !#skip { #ser }),
            }
-        })
-        .collect()
+        }).collect()
 }

 fn serialize_struct_visitor(
@@ -1138,8 +1136,7 @@ fn wrap_serialize_variant_with(
                }
            };
            quote!(#id)
-        })
-        .collect();
+        }).collect();
    wrap_serialize_with(
        params,
        serialize_with,
@@ -9,7 +9,12 @@
 #![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.23.1")]
 #![cfg_attr(
    feature = "cargo-clippy",
-    allow(cyclomatic_complexity, doc_markdown, match_same_arms, redundant_field_names)
+    allow(
+        cyclomatic_complexity,
+        doc_markdown,
+        match_same_arms,
+        redundant_field_names
+    )
 )]

 #[macro_use]
@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.65" # remember to update html_root_url
+version = "1.0.71" # 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"
@@ -253,7 +253,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
            Token::UnitVariant { name: n, .. }
            | Token::NewtypeVariant { name: n, .. }
            | Token::TupleVariant { name: n, .. }
-            | Token::StructVariant { name: n, .. } if name == n =>
+            | Token::StructVariant { name: n, .. }
+                if name == n =>
            {
                visitor.visit_enum(DeserializerEnumVisitor { de: self })
            }
@@ -161,7 +161,7 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.65")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.71")]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Whitelisted clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
@@ -169,8 +169,12 @@
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
-        empty_line_after_outer_attr, missing_docs_in_private_items, redundant_field_names, stutter,
-        use_debug, use_self
+        empty_line_after_outer_attr,
+        missing_docs_in_private_items,
+        redundant_field_names,
+        stutter,
+        use_debug,
+        use_self
    )
 )]

@@ -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() {}
@@ -29,8 +29,3 @@ fn run_mode(mode: &'static str) {
 fn compile_fail() {
    run_mode("compile-fail");
 }
-
-#[test]
-fn run_pass() {
-    run_mode("run-pass");
-}
@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![deny(identity_op)]
-
-#[macro_use]
-extern crate serde_derive;
-
-// The derived implementation uses 0+1 to add up the number of fields
-// serialized, which Clippy warns about. If the expansion info is registered
-// correctly, the Clippy lint is not triggered.
-#[derive(Serialize)]
-struct A { b: u8 }
-
-fn main() {}
@@ -348,7 +348,10 @@ struct ContainsNotDeserialize<A, B, C: DeserializeWith, E: MyDefault> {
    a: A,
    #[serde(skip_deserializing, default)]
    b: B,
-    #[serde(deserialize_with = "DeserializeWith::deserialize_with", default)]
+    #[serde(
+        deserialize_with = "DeserializeWith::deserialize_with",
+        default
+    )]
    c: C,
    #[serde(skip_deserializing, default = "MyDefault::my_default")]
    e: E,
@@ -6,14 +6,18 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.

-#![cfg_attr(feature = "cargo-clippy", allow(decimal_literal_representation))]
+#![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 +25,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};

@@ -217,9 +218,9 @@ fn assert_de_tokens_ignore(ignorable_tokens: &[Token]) {
        Token::I32(1),
        Token::Str("ignored"),
    ].into_iter()
-        .chain(ignorable_tokens.to_vec().into_iter())
-        .chain(vec![Token::MapEnd].into_iter())
-        .collect();
+    .chain(ignorable_tokens.to_vec().into_iter())
+    .chain(vec![Token::MapEnd].into_iter())
+    .collect();

    let mut de = serde_test::Deserializer::new(&concated_tokens);
    let base = IgnoreBase::deserialize(&mut de).unwrap();
@@ -810,6 +811,23 @@ declare_tests! {
            Token::SeqEnd,
        ],
    }
+    test_range_inclusive {
+        1u32..=2u32 => &[
+            Token::Struct { name: "RangeInclusive", len: 2 },
+                Token::Str("start"),
+                Token::U32(1),
+
+                Token::Str("end"),
+                Token::U32(2),
+            Token::StructEnd,
+        ],
+        1u32..=2u32 => &[
+            Token::Seq { len: Some(2) },
+                Token::U64(1),
+                Token::U64(2),
+            Token::SeqEnd,
+        ],
+    }
    test_path {
        Path::new("/usr/local/lib") => &[
            Token::BorrowedStr("/usr/local/lib"),
@@ -865,6 +883,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 +1000,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 +1048,6 @@ fn test_osstring() {
    assert_de_tokens_ignore(&tokens);
 }

-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr() {
    assert_de_tokens::<Box<CStr>>(
@@ -1033,7 +1056,6 @@ fn test_cstr() {
    );
 }

-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr_internal_null() {
    assert_de_tokens_error::<Box<CStr>>(
@@ -1042,7 +1064,6 @@ fn test_cstr_internal_null() {
    );
 }

-#[cfg(feature = "unstable")]
 #[test]
 fn test_cstr_internal_null_end() {
    assert_de_tokens_error::<Box<CStr>>(
@@ -1051,6 +1072,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> {
        &[
@@ -198,7 +198,12 @@ fn test_gen() {
    assert::<WithTraits1<X, X>>();

    #[derive(Serialize, Deserialize)]
-    #[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))]
+    #[serde(
+        bound(
+            serialize = "D: SerializeWith",
+            deserialize = "D: DeserializeWith"
+        )
+    )]
    struct WithTraits2<D, E> {
        #[serde(
            serialize_with = "SerializeWith::serialize_with",
@@ -206,7 +211,8 @@ fn test_gen() {
        )]
        d: D,
        #[serde(
-            serialize_with = "SerializeWith::serialize_with", bound(serialize = "E: SerializeWith")
+            serialize_with = "SerializeWith::serialize_with",
+            bound(serialize = "E: SerializeWith")
        )]
        #[serde(
            deserialize_with = "DeserializeWith::deserialize_with",
@@ -234,7 +240,12 @@ fn test_gen() {
    assert::<VariantWithTraits1<X, X>>();

    #[derive(Serialize, Deserialize)]
-    #[serde(bound(serialize = "D: SerializeWith", deserialize = "D: DeserializeWith"))]
+    #[serde(
+        bound(
+            serialize = "D: SerializeWith",
+            deserialize = "D: DeserializeWith"
+        )
+    )]
    enum VariantWithTraits2<D, E> {
        #[serde(
            serialize_with = "SerializeWith::serialize_with",
@@ -242,7 +253,8 @@ fn test_gen() {
        )]
        D(D),
        #[serde(
-            serialize_with = "SerializeWith::serialize_with", bound(serialize = "E: SerializeWith")
+            serialize_with = "SerializeWith::serialize_with",
+            bound(serialize = "E: SerializeWith")
        )]
        #[serde(
            deserialize_with = "DeserializeWith::deserialize_with",
@@ -297,11 +309,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 +337,6 @@ fn test_gen() {
        Variant,
    }

-    #[cfg(feature = "unstable")]
    #[derive(Serialize, Deserialize)]
    enum EmptyVariants {
        Braced {},
@@ -339,7 +348,6 @@ fn test_gen() {
        TupleSkip(#[serde(skip_deserializing)] u8),
    }

-    #[cfg(feature = "unstable")]
    #[derive(Serialize, Deserialize)]
    #[serde(deny_unknown_fields)]
    enum EmptyVariantsDenyUnknown {
@@ -6,6 +6,8 @@
 // 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;

@@ -375,6 +377,17 @@ declare_tests! {
            Token::StructEnd,
        ],
    }
+    test_range_inclusive {
+        1u32..=2u32 => &[
+            Token::Struct { name: "RangeInclusive", len: 2 },
+                Token::Str("start"),
+                Token::U32(1),
+
+                Token::Str("end"),
+                Token::U32(2),
+            Token::StructEnd,
+        ],
+    }
    test_path {
        Path::new("/usr/local/lib") => &[
            Token::Str("/usr/local/lib"),
@@ -440,6 +453,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! {
@@ -523,27 +561,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),
        ],
    }
 }
@@ -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	24c4df7831	Release 1.0.71	2018-08-06 23:55:55 -07:00
David Tolnay	a077ae039e	Merge pull request #1349 from dtolnay/range Share some code between the Range and RangeInclusive impls	2018-08-06 23:30:03 -07:00
David Tolnay	20b34d3b43	Share some code between the Range and RangeInclusive impls	2018-08-06 23:16:47 -07:00
David Tolnay	b5451d1905	Merge pull request #1348 from dtolnay/range Provide ops::Range impls whether or not std is used	2018-08-06 23:04:26 -07:00
David Tolnay	e26960f7f8	Remove useless run-pass test When originally added, this test used to contain a `#![plugin(clippy)]`. This was removed at some point along the way, at which point this test no longer tests anything. It prints: warning: unknown lint: `identity_op` --> src/main.rs:1:9 \| 1 \| #![deny(identity_op)] \| ^^^^^^^^^^^ \| = note: #[warn(unknown_lints)] on by default which is swallowed and ignored by compiletest. Nowadays Clippy handles warnings inside of macro expanded code intelligently and this is something they would be responsible for testing.	2018-08-06 22:57:46 -07:00
David Tolnay	228b5a4a63	Provide ops::Range impls whether or not std is used	2018-08-06 22:49:09 -07:00
David Tolnay	28db9d4989	Format with rustfmt 0.99.1	2018-08-06 22:40:28 -07:00
David Tolnay	5fff0d936d	Merge pull request #1347 from c410-f3r/master Implement Serialize and Deserialize for RangeInclusive	2018-08-06 22:36:12 -07:00
Caio	8eb195edf0	Fix tests	2018-08-05 17:38:41 -03:00
Caio	8b2e6baf78	Implement Serialize and Deserialize for RangeInclusive	2018-08-05 10:45:50 -03:00
David Tolnay	4e54aaf796	Format with rustfmt 0.8.2	2018-07-08 19:02:44 -07:00
David Tolnay	4cddcbe194	Release 1.0.70	2018-07-06 20:21:26 -07:00
David Tolnay	54b6798ef6	Merge pull request #1336 from dtolnay/collections Update path to alloc::collections for nightly-2018-07-07	2018-07-06 20:19:59 -07:00
David Tolnay	229a9d90ba	Update path to alloc::collections for nightly-2018-07-07	2018-07-06 20:04:23 -07:00
David Tolnay	3bcd568c86	Release 1.0.69	2018-06-30 23:40:28 -07:00
David Tolnay	dc56077aac	Local inner macros	2018-06-30 23:38:14 -07:00
David Tolnay	46bd36e17c	Link to issue picker	2018-06-30 10:30:14 -07:00
David Tolnay	5dee9118c7	Factor out the getting help links	2018-06-30 10:29:36 -07:00
David Tolnay	a916aa9420	Release 1.0.68	2018-06-28 09:31:12 -07:00
David Tolnay	d9c63d0784	Merge pull request #1324 from jechase/suppress_2018_warning Suppress 'extern crate' warning for rust 2018	2018-06-28 09:30:40 -07:00
Josh Chase	41dcb969e8	Shut clippy up	2018-06-28 11:12:27 -04:00
Josh Chase	6dbaea34ba	Suppress 'extern crate' warning for rust 2018	2018-06-28 10:51:57 -04:00
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
Adam Crume	993710eb16	Use compile_error! instead of panicking Fixes #1168	2018-05-31 19:57:23 -07:00