Release 1.0.84

Test with same features in Travis and AppVeyor
Enable extra features in playground
2026-04-23 17:38:04 +00:00 · 2018-12-31 23:45:34 -05:00 · 2018-12-31 23:31:49 -05:00 · 2018-12-31 23:28:10 -05:00 · 2018-12-31 23:22:13 -05:00 · 2018-12-31 23:22:12 -05:00
225 changed files with 686 additions and 991 deletions
@@ -9,7 +9,7 @@ matrix:
        - cargo build --no-default-features
        - cd "${TRAVIS_BUILD_DIR}/serde_test"
        - cargo build
-        - cargo test
+        - cargo test --features serde/derive,serde/rc

    - rust: beta
      script:
@@ -25,11 +25,11 @@ matrix:
        - cargo build --no-default-features
        - cargo build --no-default-features --features alloc
        - cargo build --no-default-features --features rc,alloc
-        - cargo test --features rc,unstable
+        - cargo test --features derive,rc,unstable
        - cd "${TRAVIS_BUILD_DIR}/test_suite/deps"
        - cargo build
        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test --features unstable
+        - cargo test --features compiletest,unstable
        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
        - cargo build

@@ -55,17 +55,17 @@ matrix:
      name: Clippy
      script:
        - rustup component add clippy-preview || travis_terminate 0
-        - cargo clippy -- -Dclippy
+        - cargo clippy -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo clippy --features rc,unstable -- -Dclippy
+        - cargo clippy --features rc,unstable -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
-        - cargo clippy -- -Dclippy
+        - cargo clippy -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo clippy -- -Dclippy
+        - cargo clippy -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo clippy --features unstable -- -Dclippy
+        - cargo clippy --tests --features unstable -- -D clippy::all
        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
-        - cargo clippy -- -Dclippy
+        - cargo clippy -- -D clippy::all

    - rust: nightly
      name: Emscripten
@@ -23,7 +23,7 @@ for:
      - cargo build --no-default-features
      - cd %APPVEYOR_BUILD_FOLDER%\serde_test
      - cargo build
-      - cargo test
+      - cargo test --features serde/derive,serde/rc

  - matrix:
      only:
@@ -34,8 +34,8 @@ for:
      - cargo build --no-default-features
      - cargo build --no-default-features --features alloc
      - cargo build --no-default-features --features rc,alloc
-      - cargo test --features rc,unstable
+      - cargo test --features derive,rc,unstable
      - cd %APPVEYOR_BUILD_FOLDER%\test_suite\deps
      - cargo build
      - cd %APPVEYOR_BUILD_FOLDER%\test_suite
-      - cargo test --features unstable
+      - cargo test --features compiletest,unstable
@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.83" # remember to update html_root_url
+version = "1.0.84" # 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"
@@ -23,6 +23,9 @@ serde_derive = { version = "1.0", optional = true, path = "../serde_derive" }
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

+[package.metadata.playground]
+features = ["derive", "rc"]
+

 ### FEATURES #################################################################

@@ -8,7 +8,7 @@ use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 /// any type, except that it does not store any information about the data that
 /// gets deserialized.
 ///
-/// ```rust
+/// ```edition2018
 /// use std::fmt;
 /// use std::marker::PhantomData;
 ///
@@ -21,7 +21,7 @@ use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 /// ///
 /// /// For example to deserialize only the element at index 3:
 /// ///
-/// /// ```rust
+/// /// ```
 /// /// NthElement::new(3).deserialize(deserializer)
 /// /// ```
 /// pub struct NthElement<T> {
@@ -153,7 +153,7 @@ macro_rules! declare_error_trait {
            ///
            /// The message should not be capitalized and should not end with a period.
            ///
-            /// ```rust
+            /// ```edition2018
            /// # use std::str::FromStr;
            /// #
            /// # struct IpAddr;
@@ -173,7 +173,7 @@ macro_rules! declare_error_trait {
            ///     where
            ///         D: Deserializer<'de>,
            ///     {
-            ///         let s = try!(String::deserialize(deserializer));
+            ///         let s = String::deserialize(deserializer)?;
            ///         s.parse().map_err(de::Error::custom)
            ///     }
            /// }
@@ -298,7 +298,7 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// This is used as an argument to the `invalid_type`, `invalid_value`, and
 /// `invalid_length` methods of the `Error` trait to build error messages.
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -423,7 +423,7 @@ impl<'a> fmt::Display for Unexpected<'a> {
 /// Within the context of a `Visitor` implementation, the `Visitor` itself
 /// (`&self`) is an implementation of this trait.
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -448,7 +448,7 @@ impl<'a> fmt::Display for Unexpected<'a> {
 ///
 /// Outside of a `Visitor`, `&"..."` can be used.
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::{self, Unexpected};
 /// #
 /// # fn example<E>() -> Result<(), E>
@@ -569,7 +569,7 @@ pub trait Deserialize<'de>: Sized {
 /// from the input string, but a `from_reader` function may only deserialize
 /// owned data.
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::{Deserialize, DeserializeOwned};
 /// # use std::io::{Read, Result};
 /// #
@@ -608,7 +608,7 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 ///
 /// The canonical API for stateless deserialization looks like this:
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::Deserialize;
 /// #
 /// # enum Error {}
@@ -622,7 +622,7 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 /// Adjusting an API like this to support stateful deserialization is a matter
 /// of accepting a seed as input:
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::DeserializeSeed;
 /// #
 /// # enum Error {}
@@ -655,7 +655,7 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 /// into it. This requires stateful deserialization using the `DeserializeSeed`
 /// trait.
 ///
-/// ```rust
+/// ```edition2018
 /// use std::fmt;
 /// use std::marker::PhantomData;
 ///
@@ -1145,7 +1145,7 @@ pub trait Deserializer<'de>: Sized {
    /// human-readable one and binary formats like Bincode will prefer the
    /// compact one.
    ///
-    /// ```
+    /// ```edition2018
    /// # use std::ops::Add;
    /// # use std::str::FromStr;
    /// #
@@ -1222,7 +1222,7 @@ pub trait Deserializer<'de>: Sized {
 ///
 /// # Example
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -1263,7 +1263,7 @@ pub trait Visitor<'de>: Sized {
    /// "an integer between 0 and 64". The message should not be capitalized and
    /// should not end with a period.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use std::fmt;
    /// #
    /// # struct S {
@@ -2004,7 +2004,7 @@ pub trait VariantAccess<'de>: Sized {
    /// If the data contains a different type of variant, the following
    /// `invalid_type` error should be constructed:
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
    /// #
    /// # struct X;
@@ -2044,7 +2044,7 @@ pub trait VariantAccess<'de>: Sized {
    /// If the data contains a different type of variant, the following
    /// `invalid_type` error should be constructed:
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
    /// #
    /// # struct X;
@@ -2100,7 +2100,7 @@ pub trait VariantAccess<'de>: Sized {
    /// If the data contains a different type of variant, the following
    /// `invalid_type` error should be constructed:
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
    /// #
    /// # struct X;
@@ -2147,7 +2147,7 @@ pub trait VariantAccess<'de>: Sized {
    /// If the data contains a different type of variant, the following
    /// `invalid_type` error should be constructed:
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
    /// #
    /// # struct X;
@@ -2207,14 +2207,10 @@ pub trait VariantAccess<'de>: Sized {
 ///
 /// # Example
 ///
-/// ```rust
-/// #[macro_use]
-/// extern crate serde_derive;
-///
-/// extern crate serde;
-///
+/// ```edition2018
 /// use std::str::FromStr;
-/// use serde::de::{value, Deserialize, IntoDeserializer};
+/// use serde::Deserialize;
+/// use serde::de::{value, IntoDeserializer};
 ///
 /// #[derive(Deserialize)]
 /// enum Setting {
@@ -2229,8 +2225,6 @@ pub trait VariantAccess<'de>: Sized {
 ///         Self::deserialize(s.into_deserializer())
 ///     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 pub trait IntoDeserializer<'de, E: Error = value::Error> {
    /// The type of the deserializer being converted into.
@@ -1,14 +1,10 @@
 //! Building blocks for deserializing basic values using the `IntoDeserializer`
 //! trait.
 //!
-//! ```rust
-//! #[macro_use]
-//! extern crate serde_derive;
-//!
-//! extern crate serde;
-//!
+//! ```edition2018
 //! use std::str::FromStr;
-//! use serde::de::{value, Deserialize, IntoDeserializer};
+//! use serde::Deserialize;
+//! use serde::de::{value, IntoDeserializer};
 //!
 //! #[derive(Deserialize)]
 //! enum Setting {
@@ -23,8 +19,6 @@
 //!         Self::deserialize(s.into_deserializer())
 //!     }
 //! }
-//! #
-//! # fn main() {}
 //! ```

 use lib::*;
@@ -9,14 +9,12 @@
 /// do not need to bother with this macro and may assume support for 128-bit
 /// integers.
 ///
-/// ```rust
-/// #[macro_use]
-/// extern crate serde;
-///
-/// use serde::Serializer;
+/// ```edition2018
 /// # use serde::private::ser::Error;
 /// #
 /// # struct MySerializer;
+/// #
+/// use serde::{serde_if_integer128, Serializer};
 ///
 /// impl Serializer for MySerializer {
 ///     type Ok = ();
@@ -41,20 +39,18 @@
 ///         }
 ///     }
 /// #
-/// #     __serialize_unimplemented! {
+/// #     serde::__serialize_unimplemented! {
 /// #         bool i8 i16 i32 u8 u16 u32 u64 f32 f64 char str bytes none some
 /// #         unit unit_struct unit_variant newtype_struct newtype_variant seq
 /// #         tuple tuple_struct tuple_variant map struct struct_variant
 /// #     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// When Serde is built with support for 128-bit integers, this macro expands
 /// transparently into just the input tokens.
 ///
-/// ```rust
+/// ```edition2018
 /// macro_rules! serde_if_integer128 {
 ///     ($($tt:tt)*) => {
 ///         $($tt)*
@@ -65,7 +61,7 @@
 /// When built without support for 128-bit integers, this macro expands to
 /// nothing.
 ///
-/// ```rust
+/// ```edition2018
 /// macro_rules! serde_if_integer128 {
 ///     ($($tt:tt)*) => {};
 /// }
@@ -75,7 +75,7 @@
 ////////////////////////////////////////////////////////////////////////////////

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.83")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.84")]
 // 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
@@ -86,7 +86,7 @@
 #![cfg_attr(feature = "alloc", feature(alloc))]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
-// Whitelisted clippy lints
+// Ignored clippy lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
@@ -101,7 +101,7 @@
        zero_prefixed_literal
    )
 )]
