Release 1.0.98

Work around failing to parse manifest in 1.27 and 1.28 builds

.travis.yml

@@ -26,10 +26,8 @@ matrix:
         - cargo build --no-default-features --features alloc
         - cargo build --no-default-features --features rc,alloc
         - cargo test --features derive,rc,unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/deps"
-        - cargo build
         - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test --features compiletest,unstable
+        - cargo test --features unstable
         - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
         - cargo build
 
@@ -46,15 +44,29 @@ matrix:
         - cd "${TRAVIS_BUILD_DIR}/serde_derive"
         - cargo build
 
+    - rust: 1.19.0
     - rust: 1.20.0
     - rust: 1.21.0
     - rust: 1.25.0
     - rust: 1.26.0
 
+    # Work around failing to parse manifest because editions are unstable.
+    - rust: 1.27.0
+      before_script: sed -i /test_suite/d Cargo.toml
+    - rust: 1.28.0
+      before_script: sed -i /test_suite/d Cargo.toml
+
+    - rust: 1.34.0
+
+    - rust: 1.36.0
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build --no-default-features --features alloc
+
     - rust: nightly
       name: Clippy
       script:
-        - rustup component add clippy-preview || travis_terminate 0
+        - rustup component add clippy || travis_terminate 0
         - cargo clippy -- -D clippy::all
         - cd "${TRAVIS_BUILD_DIR}/serde"
         - cargo clippy --features rc,unstable -- -D clippy::all

README.md

@@ -25,19 +25,17 @@ You may be looking for:
 <details>
 <summary>
 Click to show Cargo.toml.
-<a href="https://play.rust-lang.org/?gist=9003c5b88c1f4989941925d7190c6eec" target="_blank">Run this code in the playground.</a>
+<a href="https://play.rust-lang.org/?edition=2018&gist=72755f28f99afc95e01d63174b28c1f5" target="_blank">Run this code in the playground.</a>
 </summary>
 
 ```toml
 [dependencies]
 
 # The core APIs, including the Serialize and Deserialize traits. Always
-# required when using Serde.
-serde = "1.0"
-
-# Support for #[derive(Serialize, Deserialize)]. Required if you want Serde
-# to work for structs and enums defined in your crate.
-serde_derive = "1.0"
+# required when using Serde. The "derive" feature is only required when
+# using #[derive(Serialize, Deserialize)] to make Serde work with structs
+# and enums defined in your crate.
+serde = { version = "1.0", features = ["derive"] }
 
 # Each data format lives in its own crate; the sample code below uses JSON
 # but you may be using a different one.
@@ -48,11 +46,7 @@ serde_json = "1.0"
 <p></p>
 
 ```rust
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-extern crate serde_json;
+use serde::{Serialize, Deserialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 struct Point {
@@ -87,19 +81,19 @@ 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
+<br>
 
-Serde is licensed under either of
+#### License
 
- * Apache License, Version 2.0, ([LICENSE-APACHE](LICENSE-APACHE) or
-   http://www.apache.org/licenses/LICENSE-2.0)
- * MIT license ([LICENSE-MIT](LICENSE-MIT) or
-   http://opensource.org/licenses/MIT)
+<sup>
+Licensed under either of <a href="LICENSE-APACHE">Apache License, Version
+2.0</a> or <a href="LICENSE-MIT">MIT license</a> at your option.
+</sup>
 
-at your option.
-
-### Contribution
+<br>
 
+<sub>
 Unless you explicitly state otherwise, any contribution intentionally submitted
 for inclusion in Serde by you, as defined in the Apache-2.0 license, shall be
 dual licensed as above, without any additional terms or conditions.
+</sub>

appveyor.yml

@@ -35,7 +35,5 @@ for:
       - cargo build --no-default-features --features alloc
       - cargo build --no-default-features --features rc,alloc
       - cargo test --features derive,rc,unstable
-      - cd %APPVEYOR_BUILD_FOLDER%\test_suite\deps
-      - cargo build
       - cd %APPVEYOR_BUILD_FOLDER%\test_suite
-      - cargo test --features compiletest,unstable
+      - cargo test --features unstable

crates-io.md

@@ -16,11 +16,7 @@ You may be looking for:
 ## Serde in action
 
 ```rust
-#[macro_use]
-extern crate serde_derive;
-
-extern crate serde;
-extern crate serde_json;
+use serde::{Serialize, Deserialize};
 
 #[derive(Serialize, Deserialize, Debug)]
 struct Point {

serde/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde"
-version = "1.0.84" # remember to update html_root_url
+version = "1.0.98" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
@@ -32,30 +32,7 @@ features = ["derive", "rc"]
 [features]
 default = ["std"]
 
-# Re-export the derive(Serialize, Deserialize) macros. This is intended for
-# library crates that provide optional Serde impls behind a Cargo cfg of their
-# own.
-#
-# Mainly this is a workaround for limitations associated with
-# rust-lang/cargo#1286 in which a library crate cannot use one "serde" cfg in
-# Cargo to enable dependencies on both serde and serde_derive crates.
-#
-# The recommended way to provide optional Serde support that requires derive is
-# as follows. In particular, please do not name your library's Serde feature
-# anything other than "serde".
-#
-#     [dependencies]
-#     serde = { version = "1.0", optional = true, features = ["derive"] }
-#
-# Within the library, these optional Serde derives would be written like this.
-#
-#     #[cfg(feature = "serde")]
-#     #[macro_use]
-#     extern crate serde;
-#
-#     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-#     struct ...
-#
+# Provide derive(Serialize, Deserialize) macros.
 derive = ["serde_derive"]
 
 # Provide impls for common standard library types like Vec<T> and HashMap<K, V>.
@@ -71,11 +48,7 @@ unstable = []
 # Provide impls for types in the Rust core allocation and collections library
 # including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
 # be enabled without depending on all of std.
-#
-# Requires a dependency on the unstable core allocation library:
-#
-#    https://doc.rust-lang.org/alloc/
-alloc = ["unstable"]
+alloc = []
 
 # Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
 # does not preserve identity and may result in multiple copies of the same data.

serde/build.rs

@@ -14,6 +14,21 @@ fn main() {
     let target = env::var("TARGET").unwrap();
     let emscripten = target == "asmjs-unknown-emscripten" || target == "wasm32-unknown-emscripten";
 
+    // std::collections::Bound was stabilized in Rust 1.17
+    // but it was moved to core::ops later in Rust 1.26:
+    // https://doc.rust-lang.org/core/ops/enum.Bound.html
+    if minor >= 26 {
+        println!("cargo:rustc-cfg=ops_bound");
+    } else if minor >= 17 && cfg!(feature = "std") {
+        println!("cargo:rustc-cfg=collections_bound");
+    }
+
+    // core::cmp::Reverse stabilized in Rust 1.19:
+    // https://doc.rust-lang.org/stable/core/cmp/struct.Reverse.html
+    if minor >= 19 {
+        println!("cargo:rustc-cfg=core_reverse");
+    }
+
     // CString::into_boxed_c_str stabilized in Rust 1.20:
     // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
     if minor >= 20 {
@@ -53,6 +68,31 @@ fn main() {
     if minor >= 28 {
         println!("cargo:rustc-cfg=num_nonzero");
     }
+
+    // TryFrom, Atomic types, and non-zero signed integers stabilized in Rust 1.34:
+    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#tryfrom-and-tryinto
+    // https://blog.rust-lang.org/2019/04/11/Rust-1.34.0.html#library-stabilizations
+    if minor >= 34 {
+        println!("cargo:rustc-cfg=core_try_from");
+        println!("cargo:rustc-cfg=num_nonzero_signed");
+
+        // Whitelist of archs that support std::sync::atomic module. Ideally we
+        // would use #[cfg(target_has_atomic = "...")] but it is not stable yet.
+        // Instead this is based on rustc's src/librustc_target/spec/*.rs.
+        let has_atomic64 = target.starts_with("x86_64")
+            || target.starts_with("i686")
+            || target.starts_with("aarch64")
+            || target.starts_with("powerpc64")
+            || target.starts_with("sparc64")
+            || target.starts_with("mips64el");
+        let has_atomic32 = has_atomic64 || emscripten;
+        if has_atomic64 {
+            println!("cargo:rustc-cfg=std_atomic64");
+        }
+        if has_atomic32 {
+            println!("cargo:rustc-cfg=std_atomic");
+        }
+    }
 }
 
 fn rustc_minor_version() -> Option<u32> {

serde/src/de/ignored_any.rs

@@ -1,6 +1,8 @@
 use lib::*;
 
-use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+use de::{
+    Deserialize, Deserializer, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor,
+};
 
 /// An efficient way of discarding data from a deserializer.
 ///
@@ -205,6 +207,13 @@ impl<'de> Visitor<'de> for IgnoredAny {
         let _ = bytes;
         Ok(IgnoredAny)
     }
+
+    fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
+    where
+        A: EnumAccess<'de>,
+    {
+        data.variant::<IgnoredAny>()?.1.newtype_variant()
+    }
 }
 
 impl<'de> Deserialize<'de> for IgnoredAny {

serde/src/de/impls.rs

@@ -578,6 +578,9 @@ macro_rules! forwarded_impl {
 #[cfg(all(feature = "std", de_boxed_c_str))]
 forwarded_impl!((), Box<CStr>, CString::into_boxed_c_str);
 
+#[cfg(core_reverse)]
+forwarded_impl!((T), Reverse<T>, Reverse);
+
 ////////////////////////////////////////////////////////////////////////////////
 
 struct OptionVisitor<T> {
@@ -787,7 +790,8 @@ seq_impl!(
     BinaryHeap::clear,
     BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
     BinaryHeap::reserve,
-    BinaryHeap::push);
+    BinaryHeap::push
+);
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
@@ -796,7 +800,8 @@ seq_impl!(
     BTreeSet::clear,
     BTreeSet::new(),
     nop_reserve,
-    BTreeSet::insert);
+    BTreeSet::insert
+);
 
 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
@@ -962,7 +967,7 @@ impl<'de, T> Deserialize<'de> for [T; 0] {
 }
 
 macro_rules! array_impls {
-    ($($len:expr => ($($n:tt $name:ident)+))+) => {
+    ($($len:expr => ($($n:tt)+))+) => {
         $(
             impl<'de, T> Visitor<'de> for ArrayVisitor<[T; $len]>
             where
@@ -979,14 +984,12 @@ macro_rules! array_impls {
                 where
                     A: SeqAccess<'de>,
                 {
-                    $(
-                        let $name = match try!(seq.next_element()) {
+                    Ok([$(
+                        match try!(seq.next_element()) {
                             Some(val) => val,
                             None => return Err(Error::invalid_length($n, &self)),
-                        };
-                    )+
-
-                    Ok([$($name),+])
+                        }
+                    ),+])
                 }
             }
 
@@ -1042,38 +1045,38 @@ macro_rules! array_impls {
 }
 
 array_impls! {
-    1 => (0 a)
-    2 => (0 a 1 b)
-    3 => (0 a 1 b 2 c)
-    4 => (0 a 1 b 2 c 3 d)
-    5 => (0 a 1 b 2 c 3 d 4 e)
-    6 => (0 a 1 b 2 c 3 d 4 e 5 f)
-    7 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g)
-    8 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h)
-    9 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i)
-    10 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j)
-    11 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k)
-    12 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l)
-    13 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m)
-    14 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n)
-    15 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o)
-    16 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p)
-    17 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q)
-    18 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r)
-    19 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s)
-    20 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t)
-    21 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u)
-    22 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v)
-    23 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w)
-    24 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x)
-    25 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y)
-    26 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z)
-    27 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa)
-    28 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab)
-    29 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac)
-    30 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad)
-    31 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad 30 ae)
-    32 => (0 a 1 b 2 c 3 d 4 e 5 f 6 g 7 h 8 i 9 j 10 k 11 l 12 m 13 n 14 o 15 p 16 q 17 r 18 s 19 t 20 u 21 v 22 w 23 x 24 y 25 z 26 aa 27 ab 28 ac 29 ad 30 ae 31 af)
+    1 => (0)
+    2 => (0 1)
+    3 => (0 1 2)
+    4 => (0 1 2 3)
+    5 => (0 1 2 3 4)
+    6 => (0 1 2 3 4 5)
+    7 => (0 1 2 3 4 5 6)
+    8 => (0 1 2 3 4 5 6 7)
+    9 => (0 1 2 3 4 5 6 7 8)
+    10 => (0 1 2 3 4 5 6 7 8 9)
+    11 => (0 1 2 3 4 5 6 7 8 9 10)
+    12 => (0 1 2 3 4 5 6 7 8 9 10 11)
+    13 => (0 1 2 3 4 5 6 7 8 9 10 11 12)
+    14 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13)
+    15 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14)
+    16 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15)
+    17 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16)
+    18 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17)
+    19 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18)
+    20 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19)
+    21 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20)
+    22 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21)
+    23 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22)
+    24 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23)
+    25 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24)
+    26 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25)
+    27 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26)
+    28 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27)
+    29 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28)
+    30 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29)
+    31 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30)
+    32 => (0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2269,6 +2272,117 @@ mod range {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(any(ops_bound, collections_bound))]
+impl<'de, T> Deserialize<'de> for Bound<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        enum Field {
+            Unbounded,
+            Included,
+            Excluded,
+        }
+
+        impl<'de> Deserialize<'de> for Field {
+            #[inline]
+            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("`Unbounded`, `Included` or `Excluded`")
+                    }
+
+                    fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
+                    where
+                        E: Error,
+                    {
+                        match value {
+                            0 => Ok(Field::Unbounded),
+                            1 => Ok(Field::Included),
+                            2 => Ok(Field::Excluded),
+                            _ => Err(Error::invalid_value(
+                                Unexpected::Unsigned(value as u64),
+                                &self,
+                            )),
+                        }
+                    }
+
+                    fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                    where
+                        E: Error,
+                    {
+                        match value {
+                            "Unbounded" => Ok(Field::Unbounded),
+                            "Included" => Ok(Field::Included),
+                            "Excluded" => Ok(Field::Excluded),
+                            _ => Err(Error::unknown_variant(value, VARIANTS)),
+                        }
+                    }
+
+                    fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                    where
+                        E: Error,
+                    {
+                        match value {
+                            b"Unbounded" => Ok(Field::Unbounded),
+                            b"Included" => Ok(Field::Included),
+                            b"Excluded" => Ok(Field::Excluded),
+                            _ => match str::from_utf8(value) {
+                                Ok(value) => Err(Error::unknown_variant(value, VARIANTS)),
+                                Err(_) => {
+                                    Err(Error::invalid_value(Unexpected::Bytes(value), &self))
+                                }
+                            },
+                        }
+                    }
+                }
+
+                deserializer.deserialize_identifier(FieldVisitor)
+            }
+        }
+
+        struct BoundVisitor<T>(PhantomData<Bound<T>>);
+
+        impl<'de, T> Visitor<'de> for BoundVisitor<T>
+        where
+            T: Deserialize<'de>,
+        {
+            type Value = Bound<T>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("enum Bound")
+            }
+
+            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
+            where
+                A: EnumAccess<'de>,
+            {
+                match try!(data.variant()) {
+                    (Field::Unbounded, v) => v.unit_variant().map(|()| Bound::Unbounded),
+                    (Field::Included, v) => v.newtype_variant().map(Bound::Included),
+                    (Field::Excluded, v) => v.newtype_variant().map(Bound::Excluded),
+                }
+            }
+        }
+
+        const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
+
+        deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 macro_rules! nonzero_integers {
     ( $( $T: ident, )+ ) => {
         $(
@@ -2290,7 +2404,6 @@ macro_rules! nonzero_integers {
 }
 
 nonzero_integers! {
-    // Not including signed NonZeroI* since they might be removed
     NonZeroU8,
     NonZeroU16,
     NonZeroU32,
@@ -2298,12 +2411,26 @@ nonzero_integers! {
     NonZeroUsize,
 }
 
+#[cfg(num_nonzero_signed)]
+nonzero_integers! {
+    NonZeroI8,
+    NonZeroI16,
+    NonZeroI32,
+    NonZeroI64,
+    NonZeroIsize,
+}
+
 // Currently 128-bit integers do not work on Emscripten targets so we need an
 // additional `#[cfg]`
 serde_if_integer128! {
     nonzero_integers! {
         NonZeroU128,
     }
+
+    #[cfg(num_nonzero_signed)]
+    nonzero_integers! {
+        NonZeroI128,
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -2431,3 +2558,31 @@ where
         Deserialize::deserialize(deserializer).map(Wrapping)
     }
 }
+
+#[cfg(all(feature = "std", std_atomic))]
+macro_rules! atomic_impl {
+    ($($ty:ident)*) => {
+        $(
+            impl<'de> Deserialize<'de> for $ty {
+                fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+                where
+                    D: Deserializer<'de>,
+                {
+                    Deserialize::deserialize(deserializer).map(Self::new)
+                }
+            }
+        )*
+    };
+}
+
+#[cfg(all(feature = "std", std_atomic))]
+atomic_impl! {
+    AtomicBool
+    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
+    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+}
+
+#[cfg(all(feature = "std", std_atomic64))]
+atomic_impl! {
+    AtomicI64 AtomicU64
+}

serde/src/de/mod.rs

@@ -59,13 +59,13 @@
 //!    - Box\<T\>
 //!    - Box\<\[T\]\>
 //!    - Box\<str\>
-//!    - Rc\<T\>
-//!    - Arc\<T\>
 //!    - Cow\<'a, T\>
 //!    - Cell\<T\>
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
+//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -89,6 +89,7 @@
 //!    - PathBuf
 //!    - Range\<T\>
 //!    - RangeInclusive\<T\>
+//!    - Bound\<T\>
 //!    - num::NonZero*
 //!    - `!` *(unstable)*
 //!  - **Net types**:

serde/src/de/value.rs

@@ -1287,10 +1287,40 @@ where
         visitor.visit_map(self.map)
     }
 
+    fn deserialize_enum<V>(
+        self,
+        _name: &str,
+        _variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_enum(self)
+    }
+
     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
+        tuple_struct map struct identifier ignored_any
+    }
+}
+
+impl<'de, A> de::EnumAccess<'de> for MapAccessDeserializer<A>
+where
+    A: de::MapAccess<'de>,
+{
+    type Error = A::Error;
+    type Variant = private::MapAsEnum<A>;
+
+    fn variant_seed<T>(mut self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        match self.map.next_key_seed(seed)? {
+            Some(key) => Ok((key, private::map_as_enum(self.map))),
+            None => Err(de::Error::invalid_type(de::Unexpected::Map, &"enum")),
+        }
     }
 }
 
@@ -1299,7 +1329,7 @@ where
 mod private {
     use lib::*;
 
-    use de::{self, Unexpected};
+    use de::{self, DeserializeSeed, Deserializer, MapAccess, Unexpected, VariantAccess, Visitor};
 
     #[derive(Clone, Debug)]
     pub struct UnitOnly<E> {
@@ -1360,6 +1390,92 @@ mod private {
         }
     }
 
+    #[derive(Clone, Debug)]
+    pub struct MapAsEnum<A> {
+        map: A,
+    }
+
+    pub fn map_as_enum<A>(map: A) -> MapAsEnum<A> {
+        MapAsEnum { map: map }
+    }
+
+    impl<'de, A> VariantAccess<'de> for MapAsEnum<A>
+    where
+        A: MapAccess<'de>,
+    {
+        type Error = A::Error;
+
+        fn unit_variant(mut self) -> Result<(), Self::Error> {
+            self.map.next_value()
+        }
+
+        fn newtype_variant_seed<T>(mut self, seed: T) -> Result<T::Value, Self::Error>
+        where
+            T: DeserializeSeed<'de>,
+        {
+            self.map.next_value_seed(seed)
+        }
+
+        fn tuple_variant<V>(mut self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.map.next_value_seed(SeedTupleVariant {
+                len: len,
+                visitor: visitor,
+            })
+        }
+
+        fn struct_variant<V>(
+            mut self,
+            _fields: &'static [&'static str],
+            visitor: V,
+        ) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>,
+        {
+            self.map
+                .next_value_seed(SeedStructVariant { visitor: visitor })
+        }
+    }
+
+    struct SeedTupleVariant<V> {
+        len: usize,
+        visitor: V,
+    }
+
+    impl<'de, V> DeserializeSeed<'de> for SeedTupleVariant<V>
+    where
+        V: Visitor<'de>,
+    {
+        type Value = V::Value;
+
+        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_tuple(self.len, self.visitor)
+        }
+    }
+
+    struct SeedStructVariant<V> {
+        visitor: V,
+    }
+
+    impl<'de, V> DeserializeSeed<'de> for SeedStructVariant<V>
+    where
+        V: Visitor<'de>,
+    {
+        type Value = V::Value;
+
+        fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            deserializer.deserialize_map(self.visitor)
+        }
+    }
+
     /// Avoid having to restate the generic types on `MapDeserializer`. The
     /// `Iterator::Item` contains enough information to figure out K and V.
     pub trait Pair {

serde/src/export.rs

@@ -9,7 +9,10 @@ pub use lib::result::Result::{self, Err, Ok};
 pub use self::string::from_utf8_lossy;
 
 #[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::Vec;
+pub use lib::{ToString, Vec};
+
+#[cfg(core_try_from)]
+pub use lib::convert::TryFrom;
 
 mod string {
     use lib::*;

serde/src/integer128.rs

@@ -1,13 +1,13 @@
 /// Conditional compilation depending on whether Serde is built with support for
 /// 128-bit integers.
 ///
-/// Data formats that wish to support Rust compiler versions older than 1.26 may
-/// place the i128 / u128 methods of their Serializer and Deserializer behind
-/// this macro.
+/// Data formats that wish to support Rust compiler versions older than 1.26
+/// (or targets that lack 128-bit integers) may place the i128 / u128 methods
+/// of their Serializer and Deserializer behind this macro.
 ///
-/// Data formats that require a minimum Rust compiler version of at least 1.26
-/// do not need to bother with this macro and may assume support for 128-bit
-/// integers.
+/// Data formats that require a minimum Rust compiler version of at least 1.26,
+/// or do not target platforms that lack 128-bit integers, do not need to
+/// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
 /// # use serde::private::ser::Error;

serde/src/lib.rs

@@ -46,7 +46,6 @@
 //! - [BSON], the data storage and network transfer format used by MongoDB.
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
-//! - [Hjson], a variant of JSON designed to be readable and writable by humans.
 //! - [JSON5], A superset of JSON including some productions from ES5.
 //! - [URL], the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
@@ -64,7 +63,6 @@
 //! [RON]: https://github.com/ron-rs/ron
 //! [BSON]: https://github.com/zonyitoo/bson-rs
 //! [Avro]: https://github.com/flavray/avro-rs
-//! [Hjson]: https://github.com/laktak/hjson-rust
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
 //! [URL]: https://github.com/nox/serde_urlencoded
 //! [Envy]: https://github.com/softprops/envy
@@ -75,7 +73,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.84")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.98")]
 // 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
