Release 1.0.92

Fix a compile error in derive(Deserialize) with no_std + alloc

.travis.yml

@@ -1,22 +1,93 @@
-sudo: false
 language: rust
-cache: cargo
-
-# run builds for all the trains (and more)
-rust:
-  - stable
-  - beta
-  - nightly
-  - 1.13.0
-  - 1.15.0
-  - 1.20.0
-  - 1.21.0
-  - 1.25.0
-  - 1.26.0
 
 matrix:
   include:
-    - rust: nightly
-      env: CLIPPY=true
+    - rust: stable
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build --features rc
+        - cargo build --no-default-features
+        - cd "${TRAVIS_BUILD_DIR}/serde_test"
+        - cargo build
+        - cargo test --features serde/derive,serde/rc
 
-script: ./travis.sh
+    - rust: beta
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build --features rc
+        - cd "${TRAVIS_BUILD_DIR}/test_suite"
+        - cargo test
+
+    - rust: nightly
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build
+        - cargo build --no-default-features
+        - 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"
+        - cargo test --features unstable
+        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
+        - cargo build
+
+    - rust: 1.13.0
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde"
+        - cargo build --features rc
+        - cargo build --no-default-features
+        - cd "${TRAVIS_BUILD_DIR}/serde_test"
+        - cargo build
+
+    - rust: 1.15.0
+      script:
+        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
+        - cargo build
+
+    - rust: 1.20.0
+    - rust: 1.21.0
+    - rust: 1.25.0
+    - rust: 1.26.0
+
+    - rust: nightly
+      name: Clippy
+      script:
+        - 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
+        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
+        - cargo clippy -- -D clippy::all
+        - cd "${TRAVIS_BUILD_DIR}/serde_test"
+        - cargo clippy -- -D clippy::all
+        - cd "${TRAVIS_BUILD_DIR}/test_suite"
+        - cargo clippy --tests --features unstable -- -D clippy::all
+        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
+        - cargo clippy -- -D clippy::all
+
+    - rust: nightly
+      name: Emscripten
+      script:
+        - CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
+        - CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
+        - CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
+
+        - nvm install 9
+        - mkdir -p ~/.cargo/bin
+        - curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
+        - chmod +x ~/.cargo/bin/cargo-web
+
+        - cd "${TRAVIS_BUILD_DIR}/test_suite"
+        - cargo web test --target=asmjs-unknown-emscripten --nodejs
+        - cargo web test --target=wasm32-unknown-emscripten --nodejs
+
+  allow_failures:
+    - rust: nightly
+      name: Clippy
+    - rust: nightly
+      name: Emscripten
+
+script:
+  - cd "${TRAVIS_BUILD_DIR}/serde"
+  - cargo build --no-default-features
+  - cargo build

LICENSE-MIT

@@ -1,5 +1,3 @@
-Copyright (c) 2014 The Rust Project Developers
-
 Permission is hereby granted, free of charge, to any
 person obtaining a copy of this software and associated
 documentation files (the "Software"), to deal in the

README.md

@@ -15,7 +15,7 @@ You may be looking for:
 
 - [An overview of Serde](https://serde.rs/)
 - [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
 - [Release notes](https://github.com/serde-rs/serde/releases)
@@ -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

@@ -13,5 +13,27 @@ install:
 
 build: false
 
-test_script:
-  - sh -c 'PATH=`rustc --print sysroot`/bin:$PATH ./travis.sh'
+for:
+  - matrix:
+      only:
+        - APPVEYOR_RUST_CHANNEL: stable
+    test_script:
+      - cd %APPVEYOR_BUILD_FOLDER%\serde
+      - cargo build --features rc
+      - cargo build --no-default-features
+      - cd %APPVEYOR_BUILD_FOLDER%\serde_test
+      - cargo build
+      - cargo test --features serde/derive,serde/rc
+
+  - matrix:
+      only:
+        - APPVEYOR_RUST_CHANNEL: nightly
+    test_script:
+      - cd %APPVEYOR_BUILD_FOLDER%\serde
+      - cargo build
+      - cargo build --no-default-features
+      - 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
+      - cargo test --features unstable

crates-io.md

@@ -8,7 +8,7 @@ You may be looking for:
 
 - [An overview of Serde](https://serde.rs/)
 - [Data formats supported by Serde](https://serde.rs/#data-formats)
-- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/derive.html)
 - [Examples](https://serde.rs/examples.html)
 - [API documentation](https://docs.serde.rs/serde/)
 - [Release notes](https://github.com/serde-rs/serde/releases)
@@ -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.69" # remember to update html_root_url
+version = "1.0.92" # 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"
@@ -23,36 +23,16 @@ serde_derive = { version = "1.0", optional = true, path = "../serde_derive" }
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
+[package.metadata.playground]
+features = ["derive", "rc"]
+
 
 ### FEATURES #################################################################
 
 [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>.

serde/build.rs

@@ -11,6 +11,24 @@ fn main() {
         None => return,
     };
 
+    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 {
@@ -32,10 +50,19 @@ fn main() {
 
     // 128-bit integers stabilized in Rust 1.26:
     // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
-    if minor >= 26 {
+    //
+    // Disabled on Emscripten targets as Emscripten doesn't
+    // currently support integers larger than 64 bits.
+    if minor >= 26 && !emscripten {
         println!("cargo:rustc-cfg=integer128");
     }
 
+    // Inclusive ranges methods stabilized in Rust 1.27:
+    // https://github.com/rust-lang/rust/pull/50758
+    if minor >= 27 {
+        println!("cargo:rustc-cfg=range_inclusive");
+    }
+
     // Non-zero integers stabilized in Rust 1.28:
     // https://github.com/rust-lang/rust/pull/50808
     if minor >= 28 {
@@ -59,11 +86,6 @@ fn rustc_minor_version() -> Option<u32> {
         Err(_) => return None,
     };
 
-    // Temporary workaround to support the old 1.26-dev compiler on docs.rs.
-    if version.contains("0eb87c9bf") {
-        return Some(25);
-    }
-
     let mut pieces = version.split('.');
     if pieces.next() != Some("rustc 1") {
         return None;

serde/src/de/from_primitive.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 macro_rules! int_to_int {

serde/src/de/ignored_any.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
@@ -16,18 +8,20 @@ use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 /// any type, except that it does not store any information about the data that
 /// gets deserialized.
 ///
-/// ```rust
+/// ```edition2018
 /// use std::fmt;
 /// use std::marker::PhantomData;
 ///
-/// use serde::de::{self, Deserialize, DeserializeSeed, Deserializer, Visitor, SeqAccess, IgnoredAny};
+/// use serde::de::{
+///     self, Deserialize, DeserializeSeed, Deserializer, IgnoredAny, SeqAccess, Visitor,
+/// };
 ///
 /// /// A seed that can be used to deserialize only the `n`th element of a sequence
 /// /// while efficiently discarding elements of any type before or after index `n`.
 /// ///
 /// /// For example to deserialize only the element at index 3:
 /// ///
-/// /// ```rust
+/// /// ```
 /// /// NthElement::new(3).deserialize(deserializer)
 /// /// ```
 /// pub struct NthElement<T> {
@@ -51,7 +45,11 @@ use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 ///     type Value = T;
 ///
 ///     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-///         write!(formatter, "a sequence in which we care about element {}", self.n)
+///         write!(
+///             formatter,
+///             "a sequence in which we care about element {}",
+///             self.n
+///         )
 ///     }
 ///
 ///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>

serde/src/de/impls.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 use de::{
@@ -586,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> {
@@ -696,7 +691,6 @@ macro_rules! seq_impl {
     (
         $ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
         $access:ident,
-        $ctor:expr,
         $clear:expr,
         $with_capacity:expr,
         $reserve:expr,
@@ -793,7 +787,6 @@ fn nop_reserve<T>(_seq: T, _n: usize) {}
 seq_impl!(
     BinaryHeap<T: Ord>,
     seq,
-    BinaryHeap::new(),
     BinaryHeap::clear,
     BinaryHeap::with_capacity(size_hint::cautious(seq.size_hint())),
     BinaryHeap::reserve,
@@ -803,7 +796,6 @@ seq_impl!(
 seq_impl!(
     BTreeSet<T: Eq + Ord>,
     seq,
-    BTreeSet::new(),
     BTreeSet::clear,
     BTreeSet::new(),
     nop_reserve,
@@ -813,7 +805,6 @@ seq_impl!(
 seq_impl!(
     LinkedList<T>,
     seq,
-    LinkedList::new(),
     LinkedList::clear,
     LinkedList::new(),
     nop_reserve,
@@ -824,28 +815,15 @@ seq_impl!(
 seq_impl!(
     HashSet<T: Eq + Hash, S: BuildHasher + Default>,
     seq,
-    HashSet::with_hasher(S::default()),
     HashSet::clear,
     HashSet::with_capacity_and_hasher(size_hint::cautious(seq.size_hint()), S::default()),
     HashSet::reserve,
     HashSet::insert);
 
-#[cfg(any(feature = "std", feature = "alloc"))]
-seq_impl!(
-    Vec<T>,
-    seq,
-    Vec::new(),
-    Vec::clear,
-    Vec::with_capacity(size_hint::cautious(seq.size_hint())),
-    Vec::reserve,
-    Vec::push
-);
-
 #[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(
     VecDeque<T>,
     seq,
-    VecDeque::new(),
     VecDeque::clear,
     VecDeque::with_capacity(size_hint::cautious(seq.size_hint())),
     VecDeque::reserve,
@@ -854,6 +832,99 @@ seq_impl!(
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'de, T> Deserialize<'de> for Vec<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct VecVisitor<T> {
+            marker: PhantomData<T>,
+        }
+
+        impl<'de, T> Visitor<'de> for VecVisitor<T>
+        where
+            T: Deserialize<'de>,
+        {
+            type Value = Vec<T>;
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a sequence")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let mut values = Vec::with_capacity(size_hint::cautious(seq.size_hint()));
+
+                while let Some(value) = try!(seq.next_element()) {
+                    values.push(value);
+                }
+
+                Ok(values)
+            }
+        }
+
+        let visitor = VecVisitor {
+            marker: PhantomData,
+        };
+        deserializer.deserialize_seq(visitor)
+    }
+
+    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        struct VecInPlaceVisitor<'a, T: 'a>(&'a mut Vec<T>);
+
+        impl<'a, 'de, T> Visitor<'de> for VecInPlaceVisitor<'a, T>
+        where
+            T: Deserialize<'de>,
+        {
+            type Value = ();
+
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                formatter.write_str("a sequence")
+            }
+
+            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            where
+                A: SeqAccess<'de>,
+            {
+                let hint = size_hint::cautious(seq.size_hint());
+                if let Some(additional) = hint.checked_sub(self.0.len()) {
+                    self.0.reserve(additional);
+                }
+
+                for i in 0..self.0.len() {
+                    let next = {
+                        let next_place = InPlaceSeed(&mut self.0[i]);
+                        try!(seq.next_element_seed(next_place))
+                    };
+                    if next.is_none() {
+                        self.0.truncate(i);
+                        return Ok(());
+                    }
+                }
+
+                while let Some(value) = try!(seq.next_element()) {
+                    self.0.push(value);
+                }
+
+                Ok(())
+            }
+        }
+
+        deserializer.deserialize_seq(VecInPlaceVisitor(place))
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 struct ArrayVisitor<A> {
     marker: PhantomData<A>,
 }
@@ -894,7 +965,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
@@ -911,14 +982,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),+])
+                        }
+                    ),+])
                 }
             }
 
@@ -974,38 +1043,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)
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1113,7 +1182,6 @@ macro_rules! map_impl {
     (
         $ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound1:ident $(+ $bound2:ident)*)* >,
         $access:ident,
-        $ctor:expr,
         $with_capacity:expr
     ) => {
         impl<'de, K, V $(, $typaram)*> Deserialize<'de> for $ty<K, V $(, $typaram)*>
@@ -1168,14 +1236,12 @@ macro_rules! map_impl {
 map_impl!(
     BTreeMap<K: Ord, V>,
     map,
-    BTreeMap::new(),
     BTreeMap::new());
 
 #[cfg(feature = "std")]
 map_impl!(
     HashMap<K: Eq + Hash, V, S: BuildHasher + Default>,
     map,
-    HashMap::with_hasher(S::default()),
     HashMap::with_capacity_and_hasher(size_hint::cautious(map.size_hint()), S::default()));
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1354,7 +1420,7 @@ impl<'de> Deserialize<'de> for net::IpAddr {
             deserializer.deserialize_str(IpAddrVisitor)
         } else {
             use lib::net::IpAddr;
-            deserialize_enum!{
+            deserialize_enum! {
                 IpAddr IpAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
                 "`V4` or `V6`",
                 deserializer
@@ -1431,7 +1497,7 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
             deserializer.deserialize_str(SocketAddrVisitor)
         } else {
             use lib::net::SocketAddr;
-            deserialize_enum!{
+            deserialize_enum! {
                 SocketAddr SocketAddrKind (V4; b"V4"; 0, V6; b"V6"; 1)
                 "`V4` or `V6`",
                 deserializer
@@ -1531,7 +1597,7 @@ impl<'de> Deserialize<'de> for PathBuf {
 //    #[derive(Deserialize)]
 //    #[serde(variant_identifier)]
 #[cfg(all(feature = "std", any(unix, windows)))]
-variant_identifier!{
+variant_identifier! {
     OsStringKind (Unix; b"Unix"; 0, Windows; b"Windows"; 1)
     "`Unix` or `Windows`",
     OSSTR_VARIANTS
@@ -1602,7 +1668,11 @@ forwarded_impl!((T), Box<[T]>, Vec::into_boxed_slice);
 #[cfg(any(feature = "std", feature = "alloc"))]
 forwarded_impl!((), Box<str>, String::into_boxed_str);
 
-#[cfg(all(not(de_rc_dst), feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(
+    not(de_rc_dst),
+    feature = "rc",
+    any(feature = "std", feature = "alloc")
+))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -1614,7 +1684,11 @@ forwarded_impl! {
     (T), Arc<T>, Arc::new
 }
 
-#[cfg(all(not(de_rc_dst), feature = "rc", any(feature = "std", feature = "alloc")))]
+#[cfg(all(
+    not(de_rc_dst),
+    feature = "rc",
+    any(feature = "std", feature = "alloc")
+))]
 forwarded_impl! {
     /// This impl requires the [`"rc"`] Cargo feature of Serde.
     ///
@@ -2024,8 +2098,7 @@ impl<'de> Deserialize<'de> for SystemTime {
 //         start: u64,
 //         end: u32,
 //     }
-#[cfg(feature = "std")]
-impl<'de, Idx> Deserialize<'de> for ops::Range<Idx>
+impl<'de, Idx> Deserialize<'de> for Range<Idx>
 where
     Idx: Deserialize<'de>,
 {
@@ -2033,16 +2106,187 @@ where
     where
         D: Deserializer<'de>,
     {
-        // If this were outside of the serde crate, it would just use:
-        //
-        //    #[derive(Deserialize)]
-        //    #[serde(field_identifier, rename_all = "lowercase")]
+        let (start, end) = deserializer.deserialize_struct(
+            "Range",
+            range::FIELDS,
+            range::RangeVisitor {
+                expecting: "struct Range",
+                phantom: PhantomData,
+            },
+        )?;
+        Ok(start..end)
+    }
+}
+
+#[cfg(range_inclusive)]
+impl<'de, Idx> Deserialize<'de> for RangeInclusive<Idx>
+where
+    Idx: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        let (start, end) = deserializer.deserialize_struct(
+            "RangeInclusive",
+            range::FIELDS,
+            range::RangeVisitor {
+                expecting: "struct RangeInclusive",
+                phantom: PhantomData,
+            },
+        )?;
+        Ok(RangeInclusive::new(start, end))
+    }
+}
+
+mod range {
+    use lib::*;
+
+    use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
+
+    pub const FIELDS: &'static [&'static str] = &["start", "end"];
+
+    // If this were outside of the serde crate, it would just use:
+    //
+    //    #[derive(Deserialize)]
+    //    #[serde(field_identifier, rename_all = "lowercase")]
+    enum Field {
+        Start,
+        End,
+    }
+
+    impl<'de> Deserialize<'de> for Field {
+        fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+        where
+            D: Deserializer<'de>,
+        {
+            struct FieldVisitor;
+
+            impl<'de> Visitor<'de> for FieldVisitor {
+                type Value = Field;
+
+                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                    formatter.write_str("`start` or `end`")
+                }
+
+                fn visit_str<E>(self, value: &str) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        "start" => Ok(Field::Start),
+                        "end" => Ok(Field::End),
+                        _ => Err(Error::unknown_field(value, FIELDS)),
+                    }
+                }
+
+                fn visit_bytes<E>(self, value: &[u8]) -> Result<Self::Value, E>
+                where
+                    E: Error,
+                {
+                    match value {
+                        b"start" => Ok(Field::Start),
+                        b"end" => Ok(Field::End),
+                        _ => {
+                            let value = ::export::from_utf8_lossy(value);
+                            Err(Error::unknown_field(&value, FIELDS))
+                        }
+                    }
+                }
+            }
+
+            deserializer.deserialize_identifier(FieldVisitor)
+        }
+    }
+
+    pub struct RangeVisitor<Idx> {
+        pub expecting: &'static str,
+        pub phantom: PhantomData<Idx>,
+    }
+
+    impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
+    where
+        Idx: Deserialize<'de>,
+    {
+        type Value = (Idx, Idx);
+
+        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+            formatter.write_str(self.expecting)
+        }
+
+        fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+        where
+            A: SeqAccess<'de>,
+        {
+            let start: Idx = match try!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(0, &self));
+                }
+            };
+            let end: Idx = match try!(seq.next_element()) {
+                Some(value) => value,
+                None => {
+                    return Err(Error::invalid_length(1, &self));
+                }
+            };
+            Ok((start, end))
+        }
+
+        fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
+        where
+            A: MapAccess<'de>,
+        {
+            let mut start: Option<Idx> = None;
+            let mut end: Option<Idx> = None;
+            while let Some(key) = try!(map.next_key()) {
+                match key {
+                    Field::Start => {
+                        if start.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("start"));
+                        }
+                        start = Some(try!(map.next_value()));
+                    }
+                    Field::End => {
+                        if end.is_some() {
+                            return Err(<A::Error as Error>::duplicate_field("end"));
+                        }
+                        end = Some(try!(map.next_value()));
+                    }
+                }
+            }
+            let start = match start {
+                Some(start) => start,
+                None => return Err(<A::Error as Error>::missing_field("start")),
+            };
+            let end = match end {
+                Some(end) => end,
+                None => return Err(<A::Error as Error>::missing_field("end")),
+            };
+            Ok((start, end))
+        }
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[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 {
-            Start,
-            End,
-        };
+            Unbounded,
+            Included,
+            Excluded,
+        }
 
         impl<'de> Deserialize<'de> for Field {
+            #[inline]
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
             where
                 D: Deserializer<'de>,
@@ -2053,7 +2297,22 @@ where
                     type Value = Field;
 
                     fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                        formatter.write_str("`start` or `end`")
+                        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>
@@ -2061,9 +2320,10 @@ where
                         E: Error,
                     {
                         match value {
-                            "start" => Ok(Field::Start),
-                            "end" => Ok(Field::End),
-                            _ => Err(Error::unknown_field(value, FIELDS)),
+                            "Unbounded" => Ok(Field::Unbounded),
+                            "Included" => Ok(Field::Included),
+                            "Excluded" => Ok(Field::Excluded),
+                            _ => Err(Error::unknown_variant(value, VARIANTS)),
                         }
                     }
 
@@ -2072,12 +2332,15 @@ where
                         E: Error,
                     {
                         match value {
-                            b"start" => Ok(Field::Start),
-                            b"end" => Ok(Field::End),
-                            _ => {
-                                let value = String::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
-                            }
+                            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))
+                                }
+                            },
                         }
                     }
                 }
@@ -2086,81 +2349,33 @@ where
             }
         }
 
-        struct RangeVisitor<Idx> {
-            phantom: PhantomData<Idx>,
-        }
+        struct BoundVisitor<T>(PhantomData<Bound<T>>);
 
-        impl<'de, Idx> Visitor<'de> for RangeVisitor<Idx>
+        impl<'de, T> Visitor<'de> for BoundVisitor<T>
         where
-            Idx: Deserialize<'de>,
+            T: Deserialize<'de>,
         {
-            type Value = ops::Range<Idx>;
+            type Value = Bound<T>;
 
             fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                formatter.write_str("struct Range")
+                formatter.write_str("enum Bound")
             }
 
-            fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
+            fn visit_enum<A>(self, data: A) -> Result<Self::Value, A::Error>
             where
-                A: SeqAccess<'de>,
+                A: EnumAccess<'de>,
             {
-                let start: Idx = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(0, &self));
-                    }
-                };
-                let end: Idx = match try!(seq.next_element()) {
-                    Some(value) => value,
-                    None => {
-                        return Err(Error::invalid_length(1, &self));
-                    }
-                };
-                Ok(start..end)
-            }
-
-            fn visit_map<A>(self, mut map: A) -> Result<Self::Value, A::Error>
-            where
-                A: MapAccess<'de>,
-            {
-                let mut start: Option<Idx> = None;
-                let mut end: Option<Idx> = None;
-                while let Some(key) = try!(map.next_key()) {
-                    match key {
-                        Field::Start => {
-                            if start.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("start"));
-                            }
-                            start = Some(try!(map.next_value()));
-                        }
-                        Field::End => {
-                            if end.is_some() {
-                                return Err(<A::Error as Error>::duplicate_field("end"));
-                            }
-                            end = Some(try!(map.next_value()));
-                        }
-                    }
+                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),
                 }