-// Whitelisted clippy_pedantic lints
+// Ignored clippy_pedantic lints
 #![cfg_attr(feature = "cargo-clippy", allow(
 // integer and float ser/de requires these sorts of casts
    cast_possible_truncation,
@@ -112,11 +112,11 @@
    invalid_upcast_comparisons,
 // things are often more readable this way
    decimal_literal_representation,
+    module_name_repetitions,
    option_unwrap_used,
    result_unwrap_used,
    shadow_reuse,
    single_match_else,
-    stutter,
    use_self,
 // not practical
    indexing_slicing,
@@ -11,10 +11,8 @@
 /// input. This requires repetitive implementations of all the [`Deserializer`]
 /// trait methods.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer;
@@ -43,18 +41,14 @@
 /// #         tuple_struct map struct enum identifier ignored_any
 /// #     }
 /// # }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// The `forward_to_deserialize_any!` macro implements these simple forwarding
 /// methods so that they forward directly to [`Deserializer::deserialize_any`].
 /// You can choose which methods to forward.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer;
@@ -77,8 +71,6 @@
 ///         tuple_struct map struct enum identifier ignored_any
 ///     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// The macro assumes the convention that your `Deserializer` lifetime parameter
@@ -86,12 +78,10 @@
 /// called `V`. A different type parameter and a different lifetime can be
 /// specified explicitly if necessary.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer<V>(PhantomData<V>);
@@ -113,8 +103,6 @@
 ///     tuple_struct map struct enum identifier ignored_any
 /// }
 /// # }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// [`Deserializer`]: trait.Deserializer.html