@@ -83,55 +81,38 @@
 //
 //    https://github.com/serde-rs/serde/issues/812
 #![cfg_attr(feature = "unstable", feature(specialization, never_type))]
-#![cfg_attr(feature = "alloc", feature(alloc))]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
-// Ignored clippy lints
+// Ignored clippy and clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        cast_lossless,
-        const_static_lifetime,
-        doc_markdown,
-        linkedlist,
-        needless_pass_by_value,
+        // not available in our oldest supported compiler
+        checked_conversions,
+        empty_enum,
         redundant_field_names,
+        redundant_static_lifetimes,
+        // integer and float ser/de requires these sorts of casts
+        cast_possible_truncation,
+        cast_possible_wrap,
+        cast_sign_loss,
+        // things are often more readable this way
+        cast_lossless,
+        module_name_repetitions,
+        single_match_else,
         type_complexity,
-        unreadable_literal,
-        zero_prefixed_literal
+        use_self,
+        zero_prefixed_literal,
+        // not practical
+        needless_pass_by_value,
+        similar_names,
+        // preference
+        doc_markdown,
     )
 )]
-// Ignored clippy_pedantic lints
-#![cfg_attr(feature = "cargo-clippy", allow(
-// integer and float ser/de requires these sorts of casts
-    cast_possible_truncation,
-    cast_possible_wrap,
-    cast_precision_loss,
-    cast_sign_loss,
-// simplifies some macros
-    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,
-    use_self,
-// not practical
-    indexing_slicing,
-    many_single_char_names,
-    missing_docs_in_private_items,
-    similar_names,
-// alternative is not stable
-    empty_enum,
-    use_debug,
-))]
-// Blacklisted Rust lints.
-//
-// Compiler bug involving unused_imports:
-// https://github.com/rust-lang/rust/issues/51661
-#![deny(missing_docs, /*unused_imports*/)]
+// Rustc lints.
+#![deny(missing_docs, unused_imports)]
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -172,7 +153,7 @@ mod lib {
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::string::{String, ToString};
     #[cfg(feature = "std")]
-    pub use std::string::String;
+    pub use std::string::{String, ToString};
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::vec::Vec;
@@ -219,11 +200,28 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::time::{SystemTime, UNIX_EPOCH};
 
-    #[cfg(any(core_duration, feature = "std"))]
-    pub use self::core::time::Duration;
+    #[cfg(all(feature = "std", collections_bound))]
+    pub use std::collections::Bound;
+
+    #[cfg(core_reverse)]
+    pub use self::core::cmp::Reverse;
+
+    #[cfg(ops_bound)]
+    pub use self::core::ops::Bound;
 
     #[cfg(range_inclusive)]
     pub use self::core::ops::RangeInclusive;
+
+    #[cfg(all(feature = "std", std_atomic))]
+    pub use std::sync::atomic::{
+        AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+        AtomicUsize, Ordering,
+    };
+    #[cfg(all(feature = "std", std_atomic64))]
+    pub use std::sync::atomic::{AtomicI64, AtomicU64};
+
+    #[cfg(any(core_duration, feature = "std"))]
+    pub use self::core::time::Duration;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -252,40 +250,6 @@ pub mod private;
 
 // Re-export #[derive(Serialize, Deserialize)].
 //
-// This is a workaround for https://github.com/rust-lang/cargo/issues/1286.
-// Without this re-export, crates that put Serde derives behind a cfg_attr would
-// need to use some silly feature name that depends on both serde and
-// serde_derive.
-//
-//     [features]
-//     serde-impls = ["serde", "serde_derive"]
-//
-//     [dependencies]
-//     serde = { version = "1.0", optional = true }
-//     serde_derive = { version = "1.0", optional = true }
-//
-//     # Used like this:
-//     # #[cfg(feature = "serde-impls")]
-//     # #[macro_use]
-//     # extern crate serde_derive;
-//     #
-//     # #[cfg_attr(feature = "serde-impls", derive(Serialize, Deserialize))]
-//     # struct S { /* ... */ }
-//
-// The re-exported derives allow crates to use "serde" as the name of their
-// Serde feature which is more intuitive.
-//
-//     [dependencies]
-//     serde = { version = "1.0", optional = true, features = ["derive"] }
-//
-//     # Used like this:
-//     # #[cfg(feature = "serde")]
-//     # #[macro_use]
-//     # extern crate serde;
-//     #
-//     # #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
-//     # struct S { /* ... */ }
-//
 // The reason re-exporting is not enabled by default is that disabling it would
 // be annoying for crates that provide handwritten impls or data formats. They
 // would need to disable default features and then explicitly re-enable std.

serde/src/private/de.rs

@@ -1420,6 +1420,7 @@ mod content {
                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
                 Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -2123,6 +2124,7 @@ mod content {
                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
                 Content::U8(v) => visitor.visit_u8(v),
+                Content::U64(v) => visitor.visit_u64(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -2709,7 +2711,7 @@ where
         }
 
         Err(Error::custom(format_args!(
-            "no variant of enum {} not found in flattened data",
+            "no variant of enum {} found in flattened data",
             name
         )))
     }

serde/src/ser/impls.rs

@@ -160,10 +160,12 @@ macro_rules! array_impls {
     }
 }
 
-array_impls!(01 02 03 04 05 06 07 08 09 10
-             11 12 13 14 15 16 17 18 19 20
-             21 22 23 24 25 26 27 28 29 30
-             31 32);
+array_impls! {
+    01 02 03 04 05 06 07 08 09 10
+    11 12 13 14 15 16 17 18 19 20
+    21 22 23 24 25 26 27 28 29 30
+    31 32
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -256,6 +258,29 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(any(ops_bound, collections_bound))]
+impl<T> Serialize for Bound<T>
+where
+    T: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        match *self {
+            Bound::Unbounded => serializer.serialize_unit_variant("Bound", 0, "Unbounded"),
+            Bound::Included(ref value) => {
+                serializer.serialize_newtype_variant("Bound", 1, "Included", value)
+            }
+            Bound::Excluded(ref value) => {
+                serializer.serialize_newtype_variant("Bound", 2, "Excluded", value)
+            }
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 impl Serialize for () {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -456,7 +481,6 @@ macro_rules! nonzero_integers {
 }
 
 nonzero_integers! {
-    // Not including signed NonZeroI* since they might be removed
     NonZeroU8,
     NonZeroU16,
     NonZeroU32,
@@ -464,12 +488,26 @@ nonzero_integers! {
     NonZeroUsize,
 }
 
+#[cfg(num_nonzero_signed)]
+nonzero_integers! {
+    NonZeroI8,
+    NonZeroI16,
+    NonZeroI32,
+    NonZeroI64,
+    NonZeroIsize,
+}
+
 // Currently 128-bit integers do not work on Emscripten targets so we need an
 // additional `#[cfg]`
 serde_if_integer128! {
     nonzero_integers! {
         NonZeroU128,
     }
+
+    #[cfg(num_nonzero_signed)]
+    nonzero_integers! {
+        NonZeroI128,
+    }
 }
 
 impl<T> Serialize for Cell<T>
@@ -595,6 +633,7 @@ impl Serialize for SystemTime {
 #[cfg(feature = "std")]
 macro_rules! serialize_display_bounded_length {
     ($value:expr, $max:expr, $serializer:expr) => {{
+        #[allow(deprecated)]
         let mut buffer: [u8; $max] = unsafe { mem::uninitialized() };
         let remaining_len = {
             let mut remaining = &mut buffer[..];
@@ -799,3 +838,47 @@ where
         self.0.serialize(serializer)
     }
 }
+
+#[cfg(core_reverse)]
+impl<T> Serialize for Reverse<T>
+where
+    T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(serializer)
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(all(feature = "std", std_atomic))]
+macro_rules! atomic_impl {
+    ($($ty:ident)*) => {
+        $(
+            impl Serialize for $ty {
+                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    self.load(Ordering::SeqCst).serialize(serializer)
+                }
+            }
+        )*
+    }
+}
+
+#[cfg(all(feature = "std", std_atomic))]
+atomic_impl! {
+    AtomicBool
+    AtomicI8 AtomicI16 AtomicI32 AtomicIsize
+    AtomicU8 AtomicU16 AtomicU32 AtomicUsize
+}
+
+#[cfg(all(feature = "std", std_atomic64))]
+atomic_impl! {
+    AtomicI64 AtomicU64
+}

serde/src/ser/mod.rs

@@ -56,13 +56,13 @@
 //!    - PhantomData\<T\>
 //!  - **Wrapper types**:
 //!    - Box\<T\>
-//!    - Rc\<T\>
-//!    - Arc\<T\>
 //!    - Cow\<'a, T\>
 //!    - Cell\<T\>
 //!    - RefCell\<T\>
 //!    - Mutex\<T\>
 //!    - RwLock\<T\>
+//!    - Rc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
+//!    - Arc\<T\>&emsp;*(if* features = ["rc"] *is enabled)*
 //!  - **Collection types**:
 //!    - BTreeMap\<K, V\>
 //!    - BTreeSet\<T\>
@@ -84,6 +84,7 @@
 //!    - PathBuf
 //!    - Range\<T\>
 //!    - RangeInclusive\<T\>
+//!    - Bound\<T\>
 //!    - num::NonZero*
 //!    - `!` *(unstable)*
 //!  - **Net types**:

serde_derive/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_derive"
-version = "1.0.84" # remember to update html_root_url
+version = "1.0.98" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_derive/src/de.rs

@@ -27,15 +27,16 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
     let body = Stmts(deserialize_body(&cont, &params));
     let delife = params.borrowed.de_lifetime();
+    let serde = cont.attrs.serde_path();
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;
         let used = pretend::pretend_used(&cont);
         quote! {
             impl #de_impl_generics #ident #ty_generics #where_clause {
-                #vis fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<#remote #ty_generics, __D::Error>
+                #vis fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<#remote #ty_generics, __D::Error>
                 where
-                    __D: _serde::Deserializer<#delife>,
+                    __D: #serde::Deserializer<#delife>,
                 {
                     #used
                     #body
@@ -47,10 +48,10 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
 
         quote! {
             #[automatically_derived]
-            impl #de_impl_generics _serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+            impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
+                fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<Self, __D::Error>
                 where
-                    __D: _serde::Deserializer<#delife>,
+                    __D: #serde::Deserializer<#delife>,
                 {
                     #body
                 }
@@ -60,7 +61,12 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
         }
     };
 
-    Ok(dummy::wrap_in_const("DESERIALIZE", ident, impl_block))
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "DESERIALIZE",
+        ident,
+        impl_block,
+    ))
 }
 
 fn precondition(cx: &Ctxt, cont: &Container) {
@@ -263,6 +269,8 @@ fn deserialize_body(cont: &Container, params: &Parameters) -> Fragment {
         deserialize_transparent(cont, params)
     } else if let Some(type_from) = cont.attrs.type_from() {
         deserialize_from(type_from)
+    } else if let Some(type_try_from) = cont.attrs.type_try_from() {
+        deserialize_try_from(type_try_from)
     } else if let attr::Identifier::No = cont.attrs.identifier() {
         match cont.data {
             Data::Enum(ref variants) => deserialize_enum(params, variants, &cont.attrs),
@@ -292,6 +300,7 @@ fn deserialize_in_place_body(cont: &Container, params: &Parameters) -> Option<St
 
     if cont.attrs.transparent()
         || cont.attrs.type_from().is_some()
+        || cont.attrs.type_try_from().is_some()
         || cont.attrs.identifier().is_some()
         || cont
             .data
@@ -384,6 +393,14 @@ fn deserialize_from(type_from: &syn::Type) -> Fragment {
     }
 }
 
+fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
+    quote_block! {
+        _serde::export::Result::and_then(
+            <#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
+            |v| _serde::export::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
+    }
+}
+
 fn deserialize_unit_struct(params: &Parameters, cattrs: &attr::Container) -> Fragment {
     let this = &params.this;
     let type_name = cattrs.name().deserialize_name();
@@ -1140,25 +1157,21 @@ fn deserialize_enum(
     }
 }
 
-fn deserialize_externally_tagged_enum(
-    params: &Parameters,
+fn prepare_enum_variant_enum(
     variants: &[Variant],
     cattrs: &attr::Container,
-) -> Fragment {
-    let this = &params.this;
-    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
-        split_with_de_lifetime(params);
-    let delife = params.borrowed.de_lifetime();
-
-    let type_name = cattrs.name().deserialize_name();
-
-    let expecting = format!("enum {}", params.type_name());
-
+) -> (TokenStream, Stmts) {
     let variant_names_idents: Vec<_> = variants
         .iter()
         .enumerate()
         .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
+        .map(|(i, variant)| {
+            (
+                variant.attrs.name().deserialize_name(),
+                field_i(i),
+                variant.attrs.aliases(),
+            )
+        })
         .collect();
 
     let other_idx = variants
@@ -1166,7 +1179,7 @@ fn deserialize_externally_tagged_enum(
         .position(|ref variant| variant.attrs.other());
 
     let variants_stmt = {
-        let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
+        let variant_names = variant_names_idents.iter().map(|&(ref name, _, _)| name);
         quote! {
             const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
         }
@@ -1179,6 +1192,24 @@ fn deserialize_externally_tagged_enum(
         other_idx,
     ));
 
+    (variants_stmt, variant_visitor)
+}
+
+fn deserialize_externally_tagged_enum(
+    params: &Parameters,
+    variants: &[Variant],
+    cattrs: &attr::Container,
+) -> Fragment {
+    let this = &params.this;
+    let (de_impl_generics, de_ty_generics, ty_generics, where_clause) =
+        split_with_de_lifetime(params);
+    let delife = params.borrowed.de_lifetime();
+
+    let type_name = cattrs.name().deserialize_name();
+    let expecting = format!("enum {}", params.type_name());
+
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
+
     // Match arms to extract a variant from a string
     let variant_arms = variants
         .iter()
@@ -1261,30 +1292,7 @@ fn deserialize_internally_tagged_enum(
     cattrs: &attr::Container,
     tag: &str,
 ) -> Fragment {
-    let variant_names_idents: Vec<_> = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
-        .collect();
-
-    let other_idx = variants
-        .iter()
-        .position(|ref variant| variant.attrs.other());
-
-    let variants_stmt = {
-        let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
-        quote! {
-            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
-        }
-    };
-
-    let variant_visitor = Stmts(deserialize_generated_identifier(
-        &variant_names_idents,
-        cattrs,
-        true,
-        other_idx,
-    ));
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
     // Match arms to extract a variant from a string
     let variant_arms = variants
@@ -1335,30 +1343,7 @@ fn deserialize_adjacently_tagged_enum(
         split_with_de_lifetime(params);
     let delife = params.borrowed.de_lifetime();
 
-    let variant_names_idents: Vec<_> = variants
-        .iter()
-        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
-        .map(|(i, variant)| (variant.attrs.name().deserialize_name(), field_i(i)))
-        .collect();
-
-    let other_idx = variants
-        .iter()
-        .position(|ref variant| variant.attrs.other());
-
-    let variants_stmt = {
-        let variant_names = variant_names_idents.iter().map(|&(ref name, _)| name);
-        quote! {
-            const VARIANTS: &'static [&'static str] = &[ #(#variant_names),* ];
-        }
-    };
-
-    let variant_visitor = Stmts(deserialize_generated_identifier(
-        &variant_names_idents,
-        cattrs,
-        true,
-        other_idx,
-    ));
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
     let variant_arms: &Vec<_> = &variants
         .iter()
@@ -1870,13 +1855,13 @@ fn deserialize_untagged_newtype_variant(
 }
 
 fn deserialize_generated_identifier(
-    fields: &[(String, Ident)],
+    fields: &[(String, Ident, Vec<String>)],
     cattrs: &attr::Container,
     is_variant: bool,
     other_idx: Option<usize>,
 ) -> Fragment {
     let this = quote!(__Field);
-    let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident)| ident).collect();
+    let field_idents: &Vec<_> = &fields.iter().map(|&(_, ref ident, _)| ident).collect();
 
     let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
         let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
@@ -1977,11 +1962,12 @@ fn deserialize_custom_identifier(
             (
                 variant.attrs.name().deserialize_name(),
                 variant.ident.clone(),
+                variant.attrs.aliases(),
             )
         })
         .collect();
 
-    let names = names_idents.iter().map(|&(ref name, _)| name);
+    let names = names_idents.iter().map(|&(ref name, _, _)| name);
 
     let names_const = if fallthrough.is_some() {
         None
@@ -2032,24 +2018,33 @@ fn deserialize_custom_identifier(
 
 fn deserialize_identifier(
     this: &TokenStream,
-    fields: &[(String, Ident)],
+    fields: &[(String, Ident, Vec<String>)],
     is_variant: bool,
     fallthrough: Option<TokenStream>,
     collect_other_fields: bool,
 ) -> Fragment {
-    let field_strs = fields.iter().map(|&(ref name, _)| name);
-    let field_borrowed_strs = fields.iter().map(|&(ref name, _)| name);
-    let field_bytes = fields
+    let mut flat_fields = Vec::new();
+    for &(_, ref ident, ref aliases) in fields {
+        flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
+    }
+
+    let field_strs = flat_fields.iter().map(|&(ref name, _)| name);
+    let field_borrowed_strs = flat_fields.iter().map(|&(ref name, _)| name);
+    let field_bytes = flat_fields
         .iter()
         .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
-    let field_borrowed_bytes = fields
+    let field_borrowed_bytes = flat_fields
         .iter()
         .map(|&(ref name, _)| Literal::byte_string(name.as_bytes()));
 
-    let constructors: &Vec<_> = &fields
+    let constructors: &Vec<_> = &flat_fields
         .iter()
         .map(|&(_, ref ident)| quote!(#this::#ident))
         .collect();
+    let main_constructors: &Vec<_> = &fields
+        .iter()
+        .map(|&(_, ref ident, _)| quote!(#this::#ident))
+        .collect();
 
     let expecting = if is_variant {
         "variant identifier"
@@ -2075,7 +2070,7 @@ fn deserialize_identifier(
     ) = if collect_other_fields {
         (
             Some(quote! {
-                let __value = _serde::private::de::Content::String(__value.to_string());
+                let __value = _serde::private::de::Content::String(_serde::export::ToString::to_string(__value));
             }),
             Some(quote! {
                 let __value = _serde::private::de::Content::Str(__value);
@@ -2237,7 +2232,7 @@ fn deserialize_identifier(
             {
                 match __value {
                     #(
-                        #variant_indices => _serde::export::Ok(#constructors),
+                        #variant_indices => _serde::export::Ok(#main_constructors),
                     )*
                     _ => _serde::export::Err(_serde::de::Error::invalid_value(
                         _serde::de::Unexpected::Unsigned(__value),
@@ -2300,11 +2295,17 @@ fn deserialize_struct_as_struct_visitor(
         .iter()
         .enumerate()
         .filter(|&(_, field)| !field.attrs.skip_deserializing())
-        .map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
+        .map(|(i, field)| {
+            (
+                field.attrs.name().deserialize_name(),
+                field_i(i),
+                field.attrs.aliases(),
+            )
+        })
         .collect();
 
     let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|&(ref name, _)| name);
+        let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
         quote_block! {
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
@@ -2327,7 +2328,13 @@ fn deserialize_struct_as_map_visitor(
         .iter()
         .enumerate()
         .filter(|&(_, field)| !field.attrs.skip_deserializing() && !field.attrs.flatten())
-        .map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
+        .map(|(i, field)| {
+            (
+                field.attrs.name().deserialize_name(),
+                field_i(i),
+                field.attrs.aliases(),
+            )
+        })
         .collect();
 
     let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
@@ -2394,7 +2401,12 @@ fn deserialize_map(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
+                        match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
+                            _serde::export::Ok(__wrapper) => __wrapper.value,
+                            _serde::export::Err(__err) => {
+                                return _serde::export::Err(__err);
+                            }
+                        }
                     })
                 }
             };
@@ -2461,7 +2473,7 @@ fn deserialize_map(
 
     let extract_collected = fields_names
         .iter()
-        .filter(|&&(field, _)| field.attrs.flatten())
+        .filter(|&&(field, _)| field.attrs.flatten() && !field.attrs.skip_deserializing())
         .map(|&(field, ref name)| {
             let field_ty = field.ty;
             let func = match field.attrs.deserialize_with() {
@@ -2481,7 +2493,9 @@ fn deserialize_map(
 
     let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
         Some(quote! {
-            if let _serde::export::Some(_serde::export::Some((__key, _))) = __collect.into_iter().filter(|x| x.is_some()).next() {
+            if let _serde::export::Some(_serde::export::Some((__key, _))) =
+                __collect.into_iter().filter(_serde::export::Option::is_some).next()
+            {
                 if let _serde::export::Some(__key) = __key.as_str() {
                     return _serde::export::Err(
                         _serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
@@ -2558,11 +2572,17 @@ fn deserialize_struct_as_struct_in_place_visitor(
         .iter()
         .enumerate()
         .filter(|&(_, field)| !field.attrs.skip_deserializing())
-        .map(|(i, field)| (field.attrs.name().deserialize_name(), field_i(i)))
+        .map(|(i, field)| {
+            (
+                field.attrs.name().deserialize_name(),
+                field_i(i),
+                field.attrs.aliases(),
+            )
+        })
         .collect();
 
     let fields_stmt = {
-        let field_names = field_names_idents.iter().map(|&(ref name, _)| name);
+        let field_names = field_names_idents.iter().map(|&(ref name, _, _)| name);
         quote_block! {
             const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
         }
@@ -2619,7 +2639,12 @@ fn deserialize_map_in_place(
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
                         #wrapper
-                        self.place.#member = try!(_serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map)).value
+                        self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
+                            _serde::export::Ok(__wrapper) => __wrapper.value,
+                            _serde::export::Err(__err) => {
+                                return _serde::export::Err(__err);
+                            }
+                        };
                     })
                 }
             };

serde_derive/src/dummy.rs

@@ -1,8 +1,14 @@
 use proc_macro2::{Ident, Span, TokenStream};
 
+use syn;
 use try;
 
-pub fn wrap_in_const(trait_: &str, ty: &Ident, code: TokenStream) -> TokenStream {
+pub fn wrap_in_const(
+    serde_path: Option<&syn::Path>,
+    trait_: &str,
+    ty: &Ident,
+    code: TokenStream,
+) -> TokenStream {
     let try_replacement = try::replacement();
 
     let dummy_const = Ident::new(
@@ -10,13 +16,22 @@ pub fn wrap_in_const(trait_: &str, ty: &Ident, code: TokenStream) -> TokenStream
         Span::call_site(),
     );
 
-    quote! {
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
+    let use_serde = match serde_path {
+        Some(path) => quote! {
+            use #path as _serde;
+        },
+        None => quote! {
             #[allow(unknown_lints)]
             #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
             #[allow(rust_2018_idioms)]
             extern crate serde as _serde;
+        },
+    };
+
+    quote! {
+        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
+        const #dummy_const: () = {
+            #use_serde
             #try_replacement
             #code
         };

serde_derive/src/internals/attr.rs

@@ -1,6 +1,7 @@
 use internals::Ctxt;
 use proc_macro2::{Group, Span, TokenStream, TokenTree};
 use quote::ToTokens;
+use std::borrow::Cow;
 use std::collections::BTreeSet;
 use std::str::FromStr;
 use syn;
@@ -20,7 +21,6 @@ use syn::NestedMeta::{Literal, Meta};
 
 pub use internals::case::RenameRule;
 
-#[derive(Clone)]
 struct Attr<'c, T> {
     cx: &'c Ctxt,
     name: &'static str,
@@ -90,9 +90,54 @@ impl<'c> BoolAttr<'c> {
     }
 }
 
+struct VecAttr<'c, T> {
+    cx: &'c Ctxt,
+    name: &'static str,
+    first_dup_tokens: TokenStream,
+    values: Vec<T>,
+}
+
+impl<'c, T> VecAttr<'c, T> {
+    fn none(cx: &'c Ctxt, name: &'static str) -> Self {
+        VecAttr {
+            cx: cx,
+            name: name,
+            first_dup_tokens: TokenStream::new(),
+            values: Vec::new(),
+        }
+    }
+
+    fn insert<A: ToTokens>(&mut self, obj: A, value: T) {
+        if self.values.len() == 1 {
+            self.first_dup_tokens = obj.into_token_stream();
+        }
+        self.values.push(value);
+    }
+
+    fn at_most_one(mut self) -> Result<Option<T>, ()> {
+        if self.values.len() > 1 {
+            let dup_token = self.first_dup_tokens;
+            self.cx.error_spanned_by(
+                dup_token,
+                format!("duplicate serde attribute `{}`", self.name),
+            );
+            Err(())
+        } else {
+            Ok(self.values.pop())
+        }
+    }
+
+    fn get(self) -> Vec<T> {
+        self.values
+    }
+}
+
 pub struct Name {
     serialize: String,
+    serialize_renamed: bool,
     deserialize: String,
+    deserialize_renamed: bool,
+    deserialize_aliases: Vec<String>,
 }
 
 #[allow(deprecated)]
@@ -104,6 +149,36 @@ fn unraw(ident: &Ident) -> String {
 }
 
 impl Name {
+    fn from_attrs(
+        source_name: String,
+        ser_name: Attr<String>,
+        de_name: Attr<String>,
+        de_aliases: Option<VecAttr<String>>,
+    ) -> Name {
+        let deserialize_aliases = match de_aliases {
+            Some(de_aliases) => {
+                let mut alias_list = BTreeSet::new();
+                for alias_name in de_aliases.get() {
+                    alias_list.insert(alias_name);
+                }
+                alias_list.into_iter().collect()
+            }
+            None => Vec::new(),
+        };
+
+        let ser_name = ser_name.get();
+        let ser_renamed = ser_name.is_some();
+        let de_name = de_name.get();
+        let de_renamed = de_name.is_some();
+        Name {
+            serialize: ser_name.unwrap_or_else(|| source_name.clone()),
+            serialize_renamed: ser_renamed,
+            deserialize: de_name.unwrap_or(source_name),
+            deserialize_renamed: de_renamed,
+            deserialize_aliases: deserialize_aliases,
+        }
+    }
+
     /// Return the container name for the container when serializing.
     pub fn serialize_name(&self) -> String {
         self.serialize.clone()
@@ -113,6 +188,15 @@ impl Name {
     pub fn deserialize_name(&self) -> String {
         self.deserialize.clone()
     }
+
+    fn deserialize_aliases(&self) -> Vec<String> {
+        let mut aliases = self.deserialize_aliases.clone();
+        let main_name = self.deserialize_name();
+        if !aliases.contains(&main_name) {
+            aliases.push(main_name);
+        }
+        aliases
+    }
 }
 
 pub struct RenameAllRules {
@@ -131,10 +215,12 @@ pub struct Container {
     de_bound: Option<Vec<syn::WherePredicate>>,
     tag: TagType,
     type_from: Option<syn::Type>,
+    type_try_from: Option<syn::Type>,
     type_into: Option<syn::Type>,
     remote: Option<syn::Path>,
     identifier: Identifier,
     has_flatten: bool,
+    serde_path: Option<syn::Path>,
 }
 
 /// Styles of representing an enum.
@@ -211,10 +297,12 @@ impl Container {
         let mut internal_tag = Attr::none(cx, "tag");
         let mut content = Attr::none(cx, "content");
         let mut type_from = Attr::none(cx, "from");
+        let mut type_try_from = Attr::none(cx, "try_from");
         let mut type_into = Attr::none(cx, "into");
         let mut remote = Attr::none(cx, "remote");
         let mut field_identifier = BoolAttr::none(cx, "field_identifier");
         let mut variant_identifier = BoolAttr::none(cx, "variant_identifier");
+        let mut serde_path = Attr::none(cx, "crate");
 
         for meta_items in item.attrs.iter().filter_map(get_serde_meta_items) {
             for meta_item in meta_items {
@@ -471,6 +559,13 @@ impl Container {
                         }
                     }
 
+                    // Parse `#[serde(try_from = "Type")]
+                    Meta(NameValue(ref m)) if m.ident == "try_from" => {
+                        if let Ok(try_from_ty) = parse_lit_into_ty(cx, &m.ident, &m.lit) {
+                            type_try_from.set_opt(&m.ident, Some(try_from_ty));
+                        }
+                    }
+
                     // Parse `#[serde(into = "Type")]
                     Meta(NameValue(ref m)) if m.ident == "into" => {
                         if let Ok(into_ty) = parse_lit_into_ty(cx, &m.ident, &m.lit) {
@@ -499,6 +594,13 @@ impl Container {
                         variant_identifier.set_true(word);
                     }
 
+                    // Parse `#[serde(crate = "foo")]`
+                    Meta(NameValue(ref m)) if m.ident == "crate" => {
+                        if let Ok(path) = parse_lit_into_path(cx, &m.ident, &m.lit) {
+                            serde_path.set(&m.ident, path)
+                        }
+                    }
+
                     Meta(ref meta_item) => {
                         cx.error_spanned_by(
                             meta_item.name(),
@@ -514,10 +616,7 @@ impl Container {
         }
 
         Container {
-            name: Name {
-                serialize: ser_name.get().unwrap_or_else(|| unraw(&item.ident)),
-                deserialize: de_name.get().unwrap_or_else(|| unraw(&item.ident)),
-            },
+            name: Name::from_attrs(unraw(&item.ident), ser_name, de_name, None),
             transparent: transparent.get(),
             deny_unknown_fields: deny_unknown_fields.get(),
             default: default.get().unwrap_or(Default::None),
@@ -529,10 +628,12 @@ impl Container {
             de_bound: de_bound.get(),
             tag: decide_tag(cx, item, untagged, internal_tag, content),
             type_from: type_from.get(),
+            type_try_from: type_try_from.get(),
             type_into: type_into.get(),
             remote: remote.get(),
             identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
             has_flatten: false,
+            serde_path: serde_path.get(),
         }
     }
 
@@ -572,6 +673,10 @@ impl Container {
         self.type_from.as_ref()
     }
 
+    pub fn type_try_from(&self) -> Option<&syn::Type> {
+        self.type_try_from.as_ref()
+    }
+
     pub fn type_into(&self) -> Option<&syn::Type> {
         self.type_into.as_ref()
     }
@@ -591,6 +696,15 @@ impl Container {
     pub fn mark_has_flatten(&mut self) {
         self.has_flatten = true;
     }
+
+    pub fn custom_serde_path(&self) -> Option<&syn::Path> {
+        self.serde_path.as_ref()
+    }
+
+    pub fn serde_path(&self) -> Cow<syn::Path> {
+        self.custom_serde_path()
+            .map_or_else(|| Cow::Owned(parse_quote!(_serde)), Cow::Borrowed)
+    }
 }
 
 fn decide_tag(
@@ -762,8 +876,6 @@ fn decide_identifier(
 /// Represents variant attribute information
 pub struct Variant {
     name: Name,
-    ser_renamed: bool,
-    de_renamed: bool,
     rename_all_rules: RenameAllRules,
     ser_bound: Option<Vec<syn::WherePredicate>>,
     de_bound: Option<Vec<syn::WherePredicate>>,
@@ -779,6 +891,7 @@ impl Variant {
     pub fn from_ast(cx: &Ctxt, variant: &syn::Variant) -> Self {
         let mut ser_name = Attr::none(cx, "rename");
         let mut de_name = Attr::none(cx, "rename");
+        let mut de_aliases = VecAttr::none(cx, "rename");
         let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
         let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");
         let mut rename_all_ser_rule = Attr::none(cx, "rename_all");
@@ -797,15 +910,26 @@ impl Variant {
                     Meta(NameValue(ref m)) if m.ident == "rename" => {
                         if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
                             ser_name.set(&m.ident, s.value());
-                            de_name.set(&m.ident, s.value());
+                            de_name.set_if_none(s.value());
+                            de_aliases.insert(&m.ident, s.value());
                         }
                     }
 
                     // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
                     Meta(List(ref m)) if m.ident == "rename" => {
-                        if let Ok((ser, de)) = get_renames(cx, &m.nested) {
+                        if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
                             ser_name.set_opt(&m.ident, ser.map(syn::LitStr::value));
-                            de_name.set_opt(&m.ident, de.map(syn::LitStr::value));
+                            for de_value in de {
+                                de_name.set_if_none(de_value.value());
+                                de_aliases.insert(&m.ident, de_value.value());
+                            }
+                        }
+                    }
+
+                    // Parse `#[serde(alias = "foo")]`
+                    Meta(NameValue(ref m)) if m.ident == "alias" => {
+                        if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
+                            de_aliases.insert(&m.ident, s.value());
                         }
                     }
 
@@ -963,17 +1087,8 @@ impl Variant {
             }
         }
 
-        let ser_name = ser_name.get();
-        let ser_renamed = ser_name.is_some();
-        let de_name = de_name.get();
-        let de_renamed = de_name.is_some();
         Variant {
-            name: Name {
-                serialize: ser_name.unwrap_or_else(|| unraw(&variant.ident)),
-                deserialize: de_name.unwrap_or_else(|| unraw(&variant.ident)),
-            },
-            ser_renamed: ser_renamed,
-            de_renamed: de_renamed,
+            name: Name::from_attrs(unraw(&variant.ident), ser_name, de_name, Some(de_aliases)),
             rename_all_rules: RenameAllRules {
                 serialize: rename_all_ser_rule.get().unwrap_or(RenameRule::None),
                 deserialize: rename_all_de_rule.get().unwrap_or(RenameRule::None),
@@ -993,11 +1108,15 @@ impl Variant {
         &self.name
     }
 
+    pub fn aliases(&self) -> Vec<String> {
+        self.name.deserialize_aliases()
+    }
+
     pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
-        if !self.ser_renamed {
+        if !self.name.serialize_renamed {
             self.name.serialize = rules.serialize.apply_to_variant(&self.name.serialize);
         }
-        if !self.de_renamed {
+        if !self.name.deserialize_renamed {
             self.name.deserialize = rules.deserialize.apply_to_variant(&self.name.deserialize);
         }
     }
@@ -1038,8 +1157,6 @@ impl Variant {
 /// Represents field attribute information
 pub struct Field {
     name: Name,
-    ser_renamed: bool,
-    de_renamed: bool,
     skip_serializing: bool,
     skip_deserializing: bool,
     skip_serializing_if: Option<syn::ExprPath>,
@@ -1084,6 +1201,7 @@ impl Field {
     ) -> Self {
         let mut ser_name = Attr::none(cx, "rename");
         let mut de_name = Attr::none(cx, "rename");
+        let mut de_aliases = VecAttr::none(cx, "rename");
         let mut skip_serializing = BoolAttr::none(cx, "skip_serializing");
         let mut skip_deserializing = BoolAttr::none(cx, "skip_deserializing");
         let mut skip_serializing_if = Attr::none(cx, "skip_serializing_if");
@@ -1117,15 +1235,26 @@ impl Field {
                     Meta(NameValue(ref m)) if m.ident == "rename" => {
                         if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
                             ser_name.set(&m.ident, s.value());
-                            de_name.set(&m.ident, s.value());
+                            de_name.set_if_none(s.value());
+                            de_aliases.insert(&m.ident, s.value());
                         }
                     }
 
                     // Parse `#[serde(rename(serialize = "foo", deserialize = "bar"))]`
                     Meta(List(ref m)) if m.ident == "rename" => {
-                        if let Ok((ser, de)) = get_renames(cx, &m.nested) {
+                        if let Ok((ser, de)) = get_multiple_renames(cx, &m.nested) {
                             ser_name.set_opt(&m.ident, ser.map(syn::LitStr::value));
-                            de_name.set_opt(&m.ident, de.map(syn::LitStr::value));
+                            for de_value in de {
+                                de_name.set_if_none(de_value.value());
+                                de_aliases.insert(&m.ident, de_value.value());
+                            }
+                        }
+                    }
+
+                    // Parse `#[serde(alias = "foo")]`
+                    Meta(NameValue(ref m)) if m.ident == "alias" => {
+                        if let Ok(s) = get_lit_str(cx, &m.ident, &m.ident, &m.lit) {
+                            de_aliases.insert(&m.ident, s.value());
                         }
                     }
 
@@ -1332,17 +1461,8 @@ impl Field {
             collect_lifetimes(&field.ty, &mut borrowed_lifetimes);
         }
 
-        let ser_name = ser_name.get();
-        let ser_renamed = ser_name.is_some();
-        let de_name = de_name.get();
-        let de_renamed = de_name.is_some();
         Field {
-            name: Name {
-                serialize: ser_name.unwrap_or_else(|| ident.clone()),
-                deserialize: de_name.unwrap_or(ident),
-            },
-            ser_renamed: ser_renamed,
-            de_renamed: de_renamed,
+            name: Name::from_attrs(ident, ser_name, de_name, Some(de_aliases)),
             skip_serializing: skip_serializing.get(),
             skip_deserializing: skip_deserializing.get(),
             skip_serializing_if: skip_serializing_if.get(),
@@ -1362,11 +1482,15 @@ impl Field {
         &self.name
     }
 
+    pub fn aliases(&self) -> Vec<String> {
+        self.name.deserialize_aliases()
+    }
+
     pub fn rename_by_rules(&mut self, rules: &RenameAllRules) {
-        if !self.ser_renamed {
+        if !self.name.serialize_renamed {
             self.name.serialize = rules.serialize.apply_to_field(&self.name.serialize);
         }
-        if !self.de_renamed {
+        if !self.name.deserialize_renamed {
             self.name.deserialize = rules.deserialize.apply_to_field(&self.name.deserialize);
         }
     }
@@ -1426,31 +1550,31 @@ impl Field {
 
 type SerAndDe<T> = (Option<T>, Option<T>);
 
-fn get_ser_and_de<'a, T, F>(
-    cx: &Ctxt,
+fn get_ser_and_de<'a, 'b, T, F>(
+    cx: &'b Ctxt,
     attr_name: &'static str,
     metas: &'a Punctuated<syn::NestedMeta, Token![,]>,
     f: F,
-) -> Result<SerAndDe<T>, ()>
+) -> Result<(VecAttr<'b, T>, VecAttr<'b, T>), ()>
 where
     T: 'a,
     F: Fn(&Ctxt, &Ident, &Ident, &'a syn::Lit) -> Result<T, ()>,
 {
-    let mut ser_meta = Attr::none(cx, attr_name);
-    let mut de_meta = Attr::none(cx, attr_name);
+    let mut ser_meta = VecAttr::none(cx, attr_name);
+    let mut de_meta = VecAttr::none(cx, attr_name);
     let attr_name = Ident::new(attr_name, Span::call_site());
 
     for meta in metas {
         match *meta {
             Meta(NameValue(ref meta)) if meta.ident == "serialize" => {
                 if let Ok(v) = f(cx, &attr_name, &meta.ident, &meta.lit) {
-                    ser_meta.set(&meta.ident, v);
+                    ser_meta.insert(&meta.ident, v);
                 }
             }
 
             Meta(NameValue(ref meta)) if meta.ident == "deserialize" => {
                 if let Ok(v) = f(cx, &attr_name, &meta.ident, &meta.lit) {
-                    de_meta.set(&meta.ident, v);
+                    de_meta.insert(&meta.ident, v);
                 }
             }
 
@@ -1468,21 +1592,31 @@ where
         }
     }
 
-    Ok((ser_meta.get(), de_meta.get()))
+    Ok((ser_meta, de_meta))
 }
 
 fn get_renames<'a>(
     cx: &Ctxt,
     items: &'a Punctuated<syn::NestedMeta, Token![,]>,
 ) -> Result<SerAndDe<&'a syn::LitStr>, ()> {
-    get_ser_and_de(cx, "rename", items, get_lit_str)
+    let (ser, de) = try!(get_ser_and_de(cx, "rename", items, get_lit_str));
+    Ok((try!(ser.at_most_one()), try!(de.at_most_one())))
+}
+
+fn get_multiple_renames<'a>(
+    cx: &Ctxt,
+    items: &'a Punctuated<syn::NestedMeta, Token![,]>,
+) -> Result<(Option<&'a syn::LitStr>, Vec<&'a syn::LitStr>), ()> {
+    let (ser, de) = try!(get_ser_and_de(cx, "rename", items, get_lit_str));
+    Ok((try!(ser.at_most_one()), de.get()))
 }
 
 fn get_where_predicates(
     cx: &Ctxt,
     items: &Punctuated<syn::NestedMeta, Token![,]>,
 ) -> Result<SerAndDe<Vec<syn::WherePredicate>>, ()> {
-    get_ser_and_de(cx, "bound", items, parse_lit_into_where)
+    let (ser, de) = try!(get_ser_and_de(cx, "bound", items, parse_lit_into_where));
+    Ok((try!(ser.at_most_one()), try!(de.at_most_one())))
 }
 
 pub fn get_serde_meta_items(attr: &syn::Attribute) -> Option<Vec<syn::NestedMeta>> {

serde_derive/src/internals/check.rs

@@ -13,6 +13,7 @@ pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     check_internal_tag_field_name_conflict(cx, cont);
     check_adjacent_tag_conflict(cx, cont);
     check_transparent(cx, cont, derive);
+    check_from_and_try_from(cx, cont);
 }
 
 /// Getters are only allowed inside structs (not enums) with the `remote`
@@ -76,25 +77,6 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
         }
         _ => {}
     }
-    if field.attrs.skip_serializing() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_serializing)]",
-        );
-    } else if field.attrs.skip_serializing_if().is_some() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_serializing_if = \"...\")]",
-        );
-    } else if field.attrs.skip_deserializing() {
-        cx.error_spanned_by(
-            field.original,
-            "#[serde(flatten)] can not be combined with \
-             #[serde(skip_deserializing)]",
-        );
-    }
 }
 
 /// The `other` attribute must be used at most once and it must be the last
@@ -295,12 +277,18 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
                     let check_de = !field.attrs.skip_deserializing();
                     let name = field.attrs.name();
                     let ser_name = name.serialize_name();
-                    let de_name = name.deserialize_name();
 
-                    if check_ser && ser_name == tag || check_de && de_name == tag {
+                    if check_ser && ser_name == tag {
                         diagnose_conflict();
                         return;
                     }
+
+                    for de_name in field.attrs.aliases() {
+                        if check_de && de_name == tag {
+                            diagnose_conflict();
+                            return;
+                        }
+                    }
                 }
             }
             Style::Unit | Style::Newtype | Style::Tuple => {}
@@ -343,6 +331,13 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
         );
     }
 
+    if cont.attrs.type_try_from().is_some() {
+        cx.error_spanned_by(
+            cont.original,
+            "#[serde(transparent)] is not allowed with #[serde(try_from = \"...\")]",
+        );
+    }
+
     if cont.attrs.type_into().is_some() {
         cx.error_spanned_by(
             cont.original,
@@ -423,3 +418,12 @@ fn allow_transparent(field: &Field, derive: Derive) -> bool {
         Derive::Deserialize => !field.attrs.skip_deserializing() && field.attrs.default().is_none(),
     }
 }
+
+fn check_from_and_try_from(cx: &Ctxt, cont: &mut Container) {
+    if cont.attrs.type_from().is_some() && cont.attrs.type_try_from().is_some() {
+        cx.error_spanned_by(
+            cont.original,
+            "#[serde(from = \"...\")] and #[serde(try_from = \"...\")] conflict with each other",
+        );
+    }
+}

serde_derive/src/lib.rs

@@ -13,14 +13,15 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.84")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.98")]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        cyclomatic_complexity,
+        cognitive_complexity,
         enum_variant_names,
         needless_pass_by_value,
         redundant_field_names,
@@ -34,6 +35,7 @@
     feature = "cargo-clippy",
     allow(
         cast_possible_truncation,
+        checked_conversions,
         doc_markdown,
         enum_glob_use,
         filter_map,

serde_derive/src/ser.rs

@@ -22,15 +22,16 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
     let params = Parameters::new(&cont);
     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
     let body = Stmts(serialize_body(&cont, &params));
+    let serde = cont.attrs.serde_path();
 
     let impl_block = if let Some(remote) = cont.attrs.remote() {
         let vis = &input.vis;
         let used = pretend::pretend_used(&cont);
         quote! {
             impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
                 where
-                    __S: _serde::Serializer,
+                    __S: #serde::Serializer,
                 {
                     #used
                     #body
@@ -40,10 +41,10 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
     } else {
         quote! {
             #[automatically_derived]
-            impl #impl_generics _serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
                 where
-                    __S: _serde::Serializer,
+                    __S: #serde::Serializer,
                 {
                     #body
                 }
@@ -51,7 +52,12 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         }
     };
 
-    Ok(dummy::wrap_in_const("SERIALIZE", ident, impl_block))
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "SERIALIZE",
+        ident,
+        impl_block,
+    ))
 }
 
 fn precondition(cx: &Ctxt, cont: &Container) {
@@ -289,37 +295,38 @@ fn serialize_struct(params: &Parameters, fields: &[Field], cattrs: &attr::Contai
     }
 }
 
+fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTrait) -> TokenStream {
+    match *cattrs.tag() {
+        attr::TagType::Internal { ref tag } => {
+            let type_name = cattrs.name().serialize_name();
+            let func = struct_trait.serialize_field(Span::call_site());
+            quote! {
+                try!(#func(&mut __serde_state, #tag, #type_name));
+            }
+        }
+        _ => quote! {},
+    }
+}
+
 fn serialize_struct_as_struct(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
 ) -> Fragment {
-    let mut serialize_fields =
+    let serialize_fields =
         serialize_struct_visitor(fields, params, false, &StructTrait::SerializeStruct);
 
     let type_name = cattrs.name().serialize_name();
 
-    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,
-                quote! {
-                    try!(#func(&mut __serde_state, #tag, #type_name));
-                },
-            );
-
-            1
-        }
-        _ => 0,
-    };
+    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeStruct);
+    let tag_field_exists = !tag_field.is_empty();
 
     let mut serialized_fields = fields
         .iter()
         .filter(|&field| !field.attrs.skip_serializing())
         .peekable();
 
-    let let_mut = mut_if(serialized_fields.peek().is_some() || additional_field_count > 0);
+    let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
 
     let len = serialized_fields
         .map(|field| match field.attrs.skip_serializing_if() {
@@ -330,12 +337,13 @@ fn serialize_struct_as_struct(
             }
         })
         .fold(
-            quote!(#additional_field_count),
+            quote!(#tag_field_exists as usize),
             |sum, expr| quote!(#sum + #expr),
         );
 
     quote_block! {
         let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len));
+        #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeStruct::end(__serde_state)
     }
@@ -349,12 +357,15 @@ fn serialize_struct_as_map(
     let serialize_fields =
         serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);
 
+    let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeMap);
+    let tag_field_exists = !tag_field.is_empty();
+
     let mut serialized_fields = fields
         .iter()
         .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() || tag_field_exists);
 
     let len = if cattrs.has_flatten() {
         quote!(_serde::export::None)
@@ -367,12 +378,16 @@ fn serialize_struct_as_map(
                     quote!(if #path(#field_expr) { 0 } else { 1 })
                 }
             })
-            .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
+            .fold(
+                quote!(#tag_field_exists as usize),
+                |sum, expr| quote!(#sum + #expr),
+            );
         quote!(_serde::export::Some(#len))
     };
 
     quote_block! {
         let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
+        #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeMap::end(__serde_state)
     }

serde_derive_internals/Cargo.toml

@@ -2,7 +2,7 @@
 name = "serde_derive_internals"
 version = "0.24.1" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_derive_internals/lib.rs

@@ -1,9 +1,10 @@
 #![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.24.1")]
+#![allow(unknown_lints, bare_trait_objects)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        cyclomatic_complexity,
+        cognitive_complexity,
         redundant_field_names,
         trivially_copy_pass_by_ref
     )

serde_test/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_test"
-version = "1.0.84" # remember to update html_root_url
+version = "1.0.98" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-license = "MIT/Apache-2.0"
+license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
 homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.84")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.98")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints

test_suite/Cargo.toml

@@ -7,14 +7,15 @@ publish = false
 
 [features]
 unstable = ["serde/unstable"]
-compiletest = ["compiletest_rs"]
+
+[dependencies]
+serde = { path = "../serde" }
 
 [dev-dependencies]
 fnv = "1.0"
 rustc-serialize = "0.3.16"
+rustversion = "0.1"
 serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
-
-[dependencies]
-compiletest_rs = { version = "0.3", optional = true, features = ["stable"] }
+trybuild = "1.0"

test_suite/deps/Cargo.toml

@@ -1,11 +0,0 @@
-[package]
-name = "serde_test_suite_deps"
-version = "0.0.0"
-authors = ["David Tolnay <dtolnay@gmail.com>"]
-publish = false
-
-[workspace]
-
-[dependencies]
-serde = { path = "../../serde" }
-serde_derive = { path = "../../serde_derive" }

test_suite/deps/src/lib.rs

@@ -1,3 +0,0 @@
-#![feature(/*=============================================]
-#![===  Serde test suite requires a nightly compiler.  ===]
-#![====================================================*/)]

test_suite/tests/compiletest.rs

@@ -1,22 +1,7 @@
-#![cfg(feature = "compiletest")]
-
-use compiletest_rs as compiletest;
-
+#[cfg(not(target_os = "emscripten"))]
+#[rustversion::attr(not(nightly), ignore)]
 #[test]
 fn ui() {
-    let config = compiletest::Config {
-        mode: compiletest::common::Mode::Ui,
-        src_base: std::path::PathBuf::from("tests/ui"),
-        target_rustcflags: Some(String::from(
-            "\
-             --edition=2018 \
-             -L deps/target/debug/deps \
-             -Z unstable-options \
-             --extern serde_derive \
-             ",
-        )),
-        ..Default::default()
-    };
-
-    compiletest::run_tests(&config);
+    let t = trybuild::TestCases::new();
+    t.compile_fail("tests/ui/**/*.rs");
 }

test_suite/tests/test_annotations.rs

@@ -4,6 +4,7 @@ use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
 
 use std::collections::{BTreeMap, HashMap};
+use std::convert::TryFrom;
 use std::fmt;
 use std::marker::PhantomData;
 
@@ -516,6 +517,16 @@ struct RenameStructSerializeDeserialize {
     a2: i32,
 }
 
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(deny_unknown_fields)]
+struct AliasStruct {
+    a1: i32,
+    #[serde(alias = "a3")]
+    a2: i32,
+    #[serde(alias = "a5", rename = "a6")]
+    a4: i32,
+}
+
 #[test]
 fn test_rename_struct() {
     assert_tokens(
@@ -562,6 +573,67 @@ fn test_rename_struct() {
             Token::StructEnd,
         ],
     );
+
+    assert_de_tokens(
+        &AliasStruct {
+            a1: 1,
+            a2: 2,
+            a4: 3,
+        },
+        &[
+            Token::Struct {
+                name: "AliasStruct",
+                len: 3,
+            },
+            Token::Str("a1"),
+            Token::I32(1),
+            Token::Str("a2"),
+            Token::I32(2),
+            Token::Str("a5"),
+            Token::I32(3),
+            Token::StructEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &AliasStruct {
+            a1: 1,
+            a2: 2,
+            a4: 3,
+        },
+        &[
+            Token::Struct {
+                name: "AliasStruct",
+                len: 3,
+            },
+            Token::Str("a1"),
+            Token::I32(1),
+            Token::Str("a3"),
+            Token::I32(2),
+            Token::Str("a6"),
+            Token::I32(3),
+            Token::StructEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_unknown_field_rename_struct() {
+    assert_de_tokens_error::<AliasStruct>(
+        &[
+            Token::Struct {
+                name: "AliasStruct",
+                len: 3,
+            },
+            Token::Str("a1"),
+            Token::I32(1),
+            Token::Str("a3"),
+            Token::I32(2),
+            Token::Str("a4"),
+            Token::I32(3),
+        ],
+        "unknown field `a4`, expected one of `a1`, `a2`, `a6`",
+    );
 }
 
 #[derive(Debug, PartialEq, Serialize, Deserialize)]
@@ -592,6 +664,19 @@ enum RenameEnumSerializeDeserialize<A> {
     },
 }
 
+#[derive(Debug, PartialEq, Deserialize)]
+#[serde(deny_unknown_fields)]
+enum AliasEnum {
+    #[serde(rename = "sailor_moon", alias = "usagi_tsukino")]
+    SailorMoon {
+        a: i8,
+        #[serde(alias = "c")]
+        b: i8,
+        #[serde(alias = "e", rename = "f")]
+        d: i8,
+    },
+}
+
 #[test]
 fn test_rename_enum() {
     assert_tokens(
@@ -678,6 +763,71 @@ fn test_rename_enum() {
             Token::StructVariantEnd,
         ],
     );
+
+    assert_de_tokens(
+        &AliasEnum::SailorMoon { a: 0, b: 1, d: 2 },
+        &[
+            Token::StructVariant {
+                name: "AliasEnum",
+                variant: "sailor_moon",
+                len: 3,
+            },
+            Token::Str("a"),
+            Token::I8(0),
+            Token::Str("b"),
+            Token::I8(1),
+            Token::Str("e"),
+            Token::I8(2),
+            Token::StructVariantEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &AliasEnum::SailorMoon { a: 0, b: 1, d: 2 },
+        &[
+            Token::StructVariant {
+                name: "AliasEnum",
+                variant: "usagi_tsukino",
+                len: 3,
+            },
+            Token::Str("a"),
+            Token::I8(0),
+            Token::Str("c"),
+            Token::I8(1),
+            Token::Str("f"),
+            Token::I8(2),
+            Token::StructVariantEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_unknown_field_rename_enum() {
+    assert_de_tokens_error::<AliasEnum>(
+        &[Token::StructVariant {
+            name: "AliasEnum",
+            variant: "SailorMoon",
+            len: 3,
+        }],
+        "unknown variant `SailorMoon`, expected `sailor_moon`",
+    );
+
+    assert_de_tokens_error::<AliasEnum>(
+        &[
+            Token::StructVariant {
+                name: "AliasEnum",
+                variant: "usagi_tsukino",
+                len: 3,
+            },
+            Token::Str("a"),
+            Token::I8(0),
+            Token::Str("c"),
+            Token::I8(1),
+            Token::Str("d"),
+            Token::I8(2),
+        ],
+        "unknown field `d`, expected one of `a`, `b`, `f`",
+    );
 }
 
 #[derive(Debug, PartialEq, Serialize)]
@@ -1439,14 +1589,35 @@ impl From<Option<u32>> for EnumToU32 {
     }
 }
 
+#[derive(Clone, Deserialize, PartialEq, Debug)]
+#[serde(try_from = "u32")]
+enum TryFromU32 {
+    One,
+    Two,
+}
+
+impl TryFrom<u32> for TryFromU32 {
+    type Error = String;
+
+    fn try_from(value: u32) -> Result<Self, Self::Error> {
+        match value {
+            1 => Ok(TryFromU32::One),
+            2 => Ok(TryFromU32::Two),
+            _ => Err("out of range".to_owned()),
+        }
+    }
+}
+
 #[test]
 fn test_from_into_traits() {
-    assert_ser_tokens::<EnumToU32>(&EnumToU32::One, &[Token::Some, Token::U32(1)]);
-    assert_ser_tokens::<EnumToU32>(&EnumToU32::Nothing, &[Token::None]);
-    assert_de_tokens::<EnumToU32>(&EnumToU32::Two, &[Token::Some, Token::U32(2)]);
-    assert_ser_tokens::<StructFromEnum>(&StructFromEnum(Some(5)), &[Token::None]);
-    assert_ser_tokens::<StructFromEnum>(&StructFromEnum(None), &[Token::None]);
-    assert_de_tokens::<StructFromEnum>(&StructFromEnum(Some(2)), &[Token::Some, Token::U32(2)]);
+    assert_ser_tokens(&EnumToU32::One, &[Token::Some, Token::U32(1)]);
+    assert_ser_tokens(&EnumToU32::Nothing, &[Token::None]);
+    assert_de_tokens(&EnumToU32::Two, &[Token::Some, Token::U32(2)]);
+    assert_ser_tokens(&StructFromEnum(Some(5)), &[Token::None]);
+    assert_ser_tokens(&StructFromEnum(None), &[Token::None]);
+    assert_de_tokens(&StructFromEnum(Some(2)), &[Token::Some, Token::U32(2)]);
+    assert_de_tokens(&TryFromU32::Two, &[Token::U32(2)]);
+    assert_de_tokens_error::<TryFromU32>(&[Token::U32(5)], "out of range");
 }
 
 #[test]

test_suite/tests/test_de.rs

@@ -1,17 +1,27 @@
-#![allow(clippy::decimal_literal_representation)]
+#![allow(clippy::decimal_literal_representation, clippy::unreadable_literal)]
 #![cfg_attr(feature = "unstable", feature(never_type))]
 
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::default::Default;
 use std::ffi::{CStr, CString, OsString};
+use std::fmt::Debug;
 use std::net;
 use std::num::Wrapping;
+use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
+use std::sync::atomic::{
+    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+    AtomicUsize, Ordering,
+};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};
 
+#[cfg(target_arch = "x86_64")]
+use std::sync::atomic::{AtomicI64, AtomicU64};
+
 use fnv::FnvHasher;
+use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer};
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Configure, Token};
 
@@ -123,6 +133,19 @@ enum EnumOther {
     Other,
 }
 
+#[derive(PartialEq, Debug)]
+struct IgnoredAny;
+
+impl<'de> Deserialize<'de> for IgnoredAny {
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        serde::de::IgnoredAny::deserialize(deserializer)?;
+        Ok(IgnoredAny)
+    }
+}
+
 //////////////////////////////////////////////////////////////////////////
 
 macro_rules! declare_tests {
@@ -836,6 +859,23 @@ declare_tests! {
             Token::SeqEnd,
         ],
     }
+    test_bound {
+        Bound::Unbounded::<()> => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Unbounded"),
+            Token::Unit,
+        ],
+        Bound::Included(0) => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Included"),
+            Token::U8(0),
+        ],
+        Bound::Excluded(0) => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Excluded"),
+            Token::U8(0),
+        ],
+    }
     test_path {
         Path::new("/usr/local/lib") => &[
             Token::BorrowedStr("/usr/local/lib"),
@@ -911,6 +951,21 @@ declare_tests! {
             Token::SeqEnd,
         ],
     }
+    test_ignored_any {
+        IgnoredAny => &[
+            Token::Str("s"),
+        ],
+        IgnoredAny => &[
+            Token::Seq { len: Some(1) },
+            Token::Bool(true),
+            Token::SeqEnd,
+        ],
+        IgnoredAny => &[
+            Token::Enum { name: "E" },
+            Token::Str("Rust"),
+            Token::Unit,
+        ],
+    }
 }
 
 declare_tests! {
@@ -1094,6 +1149,45 @@ fn test_never_type() {
     );
 }
 
+#[test]
+fn test_atomics() {
+    fn test<L, A, T>(load: L, val: T, token: Token)
+    where
+        L: Fn(&A, Ordering) -> T,
+        A: DeserializeOwned,
+        T: PartialEq + Debug,
+    {
+        let tokens = &[token];
+        let mut de = serde_test::Deserializer::new(tokens);
+        match A::deserialize(&mut de) {
+            Ok(v) => {
+                let loaded = load(&v, Ordering::SeqCst);
+                assert_eq!(val, loaded);
+            }
+            Err(e) => panic!("tokens failed to deserialize: {}", e),
+        };
+        if de.remaining() > 0 {
+            panic!("{} remaining tokens", de.remaining());
+        }
+    }
+
+    test(AtomicBool::load, true, Token::Bool(true));
+    test(AtomicI8::load, -127, Token::I8(-127i8));
+    test(AtomicI16::load, -510, Token::I16(-510i16));
+    test(AtomicI32::load, -131072, Token::I32(-131072i32));
+    test(AtomicIsize::load, -131072isize, Token::I32(-131072));
+    test(AtomicU8::load, 127, Token::U8(127u8));
+    test(AtomicU16::load, 510u16, Token::U16(510u16));
+    test(AtomicU32::load, 131072u32, Token::U32(131072u32));
+    test(AtomicUsize::load, 131072usize, Token::U32(131072));
+
+    #[cfg(target_arch = "x86_64")]
+    {
+        test(AtomicI64::load, -8589934592, Token::I64(-8589934592));
+        test(AtomicU64::load, 8589934592u64, Token::U64(8589934592));
+    }
+}
+
 declare_error_tests! {
     test_unknown_field<StructDenyUnknown> {
         &[

test_suite/tests/test_gen.rs

@@ -265,7 +265,7 @@ fn test_gen() {
     #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     struct NonAsciiIdents {
-        σ: f64,
+        σ:  f64,
     }
 
     #[derive(Serialize, Deserialize)]
@@ -522,6 +522,13 @@ fn test_gen() {
     }
     assert::<FlattenWith>();
 
+    #[derive(Serialize, Deserialize)]
+    #[serde(deny_unknown_fields)]
+    struct FlattenDenyUnknown<T> {
+        #[serde(flatten)]
+        t: T,
+    }
+
     #[derive(Serialize, Deserialize)]
     struct StaticStrStruct<'a> {
         a: &'a str,
@@ -665,6 +672,25 @@ fn test_gen() {
         ty: &'a str,
         id: String,
     }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipSerializing<T> {
+        #[serde(flatten, skip_serializing)]
+        #[allow(dead_code)]
+        flat: T,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipSerializingIf<T> {
+        #[serde(flatten, skip_serializing_if = "StdOption::is_none")]
+        flat: StdOption<T>,
+    }
+
+    #[derive(Serialize, Deserialize)]
+    struct FlattenSkipDeserializing<T> {
+        #[serde(flatten, skip_deserializing)]
+        flat: T,
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////

test_suite/tests/test_ignored_any.rs

@@ -0,0 +1,104 @@
+use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
+use serde::de::{
+    DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
+};
+use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
+
+#[derive(PartialEq, Debug, Deserialize)]
+enum Target {
+    Unit,
+    Newtype(i32),
+    Tuple(i32, i32),
+    Struct { a: i32 },
+}
+
+struct Enum(&'static str);
+
+impl<'de> Deserializer<'de> for Enum {
+    type Error = Error;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_enum(self)
+    }
+
+    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
+    }
+}
+
+impl<'de> EnumAccess<'de> for Enum {
+    type Error = Error;
+    type Variant = Self;
+
+    fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+    where
+        V: DeserializeSeed<'de>,
+    {
+        let v = seed.deserialize(self.0.into_deserializer())?;
+        Ok((v, self))
+    }
+}
+
+impl<'de> VariantAccess<'de> for Enum {
+    type Error = Error;
+
+    fn unit_variant(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+
+    fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, Self::Error>
+    where
+        T: DeserializeSeed<'de>,
+    {
+        seed.deserialize(10i32.into_deserializer())
+    }
+
+    fn tuple_variant<V>(self, _len: usize, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let seq = SeqDeserializer::new(vec![1i32, 2].into_iter());
+        visitor.visit_seq(seq)
+    }
+
+    fn struct_variant<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let map = MapDeserializer::new(vec![("a", 10i32)].into_iter());
+        visitor.visit_map(map)
+    }
+}
+
+#[test]
+fn test_deserialize_enum() {
+    // First just make sure the Deserializer impl works
+    assert_eq!(Target::Unit, Target::deserialize(Enum("Unit")).unwrap());
+    assert_eq!(
+        Target::Newtype(10),
+        Target::deserialize(Enum("Newtype")).unwrap()
+    );
+    assert_eq!(
+        Target::Tuple(1, 2),
+        Target::deserialize(Enum("Tuple")).unwrap()
+    );
+    assert_eq!(
+        Target::Struct { a: 10 },
+        Target::deserialize(Enum("Struct")).unwrap()
+    );
+
+    // Now try IgnoredAny
+    IgnoredAny::deserialize(Enum("Unit")).unwrap();
+    IgnoredAny::deserialize(Enum("Newtype")).unwrap();
+    IgnoredAny::deserialize(Enum("Tuple")).unwrap();
+    IgnoredAny::deserialize(Enum("Struct")).unwrap();
+}

test_suite/tests/test_macros.rs

@@ -1424,6 +1424,76 @@ fn test_internally_tagged_braced_struct_with_zero_fields() {
     );
 }
 
+#[test]
+fn test_internally_tagged_struct_with_flattened_field() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag_struct")]
+    pub struct Struct {
+        #[serde(flatten)]
+        pub flat: Enum,
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "tag_enum", content = "content")]
+    pub enum Enum {
+        A(u64),
+    }
+
+    assert_tokens(
+        &Struct { flat: Enum::A(0) },
+        &[
+            Token::Map { len: None },
+            Token::Str("tag_struct"),
+            Token::Str("Struct"),
+            Token::Str("tag_enum"),
+            Token::Str("A"),
+            Token::Str("content"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+
+    assert_de_tokens(
+        &Struct { flat: Enum::A(0) },
+        &[
+            Token::Map { len: None },
+            Token::Str("tag_enum"),
+            Token::Str("A"),
+            Token::Str("content"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
+#[test]
+fn test_untagged_enum_with_flattened_integer_key() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(untagged)]
+    pub enum Untagged {
+        Variant {
+            #[serde(flatten)]
+            map: BTreeMap<u64, String>,
+        },
+    }
+
+    assert_tokens(
+        &Untagged::Variant {
+            map: {
+                let mut map = BTreeMap::new();
+                map.insert(100, "BTreeMap".to_owned());
+                map
+            },
+        },
+        &[
+            Token::Map { len: None },
+            Token::U64(100),
+            Token::Str("BTreeMap"),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_enum_in_untagged_enum() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]

test_suite/tests/test_ser.rs

@@ -1,3 +1,4 @@
+#![allow(clippy::unreadable_literal)]
 #![cfg_attr(feature = "unstable", feature(never_type))]
 
 use std::cell::RefCell;
@@ -6,13 +7,20 @@ use std::ffi::CString;
 use std::mem;
 use std::net;
 use std::num::Wrapping;
+use std::ops::Bound;
 use std::path::{Path, PathBuf};
 use std::rc::{Rc, Weak as RcWeak};
+use std::sync::atomic::{
+    AtomicBool, AtomicI16, AtomicI32, AtomicI8, AtomicIsize, AtomicU16, AtomicU32, AtomicU8,
+    AtomicUsize,
+};
 use std::sync::{Arc, Weak as ArcWeak};
 use std::time::{Duration, UNIX_EPOCH};
 
 #[cfg(unix)]
 use std::str;
+#[cfg(target_arch = "x86_64")]
+use std::sync::atomic::{AtomicI64, AtomicU64};
 
 use fnv::FnvHasher;
 use serde::Serialize;
@@ -375,6 +383,23 @@ declare_tests! {
             Token::StructEnd,
         ],
     }
+    test_bound {
+        Bound::Unbounded::<()> => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Unbounded"),
+            Token::Unit,
+        ],
+        Bound::Included(0u8) => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Included"),
+            Token::U8(0),
+        ],
+        Bound::Excluded(0u8) => &[
+            Token::Enum { name: "Bound" },
+            Token::Str("Excluded"),
+            Token::U8(0),
+        ],
+    }
     test_path {
         Path::new("/usr/local/lib") => &[
             Token::Str("/usr/local/lib"),
@@ -465,6 +490,26 @@ declare_tests! {
             Token::Str("1a"),
         ],
     }
+    test_atomic {
+        AtomicBool::new(false) => &[Token::Bool(false)],
+        AtomicBool::new(true) => &[Token::Bool(true)],
+        AtomicI8::new(63i8) => &[Token::I8(63i8)],
+        AtomicI16::new(-318i16) => &[Token::I16(-318i16)],
+        AtomicI32::new(65792i32) => &[Token::I32(65792i32)],
+        AtomicIsize::new(-65792isize) => &[Token::I64(-65792i64)],
+        AtomicU8::new(192u8) => &[Token::U8(192u8)],
+        AtomicU16::new(510u16) => &[Token::U16(510u16)],
+        AtomicU32::new(131072u32) => &[Token::U32(131072u32)],
+        AtomicUsize::new(655360usize) => &[Token::U64(655360u64)],
+    }
+}
+
+#[cfg(target_arch = "x86_64")]
+declare_tests! {
+    test_atomic64 {
+        AtomicI64::new(-4295032832i64) => &[Token::I64(-4295032832i64)],
+        AtomicU64::new(12884901888u64) => &[Token::U64(12884901888u64)],
+    }
 }
 
 declare_tests! {

test_suite/tests/test_serde_path.rs

@@ -0,0 +1,40 @@
+#[test]
+fn test_gen_custom_serde() {
+    #[derive(serde::Serialize, serde::Deserialize)]
+    #[serde(crate = "fake_serde")]
+    struct Foo;
+
+    // Would be overlapping if serde::Serialize were implemented
+    impl AssertNotSerdeSerialize for Foo {}
+    // Would be overlapping if serde::Deserialize were implemented
+    impl<'a> AssertNotSerdeDeserialize<'a> for Foo {}
+
+    fake_serde::assert::<Foo>();
+}
+
+mod fake_serde {
+    pub use serde::*;
+
+    pub fn assert<T>()
+    where
+        T: Serialize,
+        T: for<'a> Deserialize<'a>,
+    {
+    }
+
+    pub trait Serialize {
+        fn serialize<S: Serializer>(&self, serializer: S) -> Result<S::Ok, S::Error>;
+    }
+
+    pub trait Deserialize<'a>: Sized {
+        fn deserialize<D: Deserializer<'a>>(deserializer: D) -> Result<Self, D::Error>;
+    }
+}
+
+trait AssertNotSerdeSerialize {}
+
+impl<T: serde::Serialize> AssertNotSerdeSerialize for T {}
+
+trait AssertNotSerdeDeserialize<'a> {}
+
+impl<'a, T: serde::Deserialize<'a>> AssertNotSerdeDeserialize<'a> for T {}

test_suite/tests/test_value.rs

@@ -1,5 +1,8 @@
-use serde::de::{value, IntoDeserializer};
-use serde::Deserialize;
+use serde::de::value::{self, MapAccessDeserializer};
+use serde::de::{IntoDeserializer, MapAccess, Visitor};
+use serde::{Deserialize, Deserializer};
+use serde_test::{assert_de_tokens, Token};
+use std::fmt;
 
 #[test]
 fn test_u32_to_enum() {
@@ -32,3 +35,60 @@ fn test_integer128() {
     // i128 to i128
     assert_eq!(1i128, i128::deserialize(de_i128).unwrap());
 }
+
+#[test]
+fn test_map_access_to_enum() {
+    #[derive(PartialEq, Debug)]
+    struct Potential(PotentialKind);
+
+    #[derive(PartialEq, Debug, Deserialize)]
+    enum PotentialKind {
+        Airebo(Airebo),
+    }
+
+    #[derive(PartialEq, Debug, Deserialize)]
+    struct Airebo {
+        lj_sigma: f64,
+    }
+
+    impl<'de> Deserialize<'de> for Potential {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct PotentialVisitor;
+
+            impl<'de> Visitor<'de> for PotentialVisitor {
+                type Value = Potential;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    write!(formatter, "a map")
+                }
+
+                fn visit_map<A>(self, map: A) -> Result<Self::Value, A::Error>
+                where
+                    A: MapAccess<'de>,
+                {
+                    Deserialize::deserialize(MapAccessDeserializer::new(map)).map(Potential)
+                }
+            }
+
+            deserializer.deserialize_any(PotentialVisitor)
+        }
+    }
+
+    let expected = Potential(PotentialKind::Airebo(Airebo { lj_sigma: 14.0 }));
+
+    assert_de_tokens(
+        &expected,
+        &[
+            Token::Map { len: Some(1) },
+            Token::Str("Airebo"),
+            Token::Map { len: Some(1) },
+            Token::Str("lj_sigma"),
+            Token::F64(14.0),
+            Token::MapEnd,
+            Token::MapEnd,
+        ],
+    );
+}

test_suite/tests/ui/borrow/bad_lifetimes.stderr

@@ -3,6 +3,3 @@ error: failed to parse borrowed lifetimes: "zzz"
   |
 5 |     #[serde(borrow = "zzz")]
   |                      ^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/duplicate_lifetime.stderr

@@ -3,6 +3,3 @@ error: duplicate borrowed lifetime `'a`
   |
 5 |     #[serde(borrow = "'a + 'a")]
   |                      ^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/duplicate_variant.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `borrow`
   |
 8 |     #[serde(borrow)]
   |             ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/empty_lifetimes.stderr

@@ -3,6 +3,3 @@ error: at least one lifetime must be borrowed
   |
 5 |     #[serde(borrow = "")]
   |                      ^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/no_lifetimes.stderr

@@ -4,6 +4,3 @@ error: field `s` has no lifetimes to borrow
 5 | /     #[serde(borrow)]
 6 | |     s: String,
   | |_____________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/struct_variant.stderr

@@ -4,6 +4,3 @@ error: #[serde(borrow)] may only be used on newtype variants
 8 | /     #[serde(borrow)]
 9 | |     S { s: Str<'a> },
   | |____________________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/borrow/wrong_lifetime.stderr

@@ -4,6 +4,3 @@ error: field `s` does not have lifetime 'b
 5 | /     #[serde(borrow = "'b")]
 6 | |     s: &'a str,
   | |______________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/adjacent-tag.stderr

@@ -7,6 +7,3 @@ error: enum tags `conflict` for type and content conflict with each other
 7 | |     B,
 8 | | }
   | |_^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/flatten-newtype-struct.stderr

@@ -3,6 +3,3 @@ error: #[serde(flatten)] cannot be used on newtype structs
   |
 6 | struct Foo(#[serde(flatten)] HashMap<String, String>);
   |            ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/flatten-skip-deserializing.rs

@@ -1,14 +0,0 @@
-use serde_derive::Deserialize;
-
-#[derive(Deserialize)]
-struct Foo {
-    #[serde(flatten, skip_deserializing)]
-    other: Other,
-}
-
-#[derive(Deserialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

test_suite/tests/ui/conflict/flatten-skip-deserializing.stderr

@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_deserializing)]
- --> $DIR/flatten-skip-deserializing.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_deserializing)]
-6 | |     other: Other,
-  | |________________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/flatten-skip-serializing-if.rs

@@ -1,14 +0,0 @@
-use serde_derive::Serialize;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing_if = "Option::is_none")]
-    other: Option<Other>,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

test_suite/tests/ui/conflict/flatten-skip-serializing-if.stderr

@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_serializing_if = "...")]
- --> $DIR/flatten-skip-serializing-if.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_serializing_if = "Option::is_none")]
-6 | |     other: Option<Other>,
-  | |________________________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/flatten-skip-serializing.rs

@@ -1,14 +0,0 @@
-use serde_derive::Serialize;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing)]
-    other: Other,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

test_suite/tests/ui/conflict/flatten-skip-serializing.stderr

@@ -1,9 +0,0 @@
-error: #[serde(flatten)] can not be combined with #[serde(skip_serializing)]
- --> $DIR/flatten-skip-serializing.rs:5:5
-  |
-5 | /     #[serde(flatten, skip_serializing)]
-6 | |     other: Other,
-  | |________________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/flatten-tuple-struct.stderr

@@ -3,6 +3,3 @@ error: #[serde(flatten)] cannot be used on tuple structs
   |
 6 | struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
   |                 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/conflict/from-try-from.rs

@@ -1,10 +1,9 @@
 use serde_derive::Serialize;
 
 #[derive(Serialize)]
+#[serde(from = "u64", try_from = "u64")]
 struct S {
-    #[serde(rename = "x")]
-    #[serde(rename(deserialize = "y"))]
-    x: (),
+    a: u8,
 }
 
 fn main() {}

test_suite/tests/ui/conflict/from-try-from.stderr

@@ -0,0 +1,8 @@
+error: #[serde(from = "...")] and #[serde(try_from = "...")] conflict with each other
+ --> $DIR/from-try-from.rs:4:1
+  |
+4 | / #[serde(from = "u64", try_from = "u64")]
+5 | | struct S {
+6 | |     a: u8,
+7 | | }
+  | |_^

test_suite/tests/ui/conflict/internal-tag-alias.rs

@@ -0,0 +1,12 @@
+use serde_derive::Serialize;
+
+#[derive(Serialize)]
+#[serde(tag = "conflict")]
+enum E {
+    A {
+        #[serde(alias = "conflict")]
+        x: (),
+    },
+}
+
+fn main() {}

test_suite/tests/ui/conflict/internal-tag-alias.stderr

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

test_suite/tests/ui/conflict/internal-tag.stderr

@@ -9,6 +9,3 @@ error: variant field name `conflict` conflicts with internal tag
 9  | |     },
 10 | | }
    | |_^
-
-error: aborting due to previous error
-

test_suite/tests/ui/default-attribute/enum.stderr

@@ -3,6 +3,3 @@ error: #[serde(default)] can only be used on structs with named fields
   |
 5 | enum E {
   | ^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/default-attribute/enum_path.stderr

@@ -3,6 +3,3 @@ error: #[serde(default = "...")] can only be used on structs with named fields
   |
 5 | enum E {
   | ^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/default-attribute/nameless_struct_fields.stderr

@@ -3,6 +3,3 @@ error: #[serde(default)] can only be used on structs with named fields
   |
 5 | struct T(u8, u8);
   |         ^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/default-attribute/nameless_struct_fields_path.stderr

@@ -3,6 +3,3 @@ error: #[serde(default = "...")] can only be used on structs with named fields
   |
 5 | struct T(u8, u8);
   |         ^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/rename-and-ser.stderr

@@ -3,6 +3,3 @@ error: unknown serde field attribute `serialize`
   |
 5 |     #[serde(rename = "x", serialize = "y")]
   |                           ^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/rename-rename-de.stderr

@@ -1,8 +0,0 @@
-error: duplicate serde attribute `rename`
- --> $DIR/rename-rename-de.rs:6:13
-  |
-6 |     #[serde(rename(deserialize = "y"))]
-  |             ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/rename-ser-rename-ser.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
   |
 5 |     #[serde(rename(serialize = "x"), rename(serialize = "y"))]
   |                                      ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/rename-ser-rename.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
   |
 6 |     #[serde(rename = "y")]
   |             ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/rename-ser-ser.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
   |
 5 |     #[serde(rename(serialize = "x", serialize = "y"))]
   |                                     ^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/two-rename-ser.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `rename`
   |
 6 |     #[serde(rename(serialize = "y"))]
   |             ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/duplicate-attribute/with-and-serialize-with.stderr

@@ -3,6 +3,3 @@ error: duplicate serde attribute `serialize_with`
   |
 5 |     #[serde(with = "w", serialize_with = "s")]
   |                         ^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/enum-representation/content-no-tag.stderr

@@ -3,6 +3,3 @@ error: #[serde(tag = "...", content = "...")] must be used together
   |
 4 | #[serde(content = "c")]
   |         ^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/enum-representation/internal-tuple-variant.stderr

@@ -3,6 +3,3 @@ error: #[serde(tag = "...")] cannot be used with tuple variants
   |
 6 |     Tuple(u8, u8),
   |     ^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/enum-representation/untagged-and-adjacent.stderr

@@ -15,6 +15,3 @@ error: untagged enum cannot have #[serde(tag = "...", content = "...")]
   |
 5 | #[serde(tag = "t", content = "c")]
   |                    ^^^^^^^
-
-error: aborting due to 3 previous errors
-

test_suite/tests/ui/enum-representation/untagged-and-content.stderr

@@ -9,6 +9,3 @@ error: untagged enum cannot have #[serde(content = "...")]
   |
 5 | #[serde(content = "c")]
   |         ^^^^^^^
-
-error: aborting due to 2 previous errors
-

test_suite/tests/ui/enum-representation/untagged-and-internal.stderr

@@ -9,6 +9,3 @@ error: enum cannot be both untagged and internally tagged
   |
 5 | #[serde(tag = "type")]
   |         ^^^
-
-error: aborting due to 2 previous errors
-

test_suite/tests/ui/enum-representation/untagged-struct.stderr

@@ -3,6 +3,3 @@ error: #[serde(untagged)] can only be used on enums
   |
 5 | struct S;
   | ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/boolean.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = true)]
   |                      ^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/byte_character.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = b'a')]
   |                      ^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/byte_string.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = b"byte string")]
   |                      ^^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/character.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = 'a')]
   |                      ^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/float.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = 3.14)]
   |                      ^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/expected-string/integer.stderr

@@ -3,6 +3,3 @@ error: expected serde rename attribute to be a string: `rename = "..."`
   |
 5 |     #[serde(rename = 100)]
   |                      ^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/both.stderr

@@ -9,6 +9,3 @@ error: #[serde(field_identifier)] and #[serde(variant_identifier)] cannot both b
   |
 4 | #[serde(field_identifier, variant_identifier)]
   |                           ^^^^^^^^^^^^^^^^^^
-
-error: aborting due to 2 previous errors
-

test_suite/tests/ui/identifier/field_struct.stderr

@@ -3,6 +3,3 @@ error: #[serde(field_identifier)] can only be used on an enum
   |
 5 | struct S;
   | ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/field_tuple.stderr

@@ -3,6 +3,3 @@ error: #[serde(field_identifier)] may only contain unit variants
   |
 7 |     B(u8, u8),
   |     ^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/newtype_not_last.stderr

@@ -3,6 +3,3 @@ error: `Other` must be the last variant
   |
 7 |     Other(String),
   |     ^^^^^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/not_unit.stderr

@@ -4,6 +4,3 @@ error: #[serde(other)] must be on a unit variant
 7 | /     #[serde(other)]
 8 | |     Other(u8, u8),
   | |_________________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/other_not_last.stderr

@@ -4,6 +4,3 @@ error: #[serde(other)] must be on the last variant
 7 | /     #[serde(other)]
 8 | |     Other,
   | |_________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/other_untagged.stderr

@@ -4,6 +4,3 @@ error: #[serde(other)] cannot appear on untagged enum
 6 | /     #[serde(other)]
 7 | |     Other,
   | |_________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/other_variant.stderr

@@ -4,6 +4,3 @@ error: #[serde(other)] may not be used on a variant identifier
 6 | /     #[serde(other)]
 7 | |     Other,
   | |_________^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/variant_struct.stderr

@@ -3,6 +3,3 @@ error: #[serde(variant_identifier)] can only be used on an enum
   |
 5 | struct S;
   | ^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/identifier/variant_tuple.stderr

@@ -3,6 +3,3 @@ error: #[serde(variant_identifier)] may only contain unit variants
   |
 7 |     B(u8, u8),
   |     ^^^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/malformed/bound.stderr

@@ -3,6 +3,3 @@ error: malformed bound attribute, expected `bound(serialize = ..., deserialize =
   |
 5 |     #[serde(bound(unknown))]
   |                   ^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/malformed/rename.stderr

@@ -3,6 +3,3 @@ error: malformed rename attribute, expected `rename(serialize = ..., deserialize
   |
 5 |     #[serde(rename(unknown))]
   |                    ^^^^^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/precondition/deserialize_de_lifetime.stderr

@@ -3,6 +3,3 @@ error: cannot deserialize when there is a lifetime parameter called 'de
   |
 4 | struct S<'de> {
   |          ^^^
-
-error: aborting due to previous error
-

test_suite/tests/ui/precondition/deserialize_dst.stderr

@@ -6,6 +6,3 @@ error: cannot deserialize a dynamically sized struct
 6 | |     slice: [u8],
 7 | | }
   | |_^
-
-error: aborting due to previous error
-

test_suite/tests/ui/precondition/serialize_field_identifier.stderr

@@ -7,6 +7,3 @@ error: field identifiers cannot be serialized
 7 | |     B,
 8 | | }
   | |_^
-
-error: aborting due to previous error
-

test_suite/tests/ui/precondition/serialize_variant_identifier.stderr

@@ -7,6 +7,3 @@ error: variant identifiers cannot be serialized
 7 | |     B,
 8 | | }
   | |_^
-
-error: aborting due to previous error
-

test_suite/tests/ui/remote/bad_getter.stderr

@@ -3,6 +3,3 @@ error: failed to parse path: "~~~"
    |
 12 |     #[serde(getter = "~~~")]
    |                      ^^^^^
-
-error: aborting due to previous error
-