-                let start = match start {
-                    Some(start) => start,
-                    None => return Err(<A::Error as Error>::missing_field("start")),
-                };
-                let end = match end {
-                    Some(end) => end,
-                    None => return Err(<A::Error as Error>::missing_field("end")),
-                };
-                Ok(start..end)
             }
         }
 
-        const FIELDS: &'static [&'static str] = &["start", "end"];
-        deserializer.deserialize_struct(
-            "Range",
-            FIELDS,
-            RangeVisitor {
-                phantom: PhantomData,
-            },
-        )
+        const VARIANTS: &'static [&'static str] = &["Unbounded", "Included", "Excluded"];
+
+        deserializer.deserialize_enum("Bound", VARIANTS, BoundVisitor(PhantomData))
     }
 }
 
@@ -2192,10 +2407,17 @@ nonzero_integers! {
     NonZeroU16,
     NonZeroU32,
     NonZeroU64,
-    // FIXME: https://github.com/serde-rs/serde/issues/1136 NonZeroU128,
     NonZeroUsize,
 }
 
+// Currently 128-bit integers do not work on Emscripten targets so we need an
+// additional `#[cfg]`
+serde_if_integer128! {
+    nonzero_integers! {
+        NonZeroU128,
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 impl<'de, T, E> Deserialize<'de> for Result<T, E>

serde/src/de/mod.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! Generic data structure deserialization framework.
 //!
 //! The two most important traits in this module are [`Deserialize`] and
@@ -24,8 +16,7 @@
 //!
 //! Additionally, Serde provides a procedural macro called [`serde_derive`] to
 //! automatically generate [`Deserialize`] implementations for structs and enums
-//! in your program. See the [codegen section of the manual] for how to use
-//! this.
+//! in your program. See the [derive section of the manual] for how to use this.
 //!
 //! In rare cases it may be necessary to implement [`Deserialize`] manually for
 //! some type in your program. See the [Implementing `Deserialize`] section of
@@ -68,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\>
@@ -97,6 +88,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
+//!    - RangeInclusive\<T\>
+//!    - Bound\<T\>
 //!    - num::NonZero*
 //!    - `!` *(unstable)*
 //!  - **Net types**:
@@ -116,7 +109,7 @@
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
 //! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
-//! [codegen section of the manual]: https://serde.rs/codegen.html
+//! [derive section of the manual]: https://serde.rs/derive.html
 //! [data formats]: https://serde.rs/#data-formats
 
 use lib::*;
@@ -161,7 +154,7 @@ macro_rules! declare_error_trait {
             ///
             /// The message should not be capitalized and should not end with a period.
             ///
-            /// ```rust
+            /// ```edition2018
             /// # use std::str::FromStr;
             /// #
             /// # struct IpAddr;
@@ -181,7 +174,7 @@ macro_rules! declare_error_trait {
             ///     where
             ///         D: Deserializer<'de>,
             ///     {
-            ///         let s = try!(String::deserialize(deserializer));
+            ///         let s = String::deserialize(deserializer)?;
             ///         s.parse().map_err(de::Error::custom)
             ///     }
             /// }
@@ -245,12 +238,16 @@ macro_rules! declare_error_trait {
             #[cold]
             fn unknown_variant(variant: &str, expected: &'static [&'static str]) -> Self {
                 if expected.is_empty() {
-                    Error::custom(format_args!("unknown variant `{}`, there are no variants",
-                                               variant))
+                    Error::custom(format_args!(
+                        "unknown variant `{}`, there are no variants",
+                        variant
+                    ))
                 } else {
-                    Error::custom(format_args!("unknown variant `{}`, expected {}",
-                                               variant,
-                                               OneOf { names: expected }))
+                    Error::custom(format_args!(
+                        "unknown variant `{}`, expected {}",
+                        variant,
+                        OneOf { names: expected }
+                    ))
                 }
             }
 
@@ -259,12 +256,16 @@ macro_rules! declare_error_trait {
             #[cold]
             fn unknown_field(field: &str, expected: &'static [&'static str]) -> Self {
                 if expected.is_empty() {
-                    Error::custom(format_args!("unknown field `{}`, there are no fields",
-                                               field))
+                    Error::custom(format_args!(
+                        "unknown field `{}`, there are no fields",
+                        field
+                    ))
                 } else {
-                    Error::custom(format_args!("unknown field `{}`, expected {}",
-                                               field,
-                                               OneOf { names: expected }))
+                    Error::custom(format_args!(
+                        "unknown field `{}`, expected {}",
+                        field,
+                        OneOf { names: expected }
+                    ))
                 }
             }
 
@@ -298,7 +299,7 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// This is used as an argument to the `invalid_type`, `invalid_value`, and
 /// `invalid_length` methods of the `Error` trait to build error messages.
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -423,7 +424,7 @@ impl<'a> fmt::Display for Unexpected<'a> {
 /// Within the context of a `Visitor` implementation, the `Visitor` itself
 /// (`&self`) is an implementation of this trait.
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -448,7 +449,7 @@ impl<'a> fmt::Display for Unexpected<'a> {
 ///
 /// Outside of a `Visitor`, `&"..."` can be used.
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::{self, Unexpected};
 /// #
 /// # fn example<E>() -> Result<(), E>
@@ -497,7 +498,7 @@ impl<'a> Display for Expected + 'a {
 ///
 /// Additionally, Serde provides a procedural macro called `serde_derive` to
 /// automatically generate `Deserialize` implementations for structs and enums
-/// in your program. See the [codegen section of the manual][codegen] for how to
+/// in your program. See the [derive section of the manual][derive] for how to
 /// use this.
 ///
 /// In rare cases it may be necessary to implement `Deserialize` manually for
@@ -510,7 +511,7 @@ impl<'a> Display for Expected + 'a {
 /// provides an implementation of `Deserialize` for it.
 ///
 /// [de]: https://docs.serde.rs/serde/de/index.html
-/// [codegen]: https://serde.rs/codegen.html
+/// [derive]: https://serde.rs/derive.html
 /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
 ///
 /// # Lifetime
@@ -569,7 +570,7 @@ pub trait Deserialize<'de>: Sized {
 /// from the input string, but a `from_reader` function may only deserialize
 /// owned data.
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::{Deserialize, DeserializeOwned};
 /// # use std::io::{Read, Result};
 /// #
@@ -608,7 +609,7 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 ///
 /// The canonical API for stateless deserialization looks like this:
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::Deserialize;
 /// #
 /// # enum Error {}
@@ -622,7 +623,7 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 /// Adjusting an API like this to support stateful deserialization is a matter
 /// of accepting a seed as input:
 ///
-/// ```rust
+/// ```edition2018
 /// # use serde::de::DeserializeSeed;
 /// #
 /// # enum Error {}
@@ -655,11 +656,11 @@ impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 /// into it. This requires stateful deserialization using the `DeserializeSeed`
 /// trait.
 ///
-/// ```rust
+/// ```edition2018
 /// use std::fmt;
 /// use std::marker::PhantomData;
 ///
-/// use serde::de::{Deserialize, DeserializeSeed, Deserializer, Visitor, SeqAccess};
+/// use serde::de::{Deserialize, DeserializeSeed, Deserializer, SeqAccess, Visitor};
 ///
 /// // A DeserializeSeed implementation that uses stateful deserialization to
 /// // append array elements onto the end of an existing vector. The preexisting
@@ -806,16 +807,16 @@ where
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
 ///  - **byte array** - \[u8\]
-///    - Similar to strings, during deserialization byte arrays can be transient,
-///      owned, or borrowed.
+///    - Similar to strings, during deserialization byte arrays can be
+///      transient, owned, or borrowed.
 ///  - **option**
 ///    - Either none or some value.
 ///  - **unit**
-///    - The type of `()` in Rust. It represents an anonymous value containing no
-///      data.
+///    - The type of `()` in Rust. It represents an anonymous value containing
+///      no data.
 ///  - **unit_struct**
-///    - For example `struct Unit` or `PhantomData<T>`. It represents a named value
-///      containing no data.
+///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
+///      value containing no data.
 ///  - **unit_variant**
 ///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
 ///  - **newtype_struct**
@@ -823,14 +824,15 @@ where
 ///  - **newtype_variant**
 ///    - For example the `E::N` in `enum E { N(u8) }`.
 ///  - **seq**
-///    - A variably sized heterogeneous sequence of values, for example `Vec<T>` or
-///      `HashSet<T>`. When serializing, the length may or may not be known before
-///      iterating through all the data. When deserializing, the length is determined
-///      by looking at the serialized data.
+///    - A variably sized heterogeneous sequence of values, for example `Vec<T>`
+///      or `HashSet<T>`. When serializing, the length may or may not be known
+///      before iterating through all the data. When deserializing, the length
+///      is determined by looking at the serialized data.
 ///  - **tuple**
-///    - A statically sized heterogeneous sequence of values for which the length
-///      will be known at deserialization time without looking at the serialized
-///      data, for example `(u8,)` or `(String, u64, Vec<T>)` or `[u64; 10]`.
+///    - A statically sized heterogeneous sequence of values for which the
+///      length will be known at deserialization time without looking at the
+///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
+///      `[u64; 10]`.
 ///  - **tuple_struct**
 ///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
 ///  - **tuple_variant**
@@ -838,9 +840,9 @@ where
 ///  - **map**
 ///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
 ///  - **struct**
-///    - A heterogeneous key-value pairing in which the keys are strings and will be
-///      known at deserialization time without looking at the serialized data, for
-///      example `struct S { r: u8, g: u8, b: u8 }`.
+///    - A heterogeneous key-value pairing in which the keys are strings and
+///      will be known at deserialization time without looking at the serialized
+///      data, for example `struct S { r: u8, g: u8, b: u8 }`.
 ///  - **struct_variant**
 ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
 ///
@@ -855,7 +857,8 @@ where
 ///    type it sees in the input. JSON uses this approach when deserializing
 ///    `serde_json::Value` which is an enum that can represent any JSON
 ///    document. Without knowing what is in a JSON document, we can deserialize
-///    it to `serde_json::Value` by going through `Deserializer::deserialize_any`.
+///    it to `serde_json::Value` by going through
+///    `Deserializer::deserialize_any`.
 ///
 /// 2. The various `deserialize_*` methods. Non-self-describing formats like
 ///    Bincode need to be told what is in the input in order to deserialize it.
@@ -865,10 +868,11 @@ where
 ///    `Deserializer::deserialize_any`.
 ///
 /// When implementing `Deserialize`, you should avoid relying on
-/// `Deserializer::deserialize_any` unless you need to be told by the Deserializer
-/// what type is in the input. Know that relying on `Deserializer::deserialize_any`
-/// means your data type will be able to deserialize from self-describing
-/// formats only, ruling out Bincode and many others.
+/// `Deserializer::deserialize_any` unless you need to be told by the
+/// Deserializer what type is in the input. Know that relying on
+/// `Deserializer::deserialize_any` means your data type will be able to
+/// deserialize from self-describing formats only, ruling out Bincode and many
+/// others.
 ///
 /// [Serde data model]: https://serde.rs/data-model.html
 ///
@@ -1142,7 +1146,7 @@ pub trait Deserializer<'de>: Sized {
     /// human-readable one and binary formats like Bincode will prefer the
     /// compact one.
     ///
-    /// ```
+    /// ```edition2018
     /// # use std::ops::Add;
     /// # use std::str::FromStr;
     /// #
@@ -1219,7 +1223,7 @@ pub trait Deserializer<'de>: Sized {
 ///
 /// # Example
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::fmt;
 /// #
 /// # use serde::de::{self, Unexpected, Visitor};
@@ -1260,7 +1264,7 @@ pub trait Visitor<'de>: Sized {
     /// "an integer between 0 and 64". The message should not be capitalized and
     /// should not end with a period.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use std::fmt;
     /// #
     /// # struct S {
@@ -2001,7 +2005,7 @@ pub trait VariantAccess<'de>: Sized {
     /// If the data contains a different type of variant, the following
     /// `invalid_type` error should be constructed:
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
     /// #
     /// # struct X;
@@ -2041,7 +2045,7 @@ pub trait VariantAccess<'de>: Sized {
     /// If the data contains a different type of variant, the following
     /// `invalid_type` error should be constructed:
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
     /// #
     /// # struct X;
@@ -2097,7 +2101,7 @@ pub trait VariantAccess<'de>: Sized {
     /// If the data contains a different type of variant, the following
     /// `invalid_type` error should be constructed:
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
     /// #
     /// # struct X;
@@ -2144,7 +2148,7 @@ pub trait VariantAccess<'de>: Sized {
     /// If the data contains a different type of variant, the following
     /// `invalid_type` error should be constructed:
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde::de::{self, value, DeserializeSeed, Visitor, VariantAccess, Unexpected};
     /// #
     /// # struct X;
@@ -2204,14 +2208,10 @@ pub trait VariantAccess<'de>: Sized {
 ///
 /// # Example
 ///
-/// ```rust
-/// #[macro_use]
-/// extern crate serde_derive;
-///
-/// extern crate serde;
-///
+/// ```edition2018
 /// use std::str::FromStr;
-/// use serde::de::{value, Deserialize, IntoDeserializer};
+/// use serde::Deserialize;
+/// use serde::de::{value, IntoDeserializer};
 ///
 /// #[derive(Deserialize)]
 /// enum Setting {
@@ -2226,8 +2226,6 @@ pub trait VariantAccess<'de>: Sized {
 ///         Self::deserialize(s.into_deserializer())
 ///     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 pub trait IntoDeserializer<'de, E: Error = value::Error> {
     /// The type of the deserializer being converted into.

serde/src/de/utf8.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 const TAG_CONT: u8 = 0b1000_0000;

serde/src/de/value.rs

@@ -1,22 +1,10 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! Building blocks for deserializing basic values using the `IntoDeserializer`
 //! trait.
 //!
-//! ```rust
-//! #[macro_use]
-//! extern crate serde_derive;
-//!
-//! extern crate serde;
-//!
+//! ```edition2018
 //! use std::str::FromStr;
-//! use serde::de::{value, Deserialize, IntoDeserializer};
+//! use serde::Deserialize;
+//! use serde::de::{value, IntoDeserializer};
 //!
 //! #[derive(Deserialize)]
 //! enum Setting {
@@ -31,8 +19,6 @@
 //!         Self::deserialize(s.into_deserializer())
 //!     }
 //! }
-//! #
-//! # fn main() {}
 //! ```
 
 use lib::*;
@@ -1301,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")),
+        }
     }
 }
 
@@ -1313,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> {
@@ -1374,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

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 pub use lib::clone::Clone;
 pub use lib::convert::{From, Into};
 pub use lib::default::Default;
@@ -17,7 +9,7 @@ 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};
 
 mod string {
     use lib::*;

serde/src/integer128.rs

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

serde/src/lib.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! # Serde
 //!
 //! Serde is a framework for ***ser***ializing and ***de***serializing Rust data
@@ -50,17 +42,16 @@
 //! - [MessagePack], an efficient binary format that resembles a compact JSON.
 //! - [TOML], a minimal configuration format used by [Cargo].
 //! - [Pickle], a format common in the Python world.
-//! - [Hjson], a variant of JSON designed to be readable and writable by humans.
+//! - [RON], a Rusty Object Notation.
 //! - [BSON], the data storage and network transfer format used by MongoDB.
 //! - [Avro], a binary format used within Apache Hadoop, with support for schema
 //!   definition.
+//! - [JSON5], A superset of JSON including some productions from ES5.
 //! - [URL], the x-www-form-urlencoded format.
-//! - [XML], the flexible machine-friendly W3C standard.
-//!   *(deserialization only)*
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(deserialization only)*
-//! - [Redis], deserialize values from Redis when using [redis-rs].
-//!   *(deserialization only)*
+//! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
+//!   Rust structs. *(deserialization only)*
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Bincode]: https://github.com/TyOverby/bincode
@@ -69,20 +60,20 @@
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
 //! [TOML]: https://github.com/alexcrichton/toml-rs
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
-//! [Hjson]: https://github.com/laktak/hjson-rust
+//! [RON]: https://github.com/ron-rs/ron
 //! [BSON]: https://github.com/zonyitoo/bson-rs
 //! [Avro]: https://github.com/flavray/avro-rs
+//! [JSON5]: https://github.com/callum-oakley/json5-rs
 //! [URL]: https://github.com/nox/serde_urlencoded
-//! [XML]: https://github.com/RReverser/serde-xml-rs
 //! [Envy]: https://github.com/softprops/envy
-//! [Redis]: https://github.com/OneSignal/serde-redis
+//! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: http://doc.crates.io/manifest.html
-//! [redis-rs]: https://crates.io/crates/redis
+//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.69")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.92")]
 // 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
@@ -91,46 +82,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))]
-// Whitelisted 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,
-        redundant_field_names, type_complexity, unreadable_literal, zero_prefixed_literal
+        // not available in our oldest supported compiler
+        const_static_lifetime,
+        empty_enum,
+        redundant_field_names,
+        // integer and float ser/de requires these sorts of casts
+        cast_possible_truncation,
+        cast_possible_wrap,
+        cast_precision_loss,
+        cast_sign_loss,
+        // things are often more readable this way
+        cast_lossless,
+        module_name_repetitions,
+        single_match_else,
+        type_complexity,
+        use_self,
+        zero_prefixed_literal,
+        // not practical
+        needless_pass_by_value,
+        similar_names,
+        // preference
+        doc_markdown,
     )
 )]