@@ -15,10 +15,7 @@ use ser::{
 /// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
 /// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
 /// # use serde::private::ser::Error;
 /// #
@@ -44,14 +41,12 @@ use ser::{
 ///     }
 ///
 ///     /* other Serializer methods */
-/// #     __serialize_unimplemented! {
+/// #     serde::__serialize_unimplemented! {
 /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
 /// #         unit unit_struct unit_variant newtype_struct newtype_variant
 /// #         tuple tuple_struct tuple_variant map struct struct_variant
 /// #     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// [`Serializer`]: trait.Serializer.html
@@ -137,7 +137,7 @@ macro_rules! declare_error_trait {
            /// For example, a filesystem [`Path`] may refuse to serialize
            /// itself if it contains invalid UTF-8 data.
            ///
-            /// ```rust
+            /// ```edition2018
            /// # struct Path;
            /// #
            /// # impl Path {
@@ -210,7 +210,7 @@ pub trait Serialize {
    /// See the [Implementing `Serialize`] section of the manual for more
    /// information about how to implement this method.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
    ///
    /// struct Person {
@@ -377,13 +377,10 @@ pub trait Serializer: Sized {

    /// Serialize a `bool` value.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for bool {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -393,8 +390,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_bool(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;

@@ -404,13 +399,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `i64` and
    /// forward to `serialize_i64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for i8 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -420,8 +412,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_i8(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;

@@ -431,13 +421,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `i64` and
    /// forward to `serialize_i64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for i16 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -447,8 +434,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_i16(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;

@@ -458,13 +443,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `i64` and
    /// forward to `serialize_i64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for i32 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -474,20 +456,15 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_i32(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;

    /// Serialize an `i64` value.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for i64 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -497,21 +474,16 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_i64(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;

    serde_if_integer128! {
        /// Serialize an `i128` value.
        ///
-        /// ```rust
-        /// # #[macro_use]
-        /// # extern crate serde;
-        /// #
+        /// ```edition2018
        /// # use serde::Serializer;
        /// #
-        /// # __private_serialize!();
+        /// # serde::__private_serialize!();
        /// #
        /// impl Serialize for i128 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -521,8 +493,6 @@ pub trait Serializer: Sized {
        ///         serializer.serialize_i128(*self)
        ///     }
        /// }
-        /// #
-        /// # fn main() {}
        /// ```
        ///
        /// This method is available only on Rust compiler versions >=1.26. The
@@ -539,13 +509,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `u64` and
    /// forward to `serialize_u64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for u8 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -555,8 +522,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_u8(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;

@@ -566,13 +531,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `u64` and
    /// forward to `serialize_u64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for u16 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -582,8 +544,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_u16(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;

@@ -593,13 +553,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `u64` and
    /// forward to `serialize_u64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for u32 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -609,20 +566,15 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_u32(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;

    /// Serialize a `u64` value.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for u64 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -632,21 +584,16 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_u64(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;

    serde_if_integer128! {
        /// Serialize a `u128` value.
        ///
-        /// ```rust
-        /// # #[macro_use]
-        /// # extern crate serde;
-        /// #
+        /// ```edition2018
        /// # use serde::Serializer;
        /// #
-        /// # __private_serialize!();
+        /// # serde::__private_serialize!();
        /// #
        /// impl Serialize for u128 {
        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -656,8 +603,6 @@ pub trait Serializer: Sized {
        ///         serializer.serialize_u128(*self)
        ///     }
        /// }
-        /// #
-        /// # fn main() {}
        /// ```
        ///
        /// This method is available only on Rust compiler versions >=1.26. The
@@ -674,13 +619,10 @@ pub trait Serializer: Sized {
    /// reasonable implementation would be to cast the value to `f64` and
    /// forward to `serialize_f64`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for f32 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -690,20 +632,15 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_f32(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;

    /// Serialize an `f64` value.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for f64 {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -713,8 +650,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_f64(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;

@@ -723,13 +658,10 @@ pub trait Serializer: Sized {
    /// If the format does not support characters, it is reasonable to serialize
    /// it as a single element `str` or a `u32`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for char {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -739,20 +671,15 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_char(*self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;

    /// Serialize a `&str`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for str {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -762,8 +689,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_str(self)
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;

@@ -775,10 +700,7 @@ pub trait Serializer: Sized {
    /// `serialize_seq`. If forwarded, the implementation looks usually just
    /// like this:
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::ser::{Serializer, SerializeSeq};
    /// # use serde::private::ser::Error;
    /// #
@@ -796,22 +718,18 @@ pub trait Serializer: Sized {
    ///     seq.end()
    /// }
    /// #
-    /// #     __serialize_unimplemented! {
+    /// #     serde::__serialize_unimplemented! {
    /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some
    /// #         unit unit_struct unit_variant newtype_struct newtype_variant
    /// #         seq tuple tuple_struct tuple_variant map struct struct_variant
    /// #     }
    /// # }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;

    /// Serialize a [`None`] value.
    ///
-    /// ```rust
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::{Serialize, Serializer};
    /// #
    /// # enum Option<T> {
@@ -819,7 +737,7 @@ pub trait Serializer: Sized {
    /// #     None,
    /// # }
    /// #
-    /// # use Option::{Some, None};
+    /// # use self::Option::{Some, None};
    /// #
    /// impl<T> Serialize for Option<T>
    /// where
@@ -844,9 +762,7 @@ pub trait Serializer: Sized {

    /// Serialize a [`Some(T)`] value.
    ///
-    /// ```rust
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::{Serialize, Serializer};
    /// #
    /// # enum Option<T> {
@@ -854,7 +770,7 @@ pub trait Serializer: Sized {
    /// #     None,
    /// # }
    /// #
-    /// # use Option::{Some, None};
+    /// # use self::Option::{Some, None};
    /// #
    /// impl<T> Serialize for Option<T>
    /// where
@@ -881,13 +797,10 @@ pub trait Serializer: Sized {

    /// Serialize a `()` value.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
    /// # use serde::Serializer;
    /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
    /// #
    /// impl Serialize for () {
    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -897,8 +810,6 @@ pub trait Serializer: Sized {
    ///         serializer.serialize_unit()
    ///     }
    /// }
-    /// #
-    /// # fn main() {}
    /// ```
    fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;

@@ -906,7 +817,7 @@ pub trait Serializer: Sized {
    ///
    /// A reasonable implementation would be to forward to `serialize_unit`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    ///
    /// struct Nothing;
@@ -928,7 +839,7 @@ pub trait Serializer: Sized {
    /// this variant within the enum, and the `variant` is the name of the
    /// variant.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    ///
    /// enum E {
@@ -961,7 +872,7 @@ pub trait Serializer: Sized {
    /// wrappers around the data they contain. A reasonable implementation would
    /// be to forward to `value.serialize(self)`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    ///
    /// struct Millimeters(u8);
@@ -989,7 +900,7 @@ pub trait Serializer: Sized {
    /// this variant within the enum, and the `variant` is the name of the
    /// variant. The `value` is the data contained within this newtype variant.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    ///
    /// enum E {
@@ -1027,7 +938,7 @@ pub trait Serializer: Sized {
    /// not be computable before the sequence is iterated. Some serializers only
    /// support sequences whose length is known up front.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use std::marker::PhantomData;
    /// #
    /// # struct Vec<T>(PhantomData<T>);
@@ -1072,7 +983,7 @@ pub trait Serializer: Sized {
    /// This call must be followed by zero or more calls to `serialize_element`,
    /// then a call to `end`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, Serializer, SerializeTuple};
    ///
    /// # mod fool {
@@ -1102,7 +1013,7 @@ pub trait Serializer: Sized {
    /// }
    /// ```
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
    ///
    /// const VRAM_SIZE: usize = 386;
@@ -1130,7 +1041,7 @@ pub trait Serializer: Sized {
    /// The `name` is the name of the tuple struct and the `len` is the number
    /// of data fields that will be serialized.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
    ///
    /// struct Rgb(u8, u8, u8);
@@ -1162,7 +1073,7 @@ pub trait Serializer: Sized {
    /// this variant within the enum, the `variant` is the name of the variant,
    /// and the `len` is the number of data fields that will be serialized.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
    ///
    /// enum E {
@@ -1208,7 +1119,7 @@ pub trait Serializer: Sized {
    /// be computable before the map is iterated. Some serializers only support
    /// maps whose length is known up front.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use std::marker::PhantomData;
    /// #
    /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
@@ -1256,7 +1167,7 @@ pub trait Serializer: Sized {
    /// The `name` is the name of the struct and the `len` is the number of
    /// data fields that will be serialized.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
    ///
    /// struct Rgb {
@@ -1292,7 +1203,7 @@ pub trait Serializer: Sized {
    /// this variant within the enum, the `variant` is the name of the variant,
    /// and the `len` is the number of data fields that will be serialized.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
    ///
    /// enum E {
@@ -1334,7 +1245,7 @@ pub trait Serializer: Sized {
    /// using [`serialize_seq`]. Implementors should not need to override this
    /// method.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    ///
    /// struct SecretlyOneHigher {
@@ -1371,7 +1282,7 @@ pub trait Serializer: Sized {
    /// using [`serialize_map`]. Implementors should not need to override this
    /// method.
    ///
-    /// ```rust
+    /// ```edition2018
    /// use serde::{Serialize, Serializer};
    /// use std::collections::BTreeSet;
    ///
@@ -1411,7 +1322,7 @@ pub trait Serializer: Sized {
    /// delegates to [`serialize_str`]. Serializers are encouraged to provide a
    /// more efficient implementation if possible.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # struct DateTime;
    /// #
    /// # impl DateTime {
@@ -1452,7 +1363,7 @@ pub trait Serializer: Sized {
    /// of this method. If no more sensible behavior is possible, the
    /// implementation is expected to return an error.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # struct DateTime;
    /// #
    /// # impl DateTime {
@@ -1487,7 +1398,7 @@ pub trait Serializer: Sized {
    /// human-readable one and binary formats like Bincode will prefer the
    /// compact one.
    ///
-    /// ```
+    /// ```edition2018
    /// # use std::fmt::{self, Display};
    /// #
    /// # struct Timestamp;
@@ -1536,7 +1447,7 @@ pub trait Serializer: Sized {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct Vec<T>(PhantomData<T>);
@@ -1600,7 +1511,7 @@ pub trait SerializeSeq {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, Serializer, SerializeTuple};
 ///
 /// # mod fool {
@@ -1630,7 +1541,7 @@ pub trait SerializeSeq {
 /// }
 /// ```
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct Array<T>(PhantomData<T>);
@@ -1700,7 +1611,7 @@ pub trait SerializeTuple {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
 ///
 /// struct Rgb(u8, u8, u8);
@@ -1745,7 +1656,7 @@ pub trait SerializeTupleStruct {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
 ///
 /// enum E {
@@ -1803,7 +1714,7 @@ pub trait SerializeTupleVariant {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
@@ -1914,7 +1825,7 @@ pub trait SerializeMap {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, SerializeStruct, Serializer};
 ///
 /// struct Rgb {
@@ -1974,7 +1885,7 @@ pub trait SerializeStruct {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
 ///
 /// enum E {
@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.83" # remember to update html_root_url
+version = "1.0.84" # 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)]"
@@ -1,8 +1,7 @@
 //! This crate provides Serde's two derive macros.
 //!
-//! ```rust
-//! # #[macro_use]
-//! # extern crate serde_derive;
+//! ```edition2018
+//! # use serde_derive::{Serialize, Deserialize};
 //! #
 //! #[derive(Serialize, Deserialize)]
 //! # struct S;
@@ -14,10 +13,10 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.83")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.84")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
-// Whitelisted clippy lints
+// Ignored clippy lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
@@ -26,10 +25,11 @@
        needless_pass_by_value,
        redundant_field_names,
        too_many_arguments,
+        trivially_copy_pass_by_ref,
        used_underscore_binding,
    )
 )]
-// Whitelisted clippy_pedantic lints
+// Ignored clippy_pedantic lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
@@ -40,9 +40,9 @@
        indexing_slicing,
        items_after_statements,
        match_same_arms,
+        module_name_repetitions,
        similar_names,
        single_match_else,
-        stutter,
        unseparated_literal_suffix,
        use_self,
    )
@@ -299,8 +299,8 @@ fn serialize_struct_as_struct(

    let type_name = cattrs.name().serialize_name();

-    let additional_field_count: usize = match cattrs.tag() {
-        &attr::TagType::Internal { ref tag } => {
+    let additional_field_count: usize = match *cattrs.tag() {
+        attr::TagType::Internal { ref tag } => {
            let func = StructTrait::SerializeStruct.serialize_field(Span::call_site());
            serialize_fields.insert(
                0,
@@ -319,7 +319,7 @@ fn serialize_struct_as_struct(
        .filter(|&field| !field.attrs.skip_serializing())
        .peekable();

-    let let_mut = mut_if(serialized_fields.peek().is_some());
+    let let_mut = mut_if(serialized_fields.peek().is_some() || additional_field_count > 0);

    let len = serialized_fields
        .map(|field| match field.attrs.skip_serializing_if() {
@@ -4,9 +4,8 @@
    feature = "cargo-clippy",
    allow(
        cyclomatic_complexity,
-        doc_markdown,
-        match_same_arms,
-        redundant_field_names
+        redundant_field_names,
+        trivially_copy_pass_by_ref
    )
 )]

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.83" # remember to update html_root_url
+version = "1.0.84" # 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"
@@ -15,7 +15,7 @@ include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-AP
 serde = { version = "1.0.60", path = "../serde" }

 [dev-dependencies]
-serde = { version = "1.0", path = "../serde", features = ["rc"] }
+serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }

 [badges]
@@ -8,13 +8,8 @@ use std::fmt::Debug;

 /// Runs both `assert_ser_tokens` and `assert_de_tokens`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_tokens, Token};
 /// #
 /// # fn main() {
@@ -45,13 +40,8 @@ where

 /// Asserts that `value` serializes to the given `tokens`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_ser_tokens, Token};
 /// #
 /// # fn main() {
@@ -90,16 +80,11 @@ where
 /// Asserts that `value` serializes to the given `tokens`, and then yields
 /// `error`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde_test;
-/// #
-/// # fn main() {
+/// ```edition2018
 /// use std::sync::{Arc, Mutex};
 /// use std::thread;
 ///
+/// use serde::Serialize;
 /// use serde_test::{assert_ser_tokens_error, Token};
 ///
 /// #[derive(Serialize)]
@@ -107,26 +92,27 @@ where
 ///     lock: Arc<Mutex<u32>>,
 /// }
 ///
-/// let example = Example { lock: Arc::new(Mutex::new(0)) };
-/// let lock = example.lock.clone();
+/// fn main() {
+///     let example = Example { lock: Arc::new(Mutex::new(0)) };
+///     let lock = example.lock.clone();
 ///
-/// let _ = thread::spawn(move || {
-///     // This thread will acquire the mutex first, unwrapping the result
-///     // of `lock` because the lock has not been poisoned.
-///     let _guard = lock.lock().unwrap();
+///     let _ = thread::spawn(move || {
+///         // This thread will acquire the mutex first, unwrapping the result
+///         // of `lock` because the lock has not been poisoned.
+///         let _guard = lock.lock().unwrap();
 ///
-///     // This panic while holding the lock (`_guard` is in scope) will
-///     // poison the mutex.
-///     panic!()
-/// }).join();
+///         // This panic while holding the lock (`_guard` is in scope) will
+///         // poison the mutex.
+///         panic!()
+///     }).join();
 ///
-/// let expected = &[
-///     Token::Struct { name: "Example", len: 1 },
-///     Token::Str("lock"),
-/// ];
-/// let error = "lock poison error while serializing";
-/// assert_ser_tokens_error(&example, expected, error);
-/// # }
+///     let expected = &[
+///         Token::Struct { name: "Example", len: 1 },
+///         Token::Str("lock"),
+///     ];
+///     let error = "lock poison error while serializing";
+///     assert_ser_tokens_error(&example, expected, error);
+/// }
 /// ```
 pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: &str)
 where
@@ -145,13 +131,8 @@ where

 /// Asserts that the given `tokens` deserialize into `value`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens, Token};
 /// #
 /// # fn main() {
@@ -205,13 +186,8 @@ where

 /// Asserts that the given `tokens` yield `error` when deserializing.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens_error, Token};
 /// #
 /// # fn main() {
@@ -14,10 +14,7 @@ pub struct Compact<T: ?Sized>(T);
 /// Trait to determine whether a value is represented in human-readable or
 /// compact form.
 ///
-/// ```
-/// extern crate serde;
-/// extern crate serde_test;
-///
+/// ```edition2018
 /// use serde::{Deserialize, Deserializer, Serialize, Serializer};
 /// use serde_test::{assert_tokens, Configure, Token};
 ///
@@ -24,19 +24,10 @@
 //!
 //! [`linked-hash-map`]: https://github.com/contain-rs/linked-hash-map
 //!
-//! ```rust
-//! # extern crate serde;
-//! #
-//! # macro_rules! ignore {
-//! #     ($($tt:tt)+) => {}
-//! # }
-//! #
-//! # ignore! {
-//! extern crate linked_hash_map;
+//! ```edition2018
+//! # const IGNORE: &str = stringify! {
 //! use linked_hash_map::LinkedHashMap;
-//! # }
-//!
-//! extern crate serde_test;
+//! # };
 //! use serde_test::{Token, assert_tokens};
 //!
 //! # use std::fmt;
@@ -153,19 +144,19 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.83")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.84")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
-// Whitelisted clippy lints
+// Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
-// Whitelisted clippy_pedantic lints
+// Ignored clippy_pedantic lints
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
        empty_line_after_outer_attr,
        missing_docs_in_private_items,
+        module_name_repetitions,
        redundant_field_names,
-        stutter,
        use_debug,
        use_self
    )
@@ -4,7 +4,7 @@ use std::fmt::{self, Debug, Display};
 pub enum Token {
    /// A serialized `bool`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&true, &[Token::Bool(true)]);
@@ -13,7 +13,7 @@ pub enum Token {

    /// A serialized `i8`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0i8, &[Token::I8(0)]);
@@ -22,7 +22,7 @@ pub enum Token {

    /// A serialized `i16`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0i16, &[Token::I16(0)]);
@@ -31,7 +31,7 @@ pub enum Token {

    /// A serialized `i32`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0i32, &[Token::I32(0)]);
@@ -40,7 +40,7 @@ pub enum Token {

    /// A serialized `i64`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0i64, &[Token::I64(0)]);
@@ -49,7 +49,7 @@ pub enum Token {

    /// A serialized `u8`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0u8, &[Token::U8(0)]);
@@ -58,7 +58,7 @@ pub enum Token {

    /// A serialized `u16`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0u16, &[Token::U16(0)]);
@@ -67,7 +67,7 @@ pub enum Token {

    /// A serialized `u32`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0u32, &[Token::U32(0)]);
@@ -76,7 +76,7 @@ pub enum Token {

    /// A serialized `u64`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0u64, &[Token::U64(0)]);
@@ -85,7 +85,7 @@ pub enum Token {

    /// A serialized `f32`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0f32, &[Token::F32(0.0)]);
@@ -94,7 +94,7 @@ pub enum Token {

    /// A serialized `f64`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&0f64, &[Token::F64(0.0)]);
@@ -103,7 +103,7 @@ pub enum Token {

    /// A serialized `char`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&'\n', &[Token::Char('\n')]);
@@ -112,7 +112,7 @@ pub enum Token {

    /// A serialized `str`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let s = String::from("transient");
@@ -122,7 +122,7 @@ pub enum Token {

    /// A borrowed `str`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let s: &str = "borrowed";
@@ -132,7 +132,7 @@ pub enum Token {

    /// A serialized `String`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let s = String::from("owned");
@@ -151,7 +151,7 @@ pub enum Token {

    /// A serialized `Option<T>` containing none.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let opt = None::<char>;
@@ -163,7 +163,7 @@ pub enum Token {
    ///
    /// The tokens of the value follow after this header.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let opt = Some('c');
@@ -176,7 +176,7 @@ pub enum Token {

    /// A serialized `()`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// assert_tokens(&(), &[Token::Unit]);
@@ -185,13 +185,8 @@ pub enum Token {

    /// A serialized unit struct of the given name.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -205,13 +200,8 @@ pub enum Token {

    /// A unit variant of an enum.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -233,13 +223,8 @@ pub enum Token {
    ///
    /// After this header is the value contained in the newtype struct.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -259,13 +244,8 @@ pub enum Token {
    ///
    /// After this header is the value contained in the newtype variant.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -291,7 +271,7 @@ pub enum Token {
    /// After this header are the elements of the sequence, followed by
    /// `SeqEnd`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let vec = vec!['a', 'b', 'c'];
@@ -312,7 +292,7 @@ pub enum Token {
    ///
    /// After this header are the elements of the tuple, followed by `TupleEnd`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// let tuple = ('a', 100);
@@ -333,13 +313,8 @@ pub enum Token {
    /// After this header are the fields of the tuple struct, followed by
    /// `TupleStructEnd`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -365,13 +340,8 @@ pub enum Token {
    /// After this header are the fields of the tuple variant, followed by
    /// `TupleVariantEnd`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -402,7 +372,7 @@ pub enum Token {
    ///
    /// After this header are the entries of the map, followed by `MapEnd`.
    ///
-    /// ```rust
+    /// ```edition2018
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// use std::collections::BTreeMap;
@@ -429,13 +399,8 @@ pub enum Token {
    ///
    /// After this header are the fields of the struct, followed by `StructEnd`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -466,13 +431,8 @@ pub enum Token {
    /// After this header are the fields of the struct variant, followed by
    /// `StructVariantEnd`.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -501,13 +461,8 @@ pub enum Token {

    /// The header to an enum of the given name.
    ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
    /// # use serde_test::{assert_tokens, Token};
    /// #
    /// # fn main() {
@@ -2,15 +2,17 @@
 name = "serde_test_suite"
 version = "0.0.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+edition = "2018"
 publish = false

 [features]
-unstable = ["serde/unstable", "compiletest_rs"]
+unstable = ["serde/unstable"]
+compiletest = ["compiletest_rs"]

 [dev-dependencies]
 fnv = "1.0"
 rustc-serialize = "0.3.16"
-serde = { path = "../serde", features = ["rc"] }
+serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }

@@ -1,11 +1,11 @@
 [package]
 name = "serde_derive_tests_no_std"
 version = "0.0.0"
+edition = "2018"
 publish = false

 [dependencies]
 libc = { version = "0.2", default-features = false }
-serde = { path = "../../serde", default-features = false }
-serde_derive = { path = "../../serde_derive" }
+serde = { path = "../../serde", default-features = false, features = ["derive"] }

 [workspace]
@@ -1,8 +1,6 @@
 #![feature(lang_items, start)]
 #![no_std]

-extern crate libc;
-
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {
    0
@@ -21,8 +19,7 @@ fn panic(_info: &core::panic::PanicInfo) -> ! {

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

-#[macro_use]
-extern crate serde_derive;
+use serde::{Serialize, Deserialize};

 #[derive(Serialize, Deserialize)]
 struct Unit;
@@ -22,7 +22,7 @@ impl<'de> Visitor<'de> for ByteBufVisitor {
        V: SeqAccess<'de>,
    {
        let mut values = Vec::new();
-        while let Some(value) = try!(visitor.next_element()) {
+        while let Some(value) = visitor.next_element()? {
            values.push(value);
        }
        Ok(values)
@@ -1,13 +1,20 @@
-#![cfg(feature = "unstable")]
+#![cfg(feature = "compiletest")]

-extern crate compiletest_rs as compiletest;
+use compiletest_rs as compiletest;

 #[test]
 fn ui() {
    let config = compiletest::Config {
        mode: compiletest::common::Mode::Ui,
        src_base: std::path::PathBuf::from("tests/ui"),
-        target_rustcflags: Some("-L deps/target/debug/deps".to_owned()),
+        target_rustcflags: Some(String::from(
+            "\
+             --edition=2018 \
+             -L deps/target/debug/deps \
+             -Z unstable-options \
+             --extern serde_derive \
+             ",
+        )),
        ..Default::default()
    };

@@ -1,19 +1,13 @@
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", allow(cast_lossless))]
+#![allow(clippy::cast_lossless, clippy::trivially_copy_pass_by_ref)]

-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-use self::serde::de::{self, MapAccess, Unexpected, Visitor};
-use self::serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde::de::{self, MapAccess, Unexpected, Visitor};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};

 use std::collections::{BTreeMap, HashMap};
 use std::fmt;
 use std::marker::PhantomData;

-extern crate serde_test;
-use self::serde_test::{
+use serde_test::{
    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_ser_tokens_error,
    assert_tokens, Token,
 };
@@ -68,7 +62,7 @@ impl DeserializeWith for i32 {
    where
        D: Deserializer<'de>,
    {
-        if try!(Deserialize::deserialize(de)) {
+        if Deserialize::deserialize(de)? {
            Ok(123)
        } else {
            Ok(2)
@@ -1,10 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
 use serde::{Deserialize, Deserializer};
-
-extern crate serde_test;
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};

 use std::borrow::Cow;
@@ -1,10 +1,6 @@
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", allow(decimal_literal_representation))]
+#![allow(clippy::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::{CStr, CString, OsString};
@@ -15,14 +11,9 @@ use std::rc::{Rc, Weak as RcWeak};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};

-extern crate serde;
+use fnv::FnvHasher;
 use serde::{Deserialize, Deserializer};
-
-extern crate fnv;
-use self::fnv::FnvHasher;
-
-extern crate serde_test;
-use self::serde_test::{assert_de_tokens, assert_de_tokens_error, Configure, Token};
+use serde_test::{assert_de_tokens, assert_de_tokens_error, Configure, Token};

 #[macro_use]
 mod macros;
@@ -4,13 +4,10 @@

 #![deny(warnings)]
 #![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
+#![allow(clippy::trivially_copy_pass_by_ref)]

-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-use self::serde::de::{DeserializeOwned, Deserializer};
-use self::serde::ser::{Serialize, Serializer};
+use serde::de::DeserializeOwned;
+use serde::{Deserialize, Deserializer, Serialize, Serializer};

 use std::borrow::Cow;
 use std::marker::PhantomData;
@@ -384,6 +381,8 @@ fn test_gen() {
    }

    mod vis {
+        use serde::{Deserialize, Serialize};
+
        pub struct S;

        #[derive(Serialize, Deserialize)]
@@ -607,6 +606,8 @@ fn test_gen() {

    mod restricted {
        mod inner {
+            use serde::{Deserialize, Serialize};
+
            #[derive(Serialize, Deserialize)]
            struct Restricted {
                pub(super) a: usize,
@@ -1,7 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde_test;
+use serde::Deserialize;
 use serde_test::{assert_de_tokens, Token};

 #[test]
@@ -1,16 +1,10 @@
 #![deny(trivial_numeric_casts)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
-
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-extern crate serde_test;
+#![allow(clippy::redundant_field_names)]

 mod bytes;

-use self::serde_test::{
+use serde::{Deserialize, Serialize};
+use serde_test::{
    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, Token,
 };

@@ -1413,6 +1407,23 @@ fn test_internally_tagged_struct() {
    );
 }

+#[test]
+fn test_internally_tagged_braced_struct_with_zero_fields() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    struct S {}
+
+    assert_tokens(
+        &S {},
+        &[
+            Token::Struct { name: "S", len: 1 },
+            Token::Str("type"),
+            Token::Str("S"),
+            Token::StructEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_enum_in_untagged_enum() {
    #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -1,8 +1,6 @@
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", allow(redundant_field_names))]
+#![allow(clippy::redundant_field_names)]

-#[macro_use]
-extern crate serde_derive;
+use serde::{Deserialize, Serialize};

 mod remote {
    pub struct Unit;
@@ -1,5 +1,4 @@
-extern crate serde_test;
-use self::serde_test::{assert_tokens, Configure, Token};
+use serde_test::{assert_tokens, Configure, Token};

 use std::net;

@@ -1,8 +1,5 @@
 #![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;
@@ -17,11 +14,9 @@ use std::time::{Duration, UNIX_EPOCH};
 #[cfg(unix)]
 use std::str;

-extern crate serde_test;
-use self::serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};
-
-extern crate fnv;
-use self::fnv::FnvHasher;
+use fnv::FnvHasher;
+use serde::Serialize;
+use serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};

 #[macro_use]
 mod macros;
@@ -1,14 +1,5 @@
 #![deny(warnings)]

-#[cfg(feature = "unstable")]
-#[macro_use]
-extern crate serde_derive;
-
-#[cfg(feature = "unstable")]
-extern crate serde;
-#[cfg(feature = "unstable")]
-extern crate serde_test;
-
 // This test target is convoluted with the actual #[test] in a separate file to
 // get it so that the stable compiler does not need to parse the code of the
 // test. If the test were written with #[cfg(feature = "unstable")] #[test]
@@ -1,7 +1,3 @@
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
 use serde::de::{value, IntoDeserializer};
 use serde::Deserialize;

@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Test<'a> {
@@ -1,7 +1,7 @@
 error: failed to parse borrowed lifetimes: "zzz"
- --> $DIR/bad_lifetimes.rs:6:22
+ --> $DIR/bad_lifetimes.rs:5:22
  |
-6 |     #[serde(borrow = "zzz")]
+5 |     #[serde(borrow = "zzz")]
  |                      ^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Test<'a> {
@@ -1,7 +1,7 @@
 error: duplicate borrowed lifetime `'a`
- --> $DIR/duplicate_lifetime.rs:6:22
+ --> $DIR/duplicate_lifetime.rs:5:22
  |
-6 |     #[serde(borrow = "'a + 'a")]
+5 |     #[serde(borrow = "'a + 'a")]
  |                      ^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Str<'a>(&'a str);
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `borrow`
- --> $DIR/duplicate_variant.rs:9:13
+ --> $DIR/duplicate_variant.rs:8:13
  |
-9 |     #[serde(borrow)]
+8 |     #[serde(borrow)]
  |             ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Test<'a> {
@@ -1,7 +1,7 @@
 error: at least one lifetime must be borrowed
- --> $DIR/empty_lifetimes.rs:6:22
+ --> $DIR/empty_lifetimes.rs:5:22
  |
-6 |     #[serde(borrow = "")]
+5 |     #[serde(borrow = "")]
  |                      ^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Test {
@@ -1,8 +1,8 @@
 error: field `s` has no lifetimes to borrow
- --> $DIR/no_lifetimes.rs:6:5
+ --> $DIR/no_lifetimes.rs:5:5
  |
-6 | /     #[serde(borrow)]
-7 | |     s: String,
+5 | /     #[serde(borrow)]
+6 | |     s: String,
  | |_____________^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Str<'a>(&'a str);
@@ -1,9 +1,9 @@
 error: #[serde(borrow)] may only be used on newtype variants
-  --> $DIR/struct_variant.rs:9:5
-   |
-9  | /     #[serde(borrow)]
-10 | |     S { s: Str<'a> },
-   | |____________________^
+ --> $DIR/struct_variant.rs:8:5
+  |
+8 | /     #[serde(borrow)]
+9 | |     S { s: Str<'a> },
+  | |____________________^

 error: aborting due to previous error

@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Test<'a> {
@@ -1,8 +1,8 @@
 error: field `s` does not have lifetime 'b
- --> $DIR/wrong_lifetime.rs:6:5
+ --> $DIR/wrong_lifetime.rs:5:5
  |
-6 | /     #[serde(borrow = "'b")]
-7 | |     s: &'a str,
+5 | /     #[serde(borrow = "'b")]
+6 | |     s: &'a str,
  | |______________^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(tag = "conflict", content = "conflict")]
@@ -1,11 +1,11 @@
 error: enum tags `conflict` for type and content conflict with each other
- --> $DIR/adjacent-tag.rs:5:1
+ --> $DIR/adjacent-tag.rs:4:1
  |
-5 | / #[serde(tag = "conflict", content = "conflict")]
-6 | | enum E {
-7 | |     A,
-8 | |     B,
-9 | | }
+4 | / #[serde(tag = "conflict", content = "conflict")]
+5 | | enum E {
+6 | |     A,
+7 | |     B,
+8 | | }
  | |_^

 error: aborting due to previous error
@@ -1,5 +1,6 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;
+
+use std::collections::HashMap;

 #[derive(Serialize)]
 struct Foo(#[serde(flatten)] HashMap<String, String>);
@@ -1,7 +1,7 @@
 error: #[serde(flatten)] cannot be used on newtype structs
- --> $DIR/flatten-newtype-struct.rs:5:12
+ --> $DIR/flatten-newtype-struct.rs:6:12
  |
-5 | struct Foo(#[serde(flatten)] HashMap<String, String>);
+6 | struct Foo(#[serde(flatten)] HashMap<String, String>);
  |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 struct Foo {
@@ -1,8 +1,8 @@
 error: #[serde(flatten)] can not be combined with #[serde(skip_deserializing)]
- --> $DIR/flatten-skip-deserializing.rs:6:5
+ --> $DIR/flatten-skip-deserializing.rs:5:5
  |
-6 | /     #[serde(flatten, skip_deserializing)]
-7 | |     other: Other,
+5 | /     #[serde(flatten, skip_deserializing)]
+6 | |     other: Other,
  | |________________^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct Foo {
@@ -1,8 +1,8 @@
 error: #[serde(flatten)] can not be combined with #[serde(skip_serializing_if = "...")]
- --> $DIR/flatten-skip-serializing-if.rs:6:5
+ --> $DIR/flatten-skip-serializing-if.rs:5:5
  |
-6 | /     #[serde(flatten, skip_serializing_if = "Option::is_none")]
-7 | |     other: Option<Other>,
+5 | /     #[serde(flatten, skip_serializing_if = "Option::is_none")]
+6 | |     other: Option<Other>,
  | |________________________^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct Foo {
@@ -1,8 +1,8 @@
 error: #[serde(flatten)] can not be combined with #[serde(skip_serializing)]
- --> $DIR/flatten-skip-serializing.rs:6:5
+ --> $DIR/flatten-skip-serializing.rs:5:5
  |
-6 | /     #[serde(flatten, skip_serializing)]
-7 | |     other: Other,
+5 | /     #[serde(flatten, skip_serializing)]
+6 | |     other: Other,
  | |________________^

 error: aborting due to previous error
@@ -1,5 +1,6 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;
+
+use std::collections::HashMap;

 #[derive(Serialize)]
 struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
@@ -1,7 +1,7 @@
 error: #[serde(flatten)] cannot be used on tuple structs
- --> $DIR/flatten-tuple-struct.rs:5:17
+ --> $DIR/flatten-tuple-struct.rs:6:17
  |
-5 | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
+6 | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
  |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(tag = "conflict")]
@@ -1,13 +1,13 @@
 error: variant field name `conflict` conflicts with internal tag
-  --> $DIR/internal-tag.rs:5:1
+  --> $DIR/internal-tag.rs:4:1
   |
-5  | / #[serde(tag = "conflict")]
-6  | | enum E {
-7  | |     A {
-8  | |         #[serde(rename = "conflict")]
-9  | |         x: (),
-10 | |     },
-11 | | }
+4  | / #[serde(tag = "conflict")]
+5  | | enum E {
+6  | |     A {
+7  | |         #[serde(rename = "conflict")]
+8  | |         x: (),
+9  | |     },
+10 | | }
   | |_^

 error: aborting due to previous error
@@ -1,8 +1,9 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 #[serde(default)]
 enum E {
    S { f: u8 },
 }
+
+fn main() {}
@@ -1,7 +1,7 @@
 error: #[serde(default)] can only be used on structs with named fields
- --> $DIR/enum.rs:6:1
+ --> $DIR/enum.rs:5:1
  |
-6 | enum E {
+5 | enum E {
  | ^^^^

 error: aborting due to previous error
@@ -1,8 +1,9 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 #[serde(default = "default_e")]
 enum E {
    S { f: u8 },
 }
+
+fn main() {}
@@ -1,7 +1,7 @@
 error: #[serde(default = "...")] can only be used on structs with named fields
- --> $DIR/enum_path.rs:6:1
+ --> $DIR/enum_path.rs:5:1
  |
-6 | enum E {
+5 | enum E {
  | ^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 #[serde(default)]
@@ -1,7 +1,7 @@
 error: #[serde(default)] can only be used on structs with named fields
- --> $DIR/nameless_struct_fields.rs:6:9
+ --> $DIR/nameless_struct_fields.rs:5:9
  |
-6 | struct T(u8, u8);
+5 | struct T(u8, u8);
  |         ^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Deserialize;

 #[derive(Deserialize)]
 #[serde(default = "default_t")]
@@ -1,7 +1,7 @@
 error: #[serde(default = "...")] can only be used on structs with named fields
- --> $DIR/nameless_struct_fields_path.rs:6:9
+ --> $DIR/nameless_struct_fields_path.rs:5:9
  |
-6 | struct T(u8, u8);
+5 | struct T(u8, u8);
  |         ^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: unknown serde field attribute `serialize`
- --> $DIR/rename-and-ser.rs:6:27
+ --> $DIR/rename-and-ser.rs:5:27
  |
-6 |     #[serde(rename = "x", serialize = "y")]
+5 |     #[serde(rename = "x", serialize = "y")]
  |                           ^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `rename`
- --> $DIR/rename-rename-de.rs:7:13
+ --> $DIR/rename-rename-de.rs:6:13
  |
-7 |     #[serde(rename(deserialize = "y"))]
+6 |     #[serde(rename(deserialize = "y"))]
  |             ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `rename`
- --> $DIR/rename-ser-rename-ser.rs:6:38
+ --> $DIR/rename-ser-rename-ser.rs:5:38
  |
-6 |     #[serde(rename(serialize = "x"), rename(serialize = "y"))]
+5 |     #[serde(rename(serialize = "x"), rename(serialize = "y"))]
  |                                      ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `rename`
- --> $DIR/rename-ser-rename.rs:7:13
+ --> $DIR/rename-ser-rename.rs:6:13
  |
-7 |     #[serde(rename = "y")]
+6 |     #[serde(rename = "y")]
  |             ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `rename`
- --> $DIR/rename-ser-ser.rs:6:37
+ --> $DIR/rename-ser-ser.rs:5:37
  |
-6 |     #[serde(rename(serialize = "x", serialize = "y"))]
+5 |     #[serde(rename(serialize = "x", serialize = "y"))]
  |                                     ^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `rename`
- --> $DIR/two-rename-ser.rs:7:13
+ --> $DIR/two-rename-ser.rs:6:13
  |
-7 |     #[serde(rename(serialize = "y"))]
+6 |     #[serde(rename(serialize = "y"))]
  |             ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: duplicate serde attribute `serialize_with`
- --> $DIR/with-and-serialize-with.rs:6:25
+ --> $DIR/with-and-serialize-with.rs:5:25
  |
-6 |     #[serde(with = "w", serialize_with = "s")]
+5 |     #[serde(with = "w", serialize_with = "s")]
  |                         ^^^^^^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(content = "c")]
@@ -1,7 +1,7 @@
 error: #[serde(tag = "...", content = "...")] must be used together
- --> $DIR/content-no-tag.rs:5:9
+ --> $DIR/content-no-tag.rs:4:9
  |
-5 | #[serde(content = "c")]
+4 | #[serde(content = "c")]
  |         ^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(tag = "type")]
@@ -1,7 +1,7 @@
 error: #[serde(tag = "...")] cannot be used with tuple variants
- --> $DIR/internal-tuple-variant.rs:7:5
+ --> $DIR/internal-tuple-variant.rs:6:5
  |
-7 |     Tuple(u8, u8),
+6 |     Tuple(u8, u8),
  |     ^^^^^^^^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(untagged)]
@@ -1,19 +1,19 @@
 error: untagged enum cannot have #[serde(tag = "...", content = "...")]
- --> $DIR/untagged-and-adjacent.rs:5:9
+ --> $DIR/untagged-and-adjacent.rs:4:9
  |
-5 | #[serde(untagged)]
+4 | #[serde(untagged)]
  |         ^^^^^^^^

 error: untagged enum cannot have #[serde(tag = "...", content = "...")]
- --> $DIR/untagged-and-adjacent.rs:6:9
+ --> $DIR/untagged-and-adjacent.rs:5:9
  |
-6 | #[serde(tag = "t", content = "c")]
+5 | #[serde(tag = "t", content = "c")]
  |         ^^^

 error: untagged enum cannot have #[serde(tag = "...", content = "...")]
- --> $DIR/untagged-and-adjacent.rs:6:20
+ --> $DIR/untagged-and-adjacent.rs:5:20
  |
-6 | #[serde(tag = "t", content = "c")]
+5 | #[serde(tag = "t", content = "c")]
  |                    ^^^^^^^

 error: aborting due to 3 previous errors
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(untagged)]
@@ -1,13 +1,13 @@
 error: untagged enum cannot have #[serde(content = "...")]
- --> $DIR/untagged-and-content.rs:5:9
+ --> $DIR/untagged-and-content.rs:4:9
  |
-5 | #[serde(untagged)]
+4 | #[serde(untagged)]
  |         ^^^^^^^^

 error: untagged enum cannot have #[serde(content = "...")]
- --> $DIR/untagged-and-content.rs:6:9
+ --> $DIR/untagged-and-content.rs:5:9
  |
-6 | #[serde(content = "c")]
+5 | #[serde(content = "c")]
  |         ^^^^^^^

 error: aborting due to 2 previous errors
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(untagged)]
@@ -1,13 +1,13 @@
 error: enum cannot be both untagged and internally tagged
- --> $DIR/untagged-and-internal.rs:5:9
+ --> $DIR/untagged-and-internal.rs:4:9
  |
-5 | #[serde(untagged)]
+4 | #[serde(untagged)]
  |         ^^^^^^^^

 error: enum cannot be both untagged and internally tagged
- --> $DIR/untagged-and-internal.rs:6:9
+ --> $DIR/untagged-and-internal.rs:5:9
  |
-6 | #[serde(tag = "type")]
+5 | #[serde(tag = "type")]
  |         ^^^

 error: aborting due to 2 previous errors
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 #[serde(untagged)]
@@ -1,7 +1,7 @@
 error: #[serde(untagged)] can only be used on enums
- --> $DIR/untagged-struct.rs:6:1
+ --> $DIR/untagged-struct.rs:5:1
  |
-6 | struct S;
+5 | struct S;
  | ^^^^^^

 error: aborting due to previous error
@@ -1,5 +1,4 @@
-#[macro_use]
-extern crate serde_derive;
+use serde_derive::Serialize;

 #[derive(Serialize)]
 struct S {
@@ -1,7 +1,7 @@
 error: expected serde rename attribute to be a string: `rename = "..."`
- --> $DIR/boolean.rs:6:22
+ --> $DIR/boolean.rs:5:22
  |
-6 |     #[serde(rename = true)]
+5 |     #[serde(rename = true)]
  |                      ^^^^

 error: aborting due to previous error
--- a/Show More
+++ b/Show More
Author	SHA1	Message	Date
David Tolnay	fea4e8e5b6	Release 1.0.84	2018-12-31 23:45:34 -05:00
David Tolnay	1df8b5785b	Test with same features in Travis and AppVeyor	2018-12-31 23:31:49 -05:00
David Tolnay	981a75d7c9	Enable extra features in playground	2018-12-31 23:28:10 -05:00
David Tolnay	11cc7014b3	Set all doc tests to 2018 edition	2018-12-31 23:22:13 -05:00
David Tolnay	0b667c88fa	Remove unneeded main functions in doc tests These used to be needed because `#[macro_use] extern crate serde` couldn't go inside of rustdoc's implicit main function.	2018-12-31 23:22:12 -05:00
David Tolnay	054ab1adaf	Update serde documentation to 2018 edition	2018-12-31 23:22:11 -05:00
David Tolnay	f1f8386f2e	Update serde_derive_internals ignored lints	2018-12-31 22:53:09 -05:00
David Tolnay	ba8c3970b0	Use tool lint naming in clippy invocation	2018-12-31 22:51:38 -05:00
David Tolnay	2f36b26a5c	Clarify that these lints are ignored	2018-12-31 22:49:38 -05:00
David Tolnay	9b4edb3a1d	Address match_ref_pats lint in serde_derive	2018-12-31 22:47:48 -05:00
David Tolnay	b8adc5ffa2	Update name of stutter lint in serde_derive	2018-12-31 22:47:18 -05:00
David Tolnay	bd90cafda7	Ignore trivially_copy_pass_by_ref lint in serde_derive	2018-12-31 22:47:03 -05:00
David Tolnay	6d43a08a1d	Remove dev-dependencies features from serde_test Apparently Cargo is applying these features to the non-dev dependency on serde as well. Concluded by running `cargo clean && cargo build` and observing that serde_derive was getting built.	2018-12-31 22:43:15 -05:00
David Tolnay	e71b8598ae	Update serde_test examples to 2018 edition	2018-12-31 22:41:23 -05:00
David Tolnay	95d0f437e3	Update ui tests to nightly 2019-01-01	2018-12-31 22:09:07 -05:00
David Tolnay	c95ee3968a	Format with rustfmt 2018-12-10	2018-12-31 22:09:06 -05:00
David Tolnay	c22dd4ada5	Suppress trivially_copy_pass_by_ref lint on fn is_zero	2018-12-31 22:09:05 -05:00
David Tolnay	727a40fc5a	Update test suite to use tool attrs	2018-12-31 21:59:40 -05:00
David Tolnay	ce84a5f1d3	Update name of deprecated stutter lint	2018-12-31 21:59:39 -05:00
David Tolnay	e6fda1c410	Fix clippy command to run against test suite	2018-12-31 21:56:10 -05:00
David Tolnay	294dccc5be	Update test suite to 2018 edition	2018-12-31 21:53:37 -05:00
David Tolnay	da346a8878	Replace `try!` macro in test suite	2018-12-31 21:46:14 -05:00
David Tolnay	c5ccb995ad	Update no_std test to 2018 edition	2018-12-31 21:42:22 -05:00
David Tolnay	05ab569a80	Update ui tests to 2018 edition	2018-12-31 21:38:13 -05:00
David Tolnay	ab3f4971f0	Move compiletest out of the unstable feature flag	2018-12-31 21:28:39 -05:00
David Tolnay	47e238aa13	Add missing imports in ui tests There is a new fallback as of nightly-2018-12-29 that makes these emit a new error unrelated to Serde.	2018-12-29 00:19:29 -05:00
David Tolnay	e49b6c708b	Add main function to ui tests without main These emit a new error not relevant to Serde as of nightly-2018-12-29.	2018-12-29 00:18:55 -05:00
David Tolnay	eb7250792b	Format with rustfmt 2018-12-10	2018-12-28 12:19:32 -05:00
David Tolnay	7e5066b878	Merge pull request #1450 from motu42/master Bug fix to support the tag attribute on braced structs with zero fields	2018-12-27 21:48:14 -05:00
Johannes Willbold	889e17816f	Bug fix for #1449 Modified serialize_struct_as_struct. Added test test_internally_tagged_braced_struct_with_zero_fields	2018-12-28 02:50:24 +01:00