-// Whitelisted 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,
-    option_unwrap_used,
-    result_unwrap_used,
-    shadow_reuse,
-    single_match_else,
-    stutter,
-    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)]
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -148,7 +131,7 @@ mod lib {
         pub use std::*;
     }
 
-    pub use self::core::{cmp, iter, mem, num, ops, slice, str};
+    pub use self::core::{cmp, iter, mem, num, slice, str};
     pub use self::core::{f32, f64};
     pub use self::core::{i16, i32, i64, i8, isize};
     pub use self::core::{u16, u32, u64, u8, usize};
@@ -159,6 +142,7 @@ mod lib {
     pub use self::core::default::{self, Default};
     pub use self::core::fmt::{self, Debug, Display};
     pub use self::core::marker::{self, PhantomData};
+    pub use self::core::ops::Range;
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
 
@@ -170,7 +154,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;
@@ -188,12 +172,12 @@ mod lib {
     pub use std::rc::{Rc, Weak as RcWeak};
 
     #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::arc::{Arc, Weak as ArcWeak};
+    pub use alloc::sync::{Arc, Weak as ArcWeak};
     #[cfg(all(feature = "rc", feature = "std"))]
     pub use std::sync::{Arc, Weak as ArcWeak};
 
     #[cfg(all(feature = "alloc", not(feature = "std")))]
-    pub use alloc::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
+    pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
     #[cfg(feature = "std")]
     pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
@@ -217,6 +201,18 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::time::{SystemTime, UNIX_EPOCH};
 
+    #[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(any(core_duration, feature = "std"))]
     pub use self::core::time::Duration;
 }
@@ -247,40 +243,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/macros.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 // Super explicit first paragraph because this shows up at the top level and
 // trips up people who are just looking for basic Serialize / Deserialize
 // documentation.
@@ -19,10 +11,8 @@
 /// input. This requires repetitive implementations of all the [`Deserializer`]
 /// trait methods.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer;
@@ -51,18 +41,14 @@
 /// #         tuple_struct map struct enum identifier ignored_any
 /// #     }
 /// # }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// The `forward_to_deserialize_any!` macro implements these simple forwarding
 /// methods so that they forward directly to [`Deserializer::deserialize_any`].
 /// You can choose which methods to forward.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer;
@@ -85,8 +71,6 @@
 ///         tuple_struct map struct enum identifier ignored_any
 ///     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// The macro assumes the convention that your `Deserializer` lifetime parameter
@@ -94,12 +78,10 @@
 /// called `V`. A different type parameter and a different lifetime can be
 /// specified explicitly if necessary.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
+/// # use serde::forward_to_deserialize_any;
 /// # use serde::de::{value, Deserializer, Visitor};
 /// #
 /// # struct MyDeserializer<V>(PhantomData<V>);
@@ -121,8 +103,6 @@
 ///     tuple_struct map struct enum identifier ignored_any
 /// }
 /// # }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// [`Deserializer`]: trait.Deserializer.html

serde/src/private/de.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
@@ -231,8 +223,8 @@ mod content {
 
     use super::size_hint;
     use de::{
-        self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, MapAccess,
-        SeqAccess, Unexpected, Visitor,
+        self, Deserialize, DeserializeSeed, Deserializer, EnumAccess, Expected, IgnoredAny,
+        MapAccess, SeqAccess, Unexpected, Visitor,
     };
 
     /// Used from generated code to buffer the contents of the Deserializer when
@@ -832,8 +824,8 @@ mod content {
     }
 
     impl<'de, T> TaggedContentVisitor<'de, T> {
-        /// Visitor for the content of an internally tagged enum with the given tag
-        /// name.
+        /// Visitor for the content of an internally tagged enum with the given
+        /// tag name.
         pub fn new(name: &'static str) -> Self {
             TaggedContentVisitor {
                 tag_name: name,
@@ -1075,8 +1067,8 @@ mod content {
         Ok(value)
     }
 
-    /// Used when deserializing an internally tagged enum because the content will
-    /// be used exactly once.
+    /// Used when deserializing an internally tagged enum because the content
+    /// will be used exactly once.
     impl<'de, E> Deserializer<'de> for ContentDeserializer<'de, E>
     where
         E: de::Error,
@@ -1427,6 +1419,7 @@ mod content {
                 Content::Str(v) => visitor.visit_borrowed_str(v),
                 Content::ByteBuf(v) => visitor.visit_byte_buf(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                Content::U8(v) => visitor.visit_u8(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -1763,7 +1756,7 @@ mod content {
         V: Visitor<'de>,
         E: de::Error,
     {
-        let seq = content.into_iter().map(ContentRefDeserializer::new);
+        let seq = content.iter().map(ContentRefDeserializer::new);
         let mut seq_visitor = de::value::SeqDeserializer::new(seq);
         let value = try!(visitor.visit_seq(&mut seq_visitor));
         try!(seq_visitor.end());
@@ -1778,7 +1771,7 @@ mod content {
         V: Visitor<'de>,
         E: de::Error,
     {
-        let map = content.into_iter().map(|&(ref k, ref v)| {
+        let map = content.iter().map(|&(ref k, ref v)| {
             (
                 ContentRefDeserializer::new(k),
                 ContentRefDeserializer::new(v),
@@ -1790,8 +1783,8 @@ mod content {
         Ok(value)
     }
 
-    /// Used when deserializing an untagged enum because the content may need to be
-    /// used more than once.
+    /// Used when deserializing an untagged enum because the content may need
+    /// to be used more than once.
     impl<'de, 'a, E> Deserializer<'de> for ContentRefDeserializer<'a, 'de, E>
     where
         E: de::Error,
@@ -2085,7 +2078,7 @@ mod content {
         {
             let (variant, value) = match *self.content {
                 Content::Map(ref value) => {
-                    let mut iter = value.into_iter();
+                    let mut iter = value.iter();
                     let &(ref variant, ref value) = match iter.next() {
                         Some(v) => v,
                         None => {
@@ -2129,6 +2122,7 @@ mod content {
                 Content::Str(v) => visitor.visit_borrowed_str(v),
                 Content::ByteBuf(ref v) => visitor.visit_bytes(v),
                 Content::Bytes(v) => visitor.visit_borrowed_bytes(v),
+                Content::U8(v) => visitor.visit_u8(v),
                 _ => Err(self.invalid_type(&visitor)),
             }
         }
@@ -2272,9 +2266,9 @@ mod content {
     where
         E: de::Error,
     {
-        fn new(vec: &'a [Content<'de>]) -> Self {
+        fn new(slice: &'a [Content<'de>]) -> Self {
             SeqRefDeserializer {
-                iter: vec.into_iter(),
+                iter: slice.iter(),
                 err: PhantomData,
             }
         }
@@ -2350,7 +2344,7 @@ mod content {
     {
         fn new(map: &'a [(Content<'de>, Content<'de>)]) -> Self {
             MapRefDeserializer {
-                iter: map.into_iter(),
+                iter: map.iter(),
                 value: None,
                 err: PhantomData,
             }
@@ -2470,10 +2464,11 @@ mod content {
             Ok(())
         }
 
-        fn visit_map<M>(self, _: M) -> Result<(), M::Error>
+        fn visit_map<M>(self, mut access: M) -> Result<(), M::Error>
         where
             M: MapAccess<'de>,
         {
+            while let Some(_) = try!(access.next_entry::<IgnoredAny, IgnoredAny>()) {}
             Ok(())
         }
     }
@@ -2714,7 +2709,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
         )))
     }
@@ -2915,18 +2910,17 @@ where
     where
         T: DeserializeSeed<'de>,
     {
-        match self.iter.next() {
-            Some(item) => {
+        while let Some(item) = self.iter.next() {
+            if let Some((ref key, ref content)) = *item {
                 // Do not take(), instead borrow this entry. The internally tagged
                 // enum does its own buffering so we can't tell whether this entry
                 // is going to be consumed. Borrowing here leaves the entry
                 // available for later flattened fields.
-                let (ref key, ref content) = *item.as_ref().unwrap();
                 self.pending = Some(content);
-                seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
+                return seed.deserialize(ContentRefDeserializer::new(key)).map(Some);
             }
-            None => Ok(None),
         }
+        Ok(None)
     }
 
     fn next_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>

serde/src/private/macros.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 #[doc(hidden)]
 #[macro_export]
 macro_rules! __private_serialize {

serde/src/private/mod.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 mod macros;
 
 pub mod de;

serde/src/private/ser.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
@@ -409,10 +401,9 @@ mod content {
         }
 
         fn end(mut self) -> Result<M::Ok, M::Error> {
-            try!(
-                self.map
-                    .serialize_value(&Content::TupleStruct(self.name, self.fields))
-            );
+            try!(self
+                .map
+                .serialize_value(&Content::TupleStruct(self.name, self.fields)));
             self.map.end()
         }
     }
@@ -454,10 +445,9 @@ mod content {
         }
 
         fn end(mut self) -> Result<M::Ok, M::Error> {
-            try!(
-                self.map
-                    .serialize_value(&Content::Struct(self.name, self.fields))
-            );
+            try!(self
+                .map
+                .serialize_value(&Content::Struct(self.name, self.fields)));
             self.map.end()
         }
     }
@@ -1328,10 +1318,9 @@ where
     }
 
     fn end(self) -> Result<(), Self::Error> {
-        try!(
-            self.map
-                .serialize_value(&Content::Struct(self.name, self.fields))
-        );
+        try!(self
+            .map
+            .serialize_value(&Content::Struct(self.name, self.fields)));
         Ok(())
     }
 }

serde/src/ser/impls.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use lib::*;
 
 use ser::{Error, Serialize, SerializeTuple, Serializer};
@@ -168,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
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -227,8 +221,7 @@ seq_impl!(VecDeque<T>);
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
-impl<Idx> Serialize for ops::Range<Idx>
+impl<Idx> Serialize for Range<Idx>
 where
     Idx: Serialize,
 {
@@ -246,6 +239,48 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(range_inclusive)]
+impl<Idx> Serialize for RangeInclusive<Idx>
+where
+    Idx: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use super::SerializeStruct;
+        let mut state = try!(serializer.serialize_struct("RangeInclusive", 2));
+        try!(state.serialize_field("start", &self.start()));
+        try!(state.serialize_field("end", &self.end()));
+        state.end()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[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>
@@ -451,10 +486,17 @@ nonzero_integers! {
     NonZeroU16,
     NonZeroU32,
     NonZeroU64,
-    // FIXME: https://github.com/serde-rs/serde/issues/1136 NonZeroU128,
     NonZeroUsize,
 }
 
+// Currently 128-bit integers do not work on Emscripten targets so we need an
+// additional `#[cfg]`
+serde_if_integer128! {
+    nonzero_integers! {
+        NonZeroU128,
+    }
+}
+
 impl<T> Serialize for Cell<T>
 where
     T: Serialize + Copy,
@@ -782,3 +824,17 @@ 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)
+    }
+}

serde/src/ser/impossible.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! This module contains `Impossible` serializer and its implementations.
 
 use lib::*;
@@ -23,10 +15,7 @@ use ser::{
 /// [`SerializeTuple`], [`SerializeTupleStruct`], [`SerializeTupleVariant`],
 /// [`SerializeMap`], [`SerializeStruct`], and [`SerializeStructVariant`].
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde;
-/// #
+/// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
 /// # use serde::private::ser::Error;
 /// #
@@ -52,14 +41,12 @@ use ser::{
 ///     }
 ///
 ///     /* other Serializer methods */
-/// #     __serialize_unimplemented! {
+/// #     serde::__serialize_unimplemented! {
 /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str bytes none some
 /// #         unit unit_struct unit_variant newtype_struct newtype_variant
 /// #         tuple tuple_struct tuple_variant map struct struct_variant
 /// #     }
 /// }
-/// #
-/// # fn main() {}
 /// ```
 ///
 /// [`Serializer`]: trait.Serializer.html

serde/src/ser/mod.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! Generic data structure serialization framework.
 //!
 //! The two most important traits in this module are [`Serialize`] and
@@ -24,8 +16,7 @@
 //!
 //! Additionally, Serde provides a procedural macro called [`serde_derive`] to
 //! automatically generate [`Serialize`] implementations for structs and enums
-//! in your program. See the [codegen section of the manual] for how to use
-//! this.
+//! in your program. See the [derive section of the manual] for how to use this.
 //!
 //! In rare cases it may be necessary to implement [`Serialize`] manually for
 //! some type in your program. See the [Implementing `Serialize`] section of the
@@ -65,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\>
@@ -92,6 +83,8 @@
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
+//!    - RangeInclusive\<T\>
+//!    - Bound\<T\>
 //!    - num::NonZero*
 //!    - `!` *(unstable)*
 //!  - **Net types**:
@@ -111,7 +104,7 @@
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
 //! [`serde_yaml`]: https://github.com/dtolnay/serde-yaml
-//! [codegen section of the manual]: https://serde.rs/codegen.html
+//! [derive section of the manual]: https://serde.rs/derive.html
 //! [data formats]: https://serde.rs/#data-formats
 
 use lib::*;
@@ -145,7 +138,7 @@ macro_rules! declare_error_trait {
             /// For example, a filesystem [`Path`] may refuse to serialize
             /// itself if it contains invalid UTF-8 data.
             ///
-            /// ```rust
+            /// ```edition2018
             /// # struct Path;
             /// #
             /// # impl Path {
@@ -195,7 +188,7 @@ declare_error_trait!(Error: Sized + Debug + Display);
 ///
 /// Additionally, Serde provides a procedural macro called [`serde_derive`] to
 /// automatically generate `Serialize` implementations for structs and enums in
-/// your program. See the [codegen section of the manual] for how to use this.
+/// your program. See the [derive section of the manual] for how to use this.
 ///
 /// In rare cases it may be necessary to implement `Serialize` manually for some
 /// type in your program. See the [Implementing `Serialize`] section of the
@@ -210,7 +203,7 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
 /// [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 /// [`serde_derive`]: https://crates.io/crates/serde_derive
-/// [codegen section of the manual]: https://serde.rs/codegen.html
+/// [derive section of the manual]: https://serde.rs/derive.html
 /// [ser]: https://docs.serde.rs/serde/ser/index.html
 pub trait Serialize {
     /// Serialize this value into the given Serde serializer.
@@ -218,8 +211,8 @@ pub trait Serialize {
     /// See the [Implementing `Serialize`] section of the manual for more
     /// information about how to implement this method.
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeStruct};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
     ///
     /// struct Person {
     ///     name: String,
@@ -273,16 +266,16 @@ pub trait Serialize {
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
 ///  - **byte array** - \[u8\]
-///    - Similar to strings, during deserialization byte arrays can be transient,
-///      owned, or borrowed.
+///    - Similar to strings, during deserialization byte arrays can be
+///      transient, owned, or borrowed.
 ///  - **option**
 ///    - Either none or some value.
 ///  - **unit**
-///    - The type of `()` in Rust. It represents an anonymous value containing no
-///      data.
+///    - The type of `()` in Rust. It represents an anonymous value containing
+///      no data.
 ///  - **unit_struct**
-///    - For example `struct Unit` or `PhantomData<T>`. It represents a named value
-///      containing no data.
+///    - For example `struct Unit` or `PhantomData<T>`. It represents a named
+///      value containing no data.
 ///  - **unit_variant**
 ///    - For example the `E::A` and `E::B` in `enum E { A, B }`.
 ///  - **newtype_struct**
@@ -290,14 +283,15 @@ pub trait Serialize {
 ///  - **newtype_variant**
 ///    - For example the `E::N` in `enum E { N(u8) }`.
 ///  - **seq**
-///    - A variably sized heterogeneous sequence of values, for example `Vec<T>` or
-///      `HashSet<T>`. When serializing, the length may or may not be known before
-///      iterating through all the data. When deserializing, the length is determined
-///      by looking at the serialized data.
+///    - A variably sized heterogeneous sequence of values, for example
+///      `Vec<T>` or `HashSet<T>`. When serializing, the length may or may not
+///      be known before iterating through all the data. When deserializing,
+///      the length is determined by looking at the serialized data.
 ///  - **tuple**
-///    - A statically sized heterogeneous sequence of values for which the length
-///      will be known at deserialization time without looking at the serialized
-///      data, for example `(u8,)` or `(String, u64, Vec<T>)` or `[u64; 10]`.
+///    - A statically sized heterogeneous sequence of values for which the
+///      length will be known at deserialization time without looking at the
+///      serialized data, for example `(u8,)` or `(String, u64, Vec<T>)` or
+///      `[u64; 10]`.
 ///  - **tuple_struct**
 ///    - A named tuple, for example `struct Rgb(u8, u8, u8)`.
 ///  - **tuple_variant**
@@ -305,9 +299,9 @@ pub trait Serialize {
 ///  - **map**
 ///    - A heterogeneous key-value pairing, for example `BTreeMap<K, V>`.
 ///  - **struct**
-///    - A heterogeneous key-value pairing in which the keys are strings and will be
-///      known at deserialization time without looking at the serialized data, for
-///      example `struct S { r: u8, g: u8, b: u8 }`.
+///    - A heterogeneous key-value pairing in which the keys are strings and
+///      will be known at deserialization time without looking at the
+///      serialized data, for example `struct S { r: u8, g: u8, b: u8 }`.
 ///  - **struct_variant**
 ///    - For example the `E::S` in `enum E { S { r: u8, g: u8, b: u8 } }`.
 ///
@@ -384,13 +378,10 @@ pub trait Serializer: Sized {
 
     /// Serialize a `bool` value.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for bool {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -400,8 +391,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_bool(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_bool(self, v: bool) -> Result<Self::Ok, Self::Error>;
 
@@ -411,13 +400,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `i64` and
     /// forward to `serialize_i64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for i8 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -427,8 +413,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_i8(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_i8(self, v: i8) -> Result<Self::Ok, Self::Error>;
 
@@ -438,13 +422,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `i64` and
     /// forward to `serialize_i64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for i16 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -454,8 +435,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_i16(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_i16(self, v: i16) -> Result<Self::Ok, Self::Error>;
 
@@ -465,13 +444,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `i64` and
     /// forward to `serialize_i64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for i32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -481,20 +457,15 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_i32(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_i32(self, v: i32) -> Result<Self::Ok, Self::Error>;
 
     /// Serialize an `i64` value.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for i64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -504,21 +475,16 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_i64(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
 
     serde_if_integer128! {
         /// Serialize an `i128` value.
         ///
-        /// ```rust
-        /// # #[macro_use]
-        /// # extern crate serde;
-        /// #
+        /// ```edition2018
         /// # use serde::Serializer;
         /// #
-        /// # __private_serialize!();
+        /// # serde::__private_serialize!();
         /// #
         /// impl Serialize for i128 {
         ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -528,8 +494,6 @@ pub trait Serializer: Sized {
         ///         serializer.serialize_i128(*self)
         ///     }
         /// }
-        /// #
-        /// # fn main() {}
         /// ```
         ///
         /// This method is available only on Rust compiler versions >=1.26. The
@@ -546,13 +510,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `u64` and
     /// forward to `serialize_u64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for u8 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -562,8 +523,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_u8(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_u8(self, v: u8) -> Result<Self::Ok, Self::Error>;
 
@@ -573,13 +532,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `u64` and
     /// forward to `serialize_u64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for u16 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -589,8 +545,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_u16(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_u16(self, v: u16) -> Result<Self::Ok, Self::Error>;
 
@@ -600,13 +554,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `u64` and
     /// forward to `serialize_u64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for u32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -616,20 +567,15 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_u32(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_u32(self, v: u32) -> Result<Self::Ok, Self::Error>;
 
     /// Serialize a `u64` value.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for u64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -639,21 +585,16 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_u64(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
 
     serde_if_integer128! {
         /// Serialize a `u128` value.
         ///
-        /// ```rust
-        /// # #[macro_use]
-        /// # extern crate serde;
-        /// #
+        /// ```edition2018
         /// # use serde::Serializer;
         /// #
-        /// # __private_serialize!();
+        /// # serde::__private_serialize!();
         /// #
         /// impl Serialize for u128 {
         ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -663,8 +604,6 @@ pub trait Serializer: Sized {
         ///         serializer.serialize_u128(*self)
         ///     }
         /// }
-        /// #
-        /// # fn main() {}
         /// ```
         ///
         /// This method is available only on Rust compiler versions >=1.26. The
@@ -681,13 +620,10 @@ pub trait Serializer: Sized {
     /// reasonable implementation would be to cast the value to `f64` and
     /// forward to `serialize_f64`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for f32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -697,20 +633,15 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_f32(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_f32(self, v: f32) -> Result<Self::Ok, Self::Error>;
 
     /// Serialize an `f64` value.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for f64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -720,8 +651,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_f64(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_f64(self, v: f64) -> Result<Self::Ok, Self::Error>;
 
@@ -730,13 +659,10 @@ pub trait Serializer: Sized {
     /// If the format does not support characters, it is reasonable to serialize
     /// it as a single element `str` or a `u32`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for char {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -746,20 +672,15 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_char(*self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_char(self, v: char) -> Result<Self::Ok, Self::Error>;
 
     /// Serialize a `&str`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for str {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -769,8 +690,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_str(self)
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_str(self, v: &str) -> Result<Self::Ok, Self::Error>;
 
@@ -782,10 +701,7 @@ pub trait Serializer: Sized {
     /// `serialize_seq`. If forwarded, the implementation looks usually just
     /// like this:
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::ser::{Serializer, SerializeSeq};
     /// # use serde::private::ser::Error;
     /// #
@@ -803,22 +719,18 @@ pub trait Serializer: Sized {
     ///     seq.end()
     /// }
     /// #
-    /// #     __serialize_unimplemented! {
+    /// #     serde::__serialize_unimplemented! {
     /// #         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str none some
     /// #         unit unit_struct unit_variant newtype_struct newtype_variant
     /// #         seq tuple tuple_struct tuple_variant map struct struct_variant
     /// #     }
     /// # }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_bytes(self, v: &[u8]) -> Result<Self::Ok, Self::Error>;
 
     /// Serialize a [`None`] value.
     ///
-    /// ```rust
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::{Serialize, Serializer};
     /// #
     /// # enum Option<T> {
@@ -826,7 +738,7 @@ pub trait Serializer: Sized {
     /// #     None,
     /// # }
     /// #
-    /// # use Option::{Some, None};
+    /// # use self::Option::{Some, None};
     /// #
     /// impl<T> Serialize for Option<T>
     /// where
@@ -851,9 +763,7 @@ pub trait Serializer: Sized {
 
     /// Serialize a [`Some(T)`] value.
     ///
-    /// ```rust
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::{Serialize, Serializer};
     /// #
     /// # enum Option<T> {
@@ -861,7 +771,7 @@ pub trait Serializer: Sized {
     /// #     None,
     /// # }
     /// #
-    /// # use Option::{Some, None};
+    /// # use self::Option::{Some, None};
     /// #
     /// impl<T> Serialize for Option<T>
     /// where
@@ -888,13 +798,10 @@ pub trait Serializer: Sized {
 
     /// Serialize a `()` value.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde;
-    /// #
+    /// ```edition2018
     /// # use serde::Serializer;
     /// #
-    /// # __private_serialize!();
+    /// # serde::__private_serialize!();
     /// #
     /// impl Serialize for () {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -904,8 +811,6 @@ pub trait Serializer: Sized {
     ///         serializer.serialize_unit()
     ///     }
     /// }
-    /// #
-    /// # fn main() {}
     /// ```
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error>;
 
@@ -913,7 +818,7 @@ pub trait Serializer: Sized {
     ///
     /// A reasonable implementation would be to forward to `serialize_unit`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
     ///
     /// struct Nothing;
@@ -935,7 +840,7 @@ pub trait Serializer: Sized {
     /// this variant within the enum, and the `variant` is the name of the
     /// variant.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
     ///
     /// enum E {
@@ -968,7 +873,7 @@ pub trait Serializer: Sized {
     /// wrappers around the data they contain. A reasonable implementation would
     /// be to forward to `value.serialize(self)`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
     ///
     /// struct Millimeters(u8);
@@ -996,7 +901,7 @@ pub trait Serializer: Sized {
     /// this variant within the enum, and the `variant` is the name of the
     /// variant. The `value` is the data contained within this newtype variant.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
     ///
     /// enum E {
@@ -1034,7 +939,7 @@ pub trait Serializer: Sized {
     /// not be computable before the sequence is iterated. Some serializers only
     /// support sequences whose length is known up front.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use std::marker::PhantomData;
     /// #
     /// # struct Vec<T>(PhantomData<T>);
@@ -1079,7 +984,7 @@ pub trait Serializer: Sized {
     /// This call must be followed by zero or more calls to `serialize_element`,
     /// then a call to `end`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::ser::{Serialize, Serializer, SerializeTuple};
     ///
     /// # mod fool {
@@ -1109,8 +1014,8 @@ pub trait Serializer: Sized {
     /// }
     /// ```
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeTuple};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeTuple, Serializer};
     ///
     /// const VRAM_SIZE: usize = 386;
     /// struct Vram([u16; VRAM_SIZE]);
@@ -1137,8 +1042,8 @@ pub trait Serializer: Sized {
     /// The `name` is the name of the tuple struct and the `len` is the number
     /// of data fields that will be serialized.
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeTupleStruct};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
     ///
     /// struct Rgb(u8, u8, u8);
     ///
@@ -1169,8 +1074,8 @@ pub trait Serializer: Sized {
     /// this variant within the enum, the `variant` is the name of the variant,
     /// and the `len` is the number of data fields that will be serialized.
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeTupleVariant};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
     ///
     /// enum E {
     ///     T(u8, u8),
@@ -1215,7 +1120,7 @@ pub trait Serializer: Sized {
     /// be computable before the map is iterated. Some serializers only support
     /// maps whose length is known up front.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use std::marker::PhantomData;
     /// #
     /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
@@ -1263,8 +1168,8 @@ pub trait Serializer: Sized {
     /// The `name` is the name of the struct and the `len` is the number of
     /// data fields that will be serialized.
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeStruct};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeStruct, Serializer};
     ///
     /// struct Rgb {
     ///     r: u8,
@@ -1299,11 +1204,11 @@ pub trait Serializer: Sized {
     /// this variant within the enum, the `variant` is the name of the variant,
     /// and the `len` is the number of data fields that will be serialized.
     ///
-    /// ```rust
-    /// use serde::ser::{Serialize, Serializer, SerializeStructVariant};
+    /// ```edition2018
+    /// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
     ///
     /// enum E {
-    ///     S { r: u8, g: u8, b: u8 }
+    ///     S { r: u8, g: u8, b: u8 },
     /// }
     ///
     /// impl Serialize for E {
@@ -1312,7 +1217,11 @@ pub trait Serializer: Sized {
     ///         S: Serializer,
     ///     {
     ///         match *self {
-    ///             E::S { ref r, ref g, ref b } => {
+    ///             E::S {
+    ///                 ref r,
+    ///                 ref g,
+    ///                 ref b,
+    ///             } => {
     ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
     ///                 sv.serialize_field("r", r)?;
     ///                 sv.serialize_field("g", g)?;
@@ -1337,7 +1246,7 @@ pub trait Serializer: Sized {
     /// using [`serialize_seq`]. Implementors should not need to override this
     /// method.
     ///
-    /// ```rust
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
     ///
     /// struct SecretlyOneHigher {
@@ -1374,9 +1283,9 @@ pub trait Serializer: Sized {
     /// using [`serialize_map`]. Implementors should not need to override this
     /// method.
     ///
-    /// ```rust
-    /// use std::collections::BTreeSet;
+    /// ```edition2018
     /// use serde::{Serialize, Serializer};
+    /// use std::collections::BTreeSet;
     ///
     /// struct MapToUnit {
     ///     keys: BTreeSet<i32>,
@@ -1414,7 +1323,7 @@ pub trait Serializer: Sized {
     /// delegates to [`serialize_str`]. Serializers are encouraged to provide a
     /// more efficient implementation if possible.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # struct DateTime;
     /// #
     /// # impl DateTime {
@@ -1455,7 +1364,7 @@ pub trait Serializer: Sized {
     /// of this method. If no more sensible behavior is possible, the
     /// implementation is expected to return an error.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # struct DateTime;
     /// #
     /// # impl DateTime {
@@ -1490,7 +1399,7 @@ pub trait Serializer: Sized {
     /// human-readable one and binary formats like Bincode will prefer the
     /// compact one.
     ///
-    /// ```
+    /// ```edition2018
     /// # use std::fmt::{self, Display};
     /// #
     /// # struct Timestamp;
@@ -1539,7 +1448,7 @@ pub trait Serializer: Sized {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct Vec<T>(PhantomData<T>);
@@ -1603,7 +1512,7 @@ pub trait SerializeSeq {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// use serde::ser::{Serialize, Serializer, SerializeTuple};
 ///
 /// # mod fool {
@@ -1633,7 +1542,7 @@ pub trait SerializeSeq {
 /// }
 /// ```
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct Array<T>(PhantomData<T>);
@@ -1703,8 +1612,8 @@ pub trait SerializeTuple {
 ///
 /// # Example use
 ///
-/// ```rust
-/// use serde::ser::{Serialize, Serializer, SerializeTupleStruct};
+/// ```edition2018
+/// use serde::ser::{Serialize, SerializeTupleStruct, Serializer};
 ///
 /// struct Rgb(u8, u8, u8);
 ///
@@ -1748,8 +1657,8 @@ pub trait SerializeTupleStruct {
 ///
 /// # Example use
 ///
-/// ```rust
-/// use serde::ser::{Serialize, Serializer, SerializeTupleVariant};
+/// ```edition2018
+/// use serde::ser::{Serialize, SerializeTupleVariant, Serializer};
 ///
 /// enum E {
 ///     T(u8, u8),
@@ -1806,7 +1715,7 @@ pub trait SerializeTupleVariant {
 ///
 /// # Example use
 ///
-/// ```rust
+/// ```edition2018
 /// # use std::marker::PhantomData;
 /// #
 /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
@@ -1917,8 +1826,8 @@ pub trait SerializeMap {
 ///
 /// # Example use
 ///
-/// ```rust
-/// use serde::ser::{Serialize, Serializer, SerializeStruct};
+/// ```edition2018
+/// use serde::ser::{Serialize, SerializeStruct, Serializer};
 ///
 /// struct Rgb {
 ///     r: u8,
@@ -1977,11 +1886,11 @@ pub trait SerializeStruct {
 ///
 /// # Example use
 ///
-/// ```rust
-/// use serde::ser::{Serialize, Serializer, SerializeStructVariant};
+/// ```edition2018
+/// use serde::ser::{Serialize, SerializeStructVariant, Serializer};
 ///
 /// enum E {
-///     S { r: u8, g: u8, b: u8 }
+///     S { r: u8, g: u8, b: u8 },
 /// }
 ///
 /// impl Serialize for E {
@@ -1990,7 +1899,11 @@ pub trait SerializeStruct {
 ///         S: Serializer,
 ///     {
 ///         match *self {
-///             E::S { ref r, ref g, ref b } => {
+///             E::S {
+///                 ref r,
+///                 ref g,
+///                 ref b,
+///             } => {
 ///                 let mut sv = serializer.serialize_struct_variant("E", 0, "S", 3)?;
 ///                 sv.serialize_field("r", r)?;
 ///                 sv.serialize_field("g", g)?;

serde_derive/Cargo.toml

@@ -1,18 +1,19 @@
 [package]
 name = "serde_derive"
-version = "1.0.69" # remember to update html_root_url
+version = "1.0.92" # 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"
-documentation = "https://serde.rs/codegen.html"
+documentation = "https://serde.rs/derive.html"
 keywords = ["serde", "serialization", "no_std"]
 readme = "crates-io.md"
 include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
+appveyor = { repository = "serde-rs/serde" }
 
 [features]
 default = []
@@ -24,8 +25,8 @@ proc-macro = true
 
 [dependencies]
 proc-macro2 = "0.4"
-quote = "0.6"
-syn = { version = "0.14", features = ["visit"] }
+quote = "0.6.3"
+syn = { version = "0.15.22", features = ["visit"] }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/src/bound.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use std::collections::HashSet;
 
 use syn;
@@ -46,7 +38,7 @@ pub fn with_where_predicates(
     generics
         .make_where_clause()
         .predicates
-        .extend(predicates.into_iter().cloned());
+        .extend(predicates.iter().cloned());
     generics
 }
 
@@ -91,7 +83,8 @@ pub fn with_where_predicates_from_variants(
 // Puts the given bound on any generic type parameters that are used in fields
 // for which filter returns true.
 //
-// For example, the following struct needs the bound `A: Serialize, B: Serialize`.
+// For example, the following struct needs the bound `A: Serialize, B:
+// Serialize`.
 //
 //     struct S<'b, A, B: 'b, C> {
 //         a: A,
@@ -168,15 +161,17 @@ pub fn with_bound(
         associated_type_usage: Vec::new(),
     };
     match cont.data {
-        Data::Enum(ref variants) => for variant in variants.iter() {
-            let relevant_fields = variant
-                .fields
-                .iter()
-                .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
-            for field in relevant_fields {
-                visitor.visit_field(field.original);
+        Data::Enum(ref variants) => {
+            for variant in variants.iter() {
+                let relevant_fields = variant
+                    .fields
+                    .iter()
+                    .filter(|field| filter(&field.attrs, Some(&variant.attrs)));
+                for field in relevant_fields {
+                    visitor.visit_field(field.original);
+                }
             }
-        },
+        }
         Data::Struct(_, ref fields) => {
             for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
                 visitor.visit_field(field.original);
@@ -207,8 +202,9 @@ pub fn with_bound(
                     modifier: syn::TraitBoundModifier::None,
                     lifetimes: None,
                     path: bound.clone(),
-                })].into_iter()
-                    .collect(),
+                })]
+                .into_iter()
+                .collect(),
             })
         });
 
@@ -240,8 +236,9 @@ pub fn with_self_bound(
                 modifier: syn::TraitBoundModifier::None,
                 lifetimes: None,
                 path: bound.clone(),
-            })].into_iter()
-                .collect(),
+            })]
+            .into_iter()
+            .collect(),
         }));
     generics
 }
@@ -312,8 +309,9 @@ fn type_of_item(cont: &Container) -> syn::Type {
                         gt_token: <Token![>]>::default(),
                     },
                 ),
-            }].into_iter()
-                .collect(),
+            }]
+            .into_iter()
+            .collect(),
         },
     })
 }

serde_derive/src/de.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use proc_macro2::{Literal, Span, TokenStream};
 use quote::ToTokens;
 use syn::punctuated::Punctuated;
@@ -13,38 +5,38 @@ use syn::spanned::Spanned;
 use syn::{self, Ident, Index, Member};
 
 use bound;
+use dummy;
 use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, Ctxt, Derive};
 use pretend;
-use try;
 
 use std::collections::BTreeSet;
 
-pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, String> {
+pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
     let ctxt = Ctxt::new();
-    let cont = Container::from_ast(&ctxt, input, Derive::Deserialize);
+    let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
+        Some(cont) => cont,
+        None => return Err(ctxt.check().unwrap_err()),
+    };
     precondition(&ctxt, &cont);
     try!(ctxt.check());
 
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (de_impl_generics, _, ty_generics, where_clause) = split_with_de_lifetime(&params);
-    let dummy_const = Ident::new(
-        &format!("_IMPL_DESERIALIZE_FOR_{}", ident),
-        Span::call_site(),
-    );
     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
@@ -56,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
                 }
@@ -69,19 +61,12 @@ pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream
         }
     };
 
-    let try_replacement = try::replacement();
-    let generated = quote! {
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
-            #[allow(unknown_lints)]
-            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
-            #[allow(rust_2018_idioms)]
-            extern crate serde as _serde;
-            #try_replacement
-            #impl_block
-        };
-    };
-    Ok(generated)
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "DESERIALIZE",
+        ident,
+        impl_block,
+    ))
 }
 
 fn precondition(cx: &Ctxt, cont: &Container) {
@@ -93,7 +78,10 @@ fn precondition_sized(cx: &Ctxt, cont: &Container) {
     if let Data::Struct(_, ref fields) = cont.data {
         if let Some(last) = fields.last() {
             if let syn::Type::Slice(_) = *last.ty {
-                cx.error("cannot deserialize a dynamically sized struct");
+                cx.error_spanned_by(
+                    cont.original,
+                    "cannot deserialize a dynamically sized struct",
+                );
             }
         }
     }
@@ -103,7 +91,10 @@ fn precondition_no_de_lifetime(cx: &Ctxt, cont: &Container) {
     if let BorrowedLifetimes::Borrowed(_) = borrowed_lifetimes(cont) {
         for param in cont.generics.lifetimes() {
             if param.lifetime.to_string() == "'de" {
-                cx.error("cannot deserialize when there is a lifetime parameter called 'de");
+                cx.error_spanned_by(
+                    &param.lifetime,
+                    "cannot deserialize when there is a lifetime parameter called 'de",
+                );
                 return;
             }
         }
@@ -204,7 +195,9 @@ fn build_generics(cont: &Container, borrowed: &BorrowedLifetimes) -> syn::Generi
 // All other fields may need a `T: Deserialize` bound where T is the type of the
 // field.
 fn needs_deserialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_deserializing() && field.deserialize_with().is_none() && field.de_bound().is_none()
+    !field.skip_deserializing()
+        && field.deserialize_with().is_none()
+        && field.de_bound().is_none()
         && variant.map_or(true, |variant| {
             !variant.skip_deserializing()
                 && variant.deserialize_with().is_none()
@@ -362,7 +355,10 @@ fn deserialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
 
     let path = match transparent_field.attrs.deserialize_with() {
         Some(path) => quote!(#path),
-        None => quote!(_serde::Deserialize::deserialize),
+        None => {
+            let span = transparent_field.original.span();
+            quote_spanned!(span=> _serde::Deserialize::deserialize)
+        }
     };
 
     let assign = fields.iter().map(|field| {
@@ -657,11 +653,18 @@ fn deserialize_seq(
                     })
                 }
             };
+            let value_if_none = match *field.attrs.default() {
+                attr::Default::Default => quote!(_serde::export::Default::default()),
+                attr::Default::Path(ref path) => quote!(#path()),
+                attr::Default::None => quote!(
+                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                ),
+            };
             let assign = quote! {
                 let #var = match #visit {
                     _serde::export::Some(__value) => __value,
                     _serde::export::None => {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                        #value_if_none
                     }
                 };
             };
@@ -736,8 +739,16 @@ fn deserialize_seq_in_place(
                 self.place.#member = #default;
             }
         } else {
-            let return_invalid_length = quote! {
-                return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+            let value_if_none = match *field.attrs.default() {
+                attr::Default::Default => quote!(
+                    self.place.#member = _serde::export::Default::default();
+                ),
+                attr::Default::Path(ref path) => quote!(
+                    self.place.#member = #path();
+                ),
+                attr::Default::None => quote!(
+                    return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+                ),
             };
             let write = match field.attrs.deserialize_with() {
                 None => {
@@ -745,23 +756,23 @@ fn deserialize_seq_in_place(
                         if let _serde::export::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
                             _serde::private::de::InPlaceSeed(&mut self.place.#member)))
                         {
-                            #return_invalid_length
+                            #value_if_none
                         }
                     }
                 }
                 Some(path) => {
                     let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
                     quote!({
-                            #wrapper
-                            match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
-                                _serde::export::Some(__wrap) => {
-                                    self.place.#member = __wrap.value;
-                                }
-                                _serde::export::None => {
-                                    #return_invalid_length
-                                }
+                        #wrapper
+                        match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
+                            _serde::export::Some(__wrap) => {
+                                self.place.#member = __wrap.value;
                             }
-                        })
+                            _serde::export::None => {
+                                #value_if_none
+                            }
+                        }
+                    })
                 }
             };
             index_in_seq += 1;
@@ -802,8 +813,10 @@ fn deserialize_newtype_struct(
 
     let value = match field.attrs.deserialize_with() {
         None => {
+            let span = field.original.span();
+            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote! {
-                try!(<#field_ty as _serde::Deserialize>::deserialize(__e))
+                try!(#func(__e))
             }
         }
         Some(path) => {
@@ -835,7 +848,8 @@ fn deserialize_newtype_struct(
 
 #[cfg(feature = "deserialize_in_place")]
 fn deserialize_newtype_struct_in_place(params: &Parameters, field: &Field) -> TokenStream {
-    // We do not generate deserialize_in_place if every field has a deserialize_with.
+    // We do not generate deserialize_in_place if every field has a
+    // deserialize_with.
     assert!(field.attrs.deserialize_with().is_none());
 
     let delife = params.borrowed.de_lifetime();
@@ -939,8 +953,8 @@ fn deserialize_struct(
         quote!(mut __seq)
     };
 
-    // untagged struct variants do not get a visit_seq method.  The same applies to structs that
-    // only have a map representation.
+    // untagged struct variants do not get a visit_seq method. The same applies to
+    // structs that only have a map representation.
     let visit_seq = match *untagged {
         Untagged::No if !cattrs.has_flatten() => Some(quote! {
             #[inline]
@@ -1120,18 +1134,56 @@ fn deserialize_enum(
     cattrs: &attr::Container,
 ) -> Fragment {
     match *cattrs.tag() {
-        attr::EnumTag::External => deserialize_externally_tagged_enum(params, variants, cattrs),
-        attr::EnumTag::Internal { ref tag } => {
+        attr::TagType::External => deserialize_externally_tagged_enum(params, variants, cattrs),
+        attr::TagType::Internal { ref tag } => {
             deserialize_internally_tagged_enum(params, variants, cattrs, tag)
         }
-        attr::EnumTag::Adjacent {
+        attr::TagType::Adjacent {
             ref tag,
             ref content,
         } => deserialize_adjacently_tagged_enum(params, variants, cattrs, tag, content),
-        attr::EnumTag::None => deserialize_untagged_enum(params, variants, cattrs),
+        attr::TagType::None => deserialize_untagged_enum(params, variants, cattrs),
     }
 }
 
+fn prepare_enum_variant_enum(
+    variants: &[Variant],
+    cattrs: &attr::Container,
+) -> (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),
+                variant.attrs.aliases(),
+            )
+        })
+        .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,
+    ));
+
+    (variants_stmt, variant_visitor)
+}
+
 fn deserialize_externally_tagged_enum(
     params: &Parameters,
     variants: &[Variant],
@@ -1143,28 +1195,9 @@ fn deserialize_externally_tagged_enum(
     let delife = params.borrowed.de_lifetime();
 
     let type_name = cattrs.name().deserialize_name();
-
     let expecting = format!("enum {}", params.type_name());
 
-    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 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,
-    ));
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
     // Match arms to extract a variant from a string
     let variant_arms = variants
@@ -1230,11 +1263,15 @@ fn deserialize_externally_tagged_enum(
 
         #variants_stmt
 
-        _serde::Deserializer::deserialize_enum(__deserializer, #type_name, VARIANTS,
-                                               __Visitor {
-                                                   marker: _serde::export::PhantomData::<#this #ty_generics>,
-                                                   lifetime: _serde::export::PhantomData,
-                                               })
+        _serde::Deserializer::deserialize_enum(
+            __deserializer,
+            #type_name,
+            VARIANTS,
+            __Visitor {
+                marker: _serde::export::PhantomData::<#this #ty_generics>,
+                lifetime: _serde::export::PhantomData,
+            },
+        )
     }
 }
 
@@ -1244,25 +1281,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 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,
-    ));
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
     // Match arms to extract a variant from a string
     let variant_arms = variants
@@ -1313,25 +1332,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 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,
-    ));
+    let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
 
     let variant_arms: &Vec<_> = &variants
         .iter()
@@ -1575,12 +1576,14 @@ fn deserialize_adjacently_tagged_enum(
                 match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
                     _serde::export::Some(__field) => {
                         // Visit the second element - the content.
-                        match try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
-                                __Seed {
-                                    field: __field,
-                                    marker: _serde::export::PhantomData,
-                                    lifetime: _serde::export::PhantomData,
-                                })) {
+                        match try!(_serde::de::SeqAccess::next_element_seed(
+                            &mut __seq,
+                            __Seed {
+                                field: __field,
+                                marker: _serde::export::PhantomData,
+                                lifetime: _serde::export::PhantomData,
+                            },
+                        )) {
                             _serde::export::Some(__ret) => _serde::export::Ok(__ret),
                             // There is no second element.
                             _serde::export::None => {
@@ -1597,11 +1600,15 @@ fn deserialize_adjacently_tagged_enum(
         }
 
         const FIELDS: &'static [&'static str] = &[#tag, #content];
-        _serde::Deserializer::deserialize_struct(__deserializer, #type_name, FIELDS,
+        _serde::Deserializer::deserialize_struct(
+            __deserializer,
+            #type_name,
+            FIELDS,
             __Visitor {
                 marker: _serde::export::PhantomData::<#this #ty_generics>,
                 lifetime: _serde::export::PhantomData,
-            })
+            },
+        )
     }
 }
 
@@ -1792,10 +1799,11 @@ fn deserialize_externally_tagged_newtype_variant(
     match field.attrs.deserialize_with() {
         None => {
             let field_ty = field.ty;
+            let span = field.original.span();
+            let func =
+                quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
             quote_expr! {
-                _serde::export::Result::map(
-                    _serde::de::VariantAccess::newtype_variant::<#field_ty>(__variant),
-                    #this::#variant_ident)
+                _serde::export::Result::map(#func(__variant), #this::#variant_ident)
             }
         }
         Some(path) => {
@@ -1820,10 +1828,10 @@ fn deserialize_untagged_newtype_variant(
     let field_ty = field.ty;
     match field.attrs.deserialize_with() {
         None => {
+            let span = field.original.span();
+            let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote_expr! {
-                _serde::export::Result::map(
-                    <#field_ty as _serde::Deserialize>::deserialize(#deserializer),
-                    #this::#variant_ident)
+                _serde::export::Result::map(#func(#deserializer), #this::#variant_ident)
             }
         }
         Some(path) => {
@@ -1836,17 +1844,22 @@ 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>),);
         let fallthrough = quote!(_serde::export::Ok(__Field::__other(__value)));
         (Some(ignore_variant), Some(fallthrough))
+    } else if let Some(other_idx) = other_idx {
+        let ignore_variant = fields[other_idx].1.clone();
+        let fallthrough = quote!(_serde::export::Ok(__Field::#ignore_variant));
+        (None, Some(fallthrough))
     } else if is_variant || cattrs.deny_unknown_fields() {
         (None, None)
     } else {
@@ -1938,11 +1951,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
@@ -1993,24 +2007,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"
@@ -2036,7 +2059,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);
@@ -2198,11 +2221,12 @@ 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),
-                                &#fallthrough_msg))
+                        _serde::de::Unexpected::Unsigned(__value),
+                        &#fallthrough_msg,
+                    ))
                 }
             }
         }
@@ -2260,17 +2284,23 @@ 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),* ];
         }
     };
 
-    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false);
+    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
 
     let visit_map = deserialize_map(struct_path, params, fields, cattrs);
 
@@ -2287,10 +2317,16 @@ 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);
+    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
 
     let visit_map = deserialize_map(struct_path, params, fields, cattrs);
 
@@ -2354,7 +2390,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);
+                            }
+                        }
                     })
                 }
             };
@@ -2421,11 +2462,14 @@ 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() {
-                None => quote!(_serde::de::Deserialize::deserialize),
+                None => {
+                    let span = field.original.span();
+                    quote_spanned!(span=> _serde::de::Deserialize::deserialize)
+                }
                 Some(path) => quote!(#path),
             };
             quote! {
@@ -2438,7 +2482,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)));
@@ -2515,17 +2561,23 @@ 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),* ];
         }
     };
 
-    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false);
+    let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
 
     let visit_map = deserialize_map_in_place(params, fields, cattrs);
 
@@ -2547,7 +2599,8 @@ fn deserialize_map_in_place(
         .map(|(i, field)| (field, field_i(i)))
         .collect();
 
-    // For deserialize_in_place, declare booleans for each field that will be deserialized.
+    // For deserialize_in_place, declare booleans for each field that will be
+    // deserialized.
     let let_flags = fields_names
         .iter()
         .filter(|&&(field, _)| !field.attrs.skip_deserializing())
@@ -2575,7 +2628,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);
+                            }
+                        };
                     })
                 }
             };
@@ -2776,7 +2834,9 @@ fn wrap_deserialize_variant_with(
 fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
     match *field.attrs.default() {
         attr::Default::Default => {
-            return quote_expr!(_serde::export::Default::default());
+            let span = field.original.span();
+            let func = quote_spanned!(span=> _serde::export::Default::default);
+            return quote_expr!(#func());
         }
         attr::Default::Path(ref path) => {
             return quote_expr!(#path());

serde_derive/src/dummy.rs

@@ -0,0 +1,47 @@
+use proc_macro2::{Ident, Span, TokenStream};
+
+use syn;
+use try;
+
+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(
+        &format!("_IMPL_{}_FOR_{}", trait_, unraw(ty)),
+        Span::call_site(),
+    );
+
+    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
+        };
+    }
+}
+
+#[allow(deprecated)]
+fn unraw(ident: &Ident) -> String {
+    // str::trim_start_matches was added in 1.30, trim_left_matches deprecated
+    // in 1.33. We currently support rustc back to 1.15 so we need to continue
+    // to use the deprecated one.
+    ident.to_string().trim_left_matches("r#").to_owned()
+}

serde_derive/src/fragment.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use proc_macro2::TokenStream;
 use quote::ToTokens;
 use syn::token;

serde_derive/src/internals/ast.rs

@@ -1,10 +1,4 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
+//! A Serde ast, parsed from the Syn ast and ready to generate Rust code.
 
 use internals::attr;
 use internals::check;
@@ -12,25 +6,39 @@ use internals::{Ctxt, Derive};
 use syn;
 use syn::punctuated::Punctuated;
 
+/// A source data structure annotated with `#[derive(Serialize)]` and/or `#[derive(Deserialize)]`,
+/// parsed into an internal representation.
 pub struct Container<'a> {
+    /// The struct or enum name (without generics).
     pub ident: syn::Ident,
+    /// Attributes on the structure, parsed for Serde.
     pub attrs: attr::Container,
+    /// The contents of the struct or enum.
     pub data: Data<'a>,
+    /// Any generics on the struct or enum.
     pub generics: &'a syn::Generics,
+    /// Original input.
+    pub original: &'a syn::DeriveInput,
 }
 
+/// The fields of a struct or enum.
+///
+/// Analagous to `syn::Data`.
 pub enum Data<'a> {
     Enum(Vec<Variant<'a>>),
     Struct(Style, Vec<Field<'a>>),
 }
 
+/// A variant of an enum.
 pub struct Variant<'a> {
     pub ident: syn::Ident,
     pub attrs: attr::Variant,
     pub style: Style,
     pub fields: Vec<Field<'a>>,
+    pub original: &'a syn::Variant,
 }
 
+/// A field of a struct.
 pub struct Field<'a> {
     pub member: syn::Member,
     pub attrs: attr::Field,
@@ -40,14 +48,23 @@ pub struct Field<'a> {
 
 #[derive(Copy, Clone)]
 pub enum Style {
+    /// Named fields.
     Struct,
+    /// Many unnamed fields.
     Tuple,
+    /// One unnamed field.
     Newtype,
+    /// No fields.
     Unit,
 }
 
 impl<'a> Container<'a> {
-    pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput, derive: Derive) -> Container<'a> {
+    /// Convert the raw Syn ast into a parsed container object, collecting errors in `cx`.
+    pub fn from_ast(
+        cx: &Ctxt,
+        item: &'a syn::DeriveInput,
+        derive: Derive,
+    ) -> Option<Container<'a>> {
         let mut attrs = attr::Container::from_ast(cx, item);
 
         let mut data = match item.data {
@@ -59,27 +76,34 @@ impl<'a> Container<'a> {
                 Data::Struct(style, fields)
             }
             syn::Data::Union(_) => {
-                panic!("Serde does not support derive for unions");
+                cx.error_spanned_by(item, "Serde does not support derive for unions");
+                return None;
             }
         };
 
         let mut has_flatten = false;
         match data {
-            Data::Enum(ref mut variants) => for variant in variants {
-                variant.attrs.rename_by_rule(attrs.rename_all());
-                for field in &mut variant.fields {
+            Data::Enum(ref mut variants) => {
+                for variant in variants {
+                    variant.attrs.rename_by_rules(attrs.rename_all_rules());
+                    for field in &mut variant.fields {
+                        if field.attrs.flatten() {
+                            has_flatten = true;
+                        }
+                        field
+                            .attrs
+                            .rename_by_rules(variant.attrs.rename_all_rules());
+                    }
+                }
+            }
+            Data::Struct(_, ref mut fields) => {
+                for field in fields {
                     if field.attrs.flatten() {
                         has_flatten = true;
                     }
-                    field.attrs.rename_by_rule(variant.attrs.rename_all());
+                    field.attrs.rename_by_rules(attrs.rename_all_rules());
                 }
-            },
-            Data::Struct(_, ref mut fields) => for field in fields {
-                if field.attrs.flatten() {
-                    has_flatten = true;
-                }
-                field.attrs.rename_by_rule(attrs.rename_all());
-            },
+            }
         }
 
         if has_flatten {
@@ -91,9 +115,10 @@ impl<'a> Container<'a> {
             attrs: attrs,
             data: data,
             generics: &item.generics,
+            original: item,
         };
         check::check(cx, &mut item, derive);
-        item
+        Some(item)
     }
 }
 
@@ -128,6 +153,7 @@ fn enum_from_ast<'a>(
                 attrs: attrs,
                 style: style,
                 fields: fields,
+                original: variant,
             }
         })
         .collect()

serde_derive/src/internals/case.rs

@@ -1,10 +1,5 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
+//! Code to convert the Rust-styled field/variant (e.g. `my_field`, `MyType`) to the
+//! case of the source (e.g. `my-field`, `MY_FIELD`).
 
 // See https://users.rust-lang.org/t/psa-dealing-with-warning-unused-import-std-ascii-asciiext-in-today-s-nightly/13726
 #[allow(deprecated, unused_imports)]
@@ -14,7 +9,8 @@ use std::str::FromStr;
 
 use self::RenameRule::*;
 
-#[derive(PartialEq)]
+/// The different possible ways to change case of fields in a struct, or variants in an enum.
+#[derive(Copy, Clone, PartialEq)]
 pub enum RenameRule {
     /// Don't apply a default rename rule.
     None,
@@ -22,13 +18,16 @@ pub enum RenameRule {
     LowerCase,
     /// Rename direct children to "UPPERCASE" style.
     UPPERCASE,
-    /// Rename direct children to "PascalCase" style, as typically used for enum variants.
+    /// Rename direct children to "PascalCase" style, as typically used for
+    /// enum variants.
     PascalCase,
     /// Rename direct children to "camelCase" style.
     CamelCase,
-    /// Rename direct children to "snake_case" style, as commonly used for fields.
+    /// Rename direct children to "snake_case" style, as commonly used for
+    /// fields.
     SnakeCase,
-    /// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly used for constants.
+    /// Rename direct children to "SCREAMING_SNAKE_CASE" style, as commonly
+    /// used for constants.
     ScreamingSnakeCase,
     /// Rename direct children to "kebab-case" style.
     KebabCase,
@@ -37,6 +36,7 @@ pub enum RenameRule {
 }
 
 impl RenameRule {
+    /// Apply a renaming rule to an enum variant, returning the version expected in the source.
     pub fn apply_to_variant(&self, variant: &str) -> String {
         match *self {
             None | PascalCase => variant.to_owned(),
@@ -61,6 +61,7 @@ impl RenameRule {
         }
     }
 
+    /// Apply a renaming rule to a struct field, returning the version expected in the source.
     pub fn apply_to_field(&self, field: &str) -> String {
         match *self {
             None | LowerCase | SnakeCase => field.to_owned(),

serde_derive/src/internals/check.rs

@@ -1,13 +1,5 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use internals::ast::{Container, Data, Field, Style};
-use internals::attr::{EnumTag, Identifier};
+use internals::attr::{Identifier, TagType};
 use internals::{Ctxt, Derive};
 use syn::{Member, Type};
 
@@ -29,12 +21,16 @@ fn check_getter(cx: &Ctxt, cont: &Container) {
     match cont.data {
         Data::Enum(_) => {
             if cont.data.has_getter() {
-                cx.error("#[serde(getter = \"...\")] is not allowed in an enum");
+                cx.error_spanned_by(
+                    cont.original,
+                    "#[serde(getter = \"...\")] is not allowed in an enum",
+                );
             }
         }
         Data::Struct(_, _) => {
             if cont.data.has_getter() && cont.attrs.remote().is_none() {
-                cx.error(
+                cx.error_spanned_by(
+                    cont.original,
                     "#[serde(getter = \"...\")] can only be used in structs \
                      that have #[serde(remote = \"...\")]",
                 );
@@ -67,33 +63,23 @@ fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
     }
     match style {
         Style::Tuple => {
-            cx.error("#[serde(flatten)] cannot be used on tuple structs");
+            cx.error_spanned_by(
+                field.original,
+                "#[serde(flatten)] cannot be used on tuple structs",
+            );
         }
         Style::Newtype => {
-            cx.error("#[serde(flatten)] cannot be used on newtype structs");
+            cx.error_spanned_by(
+                field.original,
+                "#[serde(flatten)] cannot be used on newtype structs",
+            );
         }
         _ => {}
     }
-    if field.attrs.skip_serializing() {
-        cx.error(
-            "#[serde(flatten] can not be combined with \
-             #[serde(skip_serializing)]",
-        );
-    } else if field.attrs.skip_serializing_if().is_some() {
-        cx.error(
-            "#[serde(flatten] can not be combined with \
-             #[serde(skip_serializing_if = \"...\")]",
-        );
-    } else if field.attrs.skip_deserializing() {
-        cx.error(
-            "#[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
-/// variant of an enum that has the `field_identifier` attribute.
+/// variant of an enum.
 ///
 /// Inside a `variant_identifier` all variants must be unit variants. Inside a
 /// `field_identifier` all but possibly one variant must be unit variants. The
@@ -111,43 +97,70 @@ fn check_identifier(cx: &Ctxt, cont: &Container) {
             variant.style,
             cont.attrs.identifier(),
             variant.attrs.other(),
+            cont.attrs.tag(),
         ) {
-            // The `other` attribute may only be used in a field_identifier.
-            (_, Identifier::Variant, true) | (_, Identifier::No, true) => {
-                cx.error("#[serde(other)] may only be used inside a field_identifier");
+            // The `other` attribute may not be used in a variant_identifier.
+            (_, Identifier::Variant, true, _) => {
+                cx.error_spanned_by(
+                    variant.original,
+                    "#[serde(other)] may not be used on a variant identifier",
+                );
+            }
+
+            // Variant with `other` attribute cannot appear in untagged enum
+            (_, Identifier::No, true, &TagType::None) => {
+                cx.error_spanned_by(
+                    variant.original,
+                    "#[serde(other)] cannot appear on untagged enum",
+                );
             }
 
             // Variant with `other` attribute must be the last one.
-            (Style::Unit, Identifier::Field, true) => {
+            (Style::Unit, Identifier::Field, true, _) | (Style::Unit, Identifier::No, true, _) => {
                 if i < variants.len() - 1 {
-                    cx.error("#[serde(other)] must be the last variant");
+                    cx.error_spanned_by(
+                        variant.original,
+                        "#[serde(other)] must be on the last variant",
+                    );
                 }
             }
 
             // Variant with `other` attribute must be a unit variant.
-            (_, Identifier::Field, true) => {
-                cx.error("#[serde(other)] must be on a unit variant");
+            (_, Identifier::Field, true, _) | (_, Identifier::No, true, _) => {
+                cx.error_spanned_by(
+                    variant.original,
+                    "#[serde(other)] must be on a unit variant",
+                );
             }
 
             // Any sort of variant is allowed if this is not an identifier.
-            (_, Identifier::No, false) => {}
+            (_, Identifier::No, false, _) => {}
 
             // Unit variant without `other` attribute is always fine.
-            (Style::Unit, _, false) => {}
+            (Style::Unit, _, false, _) => {}
 
             // The last field is allowed to be a newtype catch-all.
-            (Style::Newtype, Identifier::Field, false) => {
+            (Style::Newtype, Identifier::Field, false, _) => {
                 if i < variants.len() - 1 {
-                    cx.error(format!("`{}` must be the last variant", variant.ident));
+                    cx.error_spanned_by(
+                        variant.original,
+                        format!("`{}` must be the last variant", variant.ident),
+                    );
                 }
             }
 
-            (_, Identifier::Field, false) => {
-                cx.error("field_identifier may only contain unit variants");
+            (_, Identifier::Field, false, _) => {
+                cx.error_spanned_by(
+                    variant.original,
+                    "#[serde(field_identifier)] may only contain unit variants",
+                );
             }
 
-            (_, Identifier::Variant, false) => {
-                cx.error("variant_identifier may only contain unit variants");
+            (_, Identifier::Variant, false, _) => {
+                cx.error_spanned_by(
+                    variant.original,
+                    "#[serde(variant_identifier)] may only contain unit variants",
+                );
             }
         }
     }
@@ -166,52 +179,67 @@ fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
     for variant in variants.iter() {
         if variant.attrs.serialize_with().is_some() {
             if variant.attrs.skip_serializing() {
-                cx.error(format!(
-                    "variant `{}` cannot have both #[serde(serialize_with)] and \
-                     #[serde(skip_serializing)]",
-                    variant.ident
-                ));
+                cx.error_spanned_by(
+                    variant.original,
+                    format!(
+                        "variant `{}` cannot have both #[serde(serialize_with)] and \
+                         #[serde(skip_serializing)]",
+                        variant.ident
+                    ),
+                );
             }
 
             for field in &variant.fields {
                 let member = member_message(&field.member);
 
                 if field.attrs.skip_serializing() {
-                    cx.error(format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and \
-                         a field {} marked with #[serde(skip_serializing)]",
-                        variant.ident, member
-                    ));
+                    cx.error_spanned_by(
+                        variant.original,
+                        format!(
+                            "variant `{}` cannot have both #[serde(serialize_with)] and \
+                             a field {} marked with #[serde(skip_serializing)]",
+                            variant.ident, member
+                        ),
+                    );
                 }
 
                 if field.attrs.skip_serializing_if().is_some() {
-                    cx.error(format!(
-                        "variant `{}` cannot have both #[serde(serialize_with)] and \
-                         a field {} marked with #[serde(skip_serializing_if)]",
-                        variant.ident, member
-                    ));
+                    cx.error_spanned_by(
+                        variant.original,
+                        format!(
+                            "variant `{}` cannot have both #[serde(serialize_with)] and \
+                             a field {} marked with #[serde(skip_serializing_if)]",
+                            variant.ident, member
+                        ),
+                    );
                 }
             }
         }
 
         if variant.attrs.deserialize_with().is_some() {
             if variant.attrs.skip_deserializing() {
-                cx.error(format!(
-                    "variant `{}` cannot have both #[serde(deserialize_with)] and \
-                     #[serde(skip_deserializing)]",
-                    variant.ident
-                ));
+                cx.error_spanned_by(
+                    variant.original,
+                    format!(
+                        "variant `{}` cannot have both #[serde(deserialize_with)] and \
+                         #[serde(skip_deserializing)]",
+                        variant.ident
+                    ),
+                );
             }
 
             for field in &variant.fields {
                 if field.attrs.skip_deserializing() {
                     let member = member_message(&field.member);
 
-                    cx.error(format!(
-                        "variant `{}` cannot have both #[serde(deserialize_with)] \
-                         and a field {} marked with #[serde(skip_deserializing)]",
-                        variant.ident, member
-                    ));
+                    cx.error_spanned_by(
+                        variant.original,
+                        format!(
+                            "variant `{}` cannot have both #[serde(deserialize_with)] \
+                             and a field {} marked with #[serde(skip_deserializing)]",
+                            variant.ident, member
+                        ),
+                    );
                 }
             }
         }
@@ -229,13 +257,15 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
     };
 
     let tag = match *cont.attrs.tag() {
-        EnumTag::Internal { ref tag } => tag.as_str(),
-        EnumTag::External | EnumTag::Adjacent { .. } | EnumTag::None => return,
+        TagType::Internal { ref tag } => tag.as_str(),
+        TagType::External | TagType::Adjacent { .. } | TagType::None => return,
     };
 
     let diagnose_conflict = || {
-        let message = format!("variant field name `{}` conflicts with internal tag", tag);
-        cx.error(message);
+        cx.error_spanned_by(
+            cont.original,
+            format!("variant field name `{}` conflicts with internal tag", tag),
+        )
     };
 
     for variant in variants {
@@ -246,12 +276,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 => {}
@@ -263,19 +299,21 @@ fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
 /// contents tag must differ, for the same reason.
 fn check_adjacent_tag_conflict(cx: &Ctxt, cont: &Container) {
     let (type_tag, content_tag) = match *cont.attrs.tag() {
-        EnumTag::Adjacent {
+        TagType::Adjacent {
             ref tag,
             ref content,
         } => (tag, content),
-        EnumTag::Internal { .. } | EnumTag::External | EnumTag::None => return,
+        TagType::Internal { .. } | TagType::External | TagType::None => return,
     };
 
     if type_tag == content_tag {
-        let message = format!(
-            "enum tags `{}` for type and content conflict with each other",
-            type_tag
+        cx.error_spanned_by(
+            cont.original,
+            format!(
+                "enum tags `{}` for type and content conflict with each other",
+                type_tag
+            ),
         );
-        cx.error(message);
     }
 }
 
@@ -286,20 +324,32 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     }
 
     if cont.attrs.type_from().is_some() {
-        cx.error("#[serde(transparent)] is not allowed with #[serde(from = \"...\")]");
+        cx.error_spanned_by(
+            cont.original,
+            "#[serde(transparent)] is not allowed with #[serde(from = \"...\")]",
+        );
     }
 
     if cont.attrs.type_into().is_some() {
-        cx.error("#[serde(transparent)] is not allowed with #[serde(into = \"...\")]");
+        cx.error_spanned_by(
+            cont.original,
+            "#[serde(transparent)] is not allowed with #[serde(into = \"...\")]",
+        );
     }
 
     let fields = match cont.data {
         Data::Enum(_) => {
-            cx.error("#[serde(transparent)] is not allowed on an enum");
+            cx.error_spanned_by(
+                cont.original,
+                "#[serde(transparent)] is not allowed on an enum",
+            );
             return;
         }
         Data::Struct(Style::Unit, _) => {
-            cx.error("#[serde(transparent)] is not allowed on a unit struct");
+            cx.error_spanned_by(
+                cont.original,
+                "#[serde(transparent)] is not allowed on a unit struct",
+            );
             return;
         }
         Data::Struct(_, ref mut fields) => fields,
@@ -310,7 +360,8 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
     for field in fields {
         if allow_transparent(field, derive) {
             if transparent_field.is_some() {
-                cx.error(
+                cx.error_spanned_by(
+                    cont.original,
                     "#[serde(transparent)] requires struct to have at most one transparent field",
                 );
                 return;
@@ -323,10 +374,16 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
         Some(transparent_field) => transparent_field.attrs.mark_transparent(),
         None => match derive {
             Derive::Serialize => {
-                cx.error("#[serde(transparent)] requires at least one field that is not skipped");
+                cx.error_spanned_by(
+                    cont.original,
+                    "#[serde(transparent)] requires at least one field that is not skipped",
+                );
             }
             Derive::Deserialize => {
-                cx.error("#[serde(transparent)] requires at least one field that is neither skipped nor has a default");
+                cx.error_spanned_by(
+                    cont.original,
+                    "#[serde(transparent)] requires at least one field that is neither skipped nor has a default",
+                );
             }
         },
     }
@@ -335,7 +392,7 @@ fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
 fn member_message(member: &Member) -> String {
     match *member {
         Member::Named(ref ident) => format!("`{}`", ident),
-        Member::Unnamed(ref i) => i.index.to_string(),
+        Member::Unnamed(ref i) => format!("#{}", i.index),
     }
 }
 

serde_derive/src/internals/ctxt.rs

@@ -1,48 +1,49 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
+use quote::ToTokens;
 use std::cell::RefCell;
 use std::fmt::Display;
 use std::thread;
+use syn;
 
+/// A type to collect errors together and format them.
+///
+/// Dropping this object will cause a panic. It must be consumed using `check`.
+///
+/// References can be shared since this type uses run-time exclusive mut checking.
 #[derive(Default)]
 pub struct Ctxt {
-    errors: RefCell<Option<Vec<String>>>,
+    // The contents will be set to `None` during checking. This is so that checking can be
+    // enforced.
+    errors: RefCell<Option<Vec<syn::Error>>>,
 }
 
 impl Ctxt {
+    /// Create a new context object.
+    ///
+    /// This object contains no errors, but will still trigger a panic if it is not `check`ed.
     pub fn new() -> Self {
         Ctxt {
             errors: RefCell::new(Some(Vec::new())),
         }
     }
 
-    pub fn error<T: Display>(&self, msg: T) {
+    /// Add an error to the context object with a tokenenizable object.
+    ///
+    /// The object is used for spanning in error messages.
+    pub fn error_spanned_by<A: ToTokens, T: Display>(&self, obj: A, msg: T) {
         self.errors
             .borrow_mut()
             .as_mut()
             .unwrap()
-            .push(msg.to_string());
+            // Curb monomorphization from generating too many identical methods.
+            .push(syn::Error::new_spanned(obj.into_token_stream(), msg));
     }
 
-    pub fn check(self) -> Result<(), String> {
-        let mut errors = self.errors.borrow_mut().take().unwrap();
+    /// Consume this object, producing a formatted error string if there are errors.
+    pub fn check(self) -> Result<(), Vec<syn::Error>> {
+        let errors = self.errors.borrow_mut().take().unwrap();
         match errors.len() {
             0 => Ok(()),
-            1 => Err(errors.pop().unwrap()),
-            n => {
-                let mut msg = format!("{} errors:", n);
-                for err in errors {
-                    msg.push_str("\n\t# ");
-                    msg.push_str(&err);
-                }
-                Err(msg)
-            }
+            _ => Err(errors),
         }
     }
 }

serde_derive/src/internals/mod.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 pub mod ast;
 pub mod attr;
 

serde_derive/src/lib.rs

@@ -1,16 +1,7 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! This crate provides Serde's two derive macros.
 //!
-//! ```rust
-//! # #[macro_use]
-//! # extern crate serde_derive;
+//! ```edition2018
+//! # use serde_derive::{Serialize, Deserialize};
 //! #
 //! #[derive(Serialize, Deserialize)]
 //! # struct S;
@@ -22,22 +13,39 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.69")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.92")]
+#![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))]
-// Whitelisted clippy lints
+// Ignored clippy lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        enum_variant_names, redundant_field_names, too_many_arguments, used_underscore_binding,
-        cyclomatic_complexity, needless_pass_by_value
+        cognitive_complexity,
+        enum_variant_names,
+        needless_pass_by_value,
+        redundant_field_names,
+        too_many_arguments,
+        trivially_copy_pass_by_ref,
+        used_underscore_binding,
     )
 )]
-// Whitelisted clippy_pedantic lints
+// Ignored clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        items_after_statements, doc_markdown, stutter, similar_names, use_self, single_match_else,
-        enum_glob_use, match_same_arms, filter_map, cast_possible_truncation, indexing_slicing,
+        cast_possible_truncation,
+        doc_markdown,
+        enum_glob_use,
+        filter_map,
+        indexing_slicing,
+        items_after_statements,
+        match_same_arms,
+        module_name_repetitions,
+        similar_names,
+        single_match_else,
+        unseparated_literal_suffix,
+        use_self,
     )
 )]
 // The `quote!` macro requires deep recursion.
@@ -62,28 +70,28 @@ mod bound;
 mod fragment;
 
 mod de;
+mod dummy;
 mod pretend;
 mod ser;
 mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = syn::parse(input).unwrap();
+    let input = parse_macro_input!(input as DeriveInput);
     ser::expand_derive_serialize(&input)
-        .unwrap_or_else(compile_error)
+        .unwrap_or_else(to_compile_errors)
         .into()
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input: DeriveInput = syn::parse(input).unwrap();
+    let input = parse_macro_input!(input as DeriveInput);
     de::expand_derive_deserialize(&input)
-        .unwrap_or_else(compile_error)
+        .unwrap_or_else(to_compile_errors)
         .into()
 }
 
-fn compile_error(message: String) -> proc_macro2::TokenStream {
-    quote! {
-        compile_error!(#message);
-    }
+fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
+    let compile_errors = errors.iter().map(syn::Error::to_compile_error);
+    quote!(#(#compile_errors)*)
 }

serde_derive/src/ser.rs

@@ -1,42 +1,37 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use proc_macro2::{Span, TokenStream};
 use syn::spanned::Spanned;
 use syn::{self, Ident, Index, Member};
 
 use bound;
+use dummy;
 use fragment::{Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
 use internals::{attr, Ctxt, Derive};
 use pretend;
-use try;
 
-pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, String> {
+pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
     let ctxt = Ctxt::new();
-    let cont = Container::from_ast(&ctxt, input, Derive::Serialize);
+    let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
+        Some(cont) => cont,
+        None => return Err(ctxt.check().unwrap_err()),
+    };
     precondition(&ctxt, &cont);
     try!(ctxt.check());
 
     let ident = &cont.ident;
     let params = Parameters::new(&cont);
     let (impl_generics, ty_generics, where_clause) = params.generics.split_for_impl();
-    let dummy_const = Ident::new(&format!("_IMPL_SERIALIZE_FOR_{}", ident), Span::call_site());
     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
@@ -46,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
                 }
@@ -57,29 +52,22 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         }
     };
 
-    let try_replacement = try::replacement();
-    let generated = quote! {
-        #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-        const #dummy_const: () = {
-            #[allow(unknown_lints)]
-            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
-            #[allow(rust_2018_idioms)]
-            extern crate serde as _serde;
-            #try_replacement
-            #impl_block
-        };
-    };
-    Ok(generated)
+    Ok(dummy::wrap_in_const(
+        cont.attrs.custom_serde_path(),
+        "SERIALIZE",
+        ident,
+        impl_block,
+    ))
 }
 
 fn precondition(cx: &Ctxt, cont: &Container) {
     match cont.attrs.identifier() {
         attr::Identifier::No => {}
         attr::Identifier::Field => {
-            cx.error("field identifiers cannot be serialized");
+            cx.error_spanned_by(cont.original, "field identifiers cannot be serialized");
         }
         attr::Identifier::Variant => {
-            cx.error("variant identifiers cannot be serialized");
+            cx.error_spanned_by(cont.original, "variant identifiers cannot be serialized");
         }
     }
 }
@@ -160,7 +148,9 @@ fn build_generics(cont: &Container) -> syn::Generics {
 // attribute specify their own bound so we do not generate one. All other fields
 // may need a `T: Serialize` bound where T is the type of the field.
 fn needs_serialize_bound(field: &attr::Field, variant: Option<&attr::Variant>) -> bool {
-    !field.skip_serializing() && field.serialize_with().is_none() && field.ser_bound().is_none()
+    !field.skip_serializing()
+        && field.serialize_with().is_none()
+        && field.ser_bound().is_none()
         && variant.map_or(true, |variant| {
             !variant.skip_serializing()
                 && variant.serialize_with().is_none()
@@ -202,7 +192,10 @@ fn serialize_transparent(cont: &Container, params: &Parameters) -> Fragment {
 
     let path = match transparent_field.attrs.serialize_with() {
         Some(path) => quote!(#path),
-        None => quote!(_serde::Serialize::serialize),
+        None => {
+            let span = transparent_field.original.span();
+            quote_spanned!(span=> _serde::Serialize::serialize)
+        }
     };
 
     quote_block! {
@@ -302,6 +295,19 @@ 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],
@@ -312,12 +318,15 @@ fn serialize_struct_as_struct(
 
     let type_name = cattrs.name().serialize_name();
 
+    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());
+    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() {
@@ -327,10 +336,14 @@ fn serialize_struct_as_struct(
                 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_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)
     }
@@ -344,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)
@@ -362,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)
     }
@@ -448,17 +468,17 @@ fn serialize_variant(
         };
 
         let body = Match(match *cattrs.tag() {
-            attr::EnumTag::External => {
+            attr::TagType::External => {
                 serialize_externally_tagged_variant(params, variant, variant_index, cattrs)
             }
-            attr::EnumTag::Internal { ref tag } => {
+            attr::TagType::Internal { ref tag } => {
                 serialize_internally_tagged_variant(params, variant, cattrs, tag)
             }
-            attr::EnumTag::Adjacent {
+            attr::TagType::Adjacent {
                 ref tag,
                 ref content,
             } => serialize_adjacently_tagged_variant(params, variant, cattrs, tag, content),
-            attr::EnumTag::None => serialize_untagged_variant(params, variant, cattrs),
+            attr::TagType::None => serialize_untagged_variant(params, variant, cattrs),
         });
 
         quote! {
@@ -507,8 +527,10 @@ fn serialize_externally_tagged_variant(
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
+            let span = field.original.span();
+            let func = quote_spanned!(span=> _serde::Serializer::serialize_newtype_variant);
             quote_expr! {
-                _serde::Serializer::serialize_newtype_variant(
+                #func(
                     __serializer,
                     #type_name,
                     #variant_index,
@@ -581,8 +603,10 @@ fn serialize_internally_tagged_variant(
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
+            let span = field.original.span();
+            let func = quote_spanned!(span=> _serde::private::ser::serialize_tagged_newtype);
             quote_expr! {
-                _serde::private::ser::serialize_tagged_newtype(
+                #func(
                     __serializer,
                     #enum_ident_str,
                     #variant_ident_str,
@@ -639,12 +663,14 @@ fn serialize_adjacently_tagged_variant(
                     field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
                 }
 
+                let span = field.original.span();
+                let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field);
                 return quote_block! {
                     let mut __struct = try!(_serde::Serializer::serialize_struct(
                         __serializer, #type_name, 2));
                     try!(_serde::ser::SerializeStruct::serialize_field(
                         &mut __struct, #tag, #variant_name));
-                    try!(_serde::ser::SerializeStruct::serialize_field(
+                    try!(#func(
                         &mut __struct, #content, #field_expr));
                     _serde::ser::SerializeStruct::end(__struct)
                 };
@@ -740,8 +766,10 @@ fn serialize_untagged_variant(
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
             }
 
+            let span = field.original.span();
+            let func = quote_spanned!(span=> _serde::Serialize::serialize);
             quote_expr! {
-                _serde::Serialize::serialize(#field_expr, __serializer)
+                #func(#field_expr, __serializer)
             }
         }
         Style::Tuple => serialize_tuple_variant(TupleVariant::Untagged, params, &variant.fields),
@@ -1081,8 +1109,9 @@ fn serialize_struct_visitor(
 
             let span = field.original.span();
             let ser = if field.attrs.flatten() {
+                let func = quote_spanned!(span=> _serde::Serialize::serialize);
                 quote! {
-                    try!(_serde::Serialize::serialize(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+                    try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
                 }
             } else {
                 let func = struct_trait.serialize_field(span);

serde_derive_internals/Cargo.toml

@@ -1,22 +1,23 @@
 [package]
 name = "serde_derive_internals"
-version = "0.23.1" # remember to update html_root_url
+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"
-documentation = "https://docs.serde.rs/serde_derive_internals/"
+documentation = "https://docs.rs/serde_derive_internals"
 keywords = ["serde", "serialization"]
-readme = "crates-io.md"
-include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [lib]
 path = "lib.rs"
 
 [dependencies]
 proc-macro2 = "0.4"
-syn = { version = "0.14", default-features = false, features = ["derive", "parsing", "clone-impls"] }
+quote = "0.6.3"
+syn = { version = "0.15", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
+appveyor = { repository = "serde-rs/serde" }

serde_derive_internals/README.md

@@ -1 +0,0 @@
-../README.md

serde_derive_internals/crates-io.md

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

serde_derive_internals/lib.rs

@@ -1,21 +1,20 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![doc(html_root_url = "https://docs.rs/serde_derive_internals/0.23.1")]
+#![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, doc_markdown, match_same_arms, redundant_field_names)
+    allow(
+        cognitive_complexity,
+        redundant_field_names,
+        trivially_copy_pass_by_ref
+    )
 )]
 
 #[macro_use]
 extern crate syn;
 
 extern crate proc_macro2;
+extern crate quote;
 
 #[path = "src/mod.rs"]
 mod internals;

serde_test/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde_test"
-version = "1.0.69" # remember to update html_root_url
+version = "1.0.92" # 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"
@@ -15,8 +15,9 @@ include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-AP
 serde = { version = "1.0.60", path = "../serde" }
 
 [dev-dependencies]
-serde = { version = "1.0", path = "../serde", features = ["rc"] }
+serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
+appveyor = { repository = "serde-rs/serde" }

serde_test/src/assert.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use serde::{Deserialize, Serialize};
 
 use de::Deserializer;
@@ -16,13 +8,8 @@ use std::fmt::Debug;
 
 /// Runs both `assert_ser_tokens` and `assert_de_tokens`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_tokens, Token};
 /// #
 /// # fn main() {
@@ -53,13 +40,8 @@ where
 
 /// Asserts that `value` serializes to the given `tokens`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_ser_tokens, Token};
 /// #
 /// # fn main() {
@@ -95,18 +77,14 @@ where
     }
 }
 
-/// Asserts that `value` serializes to the given `tokens`, and then yields `error`.
+/// Asserts that `value` serializes to the given `tokens`, and then yields
+/// `error`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde_test;
-/// #
-/// # fn main() {
+/// ```edition2018
 /// use std::sync::{Arc, Mutex};
 /// use std::thread;
 ///
+/// use serde::Serialize;
 /// use serde_test::{assert_ser_tokens_error, Token};
 ///
 /// #[derive(Serialize)]
@@ -114,26 +92,27 @@ where
 ///     lock: Arc<Mutex<u32>>,
 /// }
 ///
-/// let example = Example { lock: Arc::new(Mutex::new(0)) };
-/// let lock = example.lock.clone();
+/// fn main() {
+///     let example = Example { lock: Arc::new(Mutex::new(0)) };
+///     let lock = example.lock.clone();
 ///
-/// let _ = thread::spawn(move || {
-///     // This thread will acquire the mutex first, unwrapping the result
-///     // of `lock` because the lock has not been poisoned.
-///     let _guard = lock.lock().unwrap();
+///     let _ = thread::spawn(move || {
+///         // This thread will acquire the mutex first, unwrapping the result
+///         // of `lock` because the lock has not been poisoned.
+///         let _guard = lock.lock().unwrap();
 ///
-///     // This panic while holding the lock (`_guard` is in scope) will
-///     // poison the mutex.
-///     panic!()
-/// }).join();
+///         // This panic while holding the lock (`_guard` is in scope) will
+///         // poison the mutex.
+///         panic!()
+///     }).join();
 ///
-/// let expected = &[
-///     Token::Struct { name: "Example", len: 1 },
-///     Token::Str("lock"),
-/// ];
-/// let error = "lock poison error while serializing";
-/// assert_ser_tokens_error(&example, expected, error);
-/// # }
+///     let expected = &[
+///         Token::Struct { name: "Example", len: 1 },
+///         Token::Str("lock"),
+///     ];
+///     let error = "lock poison error while serializing";
+///     assert_ser_tokens_error(&example, expected, error);
+/// }
 /// ```
 pub fn assert_ser_tokens_error<T>(value: &T, tokens: &[Token], error: &str)
 where
@@ -152,13 +131,8 @@ where
 
 /// Asserts that the given `tokens` deserialize into `value`.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens, Token};
 /// #
 /// # fn main() {
@@ -212,13 +186,8 @@ where
 
 /// Asserts that the given `tokens` yield `error` when deserializing.
 ///
-/// ```rust
-/// # #[macro_use]
-/// # extern crate serde_derive;
-/// #
-/// # extern crate serde;
-/// # extern crate serde_test;
-/// #
+/// ```edition2018
+/// # use serde::{Serialize, Deserialize};
 /// # use serde_test::{assert_de_tokens_error, Token};
 /// #
 /// # fn main() {

serde_test/src/configure.rs

@@ -14,12 +14,9 @@ pub struct Compact<T: ?Sized>(T);
 /// Trait to determine whether a value is represented in human-readable or
 /// compact form.
 ///
-/// ```
-/// extern crate serde;
-/// extern crate serde_test;
-///
+/// ```edition2018
 /// use serde::{Deserialize, Deserializer, Serialize, Serializer};
-/// use serde_test::{Configure, Token, assert_tokens};
+/// use serde_test::{assert_tokens, Configure, Token};
 ///
 /// #[derive(Debug, PartialEq)]
 /// struct Example(u8, u8);
@@ -67,12 +64,7 @@ pub struct Compact<T: ?Sized>(T);
 ///             Token::TupleEnd,
 ///         ],
 ///     );
-///     assert_tokens(
-///         &Example(1, 0).readable(),
-///         &[
-///             Token::Str("1.0"),
-///         ],
-///     );
+///     assert_tokens(&Example(1, 0).readable(), &[Token::Str("1.0")]);
 /// }
 /// ```
 pub trait Configure {
@@ -205,7 +197,7 @@ macro_rules! impl_serializer {
                 $is_human_readable
             }
 
-            forward_serialize_methods!{
+            forward_serialize_methods! {
                 serialize_bool bool,
                 serialize_i8 i8,
                 serialize_i16 i16,

serde_test/src/de.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
 use serde::de::{
     self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
@@ -253,7 +245,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::UnitVariant { name: n, .. }
             | Token::NewtypeVariant { name: n, .. }
             | Token::TupleVariant { name: n, .. }
-            | Token::StructVariant { name: n, .. } if name == n =>
+            | Token::StructVariant { name: n, .. }
+                if name == n =>
             {
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }

serde_test/src/error.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use std::error;
 use std::fmt::{self, Display};
 

serde_test/src/lib.rs

@@ -1,11 +1,3 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 //! This crate provides a convenient concise way to write unit tests for
 //! implementations of [`Serialize`] and [`Deserialize`].
 //!
@@ -32,19 +24,10 @@
 //!
 //! [`linked-hash-map`]: https://github.com/contain-rs/linked-hash-map
 //!
-//! ```rust
-//! # extern crate serde;
-//! #
-//! # macro_rules! ignore {
-//! #     ($($tt:tt)+) => {}
-//! # }
-//! #
-//! # ignore! {
-//! extern crate linked_hash_map;
+//! ```edition2018
+//! # const IGNORE: &str = stringify! {
 //! use linked_hash_map::LinkedHashMap;
-//! # }
-//!
-//! extern crate serde_test;
+//! # };
 //! use serde_test::{Token, assert_tokens};
 //!
 //! # use std::fmt;
@@ -161,16 +144,21 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.69")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.92")]
+#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
-// Whitelisted clippy lints
+// Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
-// Whitelisted clippy_pedantic lints
+// Ignored clippy_pedantic lints
 #![cfg_attr(
     feature = "cargo-clippy",
     allow(
-        empty_line_after_outer_attr, missing_docs_in_private_items, redundant_field_names, stutter,
-        use_debug, use_self
+        empty_line_after_outer_attr,
+        missing_docs_in_private_items,
+        module_name_repetitions,
+        redundant_field_names,
+        use_debug,
+        use_self
     )
 )]
 

serde_test/src/ser.rs

@@ -1,17 +1,10 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use serde::{ser, Serialize};
 
 use error::Error;
 use token::Token;
 
-/// A `Serializer` that ensures that a value serializes to a given list of tokens.
+/// A `Serializer` that ensures that a value serializes to a given list of
+/// tokens.
 #[derive(Debug)]
 pub struct Serializer<'a> {
     tokens: &'a [Token],

serde_test/src/token.rs

@@ -1,18 +1,10 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
 use std::fmt::{self, Debug, Display};
 
 #[derive(Copy, Clone, PartialEq, Debug)]
 pub enum Token {
     /// A serialized `bool`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&true, &[Token::Bool(true)]);
@@ -21,7 +13,7 @@ pub enum Token {
 
     /// A serialized `i8`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0i8, &[Token::I8(0)]);
@@ -30,7 +22,7 @@ pub enum Token {
 
     /// A serialized `i16`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0i16, &[Token::I16(0)]);
@@ -39,7 +31,7 @@ pub enum Token {
 
     /// A serialized `i32`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0i32, &[Token::I32(0)]);
@@ -48,7 +40,7 @@ pub enum Token {
 
     /// A serialized `i64`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0i64, &[Token::I64(0)]);
@@ -57,7 +49,7 @@ pub enum Token {
 
     /// A serialized `u8`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0u8, &[Token::U8(0)]);
@@ -66,7 +58,7 @@ pub enum Token {
 
     /// A serialized `u16`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0u16, &[Token::U16(0)]);
@@ -75,7 +67,7 @@ pub enum Token {
 
     /// A serialized `u32`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0u32, &[Token::U32(0)]);
@@ -84,7 +76,7 @@ pub enum Token {
 
     /// A serialized `u64`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0u64, &[Token::U64(0)]);
@@ -93,7 +85,7 @@ pub enum Token {
 
     /// A serialized `f32`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0f32, &[Token::F32(0.0)]);
@@ -102,7 +94,7 @@ pub enum Token {
 
     /// A serialized `f64`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&0f64, &[Token::F64(0.0)]);
@@ -111,7 +103,7 @@ pub enum Token {
 
     /// A serialized `char`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&'\n', &[Token::Char('\n')]);
@@ -120,7 +112,7 @@ pub enum Token {
 
     /// A serialized `str`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let s = String::from("transient");
@@ -130,7 +122,7 @@ pub enum Token {
 
     /// A borrowed `str`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let s: &str = "borrowed";
@@ -140,7 +132,7 @@ pub enum Token {
 
     /// A serialized `String`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let s = String::from("owned");
@@ -159,7 +151,7 @@ pub enum Token {
 
     /// A serialized `Option<T>` containing none.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let opt = None::<char>;
@@ -171,7 +163,7 @@ pub enum Token {
     ///
     /// The tokens of the value follow after this header.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let opt = Some('c');
@@ -184,7 +176,7 @@ pub enum Token {
 
     /// A serialized `()`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// assert_tokens(&(), &[Token::Unit]);
@@ -193,13 +185,8 @@ pub enum Token {
 
     /// A serialized unit struct of the given name.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -213,13 +200,8 @@ pub enum Token {
 
     /// A unit variant of an enum.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -241,13 +223,8 @@ pub enum Token {
     ///
     /// After this header is the value contained in the newtype struct.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -267,13 +244,8 @@ pub enum Token {
     ///
     /// After this header is the value contained in the newtype variant.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -299,7 +271,7 @@ pub enum Token {
     /// After this header are the elements of the sequence, followed by
     /// `SeqEnd`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let vec = vec!['a', 'b', 'c'];
@@ -320,7 +292,7 @@ pub enum Token {
     ///
     /// After this header are the elements of the tuple, followed by `TupleEnd`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// let tuple = ('a', 100);
@@ -341,13 +313,8 @@ pub enum Token {
     /// After this header are the fields of the tuple struct, followed by
     /// `TupleStructEnd`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -373,13 +340,8 @@ pub enum Token {
     /// After this header are the fields of the tuple variant, followed by
     /// `TupleVariantEnd`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -410,7 +372,7 @@ pub enum Token {
     ///
     /// After this header are the entries of the map, followed by `MapEnd`.
     ///
-    /// ```rust
+    /// ```edition2018
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// use std::collections::BTreeMap;
@@ -437,13 +399,8 @@ pub enum Token {
     ///
     /// After this header are the fields of the struct, followed by `StructEnd`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -474,13 +431,8 @@ pub enum Token {
     /// After this header are the fields of the struct variant, followed by
     /// `StructVariantEnd`.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {
@@ -509,13 +461,8 @@ pub enum Token {
 
     /// The header to an enum of the given name.
     ///
-    /// ```rust
-    /// # #[macro_use]
-    /// # extern crate serde_derive;
-    /// #
-    /// # extern crate serde;
-    /// # extern crate serde_test;
-    /// #
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
     /// # use serde_test::{assert_tokens, Token};
     /// #
     /// # fn main() {

test_suite/Cargo.toml

@@ -2,18 +2,20 @@
 name = "serde_test_suite"
 version = "0.0.0"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
+edition = "2018"
 publish = false
 
 [features]
-unstable = ["serde/unstable", "compiletest_rs"]
+unstable = ["serde/unstable"]
+
+[dependencies]
+serde = { path = "../serde" }
 
 [dev-dependencies]
 fnv = "1.0"
-proc-macro2 = "0.4"
 rustc-serialize = "0.3.16"
-serde = { path = "../serde", features = ["rc"] }
+select-rustc = "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 }
+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,11 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(/*=============================================]
-#![===  Serde test suite requires a nightly compiler.  ===]
-#![====================================================*/)]

test_suite/no_std/Cargo.toml

@@ -1,11 +1,11 @@
 [package]
 name = "serde_derive_tests_no_std"
 version = "0.0.0"
+edition = "2018"
 publish = false
 
 [dependencies]
 libc = { version = "0.2", default-features = false }
-serde = { path = "../../serde", default-features = false }
-serde_derive = { path = "../../serde_derive" }
+serde = { path = "../../serde", default-features = false, features = ["derive"] }
 
 [workspace]

test_suite/no_std/src/main.rs

@@ -1,16 +1,6 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#![feature(lang_items, start, panic_implementation)]
+#![feature(lang_items, start)]
 #![no_std]
 
-extern crate libc;
-
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {
     0
@@ -20,7 +10,7 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
 #[no_mangle]
 pub extern "C" fn rust_eh_personality() {}
 
-#[panic_implementation]
+#[panic_handler]
 fn panic(_info: &core::panic::PanicInfo) -> ! {
     unsafe {
         libc::abort();
@@ -29,8 +19,7 @@ fn panic(_info: &core::panic::PanicInfo) -> ! {
 
 //////////////////////////////////////////////////////////////////////////////
 
-#[macro_use]
-extern crate serde_derive;
+use serde::{Serialize, Deserialize};
 
 #[derive(Serialize, Deserialize)]
 struct Unit;

test_suite/tests/bytes/mod.rs

@@ -22,7 +22,7 @@ impl<'de> Visitor<'de> for ByteBufVisitor {
         V: SeqAccess<'de>,
     {
         let mut values = Vec::new();
-        while let Some(value) = try!(visitor.next_element()) {
+        while let Some(value) = visitor.next_element()? {
             values.push(value);
         }
         Ok(values)

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Test<'a> {
-    #[serde(borrow = "zzz")]
-    //~^^^ ERROR: failed to parse borrowed lifetimes: "zzz"
-    s: &'a str,
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Test<'a> {
-    #[serde(borrow = "'a + 'a")]
-    //~^^^ ERROR: duplicate borrowed lifetime `'a`
-    s: &'a str,
-}
-
-fn main() {}

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

@@ -1,22 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Str<'a>(&'a str);
-
-#[derive(Deserialize)]
-enum Test<'a> {
-    #[serde(borrow)]
-    //~^^^ ERROR: duplicate serde attribute `borrow`
-    S(#[serde(borrow)] Str<'a>),
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Test<'a> {
-    #[serde(borrow = "")]
-    //~^^^ ERROR: at least one lifetime must be borrowed
-    s: &'a str,
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Test {
-    #[serde(borrow)]
-    //~^^^ ERROR: field `s` has no lifetimes to borrow
-    s: String,
-}
-
-fn main() {}

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

@@ -1,22 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Str<'a>(&'a str);
-
-#[derive(Deserialize)]
-enum Test<'a> {
-    #[serde(borrow)]
-    //~^^^ ERROR: #[serde(borrow)] may only be used on newtype variants
-    S { s: Str<'a> },
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Test<'a> {
-    #[serde(borrow = "'b")]
-    //~^^^ ERROR: field `s` does not have lifetime 'b
-    s: &'a str,
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(tag = "conflict", content = "conflict")]
-//~^^ ERROR: enum tags `conflict` for type and content conflict with each other
-enum E {
-    A,
-    B,
-}
-
-fn main() {}

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

@@ -1,16 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct Foo(#[serde(flatten)] HashMap<String, String>);
-//~^^ ERROR: #[serde(flatten)] cannot be used on newtype structs
-
-fn main() {}

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

@@ -1,24 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct Foo {
-    #[serde(flatten, skip_deserializing)]
-    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_deserializing)]
-    other: Other,
-}
-
-#[derive(Deserialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

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

@@ -1,24 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing_if = "Option::is_none")]
-    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_serializing_if = "...")]
-    other: Option<Other>,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

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

@@ -1,24 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct Foo {
-    #[serde(flatten, skip_serializing)]
-    //~^^^ ERROR: #[serde(flatten] can not be combined with #[serde(skip_serializing)]
-    other: Other,
-}
-
-#[derive(Serialize)]
-struct Other {
-    x: u32,
-}
-
-fn main() {}

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

@@ -1,16 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct Foo(u32, #[serde(flatten)] HashMap<String, String>);
-//~^^ ERROR: #[serde(flatten)] cannot be used on tuple structs
-
-fn main() {}

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

@@ -1,22 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(tag = "conflict")]
-//~^^ ERROR: variant field name `conflict` conflicts with internal tag
-enum E {
-    A {
-        #[serde(rename = "conflict")]
-        x: (),
-    },
-}
-
-fn main() {}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(default)]
-//~^^ ERROR: #[serde(default)] can only be used on structs
-enum E {
-    S { f: u8 },
-}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(default)]
-//~^^ ERROR: #[serde(default)] can only be used on structs
-struct T(u8, u8);
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename = "x", serialize = "y")]
-    //~^^^ ERROR: unknown serde field attribute `serialize`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename = "x")]
-    #[serde(rename(deserialize = "y"))]
-    //~^^^^ ERROR: duplicate serde attribute `rename`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename(serialize = "x"), rename(serialize = "y"))]
-    //~^^^ ERROR: duplicate serde attribute `rename`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename(serialize = "x"))]
-    #[serde(rename = "y")]
-    //~^^^^ ERROR: duplicate serde attribute `rename`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename(serialize = "x", serialize = "y"))]
-    //~^^^ ERROR: duplicate serde attribute `rename`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(rename(serialize = "x"))]
-    #[serde(rename(serialize = "y"))]
-    //~^^^^ ERROR: duplicate serde attribute `rename`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(with = "w", serialize_with = "s")]
-    //~^^^ ERROR: duplicate serde attribute `serialize_with`
-    x: (),
-}
-
-fn main() {}

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

@@ -1,19 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(tag = "type")]
-//~^^ ERROR: #[serde(tag = "...")] cannot be used with tuple variants
-enum E {
-    Tuple(u8, u8),
-}
-
-fn main() {}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(tag = "type")]
-//~^^ ERROR: #[serde(tag = "...")] can only be used on enums
-struct S;
-
-fn main() {}

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

@@ -1,21 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(untagged)]
-#[serde(tag = "type")]
-//~^^^ ERROR: enum cannot be both untagged and internally tagged
-enum E {
-    A(u8),
-    B(String),
-}
-
-fn main() {}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(untagged)]
-//~^^ ERROR: #[serde(untagged)] can only be used on enums
-struct S;
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier, variant_identifier)]
-//~^^ ERROR: `field_identifier` and `variant_identifier` cannot both be set
-enum F {
-    A,
-    B,
-}
-
-fn main() {}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier)]
-//~^^ ERROR: `field_identifier` can only be used on an enum
-struct S;
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier)]
-enum F {
-    A,
-    B(u8, u8),
-    //~^^^^^ ERROR: field_identifier may only contain unit variants
-}
-
-fn main() {}

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

@@ -1,21 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier)]
-enum F {
-    A,
-    Other(String),
-    //~^^^^^ ERROR: `Other` must be the last variant
-    B,
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-enum F {
-    A,
-    #[serde(other)]
-    //~^^^^ ERROR: #[serde(other)] may only be used inside a field_identifier
-    B,
-}
-
-fn main() {}

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

@@ -1,21 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier)]
-enum F {
-    A,
-    #[serde(other)]
-    //~^^^^^ ERROR: #[serde(other)] must be on a unit variant
-    Other(u8, u8),
-}
-
-fn main() {}

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

@@ -1,22 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(field_identifier)]
-enum F {
-    A,
-    #[serde(other)]
-    //~^^^^^ ERROR: #[serde(other)] must be the last variant
-    Other,
-    B,
-}
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-#[serde(field_identifier)]
-//~^^ ERROR: field identifiers cannot be serialized
-enum F {
-    A,
-    B,
-}
-
-fn main() {}

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

@@ -1,17 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(variant_identifier)]
-//~^^ ERROR: `variant_identifier` can only be used on an enum
-struct S;
-
-fn main() {}

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

@@ -1,20 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-#[serde(variant_identifier)]
-enum F {
-    A,
-    B(u8, u8),
-    //~^^^^^ ERROR: variant_identifier may only contain unit variants
-}
-
-fn main() {}

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

@@ -1,16 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct S<'de> {
-    //~^^ ERROR: cannot deserialize when there is a lifetime parameter called 'de
-    s: &'de str,
-}

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

@@ -1,17 +0,0 @@
-// Copyright 2018 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Deserialize)]
-struct S {
-    string: String,
-    slice: [u8],
-    //~^^^^ ERROR: cannot deserialize a dynamically sized struct
-}

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

@@ -1,26 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-mod remote {
-    pub struct S {
-        a: u8,
-    }
-}
-
-#[derive(Serialize)]
-#[serde(remote = "remote::S")]
-struct S {
-    #[serde(getter = "~~~")]
-    //~^^^^ ERROR: failed to parse path: "~~~"
-    a: u8,
-}
-
-fn main() {}

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

@@ -1,25 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-mod remote {
-    pub struct S {
-        a: u8,
-    }
-}
-
-#[derive(Serialize)]
-#[serde(remote = "~~~")]
-//~^^ ERROR: failed to parse path: "~~~"
-struct S {
-    a: u8,
-}
-
-fn main() {}

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

@@ -1,28 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-mod remote {
-    pub enum E {
-        A { a: u8 },
-    }
-}
-
-#[derive(Serialize)]
-#[serde(remote = "remote::E")]
-pub enum E {
-    A {
-        #[serde(getter = "get_a")]
-        //~^^^^^ ERROR: #[serde(getter = "...")] is not allowed in an enum
-        a: u8,
-    },
-}
-
-fn main() {}

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

@@ -1,26 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-mod remote {
-    pub struct S {
-        pub a: u8,
-        pub b: u8,
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::S")]
-struct S {
-    a: u8,
-    //~^^^^ ERROR: missing field `b` in initializer of `remote::S`
-}
-
-fn main() {}

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

@@ -1,25 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-#[derive(Serialize)]
-struct S {
-    #[serde(getter = "S::get")]
-    //~^^^ ERROR: #[serde(getter = "...")] can only be used in structs that have #[serde(remote = "...")]
-    a: u8,
-}
-
-impl S {
-    fn get(&self) -> u8 {
-        self.a
-    }
-}
-
-fn main() {}

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

@@ -1,26 +0,0 @@
-// Copyright 2017 Serde Developers
-//
-// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
-// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
-// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
-// option. This file may not be copied, modified, or distributed
-// except according to those terms.
-
-#[macro_use]
-extern crate serde_derive;
-
-mod remote {
-    pub struct S {
-        pub a: u8,
-    }
-}
-
-#[derive(Serialize, Deserialize)]
-#[serde(remote = "remote::S")]
-struct S {
-    //~^^^ ERROR: struct `remote::S` has no field named `b`
-    b: u8,
-    //~^^^^^ ERROR: no field `b` on type `&remote::S`
-}
-
-fn main() {}