Release 1.0.70

Update path to alloc::collections for nightly-2018-07-07

.github/ISSUE_TEMPLATE/1-problem.md

@@ -0,0 +1,7 @@
+---
+name: Problem
+about: Something does not seem right
+
+---
+
+

.github/ISSUE_TEMPLATE/2-suggestion.md

@@ -0,0 +1,7 @@
+---
+name: Suggestion
+about: Share how Serde could support your use case better
+
+---
+
+

.github/ISSUE_TEMPLATE/3-documentation.md

@@ -0,0 +1,7 @@
+---
+name: Documentation
+about: Certainly there is room for improvement
+
+---
+
+

.github/ISSUE_TEMPLATE/4-discussion.md

@@ -0,0 +1,7 @@
+---
+name: Help or discussion
+about: This is the right place
+
+---
+
+

.github/ISSUE_TEMPLATE/5-other.md

@@ -0,0 +1,7 @@
+---
+name: Anything else!
+about: Whatever is on your mind
+
+---
+
+

.travis.yml

@@ -4,10 +4,15 @@ cache: cargo
 
 # run builds for all the trains (and more)
 rust:
-  - 1.13.0
   - stable
   - beta
   - nightly
+  - 1.13.0
+  - 1.15.0
+  - 1.20.0
+  - 1.21.0
+  - 1.25.0
+  - 1.26.0
 
 matrix:
   include:

CONTRIBUTING.md

@@ -1,45 +1,66 @@
 # Contributing to Serde
 
-Serde welcomes contribution from everyone. Here are the guidelines if you are
-thinking of helping us:
+Serde welcomes contribution from everyone in the form of suggestions, bug
+reports, pull requests, and feedback. This document gives some guidance if you
+are thinking of helping us.
 
-## Contributions
+Please reach out here in a GitHub issue or in the #serde IRC channel on
+[`irc.mozilla.org`] if we can do anything to help you contribute.
 
-Contributions to Serde or its dependencies should be made in the form of GitHub
-pull requests. Each pull request will be reviewed by a core contributor
-(someone with permission to land patches) and either landed in the main tree or
-given feedback for changes that would be required. All contributions should
-follow this format, even those from core contributors.
+[`irc.mozilla.org`]: https://wiki.mozilla.org/IRC
 
-Should you wish to work on an issue, please claim it first by commenting on
-the GitHub issue that you want to work on it. This is to prevent duplicated
-efforts from contributors on the same issue.
+## Submitting bug reports and feature requests
 
-## Pull Request Checklist
+Serde development is spread across lots of repositories, but this serde-rs/serde
+repository is always a safe choice for opening any issues related to Serde.
 
-- Branch from the master branch and, if needed, rebase to the current master
-  branch before submitting your pull request. If it doesn't merge cleanly with
-  master you may be asked to rebase your changes.
+When reporting a bug or asking for help, please include enough details so that
+the people helping you can reproduce the behavior you are seeing. For some tips
+on how to approach this, read about how to produce a [Minimal, Complete, and
+Verifiable example].
 
-- Commits should be as small as possible, while ensuring that each commit is
-  correct independently (i.e., each commit should compile and pass tests). 
+[Minimal, Complete, and Verifiable example]: https://stackoverflow.com/help/mcve
 
-- If your patch is not getting reviewed or you need a specific person to review
-  it, you can @-reply a reviewer asking for a review in the pull request or a
-  comment, or you can ask for a review in `#serde` on `irc.mozilla.org`.
+When making a feature request, please make it clear what problem you intend to
+solve with the feature, any ideas for how Serde could support solving that
+problem, any possible alternatives, and any disadvantages.
 
-- Add tests relevant to the fixed bug or new feature.
+## Running the test suite
+
+We encourage you to check that the test suite passes locally before submitting a
+pull request with your changes. If anything does not pass, typically it will be
+easier to iterate and fix it locally than waiting for the CI servers to run
+tests for you.
+
+##### In the [`serde`] directory
+
+```sh
+# Test all the example code in Serde documentation
+cargo test
+```
+
+##### In the [`test_suite/deps`] directory
+
+```sh
+# This is a prerequisite for running the full test suite
+cargo clean && cargo update && cargo build
+```
+
+##### In the [`test_suite`] directory
+
+```sh
+# Run the full test suite, including tests of unstable functionality
+cargo test --features unstable
+```
+
+[`serde`]: https://github.com/serde-rs/serde/tree/master/serde
+[`test_suite/deps`]: https://github.com/serde-rs/serde/tree/master/test_suite/deps
+[`test_suite`]: https://github.com/serde-rs/serde/tree/master/test_suite
 
 ## Conduct
 
-In all Serde-related forums, we follow the [Rust Code of
-Conduct](https://www.rust-lang.org/conduct.html).  For escalation or moderation
-issues, please contact Erick (erick.tryzelaar@gmail.com) instead of the Rust
-moderation team.
+In all Serde-related forums, we follow the [Rust Code of Conduct]. For
+escalation or moderation issues please contact Erick (erick.tryzelaar@gmail.com)
+instead of the Rust moderation team.
 
-## Communication
-
-Beyond opening tickets on the
-[serde-rs/serde](https://github.com/serde-rs/serde) project, Serde contributors
-frequent the `#serde` channel on
-[`irc.mozilla.org`](https://wiki.mozilla.org/IRC).
+[Rust Code of Conduct]: https://www.rust-lang.org/conduct.html

Cargo.toml

@@ -5,5 +5,4 @@ members = [
     "serde_derive_internals",
     "serde_test",
     "test_suite",
-    "test_suite/no_std",
 ]

README.md

@@ -1,9 +1,11 @@
-# Serde   [![Build Status]][travis] [![Latest Version]][crates.io]
+# Serde   [![Build Status]][travis] [![Latest Version]][crates.io] [![Rustc Version 1.13+]][rustc]
 
 [Build Status]: https://api.travis-ci.org/serde-rs/serde.svg?branch=master
 [travis]: https://travis-ci.org/serde-rs/serde
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
+[Rustc Version 1.13+]: https://img.shields.io/badge/rustc-1.13+-lightgray.svg
+[rustc]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
 
 **Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
 
@@ -20,9 +22,30 @@ You may be looking for:
 
 ## Serde in action
 
-<a href="http://play.integer32.com/?gist=9003c5b88c1f4989941925d7190c6eec" target="_blank">
-<img align="right" width="50" src="https://raw.githubusercontent.com/serde-rs/serde-rs.github.io/master/img/run.png">
-</a>
+<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>
+</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"
+
+# Each data format lives in its own crate; the sample code below uses JSON
+# but you may be using a different one.
+serde_json = "1.0"
+```
+
+</details>
+<p></p>
 
 ```rust
 #[macro_use]
@@ -56,12 +79,13 @@ fn main() {
 
 ## Getting help
 
-Serde developers live in the #serde channel on
-[`irc.mozilla.org`](https://wiki.mozilla.org/IRC). The #rust channel is also a
-good resource with generally faster response time but less specific knowledge
-about Serde. If IRC is not your thing or you don't get a good response, we are
-happy to respond to [GitHub issues](https://github.com/serde-rs/serde/issues/new)
-as well.
+Serde developers live in the #serde channel on [`irc.mozilla.org`][irc]. The
+\#rust channel is also a good resource with generally faster response time but
+less specific knowledge about Serde. If IRC is not your thing or you don't get a
+good response, we are happy to respond to [GitHub issues][issues] as well.
+
+[irc]: https://wiki.mozilla.org/IRC
+[issues]: https://github.com/serde-rs/serde/issues/new/choose
 
 ## License
 

appveyor.yml

@@ -5,7 +5,7 @@ environment:
 
 install:
   # Install rust, x86_64-pc-windows-msvc host
-  - appveyor DownloadFile https://win.rustup.rs/ -FileName rustup-init.exe
+  - curl -sSf -o rustup-init.exe https://win.rustup.rs/
   - rustup-init.exe -y --default-host x86_64-pc-windows-msvc --default-toolchain %APPVEYOR_RUST_CHANNEL%
   - set PATH=C:\msys64\usr\bin;%PATH%;C:\Users\appveyor\.cargo\bin
   - rustc -vV

crates-io.md

@@ -0,0 +1,56 @@
+<!-- Serde readme rendered on crates.io -->
+
+**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
+
+---
+
+You may be looking for:
+
+- [An overview of Serde](https://serde.rs/)
+- [Data formats supported by Serde](https://serde.rs/#data-formats)
+- [Setting up `#[derive(Serialize, Deserialize)]`](https://serde.rs/codegen.html)
+- [Examples](https://serde.rs/examples.html)
+- [API documentation](https://docs.serde.rs/serde/)
+- [Release notes](https://github.com/serde-rs/serde/releases)
+
+## Serde in action
+
+```rust
+#[macro_use]
+extern crate serde_derive;
+
+extern crate serde;
+extern crate serde_json;
+
+#[derive(Serialize, Deserialize, Debug)]
+struct Point {
+    x: i32,
+    y: i32,
+}
+
+fn main() {
+    let point = Point { x: 1, y: 2 };
+
+    // Convert the Point to a JSON string.
+    let serialized = serde_json::to_string(&point).unwrap();
+
+    // Prints serialized = {"x":1,"y":2}
+    println!("serialized = {}", serialized);
+
+    // Convert the JSON string back to a Point.
+    let deserialized: Point = serde_json::from_str(&serialized).unwrap();
+
+    // Prints deserialized = Point { x: 1, y: 2 }
+    println!("deserialized = {:?}", deserialized);
+}
+```
+
+## Getting help
+
+Serde developers live in the #serde channel on [`irc.mozilla.org`][irc]. The
+\#rust channel is also a good resource with generally faster response time but
+less specific knowledge about Serde. If IRC is not your thing or you don't get a
+good response, we are happy to respond to [GitHub issues][issues] as well.
+
+[irc]: https://wiki.mozilla.org/IRC
+[issues]: https://github.com/serde-rs/serde/issues/new/choose

rustfmt.toml

@@ -1,5 +1 @@
-fn_args_layout = "Block"
-array_layout = "Block"
-where_style = "Rfc"
-generics_indent = "Block"
-fn_call_style = "Block"
+error_on_line_overflow = false

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.0" # remember to update html_root_url
+version = "1.0.70" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -9,8 +9,9 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde/"
 keywords = ["serde", "serialization", "no_std"]
 categories = ["encoding"]
-readme = "README.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+build = "build.rs"
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
@@ -28,14 +29,30 @@ serde_derive = { version = "1.0", path = "../serde_derive" }
 [features]
 default = ["std"]
 
-# Re-export the derive(Serialize, Deserialize) macros. This is specifically
-# intended for library crates that provide optional Serde impls behind a Cargo
-# cfg of their own. All other crates should depend on serde_derive directly.
+# Re-export the derive(Serialize, Deserialize) macros. This is intended for
+# library crates that provide optional Serde impls behind a Cargo cfg of their
+# own.
+#
+# Mainly this is a workaround for limitations associated with
+# rust-lang/cargo#1286 in which a library crate cannot use one "serde" cfg in
+# Cargo to enable dependencies on both serde and serde_derive crates.
+#
+# The recommended way to provide optional Serde support that requires derive is
+# as follows. In particular, please do not name your library's Serde feature
+# anything other than "serde".
+#
+#     [dependencies]
+#     serde = { version = "1.0", optional = true, features = ["derive"] }
+#
+# Within the library, these optional Serde derives would be written like this.
+#
+#     #[cfg(feature = "serde")]
+#     #[macro_use]
+#     extern crate serde;
+#
+#     #[cfg_attr(feature = "serde", derive(Serialize, Deserialize))]
+#     struct ...
 #
-# Please refer to the long comment above the line `pub use serde_derive::*` in
-# src/lib.rs before enabling this feature. If you think you need this feature
-# and your use case does not precisely match the one described in the comment,
-# please open an issue to let us know about your use case.
 derive = ["serde_derive"]
 
 # Provide impls for common standard library types like Vec<T> and HashMap<K, V>.
@@ -48,28 +65,16 @@ std = []
 #    https://github.com/serde-rs/serde/issues/812
 unstable = []
 
-# Provide impls for types that require memory allocation like Box<T> and Rc<T>.
-# This is a subset of std but may be enabled without depending on all of std.
+# Provide impls for types in the Rust core allocation and collections library
+# including String, Box<T>, Vec<T>, and Cow<T>. This is a subset of std but may
+# be enabled without depending on all of std.
 #
 # Requires a dependency on the unstable core allocation library:
 #
 #    https://doc.rust-lang.org/alloc/
 alloc = ["unstable"]
 
-# Provide impls for collection types like String and Cow<T>. This is a subset of
-# std but may be enabled without depending on all of std.
-#
-# Requires a dependency on the unstable collections library:
-#
-#    https://doc.rust-lang.org/collections/
-collections = ["alloc"]
-
 # Opt into impls for Rc<T> and Arc<T>. Serializing and deserializing these types
 # does not preserve identity and may result in multiple copies of the same data.
 # Be sure that this is what you want before enabling this feature.
 rc = []
-
-# Get serde_derive picked up by the Integer 32 playground. Not public API.
-#
-#    http://play.integer32.com/
-playground = ["serde_derive"]

serde/build.rs

@@ -0,0 +1,78 @@
+use std::env;
+use std::process::Command;
+use std::str::{self, FromStr};
+
+// The rustc-cfg strings below are *not* public API. Please let us know by
+// opening a GitHub issue if your build environment requires some way to enable
+// these cfgs other than by executing our build script.
+fn main() {
+    let minor = match rustc_minor_version() {
+        Some(minor) => minor,
+        None => return,
+    };
+
+    // CString::into_boxed_c_str stabilized in Rust 1.20:
+    // https://doc.rust-lang.org/std/ffi/struct.CString.html#method.into_boxed_c_str
+    if minor >= 20 {
+        println!("cargo:rustc-cfg=de_boxed_c_str");
+    }
+
+    // From<Box<T>> for Rc<T> / Arc<T> stabilized in Rust 1.21:
+    // https://doc.rust-lang.org/std/rc/struct.Rc.html#impl-From<Box<T>>
+    // https://doc.rust-lang.org/std/sync/struct.Arc.html#impl-From<Box<T>>
+    if minor >= 21 {
+        println!("cargo:rustc-cfg=de_rc_dst");
+    }
+
+    // Duration available in core since Rust 1.25:
+    // https://blog.rust-lang.org/2018/03/29/Rust-1.25.html#library-stabilizations
+    if minor >= 25 {
+        println!("cargo:rustc-cfg=core_duration");
+    }
+
+    // 128-bit integers stabilized in Rust 1.26:
+    // https://blog.rust-lang.org/2018/05/10/Rust-1.26.html
+    if minor >= 26 {
+        println!("cargo:rustc-cfg=integer128");
+    }
+
+    // Non-zero integers stabilized in Rust 1.28:
+    // https://github.com/rust-lang/rust/pull/50808
+    if minor >= 28 {
+        println!("cargo:rustc-cfg=num_nonzero");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = match env::var_os("RUSTC") {
+        Some(rustc) => rustc,
+        None => return None,
+    };
+
+    let output = match Command::new(rustc).arg("--version").output() {
+        Ok(output) => output,
+        Err(_) => return None,
+    };
+
+    let version = match str::from_utf8(&output.stdout) {
+        Ok(version) => version,
+        Err(_) => return None,
+    };
+
+    // Temporary workaround to support the old 1.26-dev compiler on docs.rs.
+    if version.contains("0eb87c9bf") {
+        return Some(25);
+    }
+
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+
+    let next = match pieces.next() {
+        Some(next) => next,
+        None => return None,
+    };
+
+    u32::from_str(next).ok()
+}

serde/crates-io.md

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

serde/src/de/from_primitive.rs

@@ -9,42 +9,40 @@
 use lib::*;
 
 macro_rules! int_to_int {
-    ($dst:ident, $n:ident) => (
-        if $dst::MIN as i64 <= $n as i64 && $n as i64 <= $dst::MAX as i64 {
+    ($dst:ident, $n:ident) => {
+        if $dst::min_value() as i64 <= $n as i64 && $n as i64 <= $dst::max_value() as i64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 macro_rules! int_to_uint {
-    ($dst:ident, $n:ident) => (
-        if 0 <= $n && $n as u64 <= $dst::MAX as u64 {
+    ($dst:ident, $n:ident) => {
+        if 0 <= $n && $n as u64 <= $dst::max_value() as u64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 macro_rules! uint_to {
-    ($dst:ident, $n:ident) => (
-        if $n as u64 <= $dst::MAX as u64 {
+    ($dst:ident, $n:ident) => {
+        if $n as u64 <= $dst::max_value() as u64 {
             Some($n as $dst)
         } else {
             None
         }
-    )
+    };
 }
 
 pub trait FromPrimitive: Sized {
-    fn from_isize(n: isize) -> Option<Self>;
     fn from_i8(n: i8) -> Option<Self>;
     fn from_i16(n: i16) -> Option<Self>;
     fn from_i32(n: i32) -> Option<Self>;
     fn from_i64(n: i64) -> Option<Self>;
-    fn from_usize(n: usize) -> Option<Self>;
     fn from_u8(n: u8) -> Option<Self>;
     fn from_u16(n: u16) -> Option<Self>;
     fn from_u32(n: u32) -> Option<Self>;
@@ -52,54 +50,120 @@ pub trait FromPrimitive: Sized {
 }
 
 macro_rules! impl_from_primitive_for_int {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { int_to_int!($t, n) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { uint_to!($t, n) }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                int_to_int!($t, n)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                uint_to!($t, n)
+            }
         }
-    )
+    };
 }
 
 macro_rules! impl_from_primitive_for_uint {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { int_to_uint!($t, n) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { uint_to!($t, n) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { uint_to!($t, n) }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                int_to_uint!($t, n)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                uint_to!($t, n)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                uint_to!($t, n)
+            }
         }
-    )
+    };
 }
 
 macro_rules! impl_from_primitive_for_float {
-    ($t:ident) => (
+    ($t:ident) => {
         impl FromPrimitive for $t {
-            #[inline] fn from_isize(n: isize) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i8(n: i8) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i16(n: i16) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i32(n: i32) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_i64(n: i64) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_usize(n: usize) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u8(n: u8) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u16(n: u16) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u32(n: u32) -> Option<Self> { Some(n as Self) }
-            #[inline] fn from_u64(n: u64) -> Option<Self> { Some(n as Self) }
+            #[inline]
+            fn from_i8(n: i8) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i16(n: i16) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i32(n: i32) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_i64(n: i64) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u8(n: u8) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u16(n: u16) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u32(n: u32) -> Option<Self> {
+                Some(n as Self)
+            }
+            #[inline]
+            fn from_u64(n: u64) -> Option<Self> {
+                Some(n as Self)
+            }
         }
-    )
+    };
 }
 
 impl_from_primitive_for_int!(isize);
@@ -114,3 +178,91 @@ impl_from_primitive_for_uint!(u32);
 impl_from_primitive_for_uint!(u64);
 impl_from_primitive_for_float!(f32);
 impl_from_primitive_for_float!(f64);
+
+serde_if_integer128! {
+    impl FromPrimitive for i128 {
+        #[inline]
+        fn from_i8(n: i8) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_i16(n: i16) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_i32(n: i32) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_i64(n: i64) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_u8(n: u8) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_u16(n: u16) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_u32(n: u32) -> Option<Self> {
+            Some(n as i128)
+        }
+        #[inline]
+        fn from_u64(n: u64) -> Option<Self> {
+            Some(n as i128)
+        }
+    }
+
+    impl FromPrimitive for u128 {
+        #[inline]
+        fn from_i8(n: i8) -> Option<Self> {
+            if n >= 0 {
+                Some(n as u128)
+            } else {
+                None
+            }
+        }
+        #[inline]
+        fn from_i16(n: i16) -> Option<Self> {
+            if n >= 0 {
+                Some(n as u128)
+            } else {
+                None
+            }
+        }
+        #[inline]
+        fn from_i32(n: i32) -> Option<Self> {
+            if n >= 0 {
+                Some(n as u128)
+            } else {
+                None
+            }
+        }
+        #[inline]
+        fn from_i64(n: i64) -> Option<Self> {
+            if n >= 0 {
+                Some(n as u128)
+            } else {
+                None
+            }
+        }
+        #[inline]
+        fn from_u8(n: u8) -> Option<Self> {
+            Some(n as u128)
+        }
+        #[inline]
+        fn from_u16(n: u16) -> Option<Self> {
+            Some(n as u128)
+        }
+        #[inline]
+        fn from_u32(n: u32) -> Option<Self> {
+            Some(n as u128)
+        }
+        #[inline]
+        fn from_u64(n: u64) -> Option<Self> {
+            Some(n as u128)
+        }
+    }
+}

serde/src/de/ignored_any.rs

@@ -8,7 +8,7 @@
 
 use lib::*;
 
-use de::{Deserialize, Deserializer, Visitor, SeqAccess, MapAccess, Error};
+use de::{Deserialize, Deserializer, Error, MapAccess, SeqAccess, Visitor};
 
 /// An efficient way of discarding data from a deserializer.
 ///
@@ -45,7 +45,8 @@ use de::{Deserialize, Deserializer, Visitor, SeqAccess, MapAccess, Error};
 /// }
 ///
 /// impl<'de, T> Visitor<'de> for NthElement<T>
-///     where T: Deserialize<'de>
+/// where
+///     T: Deserialize<'de>,
 /// {
 ///     type Value = T;
 ///
@@ -54,7 +55,8 @@ use de::{Deserialize, Deserializer, Visitor, SeqAccess, MapAccess, Error};
 ///     }
 ///
 ///     fn visit_seq<A>(self, mut seq: A) -> Result<Self::Value, A::Error>
-///         where A: SeqAccess<'de>
+///     where
+///         A: SeqAccess<'de>,
 ///     {
 ///         // Skip over the first `n` elements.
 ///         for i in 0..self.n {
@@ -82,19 +84,22 @@ use de::{Deserialize, Deserializer, Visitor, SeqAccess, MapAccess, Error};
 /// }
 ///
 /// impl<'de, T> DeserializeSeed<'de> for NthElement<T>
-///     where T: Deserialize<'de>
+/// where
+///     T: Deserialize<'de>,
 /// {
 ///     type Value = T;
 ///
 ///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///         where D: Deserializer<'de>
+///     where
+///         D: Deserializer<'de>,
 ///     {
 ///         deserializer.deserialize_seq(self)
 ///     }
 /// }
 ///
 /// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// #     where D: Deserializer<'de>
+/// # where
+/// #     D: Deserializer<'de>,
 /// # {
 /// // Deserialize only the sequence element at index 3 from this deserializer.
 /// // The element at index 3 is required to be a string. Elements before and

serde/src/de/mod.rs

@@ -52,12 +52,12 @@
 //!
 //!  - **Primitive types**:
 //!    - bool
-//!    - i8, i16, i32, i64, isize
-//!    - u8, u16, u32, u64, usize
+//!    - i8, i16, i32, i64, i128, isize
+//!    - u8, u16, u32, u64, u128, usize
 //!    - f32, f64
 //!    - char
 //!  - **Compound types**:
-//!    - [T; 0] through [T; 32]
+//!    - \[T; 0\] through \[T; 32\]
 //!    - tuples up to size 16
 //!  - **Common standard library types**:
 //!    - String
@@ -66,7 +66,7 @@
 //!    - PhantomData\<T\>
 //!  - **Wrapper types**:
 //!    - Box\<T\>
-//!    - Box\<[T]\>
+//!    - Box\<\[T\]\>
 //!    - Box\<str\>
 //!    - Rc\<T\>
 //!    - Arc\<T\>
@@ -84,20 +84,21 @@
 //!    - LinkedList\<T\>
 //!    - VecDeque\<T\>
 //!    - Vec\<T\>
-//!    - EnumSet\<T\> (unstable)
 //!  - **Zero-copy types**:
 //!    - &str
-//!    - &[u8]
+//!    - &\[u8\]
 //!  - **FFI types**:
 //!    - CString
 //!    - Box\<CStr\>
 //!    - OsString
 //!  - **Miscellaneous standard library types**:
 //!    - Duration
+//!    - SystemTime
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - NonZero\<T\> (unstable)
+//!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -148,6 +149,13 @@ macro_rules! declare_error_trait {
         ///
         /// Most deserializers should only need to provide the `Error::custom` method
         /// and inherit the default behavior for the other methods.
+        ///
+        /// # Example implementation
+        ///
+        /// The [example data format] presented on the website shows an error
+        /// type appropriate for a basic JSON data format.
+        ///
+        /// [example data format]: https://serde.rs/data-format.html
         pub trait Error: Sized $(+ $($supertrait)::+)* {
             /// Raised when there is general error when deserializing a type.
             ///
@@ -170,7 +178,8 @@ macro_rules! declare_error_trait {
             ///
             /// impl<'de> Deserialize<'de> for IpAddr {
             ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-            ///         where D: Deserializer<'de>
+            ///     where
+            ///         D: Deserializer<'de>,
             ///     {
             ///         let s = try!(String::deserialize(deserializer));
             ///         s.parse().map_err(de::Error::custom)
@@ -194,6 +203,7 @@ macro_rules! declare_error_trait {
             /// For example if we try to deserialize a String out of a JSON file
             /// containing an integer, the unexpected type is the integer and the
             /// expected type is the string.
+            #[cold]
             fn invalid_type(unexp: Unexpected, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid type: {}, expected {}", unexp, exp))
             }
@@ -211,6 +221,7 @@ macro_rules! declare_error_trait {
             /// For example if we try to deserialize a String out of some binary data
             /// that is not valid UTF-8, the unexpected value is the bytes and the
             /// expected value is a string.
+            #[cold]
             fn invalid_value(unexp: Unexpected, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid value: {}, expected {}", unexp, exp))
             }
@@ -224,12 +235,14 @@ macro_rules! declare_error_trait {
             /// The `exp` argument provides information about what data was being
             /// expected. For example `exp` might say that a tuple of size 6 was
             /// expected.
+            #[cold]
             fn invalid_length(len: usize, exp: &Expected) -> Self {
                 Error::custom(format_args!("invalid length {}, expected {}", len, exp))
             }
 
             /// Raised when a `Deserialize` enum type received a variant with an
             /// unrecognized name.
+            #[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",
@@ -243,6 +256,7 @@ macro_rules! declare_error_trait {
 
             /// Raised when a `Deserialize` struct type received a field with an
             /// unrecognized name.
+            #[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",
@@ -257,12 +271,14 @@ macro_rules! declare_error_trait {
             /// Raised when a `Deserialize` struct type expected to receive a required
             /// field with a particular name but that field was not present in the
             /// input.
+            #[cold]
             fn missing_field(field: &'static str) -> Self {
                 Error::custom(format_args!("missing field `{}`", field))
             }
 
             /// Raised when a `Deserialize` struct type received more than one of the
             /// same field.
+            #[cold]
             fn duplicate_field(field: &'static str) -> Self {
                 Error::custom(format_args!("duplicate field `{}`", field))
             }
@@ -297,7 +313,8 @@ declare_error_trait!(Error: Sized + Debug + Display);
 /// #     }
 /// #
 /// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-///     where E: de::Error
+/// where
+///     E: de::Error,
 /// {
 ///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
 /// }
@@ -421,7 +438,8 @@ impl<'a> fmt::Display for Unexpected<'a> {
 /// #     }
 /// #
 /// fn visit_bool<E>(self, v: bool) -> Result<Self::Value, E>
-///     where E: de::Error
+/// where
+///     E: de::Error,
 /// {
 ///     Err(de::Error::invalid_type(Unexpected::Bool(v), &self))
 /// }
@@ -434,7 +452,8 @@ impl<'a> fmt::Display for Unexpected<'a> {
 /// # use serde::de::{self, Unexpected};
 /// #
 /// # fn example<E>() -> Result<(), E>
-/// #     where E: de::Error
+/// # where
+/// #     E: de::Error,
 /// # {
 /// #     let v = true;
 /// return Err(de::Error::invalid_type(Unexpected::Bool(v), &"a negative integer"));
@@ -493,6 +512,14 @@ impl<'a> Display for Expected + 'a {
 /// [de]: https://docs.serde.rs/serde/de/index.html
 /// [codegen]: https://serde.rs/codegen.html
 /// [impl-deserialize]: https://serde.rs/impl-deserialize.html
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by `Self` when deserialized. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
 pub trait Deserialize<'de>: Sized {
     /// Deserialize this value from the given Serde deserializer.
     ///
@@ -503,6 +530,35 @@ pub trait Deserialize<'de>: Sized {
     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
     where
         D: Deserializer<'de>;
+
+    /// Deserializes a value into `self` from the given Deserializer.
+    ///
+    /// The purpose of this method is to allow the deserializer to reuse
+    /// resources and avoid copies. As such, if this method returns an error,
+    /// `self` will be in an indeterminate state where some parts of the struct
+    /// have been overwritten. Although whatever state that is will be
+    /// memory-safe.
+    ///
+    /// This is generally useful when repeatedly deserializing values that
+    /// are processed one at a time, where the value of `self` doesn't matter
+    /// when the next deserialization occurs.
+    ///
+    /// If you manually implement this, your recursive deserializations should
+    /// use `deserialize_in_place`.
+    ///
+    /// This method is stable and an official public API, but hidden from the
+    /// documentation because it is almost never what newbies are looking for.
+    /// Showing it in rustdoc would cause it to be featured more prominently
+    /// than it deserves.
+    #[doc(hidden)]
+    fn deserialize_in_place<D>(deserializer: D, place: &mut Self) -> Result<(), D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        // Default implementation just delegates to `deserialize` impl.
+        *place = Deserialize::deserialize(deserializer)?;
+        Ok(())
+    }
 }
 
 /// A data structure that can be deserialized without borrowing any data from
@@ -519,19 +575,25 @@ pub trait Deserialize<'de>: Sized {
 /// #
 /// # trait Ignore {
 /// fn from_str<'a, T>(s: &'a str) -> Result<T>
-///     where T: Deserialize<'a>;
+/// where
+///     T: Deserialize<'a>;
 ///
 /// fn from_reader<R, T>(rdr: R) -> Result<T>
-///     where R: Read,
-///           T: DeserializeOwned;
+/// where
+///     R: Read,
+///     T: DeserializeOwned;
 /// # }
 /// ```
+///
+/// # Lifetime
+///
+/// The relationship between `Deserialize` and `DeserializeOwned` in trait
+/// bounds is explained in more detail on the page [Understanding deserializer
+/// lifetimes].
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
 pub trait DeserializeOwned: for<'de> Deserialize<'de> {}
-impl<T> DeserializeOwned for T
-where
-    T: for<'de> Deserialize<'de>,
-{
-}
+impl<T> DeserializeOwned for T where T: for<'de> Deserialize<'de> {}
 
 /// `DeserializeSeed` is the stateful form of the `Deserialize` trait. If you
 /// ever find yourself looking for a way to pass data into a `Deserialize` impl,
@@ -576,6 +638,14 @@ where
 /// seed can be appeased by passing `std::marker::PhantomData` as a seed in the
 /// case of stateless deserialization.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by `Self::Value` when deserialized. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
 /// # Example
 ///
 /// Suppose we have JSON that looks like `[[1, 2], [3, 4, 5], [6]]` and we need
@@ -599,7 +669,8 @@ where
 /// struct ExtendVec<'a, T: 'a>(&'a mut Vec<T>);
 ///
 /// impl<'de, 'a, T> DeserializeSeed<'de> for ExtendVec<'a, T>
-///     where T: Deserialize<'de>
+/// where
+///     T: Deserialize<'de>,
 /// {
 ///     // The return type of the `deserialize` method. This implementation
 ///     // appends onto an existing vector but does not create any new data
@@ -607,14 +678,16 @@ where
 ///     type Value = ();
 ///
 ///     fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
-///         where D: Deserializer<'de>
+///     where
+///         D: Deserializer<'de>,
 ///     {
 ///         // Visitor implementation that will walk an inner array of the JSON
 ///         // input.
 ///         struct ExtendVecVisitor<'a, T: 'a>(&'a mut Vec<T>);
 ///
 ///         impl<'de, 'a, T> Visitor<'de> for ExtendVecVisitor<'a, T>
-///             where T: Deserialize<'de>
+///         where
+///             T: Deserialize<'de>,
 ///         {
 ///             type Value = ();
 ///
@@ -623,7 +696,8 @@ where
 ///             }
 ///
 ///             fn visit_seq<A>(self, mut seq: A) -> Result<(), A::Error>
-///                 where A: SeqAccess<'de>
+///             where
+///                 A: SeqAccess<'de>,
 ///             {
 ///                 // Visit each element in the inner array and push it onto
 ///                 // the existing vector.
@@ -642,7 +716,8 @@ where
 /// struct FlattenedVecVisitor<T>(PhantomData<T>);
 ///
 /// impl<'de, T> Visitor<'de> for FlattenedVecVisitor<T>
-///     where T: Deserialize<'de>
+/// where
+///     T: Deserialize<'de>,
 /// {
 ///     // This Visitor constructs a single Vec<T> to hold the flattened
 ///     // contents of the inner arrays.
@@ -653,7 +728,8 @@ where
 ///     }
 ///
 ///     fn visit_seq<A>(self, mut seq: A) -> Result<Vec<T>, A::Error>
-///         where A: SeqAccess<'de>
+///     where
+///         A: SeqAccess<'de>,
 ///     {
 ///         // Create a single Vec to hold the flattened contents.
 ///         let mut vec = Vec::new();
@@ -669,7 +745,8 @@ where
 /// }
 ///
 /// # fn example<'de, D>(deserializer: D) -> Result<(), D::Error>
-/// #     where D: Deserializer<'de>
+/// # where
+/// #     D: Deserializer<'de>,
 /// # {
 /// let visitor = FlattenedVecVisitor(PhantomData);
 /// let flattened: Vec<u64> = deserializer.deserialize_seq(visitor)?;
@@ -707,10 +784,10 @@ where
 /// A **data format** that can deserialize any data structure supported by
 /// Serde.
 ///
-/// The role of this trait is to define the deserialization half of the Serde
-/// data model, which is a way to categorize every Rust data type into one of 27
-/// possible types. Each method of the `Serializer` trait corresponds to one of
-/// the types of the data model.
+/// The role of this trait is to define the deserialization half of the [Serde
+/// data model], which is a way to categorize every Rust data type into one of
+/// 29 possible types. Each method of the `Serializer` trait corresponds to one
+/// of the types of the data model.
 ///
 /// Implementations of `Deserialize` map themselves into this data model by
 /// passing to the `Deserializer` a `Visitor` implementation that can receive
@@ -718,17 +795,17 @@ where
 ///
 /// The types that make up the Serde data model are:
 ///
-///  - **12 primitive types**
+///  - **14 primitive types**
 ///    - bool
-///    - i8, i16, i32, i64
-///    - u8, u16, u32, u64
+///    - i8, i16, i32, i64, i128
+///    - u8, u16, u32, u64, u128
 ///    - f32, f64
 ///    - char
 ///  - **string**
 ///    - UTF-8 bytes with a length and no null terminator.
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - [u8]
+///  - **byte array** - \[u8\]
 ///    - Similar to strings, during deserialization byte arrays can be transient,
 ///      owned, or borrowed.
 ///  - **option**
@@ -792,6 +869,23 @@ where
 /// what type is in the input. Know that relying on `Deserializer::deserialize_any`
 /// means your data type will be able to deserialize from self-describing
 /// formats only, ruling out Bincode and many others.
+///
+/// [Serde data model]: https://serde.rs/data-model.html
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed from the input when deserializing. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website contains example code for
+/// a basic JSON `Deserializer`.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait Deserializer<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -835,6 +929,20 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
+    serde_if_integer128! {
+        /// Hint that the `Deserialize` type is expecting an `i128` value.
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default behavior unconditionally returns an error.
+        fn deserialize_i128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>
+        {
+            let _ = visitor;
+            Err(Error::custom("i128 is not supported"))
+        }
+    }
+
     /// Hint that the `Deserialize` type is expecting a `u8` value.
     fn deserialize_u8<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
@@ -855,6 +963,20 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
+    serde_if_integer128! {
+        /// Hint that the `Deserialize` type is expecting an `u128` value.
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default behavior unconditionally returns an error.
+        fn deserialize_u128<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where
+            V: Visitor<'de>
+        {
+            let _ = visitor;
+            Err(Error::custom("u128 is not supported"))
+        }
+    }
+
     /// Hint that the `Deserialize` type is expecting a `f32` value.
     fn deserialize_f32<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
@@ -1010,12 +1132,93 @@ pub trait Deserializer<'de>: Sized {
     fn deserialize_ignored_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: Visitor<'de>;
+
+    /// Determine whether `Deserialize` implementations should expect to
+    /// deserialize their human-readable form.
+    ///
+    /// Some types have a human-readable form that may be somewhat expensive to
+    /// construct, as well as a binary form that is compact and efficient.
+    /// Generally text-based formats like JSON and YAML will prefer to use the
+    /// human-readable one and binary formats like Bincode will prefer the
+    /// compact one.
+    ///
+    /// ```
+    /// # use std::ops::Add;
+    /// # use std::str::FromStr;
+    /// #
+    /// # struct Timestamp;
+    /// #
+    /// # impl Timestamp {
+    /// #     const EPOCH: Timestamp = Timestamp;
+    /// # }
+    /// #
+    /// # impl FromStr for Timestamp {
+    /// #     type Err = String;
+    /// #     fn from_str(_: &str) -> Result<Self, Self::Err> {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # struct Duration;
+    /// #
+    /// # impl Duration {
+    /// #     fn seconds(_: u64) -> Self { unimplemented!() }
+    /// # }
+    /// #
+    /// # impl Add<Duration> for Timestamp {
+    /// #     type Output = Timestamp;
+    /// #     fn add(self, _: Duration) -> Self::Output {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// use serde::de::{self, Deserialize, Deserializer};
+    ///
+    /// impl<'de> Deserialize<'de> for Timestamp {
+    ///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    ///     where
+    ///         D: Deserializer<'de>,
+    ///     {
+    ///         if deserializer.is_human_readable() {
+    ///             // Deserialize from a human-readable string like "2015-05-15T17:01:00Z".
+    ///             let s = String::deserialize(deserializer)?;
+    ///             Timestamp::from_str(&s).map_err(de::Error::custom)
+    ///         } else {
+    ///             // Deserialize from a compact binary representation, seconds since
+    ///             // the Unix epoch.
+    ///             let n = u64::deserialize(deserializer)?;
+    ///             Ok(Timestamp::EPOCH + Duration::seconds(n))
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default implementation of this method returns `true`. Data formats
+    /// may override this to `false` to request a compact form for types that
+    /// support one. Note that modifying this method to change a format from
+    /// human-readable to compact or vice versa should be regarded as a breaking
+    /// change, as a value serialized in human-readable mode is not required to
+    /// deserialize from the same data in compact mode.
+    #[inline]
+    fn is_human_readable(&self) -> bool {
+        true
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
 
 /// This trait represents a visitor that walks through a deserializer.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the requirement for lifetime of data
+/// that may be borrowed by `Self::Value`. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example
+///
 /// ```rust
 /// # use std::fmt;
 /// #
@@ -1035,7 +1238,8 @@ pub trait Deserializer<'de>: Sized {
 ///     }
 ///
 ///     fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-///         where E: de::Error
+///     where
+///         E: de::Error,
 ///     {
 ///         if s.len() >= self.min {
 ///             Ok(s.to_owned())
@@ -1119,7 +1323,7 @@ pub trait Visitor<'de>: Sized {
         self.visit_i64(v as i64)
     }
 
-    /// The input contains an `i32`.
+    /// The input contains an `i64`.
     ///
     /// The default implementation fails with a type error.
     fn visit_i64<E>(self, v: i64) -> Result<Self::Value, E>
@@ -1129,6 +1333,20 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Signed(v), &self))
     }
 
+    serde_if_integer128! {
+        /// The input contains a `i128`.
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default implementation fails with a type error.
+        fn visit_i128<E>(self, v: i128) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            let _ = v;
+            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
+        }
+    }
+
     /// The input contains a `u8`.
     ///
     /// The default implementation forwards to [`visit_u64`].
@@ -1175,6 +1393,20 @@ pub trait Visitor<'de>: Sized {
         Err(Error::invalid_type(Unexpected::Unsigned(v), &self))
     }
 
+    serde_if_integer128! {
+        /// The input contains a `u128`.
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default implementation fails with a type error.
+        fn visit_u128<E>(self, v: u128) -> Result<Self::Value, E>
+        where
+            E: Error,
+        {
+            let _ = v;
+            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
+        }
+    }
+
     /// The input contains an `f32`.
     ///
     /// The default implementation forwards to [`visit_f64`].
@@ -1262,7 +1494,7 @@ pub trait Visitor<'de>: Sized {
     /// The default implementation forwards to `visit_str` and then drops the
     /// `String`.
     #[inline]
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1321,7 +1553,7 @@ pub trait Visitor<'de>: Sized {
     ///
     /// The default implementation forwards to `visit_bytes` and then drops the
     /// `Vec<u8>`.
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
     where
         E: Error,
@@ -1406,6 +1638,15 @@ pub trait Visitor<'de>: Sized {
         let _ = data;
         Err(Error::invalid_type(Unexpected::Enum, &self))
     }
+
+    // Used when deserializing a flattened Option field. Not public API.
+    #[doc(hidden)]
+    fn __private_visit_untagged_option<D>(self, _: D) -> Result<Self::Value, ()>
+    where
+        D: Deserializer<'de>,
+    {
+        Err(())
+    }
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -1414,6 +1655,21 @@ pub trait Visitor<'de>: Sized {
 ///
 /// This is a trait that a `Deserializer` passes to a `Visitor` implementation,
 /// which deserializes each item in a sequence.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by deserialized sequence elements. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SeqAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SeqAccess<'de> {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1423,7 +1679,7 @@ pub trait SeqAccess<'de> {
     /// `Ok(None)` if there are no more remaining items.
     ///
     /// `Deserialize` implementations should typically use
-    /// `SeqAcccess::next_element` instead.
+    /// `SeqAccess::next_element` instead.
     fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
     where
         T: DeserializeSeed<'de>;
@@ -1481,6 +1737,21 @@ where
 /// Provides a `Visitor` access to each entry of a map in the input.
 ///
 /// This is a trait that a `Deserializer` passes to a `Visitor` implementation.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by deserialized map entries. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `MapAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait MapAccess<'de> {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1658,6 +1929,21 @@ where
 ///
 /// `EnumAccess` is created by the `Deserializer` and passed to the
 /// `Visitor` in order to identify which variant of an enum to deserialize.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by the deserialized enum variant. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `EnumAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait EnumAccess<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization.
@@ -1690,6 +1976,21 @@ pub trait EnumAccess<'de>: Sized {
 /// `VariantAccess` is a visitor that is created by the `Deserializer` and
 /// passed to the `Deserialize` to deserialize the content of a particular enum
 /// variant.
+///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed by the deserialized enum variant. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `VariantAccess` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait VariantAccess<'de>: Sized {
     /// The error type that can be returned if some error occurs during
     /// deserialization. Must match the error type of our `EnumAccess`.
@@ -1715,15 +2016,18 @@ pub trait VariantAccess<'de>: Sized {
     /// }
     /// #
     /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #         where T: DeserializeSeed<'de>
+    /// #     where
+    /// #         T: DeserializeSeed<'de>,
     /// #     { unimplemented!() }
     /// #
     /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// #
     /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// # }
     /// ```
@@ -1750,7 +2054,8 @@ pub trait VariantAccess<'de>: Sized {
     /// #     }
     /// #
     /// fn newtype_variant_seed<T>(self, _seed: T) -> Result<T::Value, Self::Error>
-    ///     where T: DeserializeSeed<'de>
+    /// where
+    ///     T: DeserializeSeed<'de>,
     /// {
     ///     // What the data actually contained; suppose it is a unit variant.
     ///     let unexp = Unexpected::UnitVariant;
@@ -1758,11 +2063,13 @@ pub trait VariantAccess<'de>: Sized {
     /// }
     /// #
     /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// #
     /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// # }
     /// ```
@@ -1803,13 +2110,17 @@ pub trait VariantAccess<'de>: Sized {
     /// #     }
     /// #
     /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #         where T: DeserializeSeed<'de>
+    /// #     where
+    /// #         T: DeserializeSeed<'de>,
     /// #     { unimplemented!() }
     /// #
-    /// fn tuple_variant<V>(self,
-    ///                         _len: usize,
-    ///                         _visitor: V) -> Result<V::Value, Self::Error>
-    ///     where V: Visitor<'de>
+    /// fn tuple_variant<V>(
+    ///     self,
+    ///     _len: usize,
+    ///     _visitor: V,
+    /// ) -> Result<V::Value, Self::Error>
+    /// where
+    ///     V: Visitor<'de>,
     /// {
     ///     // What the data actually contained; suppose it is a unit variant.
     ///     let unexp = Unexpected::UnitVariant;
@@ -1817,7 +2128,8 @@ pub trait VariantAccess<'de>: Sized {
     /// }
     /// #
     /// #     fn struct_variant<V>(self, _: &[&str], _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// # }
     /// ```
@@ -1845,17 +2157,22 @@ pub trait VariantAccess<'de>: Sized {
     /// #     }
     /// #
     /// #     fn newtype_variant_seed<T>(self, _: T) -> Result<T::Value, Self::Error>
-    /// #         where T: DeserializeSeed<'de>
+    /// #     where
+    /// #         T: DeserializeSeed<'de>,
     /// #     { unimplemented!() }
     /// #
     /// #     fn tuple_variant<V>(self, _: usize, _: V) -> Result<V::Value, Self::Error>
-    /// #         where V: Visitor<'de>
+    /// #     where
+    /// #         V: Visitor<'de>,
     /// #     { unimplemented!() }
     /// #
-    /// fn struct_variant<V>(self,
-    ///                          _fields: &'static [&'static str],
-    ///                          _visitor: V) -> Result<V::Value, Self::Error>
-    ///     where V: Visitor<'de>
+    /// fn struct_variant<V>(
+    ///     self,
+    ///     _fields: &'static [&'static str],
+    ///     _visitor: V,
+    /// ) -> Result<V::Value, Self::Error>
+    /// where
+    ///     V: Visitor<'de>,
     /// {
     ///     // What the data actually contained; suppose it is a unit variant.
     ///     let unexp = Unexpected::UnitVariant;
@@ -1877,6 +2194,16 @@ pub trait VariantAccess<'de>: Sized {
 /// Converts an existing value into a `Deserializer` from which other values can
 /// be deserialized.
 ///
+/// # Lifetime
+///
+/// The `'de` lifetime of this trait is the lifetime of data that may be
+/// borrowed from the resulting `Deserializer`. See the page [Understanding
+/// deserializer lifetimes] for a more detailed explanation of these lifetimes.
+///
+/// [Understanding deserializer lifetimes]: https://serde.rs/lifetimes.html
+///
+/// # Example
+///
 /// ```rust
 /// #[macro_use]
 /// extern crate serde_derive;

serde/src/de/value.rs

@@ -37,10 +37,26 @@
 
 use lib::*;
 
-use de::{self, IntoDeserializer, Expected, SeqAccess};
+use self::private::{First, Second};
+use de::{self, Expected, IntoDeserializer, SeqAccess};
 use private::de::size_hint;
 use ser;
-use self::private::{First, Second};
+
+////////////////////////////////////////////////////////////////////////////////
+
+// For structs that contain a PhantomData. We do not want the trait
+// bound `E: Clone` inferred by derive(Clone).
+macro_rules! impl_copy_clone {
+    ($ty:ident $(<$lifetime:tt>)*) => {
+        impl<$($lifetime,)* E> Copy for $ty<$($lifetime,)* E> {}
+
+        impl<$($lifetime,)* E> Clone for $ty<$($lifetime,)* E> {
+            fn clone(&self) -> Self {
+                *self
+            }
+        }
+    };
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -51,21 +67,25 @@ pub struct Error {
     err: ErrorImpl,
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 type ErrorImpl = Box<str>;
-#[cfg(not(any(feature = "std", feature = "collections")))]
+#[cfg(not(any(feature = "std", feature = "alloc")))]
 type ErrorImpl = ();
 
 impl de::Error for Error {
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
     {
-        Error { err: msg.to_string().into_boxed_str() }
+        Error {
+            err: msg.to_string().into_boxed_str(),
+        }
     }
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
@@ -76,6 +96,7 @@ impl de::Error for Error {
 }
 
 impl ser::Error for Error {
+    #[cold]
     fn custom<T>(msg: T) -> Self
     where
         T: Display,
@@ -85,12 +106,12 @@ impl ser::Error for Error {
 }
 
 impl Display for Error {
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         formatter.write_str(&self.err)
     }
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     fn fmt(&self, formatter: &mut fmt::Formatter) -> Result<(), fmt::Error> {
         formatter.write_str("Serde deserialization error")
     }
@@ -112,16 +133,20 @@ where
     type Deserializer = UnitDeserializer<E>;
 
     fn into_deserializer(self) -> UnitDeserializer<E> {
-        UnitDeserializer { marker: PhantomData }
+        UnitDeserializer {
+            marker: PhantomData,
+        }
     }
 }
 
 /// A deserializer holding a `()`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct UnitDeserializer<E> {
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(UnitDeserializer);
+
 impl<'de, E> de::Deserializer<'de> for UnitDeserializer<E>
 where
     E: de::Error,
@@ -129,9 +154,9 @@ where
     type Error = E;
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf unit unit_struct newtype_struct seq tuple tuple_struct map
-        struct enum identifier ignored_any
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf unit unit_struct newtype_struct seq tuple tuple_struct
+        map struct enum identifier ignored_any
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -151,16 +176,60 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer that cannot be instantiated.
+#[cfg(feature = "unstable")]
+pub struct NeverDeserializer<E> {
+    never: !,
+    marker: PhantomData<E>,
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> IntoDeserializer<'de, E> for !
+where
+    E: de::Error,
+{
+    type Deserializer = NeverDeserializer<E>;
+
+    fn into_deserializer(self) -> Self::Deserializer {
+        self
+    }
+}
+
+#[cfg(feature = "unstable")]
+impl<'de, E> de::Deserializer<'de> for NeverDeserializer<E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, _visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        self.never
+    }
+
+    forward_to_deserialize_any! {
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf option unit unit_struct newtype_struct seq tuple
+        tuple_struct map struct enum identifier ignored_any
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 macro_rules! primitive_deserializer {
     ($ty:ty, $doc:tt, $name:ident, $method:ident $($cast:tt)*) => {
         #[doc = "A deserializer holding"]
         #[doc = $doc]
-        #[derive(Clone, Debug)]
+        #[derive(Debug)]
         pub struct $name<E> {
             value: $ty,
             marker: PhantomData<E>
         }
 
+        impl_copy_clone!($name);
+
         impl<'de, E> IntoDeserializer<'de, E> for $ty
         where
             E: de::Error,
@@ -182,9 +251,9 @@ macro_rules! primitive_deserializer {
             type Error = E;
 
             forward_to_deserialize_any! {
-                bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-                byte_buf option unit unit_struct newtype_struct seq tuple
-                tuple_struct map struct enum identifier ignored_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
             }
 
             fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -211,13 +280,20 @@ primitive_deserializer!(f32, "an `f32`.", F32Deserializer, visit_f32);
 primitive_deserializer!(f64, "an `f64`.", F64Deserializer, visit_f64);
 primitive_deserializer!(char, "a `char`.", CharDeserializer, visit_char);
 
+serde_if_integer128! {
+    primitive_deserializer!(i128, "an `i128`.", I128Deserializer, visit_i128);
+    primitive_deserializer!(u128, "a `u128`.", U128Deserializer, visit_u128);
+}
+
 /// A deserializer holding a `u32`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct U32Deserializer<E> {
     value: u32,
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(U32Deserializer);
+
 impl<'de, E> IntoDeserializer<'de, E> for u32
 where
     E: de::Error,
@@ -239,9 +315,9 @@ where
     type Error = E;
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct identifier ignored_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 identifier ignored_any
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -284,12 +360,14 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `&str`.
-#[derive(Clone, Debug)]
+#[derive(Debug)]
 pub struct StrDeserializer<'a, E> {
     value: &'a str,
     marker: PhantomData<E>,
 }
 
+impl_copy_clone!(StrDeserializer<'de>);
+
 impl<'de, 'a, E> IntoDeserializer<'de, E> for &'a str
 where
     E: de::Error,
@@ -332,9 +410,9 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct identifier ignored_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 identifier ignored_any
     }
 }
 
@@ -355,15 +433,96 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer holding a `&str` with a lifetime tied to another
+/// deserializer.
+#[derive(Debug)]
+pub struct BorrowedStrDeserializer<'de, E> {
+    value: &'de str,
+    marker: PhantomData<E>,
+}
+
+impl_copy_clone!(BorrowedStrDeserializer<'de>);
+
+impl<'de, E> BorrowedStrDeserializer<'de, E> {
+    /// Create a new borrowed deserializer from the given string.
+    pub fn new(value: &'de str) -> BorrowedStrDeserializer<'de, E> {
+        BorrowedStrDeserializer {
+            value: value,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, E> de::Deserializer<'de> for BorrowedStrDeserializer<'de, E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_borrowed_str(self.value)
+    }
+
+    fn deserialize_enum<V>(
+        self,
+        name: &str,
+        variants: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        let _ = name;
+        let _ = variants;
+        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 identifier ignored_any
+    }
+}
+
+impl<'de, E> de::EnumAccess<'de> for BorrowedStrDeserializer<'de, E>
+where
+    E: de::Error,
+{
+    type Error = E;
+    type Variant = private::UnitOnly<E>;
+
+    fn variant_seed<T>(self, seed: T) -> Result<(T::Value, Self::Variant), Self::Error>
+    where
+        T: de::DeserializeSeed<'de>,
+    {
+        seed.deserialize(self).map(private::unit_only)
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 /// A deserializer holding a `String`.
-#[cfg(any(feature = "std", feature = "collections"))]
-#[derive(Clone, Debug)]
+#[cfg(any(feature = "std", feature = "alloc"))]
+#[derive(Debug)]
 pub struct StringDeserializer<E> {
     value: String,
     marker: PhantomData<E>,
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<E> Clone for StringDeserializer<E> {
+    fn clone(&self) -> Self {
+        StringDeserializer {
+            value: self.value.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, E> IntoDeserializer<'de, E> for String
 where
     E: de::Error,
@@ -378,7 +537,7 @@ where
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, E> de::Deserializer<'de> for StringDeserializer<E>
 where
     E: de::Error,
@@ -407,13 +566,13 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct identifier ignored_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 identifier ignored_any
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
 where
     E: de::Error,
@@ -432,14 +591,24 @@ where
 ////////////////////////////////////////////////////////////////////////////////
 
 /// A deserializer holding a `Cow<str>`.
-#[cfg(any(feature = "std", feature = "collections"))]
-#[derive(Clone, Debug)]
+#[cfg(any(feature = "std", feature = "alloc"))]
+#[derive(Debug)]
 pub struct CowStrDeserializer<'a, E> {
     value: Cow<'a, str>,
     marker: PhantomData<E>,
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, E> Clone for CowStrDeserializer<'a, E> {
+    fn clone(&self) -> Self {
+        CowStrDeserializer {
+            value: self.value.clone(),
+            marker: PhantomData,
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, E> IntoDeserializer<'de, E> for Cow<'a, str>
 where
     E: de::Error,
@@ -454,7 +623,7 @@ where
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, E> de::Deserializer<'de> for CowStrDeserializer<'a, E>
 where
     E: de::Error,
@@ -486,13 +655,13 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct identifier ignored_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 identifier ignored_any
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, 'a, E> de::EnumAccess<'de> for CowStrDeserializer<'a, E>
 where
     E: de::Error,
@@ -510,6 +679,48 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
+/// A deserializer holding a `&[u8]` with a lifetime tied to another
+/// deserializer.
+#[derive(Debug)]
+pub struct BorrowedBytesDeserializer<'de, E> {
+    value: &'de [u8],
+    marker: PhantomData<E>,
+}
+
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
+impl<'de, E> BorrowedBytesDeserializer<'de, E> {
+    /// Create a new borrowed deserializer from the given byte slice.
+    pub fn new(value: &'de [u8]) -> BorrowedBytesDeserializer<'de, E> {
+        BorrowedBytesDeserializer {
+            value: value,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+where
+    E: de::Error,
+{
+    type Error = E;
+
+    fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: de::Visitor<'de>,
+    {
+        visitor.visit_borrowed_bytes(self.value)
+    }
+
+    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 identifier ignored_any enum
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 /// A deserializer that iterates over a sequence.
 #[derive(Clone, Debug)]
 pub struct SeqDeserializer<I, E> {
@@ -539,17 +750,17 @@ where
 {
     /// Check for remaining elements after passing a `SeqDeserializer` to
     /// `Visitor::visit_seq`.
-    pub fn end(mut self) -> Result<(), E> {
-        let mut remaining = 0;
-        while self.iter.next().is_some() {
-            remaining += 1;
-        }
+    pub fn end(self) -> Result<(), E> {
+        let remaining = self.iter.count();
         if remaining == 0 {
             Ok(())
         } else {
             // First argument is the number of elements in the data, second
             // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(self.count + remaining, &ExpectedInSeq(self.count)),)
+            Err(de::Error::invalid_length(
+                self.count + remaining,
+                &ExpectedInSeq(self.count),
+            ))
         }
     }
 }
@@ -572,9 +783,9 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_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
     }
 }
 
@@ -618,26 +829,26 @@ impl Expected for ExpectedInSeq {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, T, E> IntoDeserializer<'de, E> for Vec<T>
 where
     T: IntoDeserializer<'de, E>,
     E: de::Error,
 {
-    type Deserializer = SeqDeserializer<<Vec<T> as IntoIterator>::IntoIter, E>;
+    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         SeqDeserializer::new(self.into_iter())
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, T, E> IntoDeserializer<'de, E> for BTreeSet<T>
 where
     T: IntoDeserializer<'de, E> + Eq + Ord,
     E: de::Error,
 {
-    type Deserializer = SeqDeserializer<<BTreeSet<T> as IntoIterator>::IntoIter, E>;
+    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         SeqDeserializer::new(self.into_iter())
@@ -645,12 +856,13 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<'de, T, E> IntoDeserializer<'de, E> for HashSet<T>
+impl<'de, T, S, E> IntoDeserializer<'de, E> for HashSet<T, S>
 where
     T: IntoDeserializer<'de, E> + Eq + Hash,
+    S: BuildHasher,
     E: de::Error,
 {
-    type Deserializer = SeqDeserializer<<HashSet<T> as IntoIterator>::IntoIter, E>;
+    type Deserializer = SeqDeserializer<<Self as IntoIterator>::IntoIter, E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         SeqDeserializer::new(self.into_iter())
@@ -686,9 +898,9 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_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
     }
 }
 
@@ -732,17 +944,17 @@ where
 {
     /// Check for remaining elements after passing a `MapDeserializer` to
     /// `Visitor::visit_map`.
-    pub fn end(mut self) -> Result<(), E> {
-        let mut remaining = 0;
-        while self.iter.next().is_some() {
-            remaining += 1;
-        }
+    pub fn end(self) -> Result<(), E> {
+        let remaining = self.iter.count();
         if remaining == 0 {
             Ok(())
         } else {
             // First argument is the number of elements in the data, second
             // argument is the number of elements expected by the Deserialize.
-            Err(de::Error::invalid_length(self.count + remaining, &ExpectedInMap(self.count)),)
+            Err(de::Error::invalid_length(
+                self.count + remaining,
+                &ExpectedInMap(self.count),
+            ))
         }
     }
 }
@@ -791,11 +1003,7 @@ where
         Ok(value)
     }
 
-    fn deserialize_tuple<V>(
-        self,
-        len: usize,
-        visitor: V,
-    ) -> Result<V::Value, Self::Error>
+    fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, Self::Error>
     where
         V: de::Visitor<'de>,
     {
@@ -804,9 +1012,9 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct tuple_struct map struct
-        enum identifier ignored_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 tuple_struct map
+        struct enum identifier ignored_any
     }
 }
 
@@ -946,9 +1154,9 @@ where
     type Error = E;
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct tuple_struct map struct
-        enum identifier ignored_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 tuple_struct map
+        struct enum identifier ignored_any
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
@@ -1036,14 +1244,14 @@ impl Expected for ExpectedInMap {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl<'de, K, V, E> IntoDeserializer<'de, E> for BTreeMap<K, V>
 where
     K: IntoDeserializer<'de, E> + Eq + Ord,
     V: IntoDeserializer<'de, E>,
     E: de::Error,
 {
-    type Deserializer = MapDeserializer<'de, <BTreeMap<K, V> as IntoIterator>::IntoIter, E>;
+    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         MapDeserializer::new(self.into_iter())
@@ -1051,13 +1259,14 @@ where
 }
 
 #[cfg(feature = "std")]
-impl<'de, K, V, E> IntoDeserializer<'de, E> for HashMap<K, V>
+impl<'de, K, V, S, E> IntoDeserializer<'de, E> for HashMap<K, V, S>
 where
     K: IntoDeserializer<'de, E> + Eq + Hash,
     V: IntoDeserializer<'de, E>,
+    S: BuildHasher,
     E: de::Error,
 {
-    type Deserializer = MapDeserializer<'de, <HashMap<K, V> as IntoIterator>::IntoIter, E>;
+    type Deserializer = MapDeserializer<'de, <Self as IntoIterator>::IntoIter, E>;
 
     fn into_deserializer(self) -> Self::Deserializer {
         MapDeserializer::new(self.into_iter())
@@ -1093,9 +1302,9 @@ where
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_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
     }
 }
 
@@ -1112,7 +1321,12 @@ mod private {
     }
 
     pub fn unit_only<T, E>(t: T) -> (T, UnitOnly<E>) {
-        (t, UnitOnly { marker: PhantomData })
+        (
+            t,
+            UnitOnly {
+                marker: PhantomData,
+            },
+        )
     }
 
     impl<'de, E> de::VariantAccess<'de> for UnitOnly<E>
@@ -1129,14 +1343,20 @@ mod private {
         where
             T: de::DeserializeSeed<'de>,
         {
-            Err(de::Error::invalid_type(Unexpected::UnitVariant, &"newtype variant"),)
+            Err(de::Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"newtype variant",
+            ))
         }
 
         fn tuple_variant<V>(self, _len: usize, _visitor: V) -> Result<V::Value, Self::Error>
         where
             V: de::Visitor<'de>,
         {
-            Err(de::Error::invalid_type(Unexpected::UnitVariant, &"tuple variant"),)
+            Err(de::Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"tuple variant",
+            ))
         }
 
         fn struct_variant<V>(
@@ -1147,7 +1367,10 @@ mod private {
         where
             V: de::Visitor<'de>,
         {
-            Err(de::Error::invalid_type(Unexpected::UnitVariant, &"struct variant"),)
+            Err(de::Error::invalid_type(
+                Unexpected::UnitVariant,
+                &"struct variant",
+            ))
         }
     }
 

serde/src/export.rs

@@ -12,14 +12,17 @@ pub use lib::default::Default;
 pub use lib::fmt::{self, Formatter};
 pub use lib::marker::PhantomData;
 pub use lib::option::Option::{self, None, Some};
-pub use lib::result::Result::{self, Ok, Err};
+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;
+
 mod string {
     use lib::*;
 
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
         String::from_utf8_lossy(bytes)
     }
@@ -31,7 +34,7 @@ mod string {
     //
     // so it is okay for the return type to be different from the std case as long
     // as the above works.
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
         // Three unicode replacement characters if it fails. They look like a
         // white-on-black question mark. The user will recognize it as invalid

serde/src/integer128.rs

@@ -0,0 +1,86 @@
+/// Conditional compilation depending on whether Serde is built with support for
+/// 128-bit integers.
+///
+/// Data formats that wish to support Rust compiler versions older than 1.26 may
+/// place the i128 / u128 methods of their Serializer and Deserializer behind
+/// this macro.
+///
+/// Data formats that require a minimum Rust compiler version of at least 1.26
+/// do not need to bother with this macro and may assume support for 128-bit
+/// integers.
+///
+/// ```rust
+/// #[macro_use]
+/// extern crate serde;
+///
+/// use serde::Serializer;
+/// # use serde::private::ser::Error;
+/// #
+/// # struct MySerializer;
+///
+/// impl Serializer for MySerializer {
+///     type Ok = ();
+///     type Error = Error;
+///
+///     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error> {
+///         /* ... */
+/// #         unimplemented!()
+///     }
+///
+///     /* ... */
+///
+///     serde_if_integer128! {
+///         fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+///             /* ... */
+/// #             unimplemented!()
+///         }
+///
+///         fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+///             /* ... */
+/// #             unimplemented!()
+///         }
+///     }
+/// #
+/// #     __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
+/// macro_rules! serde_if_integer128 {
+///     ($($tt:tt)*) => {
+///         $($tt)*
+///     };
+/// }
+/// ```
+///
+/// When built without support for 128-bit integers, this macro expands to
+/// nothing.
+///
+/// ```rust
+/// macro_rules! serde_if_integer128 {
+///     ($($tt:tt)*) => {};
+/// }
+/// ```
+#[cfg(integer128)]
+#[macro_export]
+macro_rules! serde_if_integer128 {
+    ($($tt:tt)*) => {
+        $($tt)*
+    };
+}
+
+#[cfg(not(integer128))]
+#[macro_export]
+#[doc(hidden)]
+macro_rules! serde_if_integer128 {
+    ($($tt:tt)*) => {};
+}

serde/src/lib.rs

@@ -52,6 +52,8 @@
 //! - [Pickle], a format common in the Python world.
 //! - [Hjson], a variant of JSON designed to be readable and writable by humans.
 //! - [BSON], the data storage and network transfer format used by MongoDB.
+//! - [Avro], a binary format used within Apache Hadoop, with support for schema
+//!   definition.
 //! - [URL], the x-www-form-urlencoded format.
 //! - [XML], the flexible machine-friendly W3C standard.
 //!   *(deserialization only)*
@@ -69,6 +71,7 @@
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [Hjson]: https://github.com/laktak/hjson-rust
 //! [BSON]: https://github.com/zonyitoo/bson-rs
+//! [Avro]: https://github.com/flavray/avro-rs
 //! [URL]: https://github.com/nox/serde_urlencoded
 //! [XML]: https://github.com/RReverser/serde-xml-rs
 //! [Envy]: https://github.com/softprops/envy
@@ -79,55 +82,76 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.0")]
-
+#![doc(html_root_url = "https://docs.rs/serde/1.0.70")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
-
 // Unstable functionality only if the user asks for it. For tracking and
 // discussion of these features please refer to this issue:
 //
 //    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(nonzero, specialization, zero_one))]
-#![cfg_attr(all(feature = "std", feature = "unstable"), feature(into_boxed_c_str))]
+#![cfg_attr(feature = "unstable", feature(specialization, never_type))]
 #![cfg_attr(feature = "alloc", feature(alloc))]
-#![cfg_attr(feature = "collections", feature(collections))]
-
-// Whitelisted clippy lints.
-#![cfg_attr(feature = "cargo-clippy", allow(doc_markdown))]
-#![cfg_attr(feature = "cargo-clippy", allow(linkedlist))]
-#![cfg_attr(feature = "cargo-clippy", allow(type_complexity))]
-#![cfg_attr(feature = "cargo-clippy", allow(zero_prefixed_literal))]
-
+#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+// Whitelisted clippy lints
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        cast_lossless, const_static_lifetime, doc_markdown, linkedlist, needless_pass_by_value,
+        redundant_field_names, type_complexity, unreadable_literal, zero_prefixed_literal
+    )
+)]
+// 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.
-#![deny(missing_docs, unused_imports)]
+//
+// Compiler bug involving unused_imports:
+// https://github.com/rust-lang/rust/issues/51661
+#![deny(missing_docs, /*unused_imports*/)]
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "collections")]
-extern crate collections;
-
 #[cfg(feature = "alloc")]
 extern crate alloc;
 
-#[cfg(all(feature = "unstable", feature = "std"))]
-extern crate core;
-
-/// A facade around all the types we need from the `std`, `core`, `alloc`, and
-/// `collections` crates. This avoids elaborate import wrangling having to
-/// happen in every module.
+/// A facade around all the types we need from the `std`, `core`, and `alloc`
+/// crates. This avoids elaborate import wrangling having to happen in every
+/// module.
 mod lib {
     mod core {
-        #[cfg(feature = "std")]
-        pub use std::*;
         #[cfg(not(feature = "std"))]
         pub use core::*;
+        #[cfg(feature = "std")]
+        pub use std::*;
     }
 
-    pub use self::core::{cmp, iter, mem, ops, str};
-    pub use self::core::{i8, i16, i32, i64, isize};
-    pub use self::core::{u8, u16, u32, u64, usize};
+    pub use self::core::{cmp, iter, mem, num, ops, 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};
 
     pub use self::core::cell::{Cell, RefCell};
     pub use self::core::clone::{self, Clone};
@@ -138,40 +162,40 @@ mod lib {
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
 
+    #[cfg(all(feature = "alloc", not(feature = "std")))]
+    pub use alloc::borrow::{Cow, ToOwned};
     #[cfg(feature = "std")]
     pub use std::borrow::{Cow, ToOwned};
-    #[cfg(all(feature = "collections", not(feature = "std")))]
-    pub use collections::borrow::{Cow, ToOwned};
 
+    #[cfg(all(feature = "alloc", not(feature = "std")))]
+    pub use alloc::string::{String, ToString};
     #[cfg(feature = "std")]
     pub use std::string::String;
-    #[cfg(all(feature = "collections", not(feature = "std")))]
-    pub use collections::string::{String, ToString};
 
+    #[cfg(all(feature = "alloc", not(feature = "std")))]
+    pub use alloc::vec::Vec;
     #[cfg(feature = "std")]
     pub use std::vec::Vec;
-    #[cfg(all(feature = "collections", not(feature = "std")))]
-    pub use collections::vec::Vec;
 
-    #[cfg(feature = "std")]
-    pub use std::boxed::Box;
     #[cfg(all(feature = "alloc", not(feature = "std")))]
     pub use alloc::boxed::Box;
-
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::rc::Rc;
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::rc::Rc;
-
-    #[cfg(all(feature = "rc", feature = "std"))]
-    pub use std::sync::Arc;
-    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
-    pub use alloc::arc::Arc;
-
     #[cfg(feature = "std")]
-    pub use std::collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque};
-    #[cfg(all(feature = "collections", not(feature = "std")))]
-    pub use collections::{BinaryHeap, BTreeMap, BTreeSet, LinkedList, VecDeque};
+    pub use std::boxed::Box;
+
+    #[cfg(all(feature = "rc", feature = "alloc", not(feature = "std")))]
+    pub use alloc::rc::{Rc, Weak as RcWeak};
+    #[cfg(all(feature = "rc", feature = "std"))]
+    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};
+    #[cfg(all(feature = "rc", feature = "std"))]
+    pub use std::sync::{Arc, Weak as ArcWeak};
+
+    #[cfg(all(feature = "alloc", not(feature = "std")))]
+    pub use alloc::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
+    #[cfg(feature = "std")]
+    pub use std::collections::{BTreeMap, BTreeSet, BinaryHeap, LinkedList, VecDeque};
 
     #[cfg(feature = "std")]
     pub use std::{error, net};
@@ -179,23 +203,22 @@ mod lib {
     #[cfg(feature = "std")]
     pub use std::collections::{HashMap, HashSet};
     #[cfg(feature = "std")]
-    pub use std::ffi::{CString, CStr, OsString, OsStr};
+    pub use std::ffi::{CStr, CString, OsStr, OsString};
     #[cfg(feature = "std")]
-    pub use std::hash::{Hash, BuildHasher};
+    pub use std::hash::{BuildHasher, Hash};
     #[cfg(feature = "std")]
     pub use std::io::Write;
     #[cfg(feature = "std")]
+    pub use std::num::Wrapping;
+    #[cfg(feature = "std")]
     pub use std::path::{Path, PathBuf};
     #[cfg(feature = "std")]
-    pub use std::time::Duration;
-    #[cfg(feature = "std")]
     pub use std::sync::{Mutex, RwLock};
+    #[cfg(feature = "std")]
+    pub use std::time::{SystemTime, UNIX_EPOCH};
 
-    #[cfg(feature = "unstable")]
-    pub use core::nonzero::{NonZero, Zeroable};
-    #[cfg(feature = "unstable")]
-    #[allow(deprecated)] // required for impl Deserialize for NonZero<T>
-    pub use core::num::Zero;
+    #[cfg(any(core_duration, feature = "std"))]
+    pub use self::core::time::Duration;
 }
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -203,13 +226,16 @@ mod lib {
 #[macro_use]
 mod macros;
 
-pub mod ser;
+#[macro_use]
+mod integer128;
+
 pub mod de;
+pub mod ser;
 
-#[doc(inline)]
-pub use ser::{Serialize, Serializer};
 #[doc(inline)]
 pub use de::{Deserialize, Deserializer};
+#[doc(inline)]
+pub use ser::{Serialize, Serializer};
 
 // Generated code uses these to support no_std. Not public API.
 #[doc(hidden)]

serde/src/macros.rs

@@ -31,21 +31,23 @@
 /// #     type Error = value::Error;
 /// #
 /// #     fn deserialize_any<V>(self, _: V) -> Result<V::Value, Self::Error>
-/// #         where V: Visitor<'de>
+/// #     where
+/// #         V: Visitor<'de>,
 /// #     {
 /// #         unimplemented!()
 /// #     }
 /// #
 /// #[inline]
 /// fn deserialize_bool<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-///     where V: Visitor<'de>
+/// where
+///     V: Visitor<'de>,
 /// {
 ///     self.deserialize_any(visitor)
 /// }
 /// #
 /// #     forward_to_deserialize_any! {
-/// #         i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-/// #         byte_buf option unit unit_struct newtype_struct seq tuple
+/// #         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
 /// #     }
 /// # }
@@ -69,7 +71,8 @@
 /// #   type Error = value::Error;
 /// #
 ///     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
-///         where V: Visitor<'de>
+///     where
+///         V: Visitor<'de>,
 ///     {
 ///         /* ... */
 /// #       let _ = visitor;
@@ -77,8 +80,8 @@
 ///     }
 ///
 ///     forward_to_deserialize_any! {
-///         bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-///         byte_buf option unit unit_struct newtype_struct seq tuple
+///         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
 ///     }
 /// }
@@ -105,16 +108,17 @@
 /// #     type Error = value::Error;
 /// #
 /// #     fn deserialize_any<W>(self, visitor: W) -> Result<W::Value, Self::Error>
-/// #         where W: Visitor<'q>
+/// #     where
+/// #         W: Visitor<'q>,
 /// #     {
 /// #         unimplemented!()
 /// #     }
 /// #
 /// forward_to_deserialize_any! {
 ///     <W: Visitor<'q>>
-///     bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-///     byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-///     map struct enum identifier ignored_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
 /// }
 /// # }
 /// #
@@ -124,7 +128,7 @@
 /// [`Deserializer`]: trait.Deserializer.html
 /// [`Visitor`]: de/trait.Visitor.html
 /// [`Deserializer::deserialize_any`]: trait.Deserializer.html#tymethod.deserialize_any
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! forward_to_deserialize_any {
     (<$visitor:ident: Visitor<$lifetime:tt>> $($func:ident)*) => {
         $(forward_to_deserialize_any_helper!{$func<$lifetime, $visitor>})*
@@ -153,7 +157,7 @@ macro_rules! forward_to_deserialize_any_method {
 }
 
 #[doc(hidden)]
-#[macro_export]
+#[macro_export(local_inner_macros)]
 macro_rules! forward_to_deserialize_any_helper {
     (bool<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_bool<$l, $v>()}
@@ -170,6 +174,11 @@ macro_rules! forward_to_deserialize_any_helper {
     (i64<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_i64<$l, $v>()}
     };
+    (i128<$l:tt, $v:ident>) => {
+        serde_if_integer128! {
+            forward_to_deserialize_any_method!{deserialize_i128<$l, $v>()}
+        }
+    };
     (u8<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_u8<$l, $v>()}
     };
@@ -182,6 +191,11 @@ macro_rules! forward_to_deserialize_any_helper {
     (u64<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_u64<$l, $v>()}
     };
+    (u128<$l:tt, $v:ident>) => {
+        serde_if_integer128! {
+            forward_to_deserialize_any_method!{deserialize_u128<$l, $v>()}
+        }
+    };
     (f32<$l:tt, $v:ident>) => {
         forward_to_deserialize_any_method!{deserialize_f32<$l, $v>()}
     };

serde/src/private/macros.rs

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

serde/src/private/mod.rs

@@ -8,5 +8,5 @@
 
 mod macros;
 
-pub mod ser;
 pub mod de;
+pub mod ser;

serde/src/private/ser.rs

@@ -8,10 +8,12 @@
 
 use lib::*;
 
-use ser::{self, Serialize, Serializer, SerializeMap, SerializeStruct, Impossible};
+use ser::{self, Impossible, Serialize, SerializeMap, SerializeStruct, Serializer};
 
-#[cfg(any(feature = "std", feature = "collections"))]
-use self::content::{SerializeTupleVariantAsMapValue, SerializeStructVariantAsMapValue};
+#[cfg(any(feature = "std", feature = "alloc"))]
+use self::content::{
+    Content, ContentSerializer, SerializeStructVariantAsMapValue, SerializeTupleVariantAsMapValue,
+};
 
 /// Used to check that serde(getter) attributes return the expected type.
 /// Not public API.
@@ -32,15 +34,13 @@ where
     S: Serializer,
     T: Serialize,
 {
-    value.serialize(
-        TaggedSerializer {
-            type_ident: type_ident,
-            variant_ident: variant_ident,
-            tag: tag,
-            variant_name: variant_name,
-            delegate: serializer,
-        },
-    )
+    value.serialize(TaggedSerializer {
+        type_ident: type_ident,
+        variant_ident: variant_ident,
+        tag: tag,
+        variant_name: variant_name,
+        delegate: serializer,
+    })
 }
 
 struct TaggedSerializer<S> {
@@ -60,11 +60,11 @@ enum Unsupported {
     ByteArray,
     Optional,
     Unit,
+    #[cfg(any(feature = "std", feature = "alloc"))]
     UnitStruct,
     Sequence,
     Tuple,
     TupleStruct,
-    #[cfg(not(any(feature = "std", feature = "collections")))]
     Enum,
 }
 
@@ -79,11 +79,11 @@ impl Display for Unsupported {
             Unsupported::ByteArray => formatter.write_str("a byte array"),
             Unsupported::Optional => formatter.write_str("an optional"),
             Unsupported::Unit => formatter.write_str("unit"),
-            Unsupported::UnitStruct => formatter.write_str("a unit struct"),
+            #[cfg(any(feature = "std", feature = "alloc"))]
+            Unsupported::UnitStruct => formatter.write_str("unit struct"),
             Unsupported::Sequence => formatter.write_str("a sequence"),
             Unsupported::Tuple => formatter.write_str("a tuple"),
             Unsupported::TupleStruct => formatter.write_str("a tuple struct"),
-            #[cfg(not(any(feature = "std", feature = "collections")))]
             Unsupported::Enum => formatter.write_str("an enum"),
         }
     }
@@ -94,13 +94,10 @@ where
     S: Serializer,
 {
     fn bad_type(self, what: Unsupported) -> S::Error {
-        ser::Error::custom(
-            format_args!(
+        ser::Error::custom(format_args!(
             "cannot serialize tagged newtype variant {}::{} containing {}",
-            self.type_ident,
-            self.variant_ident,
-            what),
-        )
+            self.type_ident, self.variant_ident, what
+        ))
     }
 }
 
@@ -117,14 +114,14 @@ where
     type SerializeMap = S::SerializeMap;
     type SerializeStruct = S::SerializeStruct;
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     type SerializeTupleVariant = SerializeTupleVariantAsMapValue<S::SerializeMap>;
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     type SerializeStructVariant = Impossible<S::Ok, S::Error>;
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     type SerializeStructVariant = SerializeStructVariantAsMapValue<S::SerializeMap>;
 
     fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
@@ -199,7 +196,9 @@ where
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::UnitStruct))
+        let mut map = try!(self.delegate.serialize_map(Some(1)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        map.end()
     }
 
     fn serialize_unit_variant(
@@ -257,7 +256,7 @@ where
         Err(self.bad_type(Unsupported::TupleStruct))
     }
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     fn serialize_tuple_variant(
         self,
         _: &'static str,
@@ -270,7 +269,7 @@ where
         Err(self.bad_type(Unsupported::Enum))
     }
 
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn serialize_tuple_variant(
         self,
         _: &'static str,
@@ -281,7 +280,11 @@ where
         let mut map = try!(self.delegate.serialize_map(Some(2)));
         try!(map.serialize_entry(self.tag, self.variant_name));
         try!(map.serialize_key(inner_variant));
-        Ok(SerializeTupleVariantAsMapValue::new(map, inner_variant, len),)
+        Ok(SerializeTupleVariantAsMapValue::new(
+            map,
+            inner_variant,
+            len,
+        ))
     }
 
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
@@ -300,7 +303,7 @@ where
         Ok(state)
     }
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     fn serialize_struct_variant(
         self,
         _: &'static str,
@@ -313,7 +316,7 @@ where
         Err(self.bad_type(Unsupported::Enum))
     }
 
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn serialize_struct_variant(
         self,
         _: &'static str,
@@ -324,10 +327,14 @@ where
         let mut map = try!(self.delegate.serialize_map(Some(2)));
         try!(map.serialize_entry(self.tag, self.variant_name));
         try!(map.serialize_key(inner_variant));
-        Ok(SerializeStructVariantAsMapValue::new(map, inner_variant, len),)
+        Ok(SerializeStructVariantAsMapValue::new(
+            map,
+            inner_variant,
+            len,
+        ))
     }
 
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     fn collect_str<T: ?Sized>(self, _: &T) -> Result<Self::Ok, Self::Error>
     where
         T: Display,
@@ -363,7 +370,7 @@ impl Display for Error {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 mod content {
     use lib::*;
 
@@ -402,7 +409,10 @@ 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()
         }
     }
@@ -444,13 +454,16 @@ 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()
         }
     }
 
     #[derive(Debug)]
-    enum Content {
+    pub enum Content {
         Bool(bool),
 
         U8(u8),
@@ -485,7 +498,12 @@ mod content {
         TupleVariant(&'static str, u32, &'static str, Vec<Content>),
         Map(Vec<(Content, Content)>),
         Struct(&'static str, Vec<(&'static str, Content)>),
-        StructVariant(&'static str, u32, &'static str, Vec<(&'static str, Content)>),
+        StructVariant(
+            &'static str,
+            u32,
+            &'static str,
+            Vec<(&'static str, Content)>,
+        ),
     }
 
     impl Serialize for Content {
@@ -570,12 +588,12 @@ mod content {
         }
     }
 
-    struct ContentSerializer<E> {
+    pub struct ContentSerializer<E> {
         error: PhantomData<E>,
     }
 
     impl<E> ContentSerializer<E> {
-        fn new() -> Self {
+        pub fn new() -> Self {
             ContentSerializer { error: PhantomData }
         }
     }
@@ -687,7 +705,10 @@ mod content {
         where
             T: Serialize,
         {
-            Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))),)
+            Ok(Content::NewtypeStruct(
+                name,
+                Box::new(try!(value.serialize(self))),
+            ))
         }
 
         fn serialize_newtype_variant<T: ?Sized>(
@@ -700,32 +721,26 @@ mod content {
         where
             T: Serialize,
         {
-            Ok(
-                Content::NewtypeVariant(
-                    name,
-                    variant_index,
-                    variant,
-                    Box::new(try!(value.serialize(self))),
-                ),
-            )
+            Ok(Content::NewtypeVariant(
+                name,
+                variant_index,
+                variant,
+                Box::new(try!(value.serialize(self))),
+            ))
         }
 
         fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, E> {
-            Ok(
-                SerializeSeq {
-                    elements: Vec::with_capacity(len.unwrap_or(0)),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeSeq {
+                elements: Vec::with_capacity(len.unwrap_or(0)),
+                error: PhantomData,
+            })
         }
 
         fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, E> {
-            Ok(
-                SerializeTuple {
-                    elements: Vec::with_capacity(len),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeTuple {
+                elements: Vec::with_capacity(len),
+                error: PhantomData,
+            })
         }
 
         fn serialize_tuple_struct(
@@ -733,13 +748,11 @@ mod content {
             name: &'static str,
             len: usize,
         ) -> Result<Self::SerializeTupleStruct, E> {
-            Ok(
-                SerializeTupleStruct {
-                    name: name,
-                    fields: Vec::with_capacity(len),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeTupleStruct {
+                name: name,
+                fields: Vec::with_capacity(len),
+                error: PhantomData,
+            })
         }
 
         fn serialize_tuple_variant(
@@ -749,25 +762,21 @@ mod content {
             variant: &'static str,
             len: usize,
         ) -> Result<Self::SerializeTupleVariant, E> {
-            Ok(
-                SerializeTupleVariant {
-                    name: name,
-                    variant_index: variant_index,
-                    variant: variant,
-                    fields: Vec::with_capacity(len),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeTupleVariant {
+                name: name,
+                variant_index: variant_index,
+                variant: variant,
+                fields: Vec::with_capacity(len),
+                error: PhantomData,
+            })
         }
 
         fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, E> {
-            Ok(
-                SerializeMap {
-                    entries: Vec::with_capacity(len.unwrap_or(0)),
-                    key: None,
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeMap {
+                entries: Vec::with_capacity(len.unwrap_or(0)),
+                key: None,
+                error: PhantomData,
+            })
         }
 
         fn serialize_struct(
@@ -775,13 +784,11 @@ mod content {
             name: &'static str,
             len: usize,
         ) -> Result<Self::SerializeStruct, E> {
-            Ok(
-                SerializeStruct {
-                    name: name,
-                    fields: Vec::with_capacity(len),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeStruct {
+                name: name,
+                fields: Vec::with_capacity(len),
+                error: PhantomData,
+            })
         }
 
         fn serialize_struct_variant(
@@ -791,19 +798,17 @@ mod content {
             variant: &'static str,
             len: usize,
         ) -> Result<Self::SerializeStructVariant, E> {
-            Ok(
-                SerializeStructVariant {
-                    name: name,
-                    variant_index: variant_index,
-                    variant: variant,
-                    fields: Vec::with_capacity(len),
-                    error: PhantomData,
-                },
-            )
+            Ok(SerializeStructVariant {
+                name: name,
+                variant_index: variant_index,
+                variant: variant,
+                fields: Vec::with_capacity(len),
+                error: PhantomData,
+            })
         }
     }
 
-    struct SerializeSeq<E> {
+    pub struct SerializeSeq<E> {
         elements: Vec<Content>,
         error: PhantomData<E>,
     }
@@ -829,7 +834,7 @@ mod content {
         }
     }
 
-    struct SerializeTuple<E> {
+    pub struct SerializeTuple<E> {
         elements: Vec<Content>,
         error: PhantomData<E>,
     }
@@ -855,7 +860,7 @@ mod content {
         }
     }
 
-    struct SerializeTupleStruct<E> {
+    pub struct SerializeTupleStruct<E> {
         name: &'static str,
         fields: Vec<Content>,
         error: PhantomData<E>,
@@ -882,7 +887,7 @@ mod content {
         }
     }
 
-    struct SerializeTupleVariant<E> {
+    pub struct SerializeTupleVariant<E> {
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
@@ -907,11 +912,16 @@ mod content {
         }
 
         fn end(self) -> Result<Content, E> {
-            Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields),)
+            Ok(Content::TupleVariant(
+                self.name,
+                self.variant_index,
+                self.variant,
+                self.fields,
+            ))
         }
     }
 
-    struct SerializeMap<E> {
+    pub struct SerializeMap<E> {
         entries: Vec<(Content, Content)>,
         key: Option<Content>,
         error: PhantomData<E>,
@@ -937,7 +947,8 @@ mod content {
         where
             T: Serialize,
         {
-            let key = self.key
+            let key = self
+                .key
                 .take()
                 .expect("serialize_value called before serialize_key");
             let value = try!(value.serialize(ContentSerializer::<E>::new()));
@@ -961,7 +972,7 @@ mod content {
         }
     }
 
-    struct SerializeStruct<E> {
+    pub struct SerializeStruct<E> {
         name: &'static str,
         fields: Vec<(&'static str, Content)>,
         error: PhantomData<E>,
@@ -988,7 +999,7 @@ mod content {
         }
     }
 
-    struct SerializeStructVariant<E> {
+    pub struct SerializeStructVariant<E> {
         name: &'static str,
         variant_index: u32,
         variant: &'static str,
@@ -1013,7 +1024,314 @@ mod content {
         }
 
         fn end(self) -> Result<Content, E> {
-            Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields),)
+            Ok(Content::StructVariant(
+                self.name,
+                self.variant_index,
+                self.variant,
+                self.fields,
+            ))
         }
     }
 }
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializer<'a, M: 'a>(pub &'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> FlatMapSerializer<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    fn bad_type(self, what: Unsupported) -> M::Error {
+        ser::Error::custom(format_args!(
+            "can only flatten structs and maps (got {})",
+            what
+        ))
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> Serializer for FlatMapSerializer<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    type SerializeSeq = Impossible<Self::Ok, M::Error>;
+    type SerializeTuple = Impossible<Self::Ok, M::Error>;
+    type SerializeTupleStruct = Impossible<Self::Ok, M::Error>;
+    type SerializeMap = FlatMapSerializeMap<'a, M>;
+    type SerializeStruct = FlatMapSerializeStruct<'a, M>;
+    type SerializeTupleVariant = Impossible<Self::Ok, M::Error>;
+    type SerializeStructVariant = FlatMapSerializeStructVariantAsMapValue<'a, M>;
+
+    fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Boolean))
+    }
+
+    fn serialize_i8(self, _: i8) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i16(self, _: i16) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i32(self, _: i32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_i64(self, _: i64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u8(self, _: u8) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u16(self, _: u16) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u32(self, _: u32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_u64(self, _: u64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Integer))
+    }
+
+    fn serialize_f32(self, _: f32) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Float))
+    }
+
+    fn serialize_f64(self, _: f64) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Float))
+    }
+
+    fn serialize_char(self, _: char) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Char))
+    }
+
+    fn serialize_str(self, _: &str) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::String))
+    }
+
+    fn serialize_bytes(self, _: &[u8]) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::ByteArray))
+    }
+
+    fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
+        Ok(())
+    }
+
+    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Unit))
+    }
+
+    fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::UnitStruct))
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+    ) -> Result<Self::Ok, Self::Error> {
+        Err(self.bad_type(Unsupported::Enum))
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(
+        self,
+        _: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        value.serialize(self)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _: &'static str,
+        _: u32,
+        variant: &'static str,
+        value: &T,
+    ) -> Result<Self::Ok, Self::Error>
+    where
+        T: Serialize,
+    {
+        try!(self.0.serialize_key(variant));
+        self.0.serialize_value(value)
+    }
+
+    fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+        Err(self.bad_type(Unsupported::Sequence))
+    }
+
+    fn serialize_tuple(self, _: usize) -> Result<Self::SerializeTuple, Self::Error> {
+        Err(self.bad_type(Unsupported::Tuple))
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+        Err(self.bad_type(Unsupported::TupleStruct))
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+        Err(self.bad_type(Unsupported::Enum))
+    }
+
+    fn serialize_map(self, _: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+        Ok(FlatMapSerializeMap(self.0))
+    }
+
+    fn serialize_struct(
+        self,
+        _: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStruct, Self::Error> {
+        Ok(FlatMapSerializeStruct(self.0))
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _: &'static str,
+        _: u32,
+        inner_variant: &'static str,
+        _: usize,
+    ) -> Result<Self::SerializeStructVariant, Self::Error> {
+        try!(self.0.serialize_key(inner_variant));
+        Ok(FlatMapSerializeStructVariantAsMapValue::new(
+            self.0,
+            inner_variant,
+        ))
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeMap<'a, M: 'a>(&'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeMap for FlatMapSerializeMap<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_key(key)
+    }
+
+    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_value(value)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeStruct<'a, M: 'a>(&'a mut M);
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeStruct for FlatMapSerializeStruct<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        self.0.serialize_entry(key, value)
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        Ok(())
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+pub struct FlatMapSerializeStructVariantAsMapValue<'a, M: 'a> {
+    map: &'a mut M,
+    name: &'static str,
+    fields: Vec<(&'static str, Content)>,
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> FlatMapSerializeStructVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    fn new(map: &'a mut M, name: &'static str) -> FlatMapSerializeStructVariantAsMapValue<'a, M> {
+        FlatMapSerializeStructVariantAsMapValue {
+            map: map,
+            name: name,
+            fields: Vec::new(),
+        }
+    }
+}
+
+#[cfg(any(feature = "std", feature = "alloc"))]
+impl<'a, M> ser::SerializeStructVariant for FlatMapSerializeStructVariantAsMapValue<'a, M>
+where
+    M: SerializeMap + 'a,
+{
+    type Ok = ();
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &T,
+    ) -> Result<(), Self::Error>
+    where
+        T: Serialize,
+    {
+        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
+        self.fields.push((key, value));
+        Ok(())
+    }
+
+    fn end(self) -> Result<(), Self::Error> {
+        try!(
+            self.map
+                .serialize_value(&Content::Struct(self.name, self.fields))
+        );
+        Ok(())
+    }
+}

serde/src/ser/impls.rs

@@ -8,10 +8,7 @@
 
 use lib::*;
 
-use ser::{Serialize, SerializeTuple, Serializer};
-
-#[cfg(feature = "std")]
-use ser::Error;
+use ser::{Error, Serialize, SerializeTuple, Serializer};
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -44,6 +41,11 @@ primitive_impl!(f32, serialize_f32);
 primitive_impl!(f64, serialize_f64);
 primitive_impl!(char, serialize_char);
 
+serde_if_integer128! {
+    primitive_impl!(i128, serialize_i128);
+    primitive_impl!(u128, serialize_u128);
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 impl Serialize for str {
@@ -56,7 +58,7 @@ impl Serialize for str {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 impl Serialize for String {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
@@ -67,6 +69,15 @@ impl Serialize for String {
     }
 }
 
+impl<'a> Serialize for fmt::Arguments<'a> {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        serializer.collect_str(self)
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 #[cfg(feature = "std")]
@@ -111,7 +122,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-impl<T> Serialize for PhantomData<T> {
+impl<T: ?Sized> Serialize for PhantomData<T> {
     #[inline]
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -177,6 +188,7 @@ where
     }
 }
 
+#[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! seq_impl {
     ($ty:ident < T $(: $tbound1:ident $(+ $tbound2:ident)*)* $(, $typaram:ident : $bound:ident)* >) => {
         impl<T $(, $typaram)*> Serialize for $ty<T $(, $typaram)*>
@@ -195,22 +207,22 @@ macro_rules! seq_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(BinaryHeap<T: Ord>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(BTreeSet<T: Ord>);
 
 #[cfg(feature = "std")]
 seq_impl!(HashSet<T: Eq + Hash, H: BuildHasher>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(LinkedList<T>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(Vec<T>);
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 seq_impl!(VecDeque<T>);
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -244,6 +256,16 @@ impl Serialize for () {
     }
 }
 
+#[cfg(feature = "unstable")]
+impl Serialize for ! {
+    fn serialize<S>(&self, _serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        *self
+    }
+}
+
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! tuple_impls {
@@ -290,6 +312,7 @@ tuple_impls! {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(any(feature = "std", feature = "alloc"))]
 macro_rules! map_impl {
     ($ty:ident < K $(: $kbound1:ident $(+ $kbound2:ident)*)*, V $(, $typaram:ident : $bound:ident)* >) => {
         impl<K, V $(, $typaram)*> Serialize for $ty<K, V $(, $typaram)*>
@@ -309,7 +332,7 @@ macro_rules! map_impl {
     }
 }
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 map_impl!(BTreeMap<K: Ord, V>);
 
 #[cfg(feature = "std")]
@@ -318,8 +341,12 @@ map_impl!(HashMap<K: Eq + Hash, V, H: BuildHasher>);
 ////////////////////////////////////////////////////////////////////////////////
 
 macro_rules! deref_impl {
-    ($($desc:tt)+) => {
-        impl $($desc)+ {
+    (
+        $(#[doc = $doc:tt])*
+        <$($desc:tt)+
+    ) => {
+        $(#[doc = $doc])*
+        impl <$($desc)+ {
             #[inline]
             fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
             where
@@ -338,19 +365,96 @@ deref_impl!(<'a, T: ?Sized> Serialize for &'a mut T where T: Serialize);
 deref_impl!(<T: ?Sized> Serialize for Box<T> where T: Serialize);
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T> Serialize for Rc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Rc` will serialize a copy of
+    /// the contents of the `Rc` each time the `Rc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Rc<T> where T: Serialize
+}
 
 #[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
-deref_impl!(<T> Serialize for Arc<T> where T: Serialize);
+deref_impl! {
+    /// This impl requires the [`"rc"`] Cargo feature of Serde.
+    ///
+    /// Serializing a data structure containing `Arc` will serialize a copy of
+    /// the contents of the `Arc` each time the `Arc` is referenced within the
+    /// data structure. Serialization will not attempt to deduplicate these
+    /// repeated data.
+    ///
+    /// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+    <T: ?Sized> Serialize for Arc<T> where T: Serialize
+}
 
-#[cfg(any(feature = "std", feature = "collections"))]
+#[cfg(any(feature = "std", feature = "alloc"))]
 deref_impl!(<'a, T: ?Sized> Serialize for Cow<'a, T> where T: Serialize + ToOwned);
 
-#[cfg(feature = "unstable")]
-deref_impl!(<T> Serialize for NonZero<T> where T: Serialize + Zeroable);
+////////////////////////////////////////////////////////////////////////////////
+
+/// This impl requires the [`"rc"`] Cargo feature of Serde.
+///
+/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+impl<T: ?Sized> Serialize for RcWeak<T>
+where
+    T: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.upgrade().serialize(serializer)
+    }
+}
+
+/// This impl requires the [`"rc"`] Cargo feature of Serde.
+///
+/// [`"rc"`]: https://serde.rs/feature-flags.html#-features-rc
+#[cfg(all(feature = "rc", any(feature = "std", feature = "alloc")))]
+impl<T: ?Sized> Serialize for ArcWeak<T>
+where
+    T: Serialize,
+{
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.upgrade().serialize(serializer)
+    }
+}
 
 ////////////////////////////////////////////////////////////////////////////////
 
+macro_rules! nonzero_integers {
+    ( $( $T: ident, )+ ) => {
+        $(
+            #[cfg(num_nonzero)]
+            impl Serialize for num::$T {
+                fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+                where
+                    S: Serializer,
+                {
+                    self.get().serialize(serializer)
+                }
+            }
+        )+
+    }
+}
+
+nonzero_integers! {
+    // Not including signed NonZeroI* since they might be removed
+    NonZeroU8,
+    NonZeroU16,
+    NonZeroU32,
+    NonZeroU64,
+    // FIXME: https://github.com/serde-rs/serde/issues/1136 NonZeroU128,
+    NonZeroUsize,
+}
+
 impl<T> Serialize for Cell<T>
 where
     T: Serialize + Copy,
@@ -371,7 +475,10 @@ where
     where
         S: Serializer,
     {
-        self.borrow().serialize(serializer)
+        match self.try_borrow() {
+            Ok(value) => value.serialize(serializer),
+            Err(_) => Err(S::Error::custom("already mutably borrowed")),
+        }
     }
 }
 
@@ -429,7 +536,7 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
+#[cfg(any(core_duration, feature = "std"))]
 impl Serialize for Duration {
     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
     where
@@ -445,6 +552,25 @@ impl Serialize for Duration {
 
 ////////////////////////////////////////////////////////////////////////////////
 
+#[cfg(feature = "std")]
+impl Serialize for SystemTime {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        use super::SerializeStruct;
+        let duration_since_epoch = self
+            .duration_since(UNIX_EPOCH)
+            .expect("SystemTime must be later than UNIX_EPOCH");
+        let mut state = try!(serializer.serialize_struct("SystemTime", 2));
+        try!(state.serialize_field("secs_since_epoch", &duration_since_epoch.as_secs()));
+        try!(state.serialize_field("nanos_since_epoch", &duration_since_epoch.subsec_nanos()));
+        state.end()
+    }
+}
+
+////////////////////////////////////////////////////////////////////////////////
+
 /// Serialize a value that implements `Display` as a string, when that string is
 /// statically known to never have more than a constant `MAX_LEN` bytes.
 ///
@@ -464,11 +590,9 @@ macro_rules! serialize_display_bounded_length {
         // write! only provides fmt::Formatter to Display implementations, which
         // has methods write_str and write_char but no method to write arbitrary
         // bytes. Therefore `written` must be valid UTF-8.
-        let written_str = unsafe {
-            str::from_utf8_unchecked(written)
-        };
+        let written_str = unsafe { str::from_utf8_unchecked(written) };
         $serializer.serialize_str(written_str)
-    }}
+    }};
 }
 
 #[cfg(feature = "std")]
@@ -477,9 +601,20 @@ impl Serialize for net::IpAddr {
     where
         S: Serializer,
     {
-        match *self {
-            net::IpAddr::V4(ref a) => a.serialize(serializer),
-            net::IpAddr::V6(ref a) => a.serialize(serializer),
+        if serializer.is_human_readable() {
+            match *self {
+                net::IpAddr::V4(ref a) => a.serialize(serializer),
+                net::IpAddr::V6(ref a) => a.serialize(serializer),
+            }
+        } else {
+            match *self {
+                net::IpAddr::V4(ref a) => {
+                    serializer.serialize_newtype_variant("IpAddr", 0, "V4", a)
+                }
+                net::IpAddr::V6(ref a) => {
+                    serializer.serialize_newtype_variant("IpAddr", 1, "V6", a)
+                }
+            }
         }
     }
 }
@@ -490,9 +625,13 @@ impl Serialize for net::Ipv4Addr {
     where
         S: Serializer,
     {
-        /// "101.102.103.104".len()
-        const MAX_LEN: usize = 15;
-        serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        if serializer.is_human_readable() {
+            const MAX_LEN: usize = 15;
+            debug_assert_eq!(MAX_LEN, "101.102.103.104".len());
+            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        } else {
+            self.octets().serialize(serializer)
+        }
     }
 }
 
@@ -502,9 +641,13 @@ impl Serialize for net::Ipv6Addr {
     where
         S: Serializer,
     {
-        /// "1000:1002:1003:1004:1005:1006:1007:1008".len()
-        const MAX_LEN: usize = 39;
-        serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        if serializer.is_human_readable() {
+            const MAX_LEN: usize = 39;
+            debug_assert_eq!(MAX_LEN, "1001:1002:1003:1004:1005:1006:1007:1008".len());
+            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        } else {
+            self.octets().serialize(serializer)
+        }
     }
 }
 
@@ -514,9 +657,20 @@ impl Serialize for net::SocketAddr {
     where
         S: Serializer,
     {
-        match *self {
-            net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
-            net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
+        if serializer.is_human_readable() {
+            match *self {
+                net::SocketAddr::V4(ref addr) => addr.serialize(serializer),
+                net::SocketAddr::V6(ref addr) => addr.serialize(serializer),
+            }
+        } else {
+            match *self {
+                net::SocketAddr::V4(ref addr) => {
+                    serializer.serialize_newtype_variant("SocketAddr", 0, "V4", addr)
+                }
+                net::SocketAddr::V6(ref addr) => {
+                    serializer.serialize_newtype_variant("SocketAddr", 1, "V6", addr)
+                }
+            }
         }
     }
 }
@@ -527,9 +681,13 @@ impl Serialize for net::SocketAddrV4 {
     where
         S: Serializer,
     {
-        /// "101.102.103.104:65000".len()
-        const MAX_LEN: usize = 21;
-        serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        if serializer.is_human_readable() {
+            const MAX_LEN: usize = 21;
+            debug_assert_eq!(MAX_LEN, "101.102.103.104:65000".len());
+            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        } else {
+            (self.ip(), self.port()).serialize(serializer)
+        }
     }
 }
 
@@ -539,9 +697,16 @@ impl Serialize for net::SocketAddrV6 {
     where
         S: Serializer,
     {
-        /// "[1000:1002:1003:1004:1005:1006:1007:1008]:65000".len()
-        const MAX_LEN: usize = 47;
-        serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        if serializer.is_human_readable() {
+            const MAX_LEN: usize = 47;
+            debug_assert_eq!(
+                MAX_LEN,
+                "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
+            );
+            serialize_display_bounded_length!(self, MAX_LEN, serializer)
+        } else {
+            (self.ip(), self.port()).serialize(serializer)
+        }
     }
 }
 
@@ -601,3 +766,19 @@ impl Serialize for OsString {
         self.as_os_str().serialize(serializer)
     }
 }
+
+////////////////////////////////////////////////////////////////////////////////
+
+#[cfg(feature = "std")]
+impl<T> Serialize for Wrapping<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

@@ -10,8 +10,10 @@
 
 use lib::*;
 
-use ser::{self, Serialize, SerializeSeq, SerializeTuple, SerializeTupleStruct,
-          SerializeTupleVariant, SerializeMap, SerializeStruct, SerializeStructVariant};
+use ser::{
+    self, Serialize, SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant,
+    SerializeTuple, SerializeTupleStruct, SerializeTupleVariant,
+};
 
 /// Helper type for implementing a `Serializer` that does not support
 /// serializing one of the compound types.

serde/src/ser/mod.rs

@@ -48,15 +48,15 @@
 //!
 //!  - **Primitive types**:
 //!    - bool
-//!    - i8, i16, i32, i64, isize
-//!    - u8, u16, u32, u64, usize
+//!    - i8, i16, i32, i64, i128, isize
+//!    - u8, u16, u32, u64, u128, usize
 //!    - f32, f64
 //!    - char
 //!    - str
 //!    - &T and &mut T
 //!  - **Compound types**:
-//!    - [T]
-//!    - [T; 0] through [T; 32]
+//!    - \[T\]
+//!    - \[T; 0\] through \[T; 32\]
 //!    - tuples up to size 16
 //!  - **Common standard library types**:
 //!    - String
@@ -81,7 +81,6 @@
 //!    - LinkedList\<T\>
 //!    - VecDeque\<T\>
 //!    - Vec\<T\>
-//!    - EnumSet\<T\> (unstable)
 //!  - **FFI types**:
 //!    - CStr
 //!    - CString
@@ -89,10 +88,12 @@
 //!    - OsString
 //!  - **Miscellaneous standard library types**:
 //!    - Duration
+//!    - SystemTime
 //!    - Path
 //!    - PathBuf
 //!    - Range\<T\>
-//!    - NonZero\<T\> (unstable)
+//!    - num::NonZero*
+//!    - `!` *(unstable)*
 //!  - **Net types**:
 //!    - IpAddr
 //!    - Ipv4Addr
@@ -127,6 +128,13 @@ macro_rules! declare_error_trait {
         /// Trait used by `Serialize` implementations to generically construct
         /// errors belonging to the `Serializer` against which they are
         /// currently running.
+        ///
+        /// # Example implementation
+        ///
+        /// The [example data format] presented on the website shows an error
+        /// type appropriate for a basic JSON data format.
+        ///
+        /// [example data format]: https://serde.rs/data-format.html
         pub trait Error: Sized $(+ $($supertrait)::+)* {
             /// Used when a [`Serialize`] implementation encounters any error
             /// while serializing a type.
@@ -150,7 +158,8 @@ macro_rules! declare_error_trait {
             ///
             /// impl Serialize for Path {
             ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-            ///         where S: Serializer
+            ///     where
+            ///         S: Serializer,
             ///     {
             ///         match self.to_str() {
             ///             Some(s) => serializer.serialize_str(s),
@@ -221,7 +230,8 @@ pub trait Serialize {
     /// // This is what #[derive(Serialize)] would generate.
     /// impl Serialize for Person {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut s = serializer.serialize_struct("Person", 3)?;
     ///         s.serialize_field("name", &self.name)?;
@@ -242,27 +252,27 @@ pub trait Serialize {
 
 /// A **data format** that can serialize any data structure supported by Serde.
 ///
-/// The role of this trait is to define the serialization half of the Serde data
-/// model, which is a way to categorize every Rust data structure into one of 27
-/// possible types. Each method of the `Serializer` trait corresponds to one of
-/// the types of the data model.
+/// The role of this trait is to define the serialization half of the [Serde
+/// data model], which is a way to categorize every Rust data structure into one
+/// of 29 possible types. Each method of the `Serializer` trait corresponds to
+/// one of the types of the data model.
 ///
 /// Implementations of `Serialize` map themselves into this data model by
 /// invoking exactly one of the `Serializer` methods.
 ///
 /// The types that make up the Serde data model are:
 ///
-///  - **12 primitive types**
+///  - **14 primitive types**
 ///    - bool
-///    - i8, i16, i32, i64
-///    - u8, u16, u32, u64
+///    - i8, i16, i32, i64, i128
+///    - u8, u16, u32, u64, u128
 ///    - f32, f64
 ///    - char
 ///  - **string**
 ///    - UTF-8 bytes with a length and no null terminator.
 ///    - When serializing, all strings are handled equally. When deserializing,
 ///      there are three flavors of strings: transient, owned, and borrowed.
-///  - **byte array** - [u8]
+///  - **byte array** - \[u8\]
 ///    - Similar to strings, during deserialization byte arrays can be transient,
 ///      owned, or borrowed.
 ///  - **option**
@@ -307,6 +317,15 @@ pub trait Serialize {
 /// is the `serde_json::value::Serializer` (distinct from the main `serde_json`
 /// serializer) that produces a `serde_json::Value` data structure in memory as
 /// output.
+///
+/// [Serde data model]: https://serde.rs/data-model.html
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website contains example code for
+/// a basic JSON `Serializer`.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait Serializer: Sized {
     /// The output type produced by this `Serializer` during successful
     /// serialization. Most serializers that produce text or binary output
@@ -375,7 +394,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for bool {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_bool(*self)
     ///     }
@@ -401,7 +421,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for i8 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_i8(*self)
     ///     }
@@ -427,7 +448,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for i16 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_i16(*self)
     ///     }
@@ -453,7 +475,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for i32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_i32(*self)
     ///     }
@@ -475,7 +498,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for i64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_i64(*self)
     ///     }
@@ -485,6 +509,37 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_i64(self, v: i64) -> Result<Self::Ok, Self::Error>;
 
+    serde_if_integer128! {
+        /// Serialize an `i128` value.
+        ///
+        /// ```rust
+        /// # #[macro_use]
+        /// # extern crate serde;
+        /// #
+        /// # use serde::Serializer;
+        /// #
+        /// # __private_serialize!();
+        /// #
+        /// impl Serialize for i128 {
+        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        ///     where
+        ///         S: Serializer,
+        ///     {
+        ///         serializer.serialize_i128(*self)
+        ///     }
+        /// }
+        /// #
+        /// # fn main() {}
+        /// ```
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default behavior unconditionally returns an error.
+        fn serialize_i128(self, v: i128) -> Result<Self::Ok, Self::Error> {
+            let _ = v;
+            Err(Error::custom("i128 is not supported"))
+        }
+    }
+
     /// Serialize a `u8` value.
     ///
     /// If the format does not differentiate between `u8` and `u64`, a
@@ -501,7 +556,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for u8 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_u8(*self)
     ///     }
@@ -527,7 +583,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for u16 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_u16(*self)
     ///     }
@@ -553,7 +610,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for u32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_u32(*self)
     ///     }
@@ -575,7 +633,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for u64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_u64(*self)
     ///     }
@@ -585,6 +644,37 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_u64(self, v: u64) -> Result<Self::Ok, Self::Error>;
 
+    serde_if_integer128! {
+        /// Serialize a `u128` value.
+        ///
+        /// ```rust
+        /// # #[macro_use]
+        /// # extern crate serde;
+        /// #
+        /// # use serde::Serializer;
+        /// #
+        /// # __private_serialize!();
+        /// #
+        /// impl Serialize for u128 {
+        ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        ///     where
+        ///         S: Serializer,
+        ///     {
+        ///         serializer.serialize_u128(*self)
+        ///     }
+        /// }
+        /// #
+        /// # fn main() {}
+        /// ```
+        ///
+        /// This method is available only on Rust compiler versions >=1.26. The
+        /// default behavior unconditionally returns an error.
+        fn serialize_u128(self, v: u128) -> Result<Self::Ok, Self::Error> {
+            let _ = v;
+            Err(Error::custom("u128 is not supported"))
+        }
+    }
+
     /// Serialize an `f32` value.
     ///
     /// If the format does not differentiate between `f32` and `f64`, a
@@ -601,7 +691,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for f32 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_f32(*self)
     ///     }
@@ -623,7 +714,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for f64 {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_f64(*self)
     ///     }
@@ -648,7 +740,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for char {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_char(*self)
     ///     }
@@ -670,7 +763,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for str {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_str(self)
     ///     }
@@ -735,10 +829,12 @@ pub trait Serializer: Sized {
     /// # use Option::{Some, None};
     /// #
     /// impl<T> Serialize for Option<T>
-    ///     where T: Serialize
+    /// where
+    ///     T: Serialize,
     /// {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             Some(ref value) => serializer.serialize_some(value),
@@ -768,10 +864,12 @@ pub trait Serializer: Sized {
     /// # use Option::{Some, None};
     /// #
     /// impl<T> Serialize for Option<T>
-    ///     where T: Serialize
+    /// where
+    ///     T: Serialize,
     /// {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             Some(ref value) => serializer.serialize_some(value),
@@ -800,7 +898,8 @@ pub trait Serializer: Sized {
     /// #
     /// impl Serialize for () {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_unit()
     ///     }
@@ -821,7 +920,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for Nothing {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_unit_struct("Nothing")
     ///     }
@@ -845,7 +945,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for E {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             E::A => serializer.serialize_unit_variant("E", 0, "A"),
@@ -874,7 +975,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for Millimeters {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.serialize_newtype_struct("Millimeters", &self.0)
     ///     }
@@ -904,7 +1006,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for E {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             E::M(ref s) => serializer.serialize_newtype_variant("E", 0, "M", s),
@@ -954,10 +1057,12 @@ pub trait Serializer: Sized {
     /// use serde::ser::{Serialize, Serializer, SerializeSeq};
     ///
     /// impl<T> Serialize for Vec<T>
-    ///     where T: Serialize
+    /// where
+    ///     T: Serialize,
     /// {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
     ///         for element in self {
@@ -986,12 +1091,14 @@ pub trait Serializer: Sized {
     /// # struct Tuple3<A, B, C>(A, B, C);
     /// #
     /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-    ///     where A: Serialize,
-    ///           B: Serialize,
-    ///           C: Serialize
+    /// where
+    ///     A: Serialize,
+    ///     B: Serialize,
+    ///     C: Serialize,
     /// {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut tup = serializer.serialize_tuple(3)?;
     ///         tup.serialize_element(&self.0)?;
@@ -1010,7 +1117,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for Vram {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut seq = serializer.serialize_tuple(VRAM_SIZE)?;
     ///         for element in &self.0[..] {
@@ -1036,7 +1144,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for Rgb {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
     ///         ts.serialize_field(&self.0)?;
@@ -1070,7 +1179,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for E {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             E::T(ref a, ref b) => {
@@ -1128,11 +1238,13 @@ pub trait Serializer: Sized {
     /// use serde::ser::{Serialize, Serializer, SerializeMap};
     ///
     /// impl<K, V> Serialize for HashMap<K, V>
-    ///     where K: Serialize,
-    ///           V: Serialize
+    /// where
+    ///     K: Serialize,
+    ///     V: Serialize,
     /// {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut map = serializer.serialize_map(Some(self.len()))?;
     ///         for (k, v) in self {
@@ -1162,7 +1274,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for Rgb {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
     ///         rgb.serialize_field("r", &self.r)?;
@@ -1195,7 +1308,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for E {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         match *self {
     ///             E::S { ref r, ref g, ref b } => {
@@ -1232,7 +1346,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for SecretlyOneHigher {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.collect_seq(self.data.iter().map(|x| x + 1))
     ///     }
@@ -1270,7 +1385,8 @@ pub trait Serializer: Sized {
     /// // Serializes as a map in which the values are all unit.
     /// impl Serialize for MapToUnit {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.collect_map(self.keys.iter().map(|k| (k, ())))
     ///     }
@@ -1310,7 +1426,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for DateTime {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.collect_str(&format_args!("{:?}{:?}",
     ///                                              self.naive_local(),
@@ -1321,7 +1438,7 @@ pub trait Serializer: Sized {
     ///
     /// [`String`]: https://doc.rust-lang.org/std/string/struct.String.html
     /// [`serialize_str`]: #tymethod.serialize_str
-    #[cfg(any(feature = "std", feature = "collections"))]
+    #[cfg(any(feature = "std", feature = "alloc"))]
     fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
         T: Display,
@@ -1350,7 +1467,8 @@ pub trait Serializer: Sized {
     ///
     /// impl Serialize for DateTime {
     ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-    ///         where S: Serializer
+    ///     where
+    ///         S: Serializer,
     ///     {
     ///         serializer.collect_str(&format_args!("{:?}{:?}",
     ///                                              self.naive_local(),
@@ -1358,14 +1476,69 @@ pub trait Serializer: Sized {
     ///     }
     /// }
     /// ```
-    #[cfg(not(any(feature = "std", feature = "collections")))]
+    #[cfg(not(any(feature = "std", feature = "alloc")))]
     fn collect_str<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
         T: Display;
+
+    /// Determine whether `Serialize` implementations should serialize in
+    /// human-readable form.
+    ///
+    /// Some types have a human-readable form that may be somewhat expensive to
+    /// construct, as well as a binary form that is compact and efficient.
+    /// Generally text-based formats like JSON and YAML will prefer to use the
+    /// human-readable one and binary formats like Bincode will prefer the
+    /// compact one.
+    ///
+    /// ```
+    /// # use std::fmt::{self, Display};
+    /// #
+    /// # struct Timestamp;
+    /// #
+    /// # impl Timestamp {
+    /// #     fn seconds_since_epoch(&self) -> u64 { unimplemented!() }
+    /// # }
+    /// #
+    /// # impl Display for Timestamp {
+    /// #     fn fmt(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// use serde::{Serialize, Serializer};
+    ///
+    /// impl Serialize for Timestamp {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         if serializer.is_human_readable() {
+    ///             // Serialize to a human-readable string "2015-05-15T17:01:00Z".
+    ///             self.to_string().serialize(serializer)
+    ///         } else {
+    ///             // Serialize to a compact binary representation.
+    ///             self.seconds_since_epoch().serialize(serializer)
+    ///         }
+    ///     }
+    /// }
+    /// ```
+    ///
+    /// The default implementation of this method returns `true`. Data formats
+    /// may override this to `false` to request a compact form for types that
+    /// support one. Note that modifying this method to change a format from
+    /// human-readable to compact or vice versa should be regarded as a breaking
+    /// change, as a value serialized in human-readable mode is not required to
+    /// deserialize from the same data in compact mode.
+    #[inline]
+    fn is_human_readable(&self) -> bool {
+        true
+    }
 }
 
 /// Returned from `Serializer::serialize_seq`.
 ///
+/// # Example use
+///
 /// ```rust
 /// # use std::marker::PhantomData;
 /// #
@@ -1388,10 +1561,12 @@ pub trait Serializer: Sized {
 /// use serde::ser::{Serialize, Serializer, SerializeSeq};
 ///
 /// impl<T> Serialize for Vec<T>
-///     where T: Serialize
+/// where
+///     T: Serialize,
 /// {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut seq = serializer.serialize_seq(Some(self.len()))?;
 ///         for element in self {
@@ -1401,6 +1576,13 @@ pub trait Serializer: Sized {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeSeq` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeSeq {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1419,6 +1601,8 @@ pub trait SerializeSeq {
 
 /// Returned from `Serializer::serialize_tuple`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTuple};
 ///
@@ -1431,12 +1615,14 @@ pub trait SerializeSeq {
 /// # struct Tuple3<A, B, C>(A, B, C);
 /// #
 /// # impl<A, B, C> Serialize for Tuple3<A, B, C>
-///     where A: Serialize,
-///           B: Serialize,
-///           C: Serialize
+/// where
+///     A: Serialize,
+///     B: Serialize,
+///     C: Serialize,
 /// {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut tup = serializer.serialize_tuple(3)?;
 ///         tup.serialize_element(&self.0)?;
@@ -1475,10 +1661,12 @@ pub trait SerializeSeq {
 /// # }
 /// #
 /// # impl<T> Serialize for Array<T>
-///     where T: Serialize
+/// where
+///     T: Serialize,
 /// {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut seq = serializer.serialize_tuple(16)?;
 ///         for element in self {
@@ -1488,6 +1676,13 @@ pub trait SerializeSeq {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTuple` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTuple {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1506,6 +1701,8 @@ pub trait SerializeTuple {
 
 /// Returned from `Serializer::serialize_tuple_struct`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTupleStruct};
 ///
@@ -1513,7 +1710,8 @@ pub trait SerializeTuple {
 ///
 /// impl Serialize for Rgb {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut ts = serializer.serialize_tuple_struct("Rgb", 3)?;
 ///         ts.serialize_field(&self.0)?;
@@ -1523,6 +1721,13 @@ pub trait SerializeTuple {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTupleStruct` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTupleStruct {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1541,6 +1746,8 @@ pub trait SerializeTupleStruct {
 
 /// Returned from `Serializer::serialize_tuple_variant`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeTupleVariant};
 ///
@@ -1551,7 +1758,8 @@ pub trait SerializeTupleStruct {
 ///
 /// impl Serialize for E {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         match *self {
 ///             E::T(ref a, ref b) => {
@@ -1571,6 +1779,13 @@ pub trait SerializeTupleStruct {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeTupleVariant` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeTupleVariant {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1589,6 +1804,8 @@ pub trait SerializeTupleVariant {
 
 /// Returned from `Serializer::serialize_map`.
 ///
+/// # Example use
+///
 /// ```rust
 /// # use std::marker::PhantomData;
 /// #
@@ -1612,11 +1829,13 @@ pub trait SerializeTupleVariant {
 /// use serde::ser::{Serialize, Serializer, SerializeMap};
 ///
 /// impl<K, V> Serialize for HashMap<K, V>
-///     where K: Serialize,
-///           V: Serialize
+/// where
+///     K: Serialize,
+///     V: Serialize,
 /// {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut map = serializer.serialize_map(Some(self.len()))?;
 ///         for (k, v) in self {
@@ -1626,6 +1845,13 @@ pub trait SerializeTupleVariant {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeMap` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeMap {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1689,6 +1915,8 @@ pub trait SerializeMap {
 
 /// Returned from `Serializer::serialize_struct`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeStruct};
 ///
@@ -1700,7 +1928,8 @@ pub trait SerializeMap {
 ///
 /// impl Serialize for Rgb {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         let mut rgb = serializer.serialize_struct("Rgb", 3)?;
 ///         rgb.serialize_field("r", &self.r)?;
@@ -1710,6 +1939,13 @@ pub trait SerializeMap {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeStruct` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeStruct {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1726,12 +1962,21 @@ pub trait SerializeStruct {
     where
         T: Serialize;
 
+    /// Indicate that a struct field has been skipped.
+    #[inline]
+    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
+        let _ = key;
+        Ok(())
+    }
+
     /// Finish serializing a struct.
     fn end(self) -> Result<Self::Ok, Self::Error>;
 }
 
 /// Returned from `Serializer::serialize_struct_variant`.
 ///
+/// # Example use
+///
 /// ```rust
 /// use serde::ser::{Serialize, Serializer, SerializeStructVariant};
 ///
@@ -1741,7 +1986,8 @@ pub trait SerializeStruct {
 ///
 /// impl Serialize for E {
 ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-///         where S: Serializer
+///     where
+///         S: Serializer,
 ///     {
 ///         match *self {
 ///             E::S { ref r, ref g, ref b } => {
@@ -1755,6 +2001,13 @@ pub trait SerializeStruct {
 ///     }
 /// }
 /// ```
+///
+/// # Example implementation
+///
+/// The [example data format] presented on the website demonstrates an
+/// implementation of `SerializeStructVariant` for a basic JSON data format.
+///
+/// [example data format]: https://serde.rs/data-format.html
 pub trait SerializeStructVariant {
     /// Must match the `Ok` type of our `Serializer`.
     type Ok;
@@ -1771,6 +2024,13 @@ pub trait SerializeStructVariant {
     where
         T: Serialize;
 
+    /// Indicate that a struct variant field has been skipped.
+    #[inline]
+    fn skip_field(&mut self, key: &'static str) -> Result<(), Self::Error> {
+        let _ = key;
+        Ok(())
+    }
+
     /// Finish serializing a struct variant.
     fn end(self) -> Result<Self::Ok, Self::Error>;
 }

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.0" # remember to update html_root_url
+version = "1.0.70" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -8,17 +8,24 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/codegen.html"
 keywords = ["serde", "serialization", "no_std"]
-readme = "README.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }
 
+[features]
+default = []
+deserialize_in_place = []
+
 [lib]
 name = "serde_derive"
 proc-macro = true
 
 [dependencies]
-quote = "0.3.8"
-serde_derive_internals = { version = "=0.15.0", default-features = false, path = "../serde_derive_internals" }
-syn = { version = "0.11", features = ["visit"] }
+proc-macro2 = "0.4"
+quote = "0.6"
+syn = { version = "0.14", features = ["visit"] }
+
+[dev-dependencies]
+serde = { version = "1.0", path = "../serde" }

serde_derive/crates-io.md

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

serde_derive/src/bound.rs

@@ -8,33 +8,31 @@
 
 use std::collections::HashSet;
 
-use syn::{self, visit};
+use syn;
+use syn::punctuated::{Pair, Punctuated};
+use syn::visit::{self, Visit};
 
-use internals::ast::Container;
+use internals::ast::{Container, Data};
 use internals::attr;
 
-macro_rules! path {
-    ($($path:tt)+) => {
-        syn::parse_path(stringify!($($path)+)).unwrap()
-    };
-}
+use proc_macro2::Span;
 
 // Remove the default from every type parameter because in the generated impls
 // they look like associated types: "error: associated type bindings are not
 // allowed here".
 pub fn without_defaults(generics: &syn::Generics) -> syn::Generics {
     syn::Generics {
-        ty_params: generics
-            .ty_params
+        params: generics
+            .params
             .iter()
-            .map(
-                |ty_param| {
-                    syn::TyParam {
-                        default: None,
-                        ..ty_param.clone()
-                    }
-                },
-            )
+            .map(|param| match *param {
+                syn::GenericParam::Type(ref param) => syn::GenericParam::Type(syn::TypeParam {
+                    eq_token: None,
+                    default: None,
+                    ..param.clone()
+                }),
+                _ => param.clone(),
+            })
             .collect(),
         ..generics.clone()
     }
@@ -46,27 +44,47 @@ pub fn with_where_predicates(
 ) -> syn::Generics {
     let mut generics = generics.clone();
     generics
-        .where_clause
+        .make_where_clause()
         .predicates
-        .extend_from_slice(predicates);
+        .extend(predicates.into_iter().cloned());
     generics
 }
 
-pub fn with_where_predicates_from_fields<F>(
+pub fn with_where_predicates_from_fields(
     cont: &Container,
     generics: &syn::Generics,
-    from_field: F,
-) -> syn::Generics
-where
-    F: Fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
-{
-    let predicates = cont.body
+    from_field: fn(&attr::Field) -> Option<&[syn::WherePredicate]>,
+) -> syn::Generics {
+    let predicates = cont
+        .data
         .all_fields()
         .flat_map(|field| from_field(&field.attrs))
         .flat_map(|predicates| predicates.to_vec());
 
     let mut generics = generics.clone();
-    generics.where_clause.predicates.extend(predicates);
+    generics.make_where_clause().predicates.extend(predicates);
+    generics
+}
+
+pub fn with_where_predicates_from_variants(
+    cont: &Container,
+    generics: &syn::Generics,
+    from_variant: fn(&attr::Variant) -> Option<&[syn::WherePredicate]>,
+) -> syn::Generics {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
+            return generics.clone();
+        }
+    };
+
+    let predicates = variants
+        .iter()
+        .flat_map(|variant| from_variant(&variant.attrs))
+        .flat_map(|predicates| predicates.to_vec());
+
+    let mut generics = generics.clone();
+    generics.make_where_clause().predicates.extend(predicates);
     generics
 }
 
@@ -81,91 +99,124 @@ where
 //         #[serde(skip_serializing)]
 //         c: C,
 //     }
-pub fn with_bound<F>(
+pub fn with_bound(
     cont: &Container,
     generics: &syn::Generics,
-    filter: F,
+    filter: fn(&attr::Field, Option<&attr::Variant>) -> bool,
     bound: &syn::Path,
-) -> syn::Generics
-where
-    F: Fn(&attr::Field) -> bool,
-{
-    struct FindTyParams {
+) -> syn::Generics {
+    struct FindTyParams<'ast> {
         // Set of all generic type parameters on the current struct (A, B, C in
         // the example). Initialized up front.
-        all_ty_params: HashSet<syn::Ident>,
+        all_type_params: HashSet<syn::Ident>,
+
         // Set of generic type parameters used in fields for which filter
         // returns true (A and B in the example). Filled in as the visitor sees
         // them.
-        relevant_ty_params: HashSet<syn::Ident>,
+        relevant_type_params: HashSet<syn::Ident>,
+
+        // Fields whose type is an associated type of one of the generic type
+        // parameters.
+        associated_type_usage: Vec<&'ast syn::TypePath>,
     }
-    impl visit::Visitor for FindTyParams {
-        fn visit_path(&mut self, path: &syn::Path) {
+    impl<'ast> Visit<'ast> for FindTyParams<'ast> {
+        fn visit_field(&mut self, field: &'ast syn::Field) {
+            if let syn::Type::Path(ref ty) = field.ty {
+                if let Some(Pair::Punctuated(ref t, _)) = ty.path.segments.first() {
+                    if self.all_type_params.contains(&t.ident) {
+                        self.associated_type_usage.push(ty);
+                    }
+                }
+            }
+            self.visit_type(&field.ty);
+        }
+
+        fn visit_path(&mut self, path: &'ast syn::Path) {
             if let Some(seg) = path.segments.last() {
-                if seg.ident == "PhantomData" {
+                if seg.into_value().ident == "PhantomData" {
                     // Hardcoded exception, because PhantomData<T> implements
                     // Serialize and Deserialize whether or not T implements it.
                     return;
                 }
             }
-            if !path.global && path.segments.len() == 1 {
-                let id = path.segments[0].ident.clone();
-                if self.all_ty_params.contains(&id) {
-                    self.relevant_ty_params.insert(id);
+            if path.leading_colon.is_none() && path.segments.len() == 1 {
+                let id = &path.segments[0].ident;
+                if self.all_type_params.contains(id) {
+                    self.relevant_type_params.insert(id.clone());
                 }
             }
-            visit::walk_path(self, path);
+            visit::visit_path(self, path);
+        }
+
+        // Type parameter should not be considered used by a macro path.
+        //
+        //     struct TypeMacro<T> {
+        //         mac: T!(),
+        //         marker: PhantomData<T>,
+        //     }
+        fn visit_macro(&mut self, _mac: &'ast syn::Macro) {}
+    }
+
+    let all_type_params = generics
+        .type_params()
+        .map(|param| param.ident.clone())
+        .collect();
+
+    let mut visitor = FindTyParams {
+        all_type_params: all_type_params,
+        relevant_type_params: HashSet::new(),
+        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::Struct(_, ref fields) => {
+            for field in fields.iter().filter(|field| filter(&field.attrs, None)) {
+                visitor.visit_field(field.original);
+            }
         }
     }
 
-    let all_ty_params: HashSet<_> = generics
-        .ty_params
-        .iter()
-        .map(|ty_param| ty_param.ident.clone())
-        .collect();
-
-    let relevant_tys = cont.body
-        .all_fields()
-        .filter(|&field| filter(&field.attrs))
-        .map(|field| &field.ty);
-
-    let mut visitor = FindTyParams {
-        all_ty_params: all_ty_params,
-        relevant_ty_params: HashSet::new(),
-    };
-    for ty in relevant_tys {
-        visit::walk_ty(&mut visitor, ty);
-    }
-
+    let relevant_type_params = visitor.relevant_type_params;
+    let associated_type_usage = visitor.associated_type_usage;
     let new_predicates = generics
-        .ty_params
-        .iter()
-        .map(|ty_param| ty_param.ident.clone())
-        .filter(|id| visitor.relevant_ty_params.contains(id))
-        .map(
-            |id| {
-                syn::WherePredicate::BoundPredicate(
-                    syn::WhereBoundPredicate {
-                        bound_lifetimes: Vec::new(),
-                        // the type parameter that is being bounded e.g. T
-                        bounded_ty: syn::Ty::Path(None, id.into()),
-                        // the bound e.g. Serialize
-                        bounds: vec![
-                            syn::TyParamBound::Trait(
-                                syn::PolyTraitRef {
-                                    bound_lifetimes: Vec::new(),
-                                    trait_ref: bound.clone(),
-                                },
-                                syn::TraitBoundModifier::None,
-                            ),
-                        ],
-                    },
-                )
-            },
-        );
+        .type_params()
+        .map(|param| param.ident.clone())
+        .filter(|id| relevant_type_params.contains(id))
+        .map(|id| syn::TypePath {
+            qself: None,
+            path: id.into(),
+        })
+        .chain(associated_type_usage.into_iter().cloned())
+        .map(|bounded_ty| {
+            syn::WherePredicate::Type(syn::PredicateType {
+                lifetimes: None,
+                // the type parameter that is being bounded e.g. T
+                bounded_ty: syn::Type::Path(bounded_ty),
+                colon_token: <Token![:]>::default(),
+                // the bound e.g. Serialize
+                bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+                    paren_token: None,
+                    modifier: syn::TraitBoundModifier::None,
+                    lifetimes: None,
+                    path: bound.clone(),
+                })].into_iter()
+                    .collect(),
+            })
+        });
 
     let mut generics = generics.clone();
-    generics.where_clause.predicates.extend(new_predicates);
+    generics
+        .make_where_clause()
+        .predicates
+        .extend(new_predicates);
     generics
 }
 
@@ -176,81 +227,93 @@ pub fn with_self_bound(
 ) -> syn::Generics {
     let mut generics = generics.clone();
     generics
-        .where_clause
+        .make_where_clause()
         .predicates
-        .push(
-            syn::WherePredicate::BoundPredicate(
-                syn::WhereBoundPredicate {
-                    bound_lifetimes: Vec::new(),
-                    // the type that is being bounded e.g. MyStruct<'a, T>
-                    bounded_ty: type_of_item(cont),
-                    // the bound e.g. Default
-                    bounds: vec![
-                        syn::TyParamBound::Trait(
-                            syn::PolyTraitRef {
-                                bound_lifetimes: Vec::new(),
-                                trait_ref: bound.clone(),
-                            },
-                            syn::TraitBoundModifier::None,
-                        ),
-                    ],
-                },
-            ),
-        );
+        .push(syn::WherePredicate::Type(syn::PredicateType {
+            lifetimes: None,
+            // the type that is being bounded e.g. MyStruct<'a, T>
+            bounded_ty: type_of_item(cont),
+            colon_token: <Token![:]>::default(),
+            // the bound e.g. Default
+            bounds: vec![syn::TypeParamBound::Trait(syn::TraitBound {
+                paren_token: None,
+                modifier: syn::TraitBoundModifier::None,
+                lifetimes: None,
+                path: bound.clone(),
+            })].into_iter()
+                .collect(),
+        }));
     generics
 }
 
 pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Generics {
-    let mut generics = generics.clone();
+    let bound = syn::Lifetime::new(lifetime, Span::call_site());
+    let def = syn::LifetimeDef {
+        attrs: Vec::new(),
+        lifetime: bound.clone(),
+        colon_token: None,
+        bounds: Punctuated::new(),
+    };
 
-    for lifetime_def in &mut generics.lifetimes {
-        lifetime_def.bounds.push(syn::Lifetime::new(lifetime));
+    let params = Some(syn::GenericParam::Lifetime(def))
+        .into_iter()
+        .chain(generics.params.iter().cloned().map(|mut param| {
+            match param {
+                syn::GenericParam::Lifetime(ref mut param) => {
+                    param.bounds.push(bound.clone());
+                }
+                syn::GenericParam::Type(ref mut param) => {
+                    param
+                        .bounds
+                        .push(syn::TypeParamBound::Lifetime(bound.clone()));
+                }
+                syn::GenericParam::Const(_) => {}
+            }
+            param
+        }))
+        .collect();
+
+    syn::Generics {
+        params: params,
+        ..generics.clone()
     }
-
-    for ty_param in &mut generics.ty_params {
-        ty_param
-            .bounds
-            .push(syn::TyParamBound::Region(syn::Lifetime::new(lifetime)));
-    }
-
-    generics
-        .lifetimes
-        .push(
-            syn::LifetimeDef {
-                attrs: Vec::new(),
-                lifetime: syn::Lifetime::new(lifetime),
-                bounds: Vec::new(),
-            },
-        );
-
-    generics
 }
 
-fn type_of_item(cont: &Container) -> syn::Ty {
-    syn::Ty::Path(
-        None,
-        syn::Path {
-            global: false,
-            segments: vec![
-                syn::PathSegment {
-                    ident: cont.ident.clone(),
-                    parameters: syn::PathParameters::AngleBracketed(
-                        syn::AngleBracketedParameterData {
-                            lifetimes: cont.generics
-                                .lifetimes
-                                .iter()
-                                .map(|def| def.lifetime.clone())
-                                .collect(),
-                            types: cont.generics
-                                .ty_params
-                                .iter()
-                                .map(|param| syn::Ty::Path(None, param.ident.clone().into()))
-                                .collect(),
-                            bindings: Vec::new(),
-                        },
-                    ),
-                },
-            ],
+fn type_of_item(cont: &Container) -> syn::Type {
+    syn::Type::Path(syn::TypePath {
+        qself: None,
+        path: syn::Path {
+            leading_colon: None,
+            segments: vec![syn::PathSegment {
+                ident: cont.ident.clone(),
+                arguments: syn::PathArguments::AngleBracketed(
+                    syn::AngleBracketedGenericArguments {
+                        colon2_token: None,
+                        lt_token: <Token![<]>::default(),
+                        args: cont
+                            .generics
+                            .params
+                            .iter()
+                            .map(|param| match *param {
+                                syn::GenericParam::Type(ref param) => {
+                                    syn::GenericArgument::Type(syn::Type::Path(syn::TypePath {
+                                        qself: None,
+                                        path: param.ident.clone().into(),
+                                    }))
+                                }
+                                syn::GenericParam::Lifetime(ref param) => {
+                                    syn::GenericArgument::Lifetime(param.lifetime.clone())
+                                }
+                                syn::GenericParam::Const(_) => {
+                                    panic!("Serde does not support const generics yet");
+                                }
+                            })
+                            .collect(),
+                        gt_token: <Token![>]>::default(),
+                    },
+                ),
+            }].into_iter()
+                .collect(),
         },
-    )
+    })
 }

serde_derive/src/fragment.rs

@@ -6,14 +6,16 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use quote::{Tokens, ToTokens};
+use proc_macro2::TokenStream;
+use quote::ToTokens;
+use syn::token;
 
 pub enum Fragment {
     /// Tokens that can be used as an expression.
-    Expr(Tokens),
+    Expr(TokenStream),
     /// Tokens that can be used inside a block. The surrounding curly braces are
     /// not part of these tokens.
-    Block(Tokens),
+    Block(TokenStream),
 }
 
 macro_rules! quote_expr {
@@ -32,13 +34,11 @@ macro_rules! quote_block {
 /// Block fragments in curly braces.
 pub struct Expr(pub Fragment);
 impl ToTokens for Expr {
-    fn to_tokens(&self, out: &mut Tokens) {
+    fn to_tokens(&self, out: &mut TokenStream) {
         match self.0 {
             Fragment::Expr(ref expr) => expr.to_tokens(out),
             Fragment::Block(ref block) => {
-                out.append("{");
-                block.to_tokens(out);
-                out.append("}");
+                token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
     }
@@ -47,7 +47,7 @@ impl ToTokens for Expr {
 /// Interpolate a fragment as the statements of a block.
 pub struct Stmts(pub Fragment);
 impl ToTokens for Stmts {
-    fn to_tokens(&self, out: &mut Tokens) {
+    fn to_tokens(&self, out: &mut TokenStream) {
         match self.0 {
             Fragment::Expr(ref expr) => expr.to_tokens(out),
             Fragment::Block(ref block) => block.to_tokens(out),
@@ -59,17 +59,24 @@ impl ToTokens for Stmts {
 /// involves putting a comma after expressions and curly braces around blocks.
 pub struct Match(pub Fragment);
 impl ToTokens for Match {
-    fn to_tokens(&self, out: &mut Tokens) {
+    fn to_tokens(&self, out: &mut TokenStream) {
         match self.0 {
             Fragment::Expr(ref expr) => {
                 expr.to_tokens(out);
-                out.append(",");
+                <Token![,]>::default().to_tokens(out);
             }
             Fragment::Block(ref block) => {
-                out.append("{");
-                block.to_tokens(out);
-                out.append("}");
+                token::Brace::default().surround(out, |out| block.to_tokens(out));
             }
         }
     }
 }
+
+impl AsRef<TokenStream> for Fragment {
+    fn as_ref(&self) -> &TokenStream {
+        match *self {
+            Fragment::Expr(ref expr) => expr,
+            Fragment::Block(ref block) => block,
+        }
+    }
+}

serde_derive/src/internals/ast.rs

@@ -0,0 +1,178 @@
+// 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::attr;
+use internals::check;
+use internals::{Ctxt, Derive};
+use syn;
+use syn::punctuated::Punctuated;
+
+pub struct Container<'a> {
+    pub ident: syn::Ident,
+    pub attrs: attr::Container,
+    pub data: Data<'a>,
+    pub generics: &'a syn::Generics,
+}
+
+pub enum Data<'a> {
+    Enum(Vec<Variant<'a>>),
+    Struct(Style, Vec<Field<'a>>),
+}
+
+pub struct Variant<'a> {
+    pub ident: syn::Ident,
+    pub attrs: attr::Variant,
+    pub style: Style,
+    pub fields: Vec<Field<'a>>,
+}
+
+pub struct Field<'a> {
+    pub member: syn::Member,
+    pub attrs: attr::Field,
+    pub ty: &'a syn::Type,
+    pub original: &'a syn::Field,
+}
+
+#[derive(Copy, Clone)]
+pub enum Style {
+    Struct,
+    Tuple,
+    Newtype,
+    Unit,
+}
+
+impl<'a> Container<'a> {
+    pub fn from_ast(cx: &Ctxt, item: &'a syn::DeriveInput, derive: Derive) -> Container<'a> {
+        let mut attrs = attr::Container::from_ast(cx, item);
+
+        let mut data = match item.data {
+            syn::Data::Enum(ref data) => {
+                Data::Enum(enum_from_ast(cx, &data.variants, attrs.default()))
+            }
+            syn::Data::Struct(ref data) => {
+                let (style, fields) = struct_from_ast(cx, &data.fields, None, attrs.default());
+                Data::Struct(style, fields)
+            }
+            syn::Data::Union(_) => {
+                panic!("Serde does not support derive for unions");
+            }
+        };
+
+        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 {
+                    if field.attrs.flatten() {
+                        has_flatten = true;
+                    }
+                    field.attrs.rename_by_rule(variant.attrs.rename_all());
+                }
+            },
+            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 {
+            attrs.mark_has_flatten();
+        }
+
+        let mut item = Container {
+            ident: item.ident.clone(),
+            attrs: attrs,
+            data: data,
+            generics: &item.generics,
+        };
+        check::check(cx, &mut item, derive);
+        item
+    }
+}
+
+impl<'a> Data<'a> {
+    pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
+        match *self {
+            Data::Enum(ref variants) => {
+                Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
+            }
+            Data::Struct(_, ref fields) => Box::new(fields.iter()),
+        }
+    }
+
+    pub fn has_getter(&self) -> bool {
+        self.all_fields().any(|f| f.attrs.getter().is_some())
+    }
+}
+
+fn enum_from_ast<'a>(
+    cx: &Ctxt,
+    variants: &'a Punctuated<syn::Variant, Token![,]>,
+    container_default: &attr::Default,
+) -> Vec<Variant<'a>> {
+    variants
+        .iter()
+        .map(|variant| {
+            let attrs = attr::Variant::from_ast(cx, variant);
+            let (style, fields) =
+                struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
+            Variant {
+                ident: variant.ident.clone(),
+                attrs: attrs,
+                style: style,
+                fields: fields,
+            }
+        })
+        .collect()
+}
+
+fn struct_from_ast<'a>(
+    cx: &Ctxt,
+    fields: &'a syn::Fields,
+    attrs: Option<&attr::Variant>,
+    container_default: &attr::Default,
+) -> (Style, Vec<Field<'a>>) {
+    match *fields {
+        syn::Fields::Named(ref fields) => (
+            Style::Struct,
+            fields_from_ast(cx, &fields.named, attrs, container_default),
+        ),
+        syn::Fields::Unnamed(ref fields) if fields.unnamed.len() == 1 => (
+            Style::Newtype,
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
+        ),
+        syn::Fields::Unnamed(ref fields) => (
+            Style::Tuple,
+            fields_from_ast(cx, &fields.unnamed, attrs, container_default),
+        ),
+        syn::Fields::Unit => (Style::Unit, Vec::new()),
+    }
+}
+
+fn fields_from_ast<'a>(
+    cx: &Ctxt,
+    fields: &'a Punctuated<syn::Field, Token![,]>,
+    attrs: Option<&attr::Variant>,
+    container_default: &attr::Default,
+) -> Vec<Field<'a>> {
+    fields
+        .iter()
+        .enumerate()
+        .map(|(i, field)| Field {
+            member: match field.ident {
+                Some(ref ident) => syn::Member::Named(ident.clone()),
+                None => syn::Member::Unnamed(i.into()),
+            },
+            attrs: attr::Field::from_ast(cx, i, field, attrs, container_default),
+            ty: &field.ty,
+            original: field,
+        })
+        .collect()
+}

serde_derive/src/internals/case.rs

@@ -6,17 +6,22 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
+// 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)]
 use std::ascii::AsciiExt;
+
 use std::str::FromStr;
 
 use self::RenameRule::*;
 
-#[derive(Debug, PartialEq)]
+#[derive(PartialEq)]
 pub enum RenameRule {
     /// Don't apply a default rename rule.
     None,
     /// Rename direct children to "lowercase" style.
     LowerCase,
+    /// Rename direct children to "UPPERCASE" style.
+    UPPERCASE,
     /// Rename direct children to "PascalCase" style, as typically used for enum variants.
     PascalCase,
     /// Rename direct children to "camelCase" style.
@@ -27,6 +32,8 @@ pub enum RenameRule {
     ScreamingSnakeCase,
     /// Rename direct children to "kebab-case" style.
     KebabCase,
+    /// Rename direct children to "SCREAMING-KEBAB-CASE" style.
+    ScreamingKebabCase,
 }
 
 impl RenameRule {
@@ -34,6 +41,7 @@ impl RenameRule {
         match *self {
             None | PascalCase => variant.to_owned(),
             LowerCase => variant.to_ascii_lowercase(),
+            UPPERCASE => variant.to_ascii_uppercase(),
             CamelCase => variant[..1].to_ascii_lowercase() + &variant[1..],
             SnakeCase => {
                 let mut snake = String::new();
@@ -47,12 +55,16 @@ impl RenameRule {
             }
             ScreamingSnakeCase => SnakeCase.apply_to_variant(variant).to_ascii_uppercase(),
             KebabCase => SnakeCase.apply_to_variant(variant).replace('_', "-"),
+            ScreamingKebabCase => ScreamingSnakeCase
+                .apply_to_variant(variant)
+                .replace('_', "-"),
         }
     }
 
     pub fn apply_to_field(&self, field: &str) -> String {
         match *self {
             None | LowerCase | SnakeCase => field.to_owned(),
+            UPPERCASE => field.to_ascii_uppercase(),
             PascalCase => {
                 let mut pascal = String::new();
                 let mut capitalize = true;
@@ -74,6 +86,7 @@ impl RenameRule {
             }
             ScreamingSnakeCase => field.to_ascii_uppercase(),
             KebabCase => field.replace('_', "-"),
+            ScreamingKebabCase => ScreamingSnakeCase.apply_to_field(field).replace('_', "-"),
         }
     }
 }
@@ -84,11 +97,13 @@ impl FromStr for RenameRule {
     fn from_str(rename_all_str: &str) -> Result<Self, Self::Err> {
         match rename_all_str {
             "lowercase" => Ok(LowerCase),
+            "UPPERCASE" => Ok(UPPERCASE),
             "PascalCase" => Ok(PascalCase),
             "camelCase" => Ok(CamelCase),
             "snake_case" => Ok(SnakeCase),
             "SCREAMING_SNAKE_CASE" => Ok(ScreamingSnakeCase),
             "kebab-case" => Ok(KebabCase),
+            "SCREAMING-KEBAB-CASE" => Ok(ScreamingKebabCase),
             _ => Err(()),
         }
     }
@@ -96,37 +111,63 @@ impl FromStr for RenameRule {
 
 #[test]
 fn rename_variants() {
-    for &(original, lower, camel, snake, screaming, kebab) in
-        &[
-            ("Outcome", "outcome", "outcome", "outcome", "OUTCOME", "outcome"),
-            ("VeryTasty", "verytasty", "veryTasty", "very_tasty", "VERY_TASTY", "very-tasty"),
-            ("A", "a", "a", "a", "A", "a"),
-            ("Z42", "z42", "z42", "z42", "Z42", "z42"),
-        ] {
+    for &(original, lower, upper, camel, snake, screaming, kebab, screaming_kebab) in &[
+        (
+            "Outcome", "outcome", "OUTCOME", "outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
+        ),
+        (
+            "VeryTasty",
+            "verytasty",
+            "VERYTASTY",
+            "veryTasty",
+            "very_tasty",
+            "VERY_TASTY",
+            "very-tasty",
+            "VERY-TASTY",
+        ),
+        ("A", "a", "A", "a", "a", "A", "a", "A"),
+        ("Z42", "z42", "Z42", "z42", "z42", "Z42", "z42", "Z42"),
+    ] {
         assert_eq!(None.apply_to_variant(original), original);
         assert_eq!(LowerCase.apply_to_variant(original), lower);
+        assert_eq!(UPPERCASE.apply_to_variant(original), upper);
         assert_eq!(PascalCase.apply_to_variant(original), original);
         assert_eq!(CamelCase.apply_to_variant(original), camel);
         assert_eq!(SnakeCase.apply_to_variant(original), snake);
         assert_eq!(ScreamingSnakeCase.apply_to_variant(original), screaming);
         assert_eq!(KebabCase.apply_to_variant(original), kebab);
+        assert_eq!(
+            ScreamingKebabCase.apply_to_variant(original),
+            screaming_kebab
+        );
     }
 }
 
 #[test]
 fn rename_fields() {
-    for &(original, pascal, camel, screaming, kebab) in
-        &[
-            ("outcome", "Outcome", "outcome", "OUTCOME", "outcome"),
-            ("very_tasty", "VeryTasty", "veryTasty", "VERY_TASTY", "very-tasty"),
-            ("a", "A", "a", "A", "a"),
-            ("z42", "Z42", "z42", "Z42", "z42"),
-        ] {
+    for &(original, upper, pascal, camel, screaming, kebab, screaming_kebab) in &[
+        (
+            "outcome", "OUTCOME", "Outcome", "outcome", "OUTCOME", "outcome", "OUTCOME",
+        ),
+        (
+            "very_tasty",
+            "VERY_TASTY",
+            "VeryTasty",
+            "veryTasty",
+            "VERY_TASTY",
+            "very-tasty",
+            "VERY-TASTY",
+        ),
+        ("a", "A", "A", "a", "A", "a", "A"),
+        ("z42", "Z42", "Z42", "z42", "Z42", "z42", "Z42"),
+    ] {
         assert_eq!(None.apply_to_field(original), original);
+        assert_eq!(UPPERCASE.apply_to_field(original), upper);
         assert_eq!(PascalCase.apply_to_field(original), pascal);
         assert_eq!(CamelCase.apply_to_field(original), camel);
         assert_eq!(SnakeCase.apply_to_field(original), original);
         assert_eq!(ScreamingSnakeCase.apply_to_field(original), screaming);
         assert_eq!(KebabCase.apply_to_field(original), kebab);
+        assert_eq!(ScreamingKebabCase.apply_to_field(original), screaming_kebab);
     }
 }

serde_derive/src/internals/check.rs

@@ -0,0 +1,355 @@
+// 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::{Ctxt, Derive};
+use syn::{Member, Type};
+
+/// Cross-cutting checks that require looking at more than a single attrs
+/// object. Simpler checks should happen when parsing and building the attrs.
+pub fn check(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+    check_getter(cx, cont);
+    check_flatten(cx, cont);
+    check_identifier(cx, cont);
+    check_variant_skip_attrs(cx, cont);
+    check_internal_tag_field_name_conflict(cx, cont);
+    check_adjacent_tag_conflict(cx, cont);
+    check_transparent(cx, cont, derive);
+}
+
+/// Getters are only allowed inside structs (not enums) with the `remote`
+/// attribute.
+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");
+            }
+        }
+        Data::Struct(_, _) => {
+            if cont.data.has_getter() && cont.attrs.remote().is_none() {
+                cx.error(
+                    "#[serde(getter = \"...\")] can only be used in structs \
+                     that have #[serde(remote = \"...\")]",
+                );
+            }
+        }
+    }
+}
+
+/// Flattening has some restrictions we can test.
+fn check_flatten(cx: &Ctxt, cont: &Container) {
+    match cont.data {
+        Data::Enum(ref variants) => {
+            for variant in variants {
+                for field in &variant.fields {
+                    check_flatten_field(cx, variant.style, field);
+                }
+            }
+        }
+        Data::Struct(style, ref fields) => {
+            for field in fields {
+                check_flatten_field(cx, style, field);
+            }
+        }
+    }
+}
+
+fn check_flatten_field(cx: &Ctxt, style: Style, field: &Field) {
+    if !field.attrs.flatten() {
+        return;
+    }
+    match style {
+        Style::Tuple => {
+            cx.error("#[serde(flatten)] cannot be used on tuple structs");
+        }
+        Style::Newtype => {
+            cx.error("#[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.
+///
+/// Inside a `variant_identifier` all variants must be unit variants. Inside a
+/// `field_identifier` all but possibly one variant must be unit variants. The
+/// last variant may be a newtype variant which is an implicit "other" case.
+fn check_identifier(cx: &Ctxt, cont: &Container) {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
+            return;
+        }
+    };
+
+    for (i, variant) in variants.iter().enumerate() {
+        match (
+            variant.style,
+            cont.attrs.identifier(),
+            variant.attrs.other(),
+        ) {
+            // 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");
+            }
+
+            // Variant with `other` attribute must be the last one.
+            (Style::Unit, Identifier::Field, true) => {
+                if i < variants.len() - 1 {
+                    cx.error("#[serde(other)] must be 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");
+            }
+
+            // Any sort of variant is allowed if this is not an identifier.
+            (_, Identifier::No, false) => {}
+
+            // Unit variant without `other` attribute is always fine.
+            (Style::Unit, _, false) => {}
+
+            // The last field is allowed to be a newtype catch-all.
+            (Style::Newtype, Identifier::Field, false) => {
+                if i < variants.len() - 1 {
+                    cx.error(format!("`{}` must be the last variant", variant.ident));
+                }
+            }
+
+            (_, Identifier::Field, false) => {
+                cx.error("field_identifier may only contain unit variants");
+            }
+
+            (_, Identifier::Variant, false) => {
+                cx.error("variant_identifier may only contain unit variants");
+            }
+        }
+    }
+}
+
+/// Skip-(de)serializing attributes are not allowed on variants marked
+/// (de)serialize_with.
+fn check_variant_skip_attrs(cx: &Ctxt, cont: &Container) {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
+            return;
+        }
+    };
+
+    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
+                ));
+            }
+
+            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
+                    ));
+                }
+
+                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
+                    ));
+                }
+            }
+        }
+
+        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
+                ));
+            }
+
+            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
+                    ));
+                }
+            }
+        }
+    }
+}
+
+/// The tag of an internally-tagged struct variant must not be
+/// the same as either one of its fields, as this would result in
+/// duplicate keys in the serialized output and/or ambiguity in
+/// the to-be-deserialized input.
+fn check_internal_tag_field_name_conflict(cx: &Ctxt, cont: &Container) {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => return,
+    };
+
+    let tag = match *cont.attrs.tag() {
+        EnumTag::Internal { ref tag } => tag.as_str(),
+        EnumTag::External | EnumTag::Adjacent { .. } | EnumTag::None => return,
+    };
+
+    let diagnose_conflict = || {
+        let message = format!("variant field name `{}` conflicts with internal tag", tag);
+        cx.error(message);
+    };
+
+    for variant in variants {
+        match variant.style {
+            Style::Struct => {
+                for field in &variant.fields {
+                    let check_ser = !field.attrs.skip_serializing();
+                    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 {
+                        diagnose_conflict();
+                        return;
+                    }
+                }
+            }
+            Style::Unit | Style::Newtype | Style::Tuple => {}
+        }
+    }
+}
+
+/// In the case of adjacently-tagged enums, the type and the
+/// 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 {
+            ref tag,
+            ref content,
+        } => (tag, content),
+        EnumTag::Internal { .. } | EnumTag::External | EnumTag::None => return,
+    };
+
+    if type_tag == content_tag {
+        let message = format!(
+            "enum tags `{}` for type and content conflict with each other",
+            type_tag
+        );
+        cx.error(message);
+    }
+}
+
+/// Enums and unit structs cannot be transparent.
+fn check_transparent(cx: &Ctxt, cont: &mut Container, derive: Derive) {
+    if !cont.attrs.transparent() {
+        return;
+    }
+
+    if cont.attrs.type_from().is_some() {
+        cx.error("#[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 = \"...\")]");
+    }
+
+    let fields = match cont.data {
+        Data::Enum(_) => {
+            cx.error("#[serde(transparent)] is not allowed on an enum");
+            return;
+        }
+        Data::Struct(Style::Unit, _) => {
+            cx.error("#[serde(transparent)] is not allowed on a unit struct");
+            return;
+        }
+        Data::Struct(_, ref mut fields) => fields,
+    };
+
+    let mut transparent_field = None;
+
+    for field in fields {
+        if allow_transparent(field, derive) {
+            if transparent_field.is_some() {
+                cx.error(
+                    "#[serde(transparent)] requires struct to have at most one transparent field",
+                );
+                return;
+            }
+            transparent_field = Some(field);
+        }
+    }
+
+    match transparent_field {
+        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");
+            }
+            Derive::Deserialize => {
+                cx.error("#[serde(transparent)] requires at least one field that is neither skipped nor has a default");
+            }
+        },
+    }
+}
+
+fn member_message(member: &Member) -> String {
+    match *member {
+        Member::Named(ref ident) => format!("`{}`", ident),
+        Member::Unnamed(ref i) => i.index.to_string(),
+    }
+}
+
+fn allow_transparent(field: &Field, derive: Derive) -> bool {
+    if let Type::Path(ref ty) = *field.ty {
+        if let Some(seg) = ty.path.segments.last() {
+            if seg.into_value().ident == "PhantomData" {
+                return false;
+            }
+        }
+    }
+
+    match derive {
+        Derive::Serialize => !field.attrs.skip_serializing(),
+        Derive::Deserialize => !field.attrs.skip_deserializing() && field.attrs.default().is_none(),
+    }
+}

serde_derive/src/internals/ctxt.rs

@@ -6,8 +6,9 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use std::fmt::Display;
 use std::cell::RefCell;
+use std::fmt::Display;
+use std::thread;
 
 #[derive(Default)]
 pub struct Ctxt {
@@ -16,7 +17,9 @@ pub struct Ctxt {
 
 impl Ctxt {
     pub fn new() -> Self {
-        Ctxt { errors: RefCell::new(Some(Vec::new())) }
+        Ctxt {
+            errors: RefCell::new(Some(Vec::new())),
+        }
     }
 
     pub fn error<T: Display>(&self, msg: T) {
@@ -46,7 +49,7 @@ impl Ctxt {
 
 impl Drop for Ctxt {
     fn drop(&mut self) {
-        if self.errors.borrow().is_some() {
+        if !thread::panicking() && self.errors.borrow().is_some() {
             panic!("forgot to check for errors");
         }
     }

serde_derive/src/internals/mod.rs

@@ -6,17 +6,17 @@
 // 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.15.0")]
-
-extern crate syn;
-#[macro_use]
-extern crate synom;
-
 pub mod ast;
 pub mod attr;
 
 mod ctxt;
-pub use ctxt::Ctxt;
+pub use self::ctxt::Ctxt;
 
 mod case;
 mod check;
+
+#[derive(Copy, Clone)]
+pub enum Derive {
+    Serialize,
+    Deserialize,
+}

serde_derive/src/lib.rs

@@ -8,53 +8,82 @@
 
 //! This crate provides Serde's two derive macros.
 //!
-//! ```rust,ignore
+//! ```rust
+//! # #[macro_use]
+//! # extern crate serde_derive;
+//! #
 //! #[derive(Serialize, Deserialize)]
+//! # struct S;
+//! #
+//! # fn main() {}
 //! ```
 //!
 //! Please refer to [https://serde.rs/derive.html] for how to set this up.
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.0")]
-
-#![cfg_attr(feature = "cargo-clippy", allow(too_many_arguments))]
-#![cfg_attr(feature = "cargo-clippy", allow(used_underscore_binding))]
-
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.70")]
+#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+// Whitelisted clippy lints
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        enum_variant_names, redundant_field_names, too_many_arguments, used_underscore_binding,
+        cyclomatic_complexity, needless_pass_by_value
+    )
+)]
+// Whitelisted clippy_pedantic lints
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(
+        items_after_statements, doc_markdown, stutter, similar_names, use_self, single_match_else,
+        enum_glob_use, match_same_arms, filter_map, cast_possible_truncation, indexing_slicing,
+    )
+)]
 // The `quote!` macro requires deep recursion.
-#![recursion_limit = "192"]
+#![recursion_limit = "512"]
 
-extern crate syn;
 #[macro_use]
 extern crate quote;
-
-extern crate serde_derive_internals as internals;
+#[macro_use]
+extern crate syn;
 
 extern crate proc_macro;
+extern crate proc_macro2;
+
+mod internals;
+
 use proc_macro::TokenStream;
+use syn::DeriveInput;
 
 #[macro_use]
 mod bound;
 #[macro_use]
 mod fragment;
 
-mod ser;
 mod de;
+mod pretend;
+mod ser;
+mod try;
 
 #[proc_macro_derive(Serialize, attributes(serde))]
 pub fn derive_serialize(input: TokenStream) -> TokenStream {
-    let input = syn::parse_derive_input(&input.to_string()).unwrap();
-    match ser::expand_derive_serialize(&input) {
-        Ok(expanded) => expanded.parse().unwrap(),
-        Err(msg) => panic!(msg),
-    }
+    let input: DeriveInput = syn::parse(input).unwrap();
+    ser::expand_derive_serialize(&input)
+        .unwrap_or_else(compile_error)
+        .into()
 }
 
 #[proc_macro_derive(Deserialize, attributes(serde))]
 pub fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let input = syn::parse_derive_input(&input.to_string()).unwrap();
-    match de::expand_derive_deserialize(&input) {
-        Ok(expanded) => expanded.parse().unwrap(),
-        Err(msg) => panic!(msg),
+    let input: DeriveInput = syn::parse(input).unwrap();
+    de::expand_derive_deserialize(&input)
+        .unwrap_or_else(compile_error)
+        .into()
+}
+
+fn compile_error(message: String) -> proc_macro2::TokenStream {
+    quote! {
+        compile_error!(#message);
     }
 }

serde_derive/src/pretend.rs

@@ -0,0 +1,140 @@
+use proc_macro2::{Span, TokenStream};
+use syn::Ident;
+
+use internals::ast::{Container, Data, Field, Style};
+
+// Suppress dead_code warnings that would otherwise appear when using a remote
+// derive. Other than this pretend code, a struct annotated with remote derive
+// never has its fields referenced and an enum annotated with remote derive
+// never has its variants constructed.
+//
+//     warning: field is never used: `i`
+//      --> src/main.rs:4:20
+//       |
+//     4 | struct StructDef { i: i32 }
+//       |                    ^^^^^^
+//
+//     warning: variant is never constructed: `V`
+//      --> src/main.rs:8:16
+//       |
+//     8 | enum EnumDef { V }
+//       |                ^
+//
+pub fn pretend_used(cont: &Container) -> TokenStream {
+    let pretend_fields = pretend_fields_used(cont);
+    let pretend_variants = pretend_variants_used(cont);
+
+    quote! {
+        #pretend_fields
+        #pretend_variants
+    }
+}
+
+// For structs with named fields, expands to:
+//
+//     match None::<T> {
+//         Some(T { a: ref __v0, b: ref __v1 }) => {}
+//         _ => {}
+//     }
+//
+// For enums, expands to the following but only including struct variants:
+//
+//     match None::<T> {
+//         Some(T::A { a: ref __v0 }) => {}
+//         Some(T::B { b: ref __v0 }) => {}
+//         _ => {}
+//     }
+//
+// The `ref` is important in case the user has written a Drop impl on their
+// type. Rust does not allow destructuring a struct or enum that has a Drop
+// impl.
+fn pretend_fields_used(cont: &Container) -> TokenStream {
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+
+    let patterns = match cont.data {
+        Data::Enum(ref variants) => variants
+            .iter()
+            .filter_map(|variant| match variant.style {
+                Style::Struct => {
+                    let variant_ident = &variant.ident;
+                    let pat = struct_pattern(&variant.fields);
+                    Some(quote!(#type_ident::#variant_ident #pat))
+                }
+                _ => None,
+            })
+            .collect::<Vec<_>>(),
+        Data::Struct(Style::Struct, ref fields) => {
+            let pat = struct_pattern(fields);
+            vec![quote!(#type_ident #pat)]
+        }
+        Data::Struct(_, _) => {
+            return quote!();
+        }
+    };
+
+    quote! {
+        match _serde::export::None::<#type_ident #ty_generics> {
+            #(
+                _serde::export::Some(#patterns) => {}
+            )*
+            _ => {}
+        }
+    }
+}
+
+// Expands to one of these per enum variant:
+//
+//     match None {
+//         Some((__v0, __v1,)) => {
+//             let _ = E::V { a: __v0, b: __v1 };
+//         }
+//         _ => {}
+//     }
+//
+fn pretend_variants_used(cont: &Container) -> TokenStream {
+    let variants = match cont.data {
+        Data::Enum(ref variants) => variants,
+        Data::Struct(_, _) => {
+            return quote!();
+        }
+    };
+
+    let type_ident = &cont.ident;
+    let (_, ty_generics, _) = cont.generics.split_for_impl();
+    let turbofish = ty_generics.as_turbofish();
+
+    let cases = variants.iter().map(|variant| {
+        let variant_ident = &variant.ident;
+        let placeholders = &(0..variant.fields.len())
+            .map(|i| Ident::new(&format!("__v{}", i), Span::call_site()))
+            .collect::<Vec<_>>();
+
+        let pat = match variant.style {
+            Style::Struct => {
+                let members = variant.fields.iter().map(|field| &field.member);
+                quote!({ #(#members: #placeholders),* })
+            }
+            Style::Tuple | Style::Newtype => quote!(( #(#placeholders),* )),
+            Style::Unit => quote!(),
+        };
+
+        quote! {
+            match _serde::export::None {
+                _serde::export::Some((#(#placeholders,)*)) => {
+                    let _ = #type_ident::#variant_ident #turbofish #pat;
+                }
+                _ => {}
+            }
+        }
+    });
+
+    quote!(#(#cases)*)
+}
+
+fn struct_pattern(fields: &[Field]) -> TokenStream {
+    let members = fields.iter().map(|field| &field.member);
+    let placeholders =
+        (0..fields.len()).map(|i| Ident::new(&format!("__v{}", i), Span::call_site()));
+    quote!({ #(#members: ref #placeholders),* })
+}

serde_derive/src/try.rs

@@ -0,0 +1,24 @@
+use proc_macro2::{Punct, Spacing, TokenStream};
+
+// None of our generated code requires the `From::from` error conversion
+// performed by the standard library's `try!` macro. With this simplified macro
+// we see a significant improvement in type checking and borrow checking time of
+// the generated code and a slight improvement in binary size.
+pub fn replacement() -> TokenStream {
+    // Cannot pass `$expr` to `quote!` prior to Rust 1.17.0 so interpolate it.
+    let dollar = Punct::new('$', Spacing::Alone);
+
+    quote! {
+        #[allow(unused_macros)]
+        macro_rules! try {
+            (#dollar __expr:expr) => {
+                match #dollar __expr {
+                    _serde::export::Ok(__val) => __val,
+                    _serde::export::Err(__err) => {
+                        return _serde::export::Err(__err);
+                    }
+                }
+            }
+        }
+    }
+}

serde_derive_internals/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive_internals"
-version = "0.15.0" # remember to update html_root_url
+version = "0.23.1" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "AST representation used by Serde derive macros. Unstable."
@@ -8,12 +8,15 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_derive_internals/"
 keywords = ["serde", "serialization"]
-readme = "README.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+
+[lib]
+path = "lib.rs"
 
 [dependencies]
-syn = { version = "0.11.10", default-features = false, features = ["parsing"] }
-synom = "0.11"
+proc-macro2 = "0.4"
+syn = { version = "0.14", default-features = false, features = ["derive", "parsing", "clone-impls"] }
 
 [badges]
 travis-ci = { repository = "serde-rs/serde" }

serde_derive_internals/crates-io.md

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

serde_derive_internals/lib.rs

@@ -0,0 +1,23 @@
+// 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")]
+#![cfg_attr(
+    feature = "cargo-clippy",
+    allow(cyclomatic_complexity, doc_markdown, match_same_arms, redundant_field_names)
+)]
+
+#[macro_use]
+extern crate syn;
+
+extern crate proc_macro2;
+
+#[path = "src/mod.rs"]
+mod internals;
+
+pub use internals::*;

serde_derive_internals/src

@@ -0,0 +1 @@
+../serde_derive/src/internals/

serde_derive_internals/src/ast.rs

@@ -1,143 +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.
-
-use syn;
-use attr;
-use check;
-use Ctxt;
-
-pub struct Container<'a> {
-    pub ident: syn::Ident,
-    pub attrs: attr::Container,
-    pub body: Body<'a>,
-    pub generics: &'a syn::Generics,
-}
-
-pub enum Body<'a> {
-    Enum(Vec<Variant<'a>>),
-    Struct(Style, Vec<Field<'a>>),
-}
-
-pub struct Variant<'a> {
-    pub ident: syn::Ident,
-    pub attrs: attr::Variant,
-    pub style: Style,
-    pub fields: Vec<Field<'a>>,
-}
-
-pub struct Field<'a> {
-    pub ident: Option<syn::Ident>,
-    pub attrs: attr::Field,
-    pub ty: &'a syn::Ty,
-}
-
-#[derive(Copy, Clone)]
-pub enum Style {
-    Struct,
-    Tuple,
-    Newtype,
-    Unit,
-}
-
-impl<'a> Container<'a> {
-    pub fn from_ast(cx: &Ctxt, item: &'a syn::MacroInput) -> Container<'a> {
-        let attrs = attr::Container::from_ast(cx, item);
-
-        let mut body = match item.body {
-            syn::Body::Enum(ref variants) => Body::Enum(enum_from_ast(cx, variants)),
-            syn::Body::Struct(ref variant_data) => {
-                let (style, fields) = struct_from_ast(cx, variant_data);
-                Body::Struct(style, fields)
-            }
-        };
-
-        match body {
-            Body::Enum(ref mut variants) => {
-                for ref mut variant in variants {
-                    variant.attrs.rename_by_rule(attrs.rename_all());
-                    for ref mut field in &mut variant.fields {
-                        field.attrs.rename_by_rule(variant.attrs.rename_all());
-                    }
-                }
-            }
-            Body::Struct(_, ref mut fields) => {
-                for field in fields {
-                    field.attrs.rename_by_rule(attrs.rename_all());
-                }
-            }
-        }
-
-        let item = Container {
-            ident: item.ident.clone(),
-            attrs: attrs,
-            body: body,
-            generics: &item.generics,
-        };
-        check::check(cx, &item);
-        item
-    }
-}
-
-impl<'a> Body<'a> {
-    pub fn all_fields(&'a self) -> Box<Iterator<Item = &'a Field<'a>> + 'a> {
-        match *self {
-            Body::Enum(ref variants) => {
-                Box::new(variants.iter().flat_map(|variant| variant.fields.iter()))
-            }
-            Body::Struct(_, ref fields) => Box::new(fields.iter()),
-        }
-    }
-
-    pub fn has_getter(&self) -> bool {
-        self.all_fields().any(|f| f.attrs.getter().is_some())
-    }
-}
-
-fn enum_from_ast<'a>(cx: &Ctxt, variants: &'a [syn::Variant]) -> Vec<Variant<'a>> {
-    variants
-        .iter()
-        .map(
-            |variant| {
-                let (style, fields) = struct_from_ast(cx, &variant.data);
-                Variant {
-                    ident: variant.ident.clone(),
-                    attrs: attr::Variant::from_ast(cx, variant),
-                    style: style,
-                    fields: fields,
-                }
-            },
-        )
-        .collect()
-}
-
-fn struct_from_ast<'a>(cx: &Ctxt, data: &'a syn::VariantData) -> (Style, Vec<Field<'a>>) {
-    match *data {
-        syn::VariantData::Struct(ref fields) => (Style::Struct, fields_from_ast(cx, fields)),
-        syn::VariantData::Tuple(ref fields) if fields.len() == 1 => {
-            (Style::Newtype, fields_from_ast(cx, fields))
-        }
-        syn::VariantData::Tuple(ref fields) => (Style::Tuple, fields_from_ast(cx, fields)),
-        syn::VariantData::Unit => (Style::Unit, Vec::new()),
-    }
-}
-
-fn fields_from_ast<'a>(cx: &Ctxt, fields: &'a [syn::Field]) -> Vec<Field<'a>> {
-    fields
-        .iter()
-        .enumerate()
-        .map(
-            |(i, field)| {
-                Field {
-                    ident: field.ident.clone(),
-                    attrs: attr::Field::from_ast(cx, i, field),
-                    ty: &field.ty,
-                }
-            },
-        )
-        .collect()
-}

serde_derive_internals/src/check.rs

@@ -1,96 +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.
-
-use ast::{Body, Container, Style};
-use attr::Identifier;
-use Ctxt;
-
-/// Cross-cutting checks that require looking at more than a single attrs
-/// object. Simpler checks should happen when parsing and building the attrs.
-pub fn check(cx: &Ctxt, cont: &Container) {
-    check_getter(cx, cont);
-    check_identifier(cx, cont);
-}
-
-/// Getters are only allowed inside structs (not enums) with the `remote`
-/// attribute.
-fn check_getter(cx: &Ctxt, cont: &Container) {
-    match cont.body {
-        Body::Enum(_) => {
-            if cont.body.has_getter() {
-                cx.error("#[serde(getter = \"...\")] is not allowed in an enum");
-            }
-        }
-        Body::Struct(_, _) => {
-            if cont.body.has_getter() && cont.attrs.remote().is_none() {
-                cx.error(
-                    "#[serde(getter = \"...\")] can only be used in structs \
-                          that have #[serde(remote = \"...\")]",
-                );
-            }
-        }
-    }
-}
-
-/// 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.
-///
-/// Inside a `variant_identifier` all variants must be unit variants. Inside a
-/// `field_identifier` all but possibly one variant must be unit variants. The
-/// last variant may be a newtype variant which is an implicit "other" case.
-fn check_identifier(cx: &Ctxt, cont: &Container) {
-    let variants = match cont.body {
-        Body::Enum(ref variants) => variants,
-        Body::Struct(_, _) => {
-            return;
-        }
-    };
-
-    for (i, variant) in variants.iter().enumerate() {
-        match (variant.style, cont.attrs.identifier(), variant.attrs.other()) {
-            // 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");
-            }
-
-            // Variant with `other` attribute must be the last one.
-            (Style::Unit, Identifier::Field, true) => {
-                if i < variants.len() - 1 {
-                    cx.error("#[serde(other)] must be 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");
-            }
-
-            // Any sort of variant is allowed if this is not an identifier.
-            (_, Identifier::No, false) => {}
-
-            // Unit variant without `other` attribute is always fine.
-            (Style::Unit, _, false) => {}
-
-            // The last field is allowed to be a newtype catch-all.
-            (Style::Newtype, Identifier::Field, false) => {
-                if i < variants.len() - 1 {
-                    cx.error(format!("`{}` must be the last variant", variant.ident));
-                }
-            }
-
-            (_, Identifier::Field, false) => {
-                cx.error("field_identifier may only contain unit variants");
-            }
-
-            (_, Identifier::Variant, false) => {
-                cx.error("variant_identifier may only contain unit variants");
-            }
-        }
-    }
-}

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.0" # remember to update html_root_url
+version = "1.0.70" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -8,11 +8,11 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_test/"
 keywords = ["serde", "serialization"]
-readme = "README.md"
-include = ["Cargo.toml", "src/**/*.rs", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+readme = "crates-io.md"
+include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 
 [dependencies]
-serde = { version = "1.0", path = "../serde" }
+serde = { version = "1.0.60", path = "../serde" }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde", features = ["rc"] }

serde_test/crates-io.md

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

serde_test/src/assert.rs

@@ -6,7 +6,7 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use serde::{Serialize, Deserialize};
+use serde::{Deserialize, Serialize};
 
 use de::Deserializer;
 use ser::Serializer;
@@ -184,11 +184,27 @@ where
     T: Deserialize<'de> + PartialEq + Debug,
 {
     let mut de = Deserializer::new(tokens);
-    match T::deserialize(&mut de) {
-        Ok(v) => assert_eq!(v, *value),
+    let mut deserialized_val = match T::deserialize(&mut de) {
+        Ok(v) => {
+            assert_eq!(v, *value);
+            v
+        }
         Err(e) => panic!("tokens failed to deserialize: {}", e),
+    };
+    if de.remaining() > 0 {
+        panic!("{} remaining tokens", de.remaining());
     }
 
+    // Do the same thing for deserialize_in_place. This isn't *great* because a
+    // no-op impl of deserialize_in_place can technically succeed here. Still,
+    // this should catch a lot of junk.
+    let mut de = Deserializer::new(tokens);
+    match T::deserialize_in_place(&mut de, &mut deserialized_val) {
+        Ok(()) => {
+            assert_eq!(deserialized_val, *value);
+        }
+        Err(e) => panic!("tokens failed to deserialize_in_place: {}", e),
+    }
     if de.remaining() > 0 {
         panic!("{} remaining tokens", de.remaining());
     }
@@ -215,7 +231,7 @@ where
 ///
 /// assert_de_tokens_error::<S>(
 ///     &[
-///         Token::Struct { name: "S", len: 1 },
+///         Token::Struct { name: "S", len: 2 },
 ///         Token::Str("x"),
 ///     ],
 ///     "unknown field `x`, expected `a` or `b`",

serde_test/src/configure.rs

@@ -0,0 +1,844 @@
+use std::fmt;
+
+use serde::ser::{
+    SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
+    SerializeTupleStruct, SerializeTupleVariant,
+};
+use serde::{Deserialize, Deserializer, Serialize, Serializer};
+
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+pub struct Readable<T: ?Sized>(T);
+#[derive(Debug, PartialEq, Eq, PartialOrd, Ord)]
+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;
+///
+/// use serde::{Deserialize, Deserializer, Serialize, Serializer};
+/// use serde_test::{Configure, Token, assert_tokens};
+///
+/// #[derive(Debug, PartialEq)]
+/// struct Example(u8, u8);
+///
+/// impl Serialize for Example {
+///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+///     where
+///         S: Serializer,
+///     {
+///         if serializer.is_human_readable() {
+///             format!("{}.{}", self.0, self.1).serialize(serializer)
+///         } else {
+///             (self.0, self.1).serialize(serializer)
+///         }
+///     }
+/// }
+///
+/// impl<'de> Deserialize<'de> for Example {
+///     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+///     where
+///         D: Deserializer<'de>,
+///     {
+///         use serde::de::Error;
+///         if deserializer.is_human_readable() {
+///             let s = String::deserialize(deserializer)?;
+///             let parts: Vec<_> = s.split('.').collect();
+///             Ok(Example(
+///                 parts[0].parse().map_err(D::Error::custom)?,
+///                 parts[1].parse().map_err(D::Error::custom)?,
+///             ))
+///         } else {
+///             let (x, y) = Deserialize::deserialize(deserializer)?;
+///             Ok(Example(x, y))
+///         }
+///     }
+/// }
+///
+/// fn main() {
+///     assert_tokens(
+///         &Example(1, 0).compact(),
+///         &[
+///             Token::Tuple { len: 2 },
+///             Token::U8(1),
+///             Token::U8(0),
+///             Token::TupleEnd,
+///         ],
+///     );
+///     assert_tokens(
+///         &Example(1, 0).readable(),
+///         &[
+///             Token::Str("1.0"),
+///         ],
+///     );
+/// }
+/// ```
+pub trait Configure {
+    /// Marks `self` as using `is_human_readable == true`
+    fn readable(self) -> Readable<Self>
+    where
+        Self: Sized,
+    {
+        Readable(self)
+    }
+    /// Marks `self` as using `is_human_readable == false`
+    fn compact(self) -> Compact<Self>
+    where
+        Self: Sized,
+    {
+        Compact(self)
+    }
+}
+
+impl<T: ?Sized> Configure for T {}
+
+impl<T: ?Sized> Serialize for Readable<T>
+where
+    T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(Readable(serializer))
+    }
+}
+impl<T: ?Sized> Serialize for Compact<T>
+where
+    T: Serialize,
+{
+    #[inline]
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    where
+        S: Serializer,
+    {
+        self.0.serialize(Compact(serializer))
+    }
+}
+impl<'de, T> Deserialize<'de> for Readable<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize(Readable(deserializer)).map(Readable)
+    }
+}
+impl<'de, T> Deserialize<'de> for Compact<T>
+where
+    T: Deserialize<'de>,
+{
+    fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        T::deserialize(Compact(deserializer)).map(Compact)
+    }
+}
+
+impl<'de, T> DeserializeSeed<'de> for Readable<T>
+where
+    T: DeserializeSeed<'de>,
+{
+    type Value = T::Value;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        self.0.deserialize(Readable(deserializer))
+    }
+}
+impl<'de, T> DeserializeSeed<'de> for Compact<T>
+where
+    T: DeserializeSeed<'de>,
+{
+    type Value = T::Value;
+
+    fn deserialize<D>(self, deserializer: D) -> Result<Self::Value, D::Error>
+    where
+        D: Deserializer<'de>,
+    {
+        self.0.deserialize(Compact(deserializer))
+    }
+}
+
+macro_rules! forward_method {
+    ($name: ident (self $(, $arg: ident : $arg_type: ty)* ) -> $return_type: ty) => {
+        fn $name (self $(, $arg : $arg_type)* ) -> $return_type {
+            (self.0).$name( $($arg),* )
+        }
+    };
+}
+
+macro_rules! forward_serialize_methods {
+    ( $( $name: ident $arg_type: ty ),* ) => {
+        $(
+            forward_method!($name(self, v : $arg_type) -> Result<Self::Ok, Self::Error>);
+        )*
+    };
+}
+
+macro_rules! impl_serializer {
+    ($wrapper:ident, $is_human_readable:expr) => {
+        impl<S> Serializer for $wrapper<S>
+        where
+            S: Serializer,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+
+            type SerializeSeq = $wrapper<S::SerializeSeq>;
+            type SerializeTuple = $wrapper<S::SerializeTuple>;
+            type SerializeTupleStruct = $wrapper<S::SerializeTupleStruct>;
+            type SerializeTupleVariant = $wrapper<S::SerializeTupleVariant>;
+            type SerializeMap = $wrapper<S::SerializeMap>;
+            type SerializeStruct = $wrapper<S::SerializeStruct>;
+            type SerializeStructVariant = $wrapper<S::SerializeStructVariant>;
+
+            fn is_human_readable(&self) -> bool {
+                $is_human_readable
+            }
+
+            forward_serialize_methods!{
+                serialize_bool bool,
+                serialize_i8 i8,
+                serialize_i16 i16,
+                serialize_i32 i32,
+                serialize_i64 i64,
+                serialize_u8 u8,
+                serialize_u16 u16,
+                serialize_u32 u32,
+                serialize_u64 u64,
+                serialize_f32 f32,
+                serialize_f64 f64,
+                serialize_char char,
+                serialize_str &str,
+                serialize_bytes &[u8],
+                serialize_unit_struct &'static str
+
+            }
+
+            fn serialize_unit(self) -> Result<S::Ok, S::Error> {
+                self.0.serialize_unit()
+            }
+
+            fn serialize_unit_variant(
+                self,
+                name: &'static str,
+                variant_index: u32,
+                variant: &'static str,
+            ) -> Result<S::Ok, S::Error> {
+                self.0.serialize_unit_variant(name, variant_index, variant)
+            }
+
+            fn serialize_newtype_struct<T: ?Sized>(
+                self,
+                name: &'static str,
+                value: &T,
+            ) -> Result<S::Ok, S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_newtype_struct(name, &$wrapper(value))
+            }
+
+            fn serialize_newtype_variant<T: ?Sized>(
+                self,
+                name: &'static str,
+                variant_index: u32,
+                variant: &'static str,
+                value: &T,
+            ) -> Result<S::Ok, S::Error>
+            where
+                T: Serialize,
+            {
+                self.0
+                    .serialize_newtype_variant(name, variant_index, variant, &$wrapper(value))
+            }
+
+            fn serialize_none(self) -> Result<S::Ok, Self::Error> {
+                self.0.serialize_none()
+            }
+
+            fn serialize_some<T: ?Sized>(self, value: &T) -> Result<S::Ok, Self::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_some(&$wrapper(value))
+            }
+
+            fn serialize_seq(self, len: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
+                self.0.serialize_seq(len).map($wrapper)
+            }
+
+            fn serialize_tuple(self, len: usize) -> Result<Self::SerializeTuple, Self::Error> {
+                self.0.serialize_tuple(len).map($wrapper)
+            }
+
+            fn serialize_tuple_struct(
+                self,
+                name: &'static str,
+                len: usize,
+            ) -> Result<Self::SerializeTupleStruct, Self::Error> {
+                self.0.serialize_tuple_struct(name, len).map($wrapper)
+            }
+
+            fn serialize_tuple_variant(
+                self,
+                name: &'static str,
+                variant_index: u32,
+                variant: &'static str,
+                len: usize,
+            ) -> Result<Self::SerializeTupleVariant, Self::Error> {
+                self.0
+                    .serialize_tuple_variant(name, variant_index, variant, len)
+                    .map($wrapper)
+            }
+
+            fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
+                self.0.serialize_map(len).map($wrapper)
+            }
+
+            fn serialize_struct(
+                self,
+                name: &'static str,
+                len: usize,
+            ) -> Result<Self::SerializeStruct, Self::Error> {
+                self.0.serialize_struct(name, len).map($wrapper)
+            }
+
+            fn serialize_struct_variant(
+                self,
+                name: &'static str,
+                variant_index: u32,
+                variant: &'static str,
+                len: usize,
+            ) -> Result<Self::SerializeStructVariant, Self::Error> {
+                self.0
+                    .serialize_struct_variant(name, variant_index, variant, len)
+                    .map($wrapper)
+            }
+        }
+
+        impl<S> SerializeSeq for $wrapper<S>
+        where
+            S: SerializeSeq,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_element(&$wrapper(value))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeTuple for $wrapper<S>
+        where
+            S: SerializeTuple,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_element(&$wrapper(value))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeTupleStruct for $wrapper<S>
+        where
+            S: SerializeTupleStruct,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_field(&$wrapper(value))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeTupleVariant for $wrapper<S>
+        where
+            S: SerializeTupleVariant,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_field(&$wrapper(value))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeMap for $wrapper<S>
+        where
+            S: SerializeMap,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_key(&$wrapper(key))
+            }
+            fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_value(&$wrapper(value))
+            }
+            fn serialize_entry<K: ?Sized, V: ?Sized>(
+                &mut self,
+                key: &K,
+                value: &V,
+            ) -> Result<(), S::Error>
+            where
+                K: Serialize,
+                V: Serialize,
+            {
+                self.0.serialize_entry(key, &$wrapper(value))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeStruct for $wrapper<S>
+        where
+            S: SerializeStruct,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_field<T: ?Sized>(
+                &mut self,
+                name: &'static str,
+                field: &T,
+            ) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_field(name, &$wrapper(field))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+
+        impl<S> SerializeStructVariant for $wrapper<S>
+        where
+            S: SerializeStructVariant,
+        {
+            type Ok = S::Ok;
+            type Error = S::Error;
+            fn serialize_field<T: ?Sized>(
+                &mut self,
+                name: &'static str,
+                field: &T,
+            ) -> Result<(), S::Error>
+            where
+                T: Serialize,
+            {
+                self.0.serialize_field(name, &$wrapper(field))
+            }
+            fn end(self) -> Result<S::Ok, S::Error> {
+                self.0.end()
+            }
+        }
+    };
+}
+
+impl_serializer!(Readable, true);
+impl_serializer!(Compact, false);
+
+use serde::de::{DeserializeSeed, EnumAccess, Error, MapAccess, SeqAccess, VariantAccess, Visitor};
+
+macro_rules! forward_deserialize_methods {
+    ( $wrapper : ident ( $( $name: ident ),* ) ) => {
+        $(
+            fn $name<V>(self, visitor: V) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                (self.0).$name($wrapper(visitor))
+            }
+        )*
+    };
+}
+
+macro_rules! impl_deserializer {
+    ($wrapper:ident, $is_human_readable:expr) => {
+        impl<'de, D> Deserializer<'de> for $wrapper<D>
+        where
+            D: Deserializer<'de>,
+        {
+            type Error = D::Error;
+
+            forward_deserialize_methods! {
+                $wrapper (
+                    deserialize_any,
+                    deserialize_bool,
+                    deserialize_u8,
+                    deserialize_u16,
+                    deserialize_u32,
+                    deserialize_u64,
+                    deserialize_i8,
+                    deserialize_i16,
+                    deserialize_i32,
+                    deserialize_i64,
+                    deserialize_f32,
+                    deserialize_f64,
+                    deserialize_char,
+                    deserialize_str,
+                    deserialize_string,
+                    deserialize_bytes,
+                    deserialize_byte_buf,
+                    deserialize_option,
+                    deserialize_unit,
+                    deserialize_seq,
+                    deserialize_map,
+                    deserialize_identifier,
+                    deserialize_ignored_any
+                )
+            }
+
+            fn deserialize_unit_struct<V>(
+                self,
+                name: &'static str,
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.deserialize_unit_struct(name, $wrapper(visitor))
+            }
+            fn deserialize_newtype_struct<V>(
+                self,
+                name: &'static str,
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.deserialize_newtype_struct(name, $wrapper(visitor))
+            }
+            fn deserialize_tuple<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.deserialize_tuple(len, $wrapper(visitor))
+            }
+            fn deserialize_tuple_struct<V>(
+                self,
+                name: &'static str,
+                len: usize,
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0
+                    .deserialize_tuple_struct(name, len, $wrapper(visitor))
+            }
+            fn deserialize_struct<V>(
+                self,
+                name: &'static str,
+                fields: &'static [&'static str],
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.deserialize_struct(name, fields, $wrapper(visitor))
+            }
+            fn deserialize_enum<V>(
+                self,
+                name: &'static str,
+                variants: &'static [&'static str],
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.deserialize_enum(name, variants, $wrapper(visitor))
+            }
+
+            fn is_human_readable(&self) -> bool {
+                $is_human_readable
+            }
+        }
+
+        impl<'de, D> Visitor<'de> for $wrapper<D>
+        where
+            D: Visitor<'de>,
+        {
+            type Value = D::Value;
+            fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+                self.0.expecting(formatter)
+            }
+            fn visit_bool<E>(self, v: bool) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_bool(v)
+            }
+            fn visit_i8<E>(self, v: i8) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_i8(v)
+            }
+            fn visit_i16<E>(self, v: i16) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_i16(v)
+            }
+            fn visit_i32<E>(self, v: i32) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_i32(v)
+            }
+            fn visit_i64<E>(self, v: i64) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_i64(v)
+            }
+            fn visit_u8<E>(self, v: u8) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_u8(v)
+            }
+            fn visit_u16<E>(self, v: u16) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_u16(v)
+            }
+            fn visit_u32<E>(self, v: u32) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_u32(v)
+            }
+            fn visit_u64<E>(self, v: u64) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_u64(v)
+            }
+            fn visit_f32<E>(self, v: f32) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_f32(v)
+            }
+            fn visit_f64<E>(self, v: f64) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_f64(v)
+            }
+            fn visit_char<E>(self, v: char) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_char(v)
+            }
+            fn visit_str<E>(self, v: &str) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_str(v)
+            }
+            fn visit_borrowed_str<E>(self, v: &'de str) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_borrowed_str(v)
+            }
+            fn visit_string<E>(self, v: String) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_string(v)
+            }
+            fn visit_bytes<E>(self, v: &[u8]) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_bytes(v)
+            }
+            fn visit_borrowed_bytes<E>(self, v: &'de [u8]) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_borrowed_bytes(v)
+            }
+            fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_byte_buf(v)
+            }
+            fn visit_none<E>(self) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_none()
+            }
+            fn visit_some<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
+            where
+                D2: Deserializer<'de>,
+            {
+                self.0.visit_some($wrapper(deserializer))
+            }
+            fn visit_unit<E>(self) -> Result<D::Value, E>
+            where
+                E: Error,
+            {
+                self.0.visit_unit()
+            }
+            fn visit_newtype_struct<D2>(self, deserializer: D2) -> Result<Self::Value, D2::Error>
+            where
+                D2: Deserializer<'de>,
+            {
+                self.0.visit_newtype_struct($wrapper(deserializer))
+            }
+            fn visit_seq<V>(self, seq: V) -> Result<D::Value, V::Error>
+            where
+                V: SeqAccess<'de>,
+            {
+                self.0.visit_seq($wrapper(seq))
+            }
+            fn visit_map<V>(self, map: V) -> Result<D::Value, V::Error>
+            where
+                V: MapAccess<'de>,
+            {
+                self.0.visit_map($wrapper(map))
+            }
+            fn visit_enum<V>(self, data: V) -> Result<D::Value, V::Error>
+            where
+                V: EnumAccess<'de>,
+            {
+                self.0.visit_enum($wrapper(data))
+            }
+        }
+
+        impl<'de, D> SeqAccess<'de> for $wrapper<D>
+        where
+            D: SeqAccess<'de>,
+        {
+            type Error = D::Error;
+            fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, D::Error>
+            where
+                T: DeserializeSeed<'de>,
+            {
+                self.0.next_element_seed($wrapper(seed))
+            }
+            fn size_hint(&self) -> Option<usize> {
+                self.0.size_hint()
+            }
+        }
+
+        impl<'de, D> MapAccess<'de> for $wrapper<D>
+        where
+            D: MapAccess<'de>,
+        {
+            type Error = D::Error;
+            fn next_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, D::Error>
+            where
+                K: DeserializeSeed<'de>,
+            {
+                self.0.next_key_seed($wrapper(seed))
+            }
+            fn next_value_seed<V>(&mut self, seed: V) -> Result<V::Value, D::Error>
+            where
+                V: DeserializeSeed<'de>,
+            {
+                self.0.next_value_seed($wrapper(seed))
+            }
+            fn size_hint(&self) -> Option<usize> {
+                self.0.size_hint()
+            }
+        }
+
+        impl<'de, D> EnumAccess<'de> for $wrapper<D>
+        where
+            D: EnumAccess<'de>,
+        {
+            type Error = D::Error;
+            type Variant = $wrapper<D::Variant>;
+            fn variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+            where
+                V: DeserializeSeed<'de>,
+            {
+                self.0
+                    .variant_seed($wrapper(seed))
+                    .map(|(value, variant)| (value, $wrapper(variant)))
+            }
+        }
+
+        impl<'de, D> VariantAccess<'de> for $wrapper<D>
+        where
+            D: VariantAccess<'de>,
+        {
+            type Error = D::Error;
+            fn unit_variant(self) -> Result<(), D::Error> {
+                self.0.unit_variant()
+            }
+            fn newtype_variant_seed<T>(self, seed: T) -> Result<T::Value, D::Error>
+            where
+                T: DeserializeSeed<'de>,
+            {
+                self.0.newtype_variant_seed($wrapper(seed))
+            }
+            fn tuple_variant<V>(self, len: usize, visitor: V) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.tuple_variant(len, $wrapper(visitor))
+            }
+            fn struct_variant<V>(
+                self,
+                fields: &'static [&'static str],
+                visitor: V,
+            ) -> Result<V::Value, D::Error>
+            where
+                V: Visitor<'de>,
+            {
+                self.0.struct_variant(fields, $wrapper(visitor))
+            }
+        }
+    };
+}
+
+impl_deserializer!(Readable, true);
+impl_deserializer!(Compact, false);

serde_test/src/de.rs

@@ -6,9 +6,11 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-use serde::de::{self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess,
-                SeqAccess, VariantAccess, Visitor};
 use serde::de::value::{MapAccessDeserializer, SeqAccessDeserializer};
+use serde::de::{
+    self, Deserialize, DeserializeSeed, EnumAccess, IntoDeserializer, MapAccess, SeqAccess,
+    VariantAccess, Visitor,
+};
 
 use error::Error;
 use token::Token;
@@ -22,28 +24,28 @@ macro_rules! assert_next_token {
     ($de:expr, $expected:expr) => {
         match $de.next_token_opt() {
             Some(token) if token == $expected => {}
-            Some(other) => {
-                panic!("expected Token::{} but deserialization wants Token::{}",
-                       other, $expected)
-            }
-            None => {
-                panic!("end of tokens but deserialization wants Token::{}",
-                       $expected)
-            }
+            Some(other) => panic!(
+                "expected Token::{} but deserialization wants Token::{}",
+                other, $expected
+            ),
+            None => panic!(
+                "end of tokens but deserialization wants Token::{}",
+                $expected
+            ),
         }
-    }
+    };
 }
 
 macro_rules! unexpected {
     ($token:expr) => {
         panic!("deserialization did not expect this token: {}", $token)
-    }
+    };
 }
 
 macro_rules! end_of_tokens {
     () => {
         panic!("ran out of tokens to deserialize")
-    }
+    };
 }
 
 impl<'de> Deserializer<'de> {
@@ -95,15 +97,11 @@ impl<'de> Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        let value = try!(
-            visitor.visit_seq(
-                DeserializerSeqVisitor {
-                    de: self,
-                    len: len,
-                    end: end.clone(),
-                },
-            )
-        );
+        let value = try!(visitor.visit_seq(DeserializerSeqVisitor {
+            de: self,
+            len: len,
+            end: end,
+        },));
         assert_next_token!(self, end);
         Ok(value)
     }
@@ -117,15 +115,11 @@ impl<'de> Deserializer<'de> {
     where
         V: Visitor<'de>,
     {
-        let value = try!(
-            visitor.visit_map(
-                DeserializerMapVisitor {
-                    de: self,
-                    len: len,
-                    end: end.clone(),
-                },
-            )
-        );
+        let value = try!(visitor.visit_map(DeserializerMapVisitor {
+            de: self,
+            len: len,
+            end: end,
+        },));
         assert_next_token!(self, end);
         Ok(value)
     }
@@ -135,8 +129,8 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
     type Error = Error;
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf unit seq map identifier ignored_any
+        bool i8 i16 i32 i64 i128 u8 u16 u32 u64 u128 f32 f64 char str string
+        bytes byte_buf unit seq map identifier ignored_any
     }
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Error>
@@ -165,15 +159,16 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             Token::ByteBuf(v) => visitor.visit_byte_buf(v.to_vec()),
             Token::None => visitor.visit_none(),
             Token::Some => visitor.visit_some(self),
-            Token::Unit => visitor.visit_unit(),
-            Token::UnitStruct { name: _ } => visitor.visit_unit(),
-            Token::NewtypeStruct { name: _ } => visitor.visit_newtype_struct(self),
+            Token::Unit | Token::UnitStruct { .. } => visitor.visit_unit(),
+            Token::NewtypeStruct { .. } => visitor.visit_newtype_struct(self),
             Token::Seq { len } => self.visit_seq(len, Token::SeqEnd, visitor),
             Token::Tuple { len } => self.visit_seq(Some(len), Token::TupleEnd, visitor),
-            Token::TupleStruct { name: _, len } => self.visit_seq(Some(len), Token::TupleStructEnd, visitor),
+            Token::TupleStruct { len, .. } => {
+                self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
+            }
             Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
-            Token::Struct { name: _, len } => self.visit_map(Some(len), Token::StructEnd, visitor),
-            Token::Enum { name: _ } => {
+            Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor),
+            Token::Enum { .. } => {
                 let variant = self.next_token();
                 let next = self.peek_token();
                 match (variant, next) {
@@ -195,18 +190,29 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                     }
                 }
             }
-            Token::UnitVariant { name: _, variant } => visitor.visit_str(variant),
-            Token::NewtypeVariant { name: _, variant } => {
-                visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Any),)
-            }
-            Token::TupleVariant { name: _, variant, len: _ } => {
-                visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Seq),)
-            }
-            Token::StructVariant { name: _, variant, len: _ } => {
-                visitor.visit_map(EnumMapVisitor::new(self, Token::Str(variant), EnumFormat::Map),)
-            }
-            Token::SeqEnd | Token::TupleEnd | Token::TupleStructEnd | Token::MapEnd |
-            Token::StructEnd | Token::TupleVariantEnd | Token::StructVariantEnd => {
+            Token::UnitVariant { variant, .. } => visitor.visit_str(variant),
+            Token::NewtypeVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
+                self,
+                Token::Str(variant),
+                EnumFormat::Any,
+            )),
+            Token::TupleVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
+                self,
+                Token::Str(variant),
+                EnumFormat::Seq,
+            )),
+            Token::StructVariant { variant, .. } => visitor.visit_map(EnumMapVisitor::new(
+                self,
+                Token::Str(variant),
+                EnumFormat::Map,
+            )),
+            Token::SeqEnd
+            | Token::TupleEnd
+            | Token::TupleStructEnd
+            | Token::MapEnd
+            | Token::StructEnd
+            | Token::TupleVariantEnd
+            | Token::StructVariantEnd => {
                 unexpected!(token);
             }
         }
@@ -217,8 +223,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::Unit |
-            Token::None => {
+            Token::Unit | Token::None => {
                 self.next_token();
                 visitor.visit_none()
             }
@@ -245,10 +250,11 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
 
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
-            Token::UnitVariant { name: n, variant: _ } |
-            Token::NewtypeVariant { name: n, variant: _ } |
-            Token::TupleVariant { name: n, variant: _, len: _ } |
-            Token::StructVariant { name: n, variant: _, len: _ } if name == n => {
+            Token::UnitVariant { name: n, .. }
+            | Token::NewtypeVariant { name: n, .. }
+            | Token::TupleVariant { name: n, .. }
+            | Token::StructVariant { name: n, .. } if name == n =>
+            {
                 visitor.visit_enum(DeserializerEnumVisitor { de: self })
             }
             _ => {
@@ -262,7 +268,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::UnitStruct { name: _ } => {
+            Token::UnitStruct { .. } => {
                 assert_next_token!(self, Token::UnitStruct { name: name });
                 visitor.visit_unit()
             }
@@ -270,12 +276,16 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         }
     }
 
-    fn deserialize_newtype_struct<V>(self, name: &'static str, visitor: V) -> Result<V::Value, Error>
+    fn deserialize_newtype_struct<V>(
+        self,
+        name: &'static str,
+        visitor: V,
+    ) -> Result<V::Value, Error>
     where
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::NewtypeStruct { name: _ } => {
+            Token::NewtypeStruct { .. } => {
                 assert_next_token!(self, Token::NewtypeStruct { name: name });
                 visitor.visit_newtype_struct(self)
             }
@@ -288,20 +298,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::Unit |
-            Token::UnitStruct { name: _ } => {
+            Token::Unit | Token::UnitStruct { .. } => {
                 self.next_token();
                 visitor.visit_unit()
             }
-            Token::Seq { len: _ } => {
+            Token::Seq { .. } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Token::Tuple { len: _ } => {
+            Token::Tuple { .. } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Token::TupleStruct { name: _, len: _ } => {
+            Token::TupleStruct { .. } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
@@ -323,19 +332,19 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                 self.next_token();
                 visitor.visit_unit()
             }
-            Token::UnitStruct { name: _ } => {
+            Token::UnitStruct { .. } => {
                 assert_next_token!(self, Token::UnitStruct { name: name });
                 visitor.visit_unit()
             }
-            Token::Seq { len: _ } => {
+            Token::Seq { .. } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::SeqEnd, visitor)
             }
-            Token::Tuple { len: _ } => {
+            Token::Tuple { .. } => {
                 self.next_token();
                 self.visit_seq(Some(len), Token::TupleEnd, visitor)
             }
-            Token::TupleStruct { name: _, len: n } => {
+            Token::TupleStruct { len: n, .. } => {
                 assert_next_token!(self, Token::TupleStruct { name: name, len: n });
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
@@ -353,17 +362,24 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
         V: Visitor<'de>,
     {
         match self.peek_token() {
-            Token::Struct { name: _, len: n } => {
+            Token::Struct { len: n, .. } => {
                 assert_next_token!(self, Token::Struct { name: name, len: n });
                 self.visit_map(Some(fields.len()), Token::StructEnd, visitor)
             }
-            Token::Map { len: _ } => {
+            Token::Map { .. } => {
                 self.next_token();
                 self.visit_map(Some(fields.len()), Token::MapEnd, visitor)
             }
             _ => self.deserialize_any(visitor),
         }
     }
+
+    fn is_human_readable(&self) -> bool {
+        panic!(
+            "Types which have different human-readable and compact representations \
+             must explicitly mark their test cases with `serde_test::Configure`"
+        );
+    }
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -442,10 +458,10 @@ impl<'de, 'a> EnumAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         V: DeserializeSeed<'de>,
     {
         match self.de.peek_token() {
-            Token::UnitVariant { name: _, variant: v } |
-            Token::NewtypeVariant { name: _, variant: v } |
-            Token::TupleVariant { name: _, variant: v, len: _ } |
-            Token::StructVariant { name: _, variant: v, len: _ } => {
+            Token::UnitVariant { variant: v, .. }
+            | Token::NewtypeVariant { variant: v, .. }
+            | Token::TupleVariant { variant: v, .. }
+            | Token::StructVariant { variant: v, .. } => {
                 let de = v.into_deserializer();
                 let value = try!(seed.deserialize(de));
                 Ok((value, self))
@@ -463,7 +479,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
 
     fn unit_variant(self) -> Result<(), Error> {
         match self.de.peek_token() {
-            Token::UnitVariant { name: _, variant: _ } => {
+            Token::UnitVariant { .. } => {
                 self.de.next_token();
                 Ok(())
             }
@@ -476,7 +492,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         T: DeserializeSeed<'de>,
     {
         match self.de.peek_token() {
-            Token::NewtypeVariant { name: _, variant: _ } => {
+            Token::NewtypeVariant { .. } => {
                 self.de.next_token();
                 seed.deserialize(self.de)
             }
@@ -489,7 +505,7 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         V: Visitor<'de>,
     {
         match self.de.peek_token() {
-            Token::TupleVariant { name: _, variant: _, len: enum_len } => {
+            Token::TupleVariant { len: enum_len, .. } => {
                 let token = self.de.next_token();
 
                 if len == enum_len {
@@ -499,7 +515,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
                     unexpected!(token);
                 }
             }
-            Token::Seq { len: Some(enum_len) } => {
+            Token::Seq {
+                len: Some(enum_len),
+            } => {
                 let token = self.de.next_token();
 
                 if len == enum_len {
@@ -512,12 +530,16 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
         }
     }
 
-    fn struct_variant<V>(self, fields: &'static [&'static str], visitor: V) -> Result<V::Value, Error>
+    fn struct_variant<V>(
+        self,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Error>
     where
         V: Visitor<'de>,
     {
         match self.de.peek_token() {
-            Token::StructVariant { name: _, variant: _, len: enum_len } => {
+            Token::StructVariant { len: enum_len, .. } => {
                 let token = self.de.next_token();
 
                 if fields.len() == enum_len {
@@ -527,7 +549,9 @@ impl<'de, 'a> VariantAccess<'de> for DeserializerEnumVisitor<'a, 'de> {
                     unexpected!(token);
                 }
             }
-            Token::Map { len: Some(enum_len) } => {
+            Token::Map {
+                len: Some(enum_len),
+            } => {
                 let token = self.de.next_token();
 
                 if fields.len() == enum_len {
@@ -575,10 +599,9 @@ impl<'de, 'a> MapAccess<'de> for EnumMapVisitor<'a, 'de> {
     {
         match self.variant.take() {
             Some(Token::Str(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
-            Some(Token::Bytes(variant)) => {
-                seed.deserialize(BytesDeserializer { value: variant })
-                    .map(Some)
-            }
+            Some(Token::Bytes(variant)) => seed
+                .deserialize(BytesDeserializer { value: variant })
+                .map(Some),
             Some(Token::U32(variant)) => seed.deserialize(variant.into_deserializer()).map(Some),
             Some(other) => unexpected!(other),
             None => Ok(None),
@@ -634,8 +657,8 @@ impl<'de> de::Deserializer<'de> for BytesDeserializer {
     }
 
     forward_to_deserialize_any! {
-        bool i8 i16 i32 i64 u8 u16 u32 u64 f32 f64 char str string bytes
-        byte_buf option unit unit_struct newtype_struct seq tuple tuple_struct
-        map struct enum identifier ignored_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
     }
 }

serde_test/src/error.rs

@@ -9,7 +9,7 @@
 use std::error;
 use std::fmt::{self, Display};
 
-use serde::{ser, de};
+use serde::{de, ser};
 
 #[derive(Clone, Debug)]
 pub struct Error {
@@ -17,14 +17,18 @@ pub struct Error {
 }
 
 impl ser::Error for Error {
-    fn custom<T: Display>(msg: T) -> Error {
-        Error { msg: msg.to_string() }
+    fn custom<T: Display>(msg: T) -> Self {
+        Error {
+            msg: msg.to_string(),
+        }
     }
 }
 
 impl de::Error for Error {
-    fn custom<T: Display>(msg: T) -> Error {
-        Error { msg: msg.to_string() }
+    fn custom<T: Display>(msg: T) -> Self {
+        Error {
+            msg: msg.to_string(),
+        }
     }
 }
 

serde_test/src/lib.rs

@@ -53,7 +53,7 @@
 //! # use serde::ser::{Serialize, Serializer, SerializeMap};
 //! # use serde::de::{Deserialize, Deserializer, Visitor, MapAccess};
 //! #
-//! # // Dumb immitation of LinkedHashMap.
+//! # // Dumb imitation of LinkedHashMap.
 //! # #[derive(PartialEq, Debug)]
 //! # struct LinkedHashMap<K, V>(Vec<(K, V)>);
 //! #
@@ -68,11 +68,13 @@
 //! # }
 //! #
 //! # impl<K, V> Serialize for LinkedHashMap<K, V>
-//! #     where K: Serialize,
-//! #           V: Serialize
+//! # where
+//! #     K: Serialize,
+//! #     V: Serialize,
 //! # {
 //! #     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
-//! #         where S: Serializer
+//! #     where
+//! #         S: Serializer,
 //! #     {
 //! #         let mut map = serializer.serialize_map(Some(self.0.len()))?;
 //! #         for &(ref k, ref v) in &self.0 {
@@ -85,8 +87,9 @@
 //! # struct LinkedHashMapVisitor<K, V>(PhantomData<(K, V)>);
 //! #
 //! # impl<'de, K, V> Visitor<'de> for LinkedHashMapVisitor<K, V>
-//! #     where K: Deserialize<'de>,
-//! #           V: Deserialize<'de>
+//! # where
+//! #     K: Deserialize<'de>,
+//! #     V: Deserialize<'de>,
 //! # {
 //! #     type Value = LinkedHashMap<K, V>;
 //! #
@@ -95,7 +98,8 @@
 //! #     }
 //! #
 //! #     fn visit_map<M>(self, mut access: M) -> Result<Self::Value, M::Error>
-//! #         where M: MapAccess<'de>
+//! #     where
+//! #         M: MapAccess<'de>,
 //! #     {
 //! #         let mut map = LinkedHashMap::new();
 //! #         while let Some((key, value)) = access.next_entry()? {
@@ -106,11 +110,13 @@
 //! # }
 //! #
 //! # impl<'de, K, V> Deserialize<'de> for LinkedHashMap<K, V>
-//! #     where K: Deserialize<'de>,
-//! #           V: Deserialize<'de>
+//! # where
+//! #     K: Deserialize<'de>,
+//! #     V: Deserialize<'de>,
 //! # {
 //! #     fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
-//! #         where D: Deserializer<'de>
+//! #     where
+//! #         D: Deserializer<'de>,
 //! #     {
 //! #         deserializer.deserialize_map(LinkedHashMapVisitor(PhantomData))
 //! #     }
@@ -155,21 +161,37 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.0")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.70")]
+#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+// Whitelisted clippy lints
+#![cfg_attr(feature = "cargo-clippy", allow(float_cmp))]
+// Whitelisted 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
+    )
+)]
 
 #[macro_use]
 extern crate serde;
 
-mod ser;
 mod de;
 mod error;
+mod ser;
 
-mod token;
 mod assert;
+mod configure;
+mod token;
 
+pub use assert::{
+    assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_ser_tokens_error,
+    assert_tokens,
+};
 pub use token::Token;
-pub use assert::{assert_tokens, assert_ser_tokens, assert_ser_tokens_error, assert_de_tokens,
-                 assert_de_tokens_error};
+
+pub use configure::{Compact, Configure, Readable};
 
 // Not public API.
 #[doc(hidden)]

serde_test/src/ser.rs

@@ -40,25 +40,43 @@ impl<'a> Serializer<'a> {
 
 macro_rules! assert_next_token {
     ($ser:expr, $expected:ident) => {
-        assert_next_token!($ser, $expected, Token::$expected, true);
+        assert_next_token!($ser, stringify!($expected), Token::$expected, true);
     };
     ($ser:expr, $expected:ident($v:expr)) => {
-        assert_next_token!($ser, $expected, Token::$expected(v), v == $v);
+        assert_next_token!(
+            $ser,
+            format_args!(concat!(stringify!($expected), "({:?})"), $v),
+            Token::$expected(v),
+            v == $v
+        );
     };
     ($ser:expr, $expected:ident { $($k:ident),* }) => {
         let compare = ($($k,)*);
-        assert_next_token!($ser, $expected, Token::$expected { $($k),* }, ($($k,)*) == compare);
+        let field_format = || {
+            use std::fmt::Write;
+            let mut buffer = String::new();
+            $(
+                write!(&mut buffer, concat!(stringify!($k), ": {:?}, "), $k).unwrap();
+            )*
+            buffer
+        };
+        assert_next_token!(
+            $ser,
+            format_args!(concat!(stringify!($expected), " {{ {}}}"), field_format()),
+            Token::$expected { $($k),* },
+            ($($k,)*) == compare
+        );
     };
-    ($ser:expr, $expected:ident, $pat:pat, $guard:expr) => {
+    ($ser:expr, $expected:expr, $pat:pat, $guard:expr) => {
         match $ser.next_token() {
             Some($pat) if $guard => {}
             Some(other) => {
                 panic!("expected Token::{} but serialized as {}",
-                       stringify!($expected), other);
+                       $expected, other);
             }
             None => {
                 panic!("expected Token::{} after end of serialized tokens",
-                       stringify!($expected));
+                       $expected);
             }
         }
     };
@@ -247,10 +265,16 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
             assert_next_token!(self, Str(variant));
             let len = Some(len);
             assert_next_token!(self, Seq { len });
-            Ok(Variant { ser: self, end: Token::SeqEnd })
+            Ok(Variant {
+                ser: self,
+                end: Token::SeqEnd,
+            })
         } else {
             assert_next_token!(self, TupleVariant { name, variant, len });
-            Ok(Variant { ser: self, end: Token::TupleVariantEnd })
+            Ok(Variant {
+                ser: self,
+                end: Token::TupleVariantEnd,
+            })
         }
     }
 
@@ -276,12 +300,25 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
             assert_next_token!(self, Str(variant));
             let len = Some(len);
             assert_next_token!(self, Map { len });
-            Ok(Variant { ser: self, end: Token::MapEnd })
+            Ok(Variant {
+                ser: self,
+                end: Token::MapEnd,
+            })
         } else {
             assert_next_token!(self, StructVariant { name, variant, len });
-            Ok(Variant { ser: self, end: Token::StructVariantEnd })
+            Ok(Variant {
+                ser: self,
+                end: Token::StructVariantEnd,
+            })
         }
     }
+
+    fn is_human_readable(&self) -> bool {
+        panic!(
+            "Types which have different human-readable and compact representations \
+             must explicitly mark their test cases with `serde_test::Configure`"
+        );
+    }
 }
 
 pub struct Variant<'s, 'a: 's> {

serde_test/src/token.rs

@@ -232,7 +232,10 @@ pub enum Token {
     /// assert_tokens(&a, &[Token::UnitVariant { name: "E", variant: "A" }]);
     /// # }
     /// ```
-    UnitVariant { name: &'static str, variant: &'static str },
+    UnitVariant {
+        name: &'static str,
+        variant: &'static str,
+    },
 
     /// The header to a serialized newtype struct of the given name.
     ///
@@ -286,7 +289,10 @@ pub enum Token {
     /// ]);
     /// # }
     /// ```
-    NewtypeVariant { name: &'static str, variant: &'static str },
+    NewtypeVariant {
+        name: &'static str,
+        variant: &'static str,
+    },
 
     /// The header to a sequence.
     ///
@@ -391,7 +397,11 @@ pub enum Token {
     /// ]);
     /// # }
     /// ```
-    TupleVariant { name: &'static str, variant: &'static str, len: usize },
+    TupleVariant {
+        name: &'static str,
+        variant: &'static str,
+        len: usize,
+    },
 
     /// An indicator of the end of a tuple variant.
     TupleVariantEnd,
@@ -488,7 +498,11 @@ pub enum Token {
     /// ]);
     /// # }
     /// ```
-    StructVariant { name: &'static str, variant: &'static str, len: usize },
+    StructVariant {
+        name: &'static str,
+        variant: &'static str,
+        len: usize,
+    },
 
     /// An indicator of the end of a struct variant.
     StructVariantEnd,

test_suite/Cargo.toml

@@ -9,10 +9,11 @@ unstable = ["serde/unstable", "compiletest_rs"]
 
 [dev-dependencies]
 fnv = "1.0"
+proc-macro2 = "0.4"
 rustc-serialize = "0.3.16"
-serde = { path = "../serde" }
-serde_derive = { path = "../serde_derive" }
+serde = { path = "../serde", features = ["rc"] }
+serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
 
 [dependencies]
-compiletest_rs = { version = "0.2", optional = true }
+compiletest_rs = { version = "0.3", optional = true }

test_suite/deps/src/lib.rs

@@ -0,0 +1,11 @@
+// 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

@@ -4,5 +4,8 @@ version = "0.0.0"
 publish = false
 
 [dependencies]
+libc = { version = "0.2", default-features = false }
 serde = { path = "../../serde", default-features = false }
 serde_derive = { path = "../../serde_derive" }
+
+[workspace]

test_suite/no_std/src/main.rs

@@ -1,8 +1,15 @@
-#![feature(lang_items, start, libc, compiler_builtins_lib)]
+// 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)]
 #![no_std]
 
 extern crate libc;
-extern crate compiler_builtins;
 
 #[start]
 fn start(_argc: isize, _argv: *const *const u8) -> isize {
@@ -11,19 +18,12 @@ fn start(_argc: isize, _argv: *const *const u8) -> isize {
 
 #[lang = "eh_personality"]
 #[no_mangle]
-pub extern fn rust_eh_personality() {}
+pub extern "C" fn rust_eh_personality() {}
 
-#[lang = "eh_unwind_resume"]
-#[no_mangle]
-pub extern fn rust_eh_unwind_resume() {}
-
-#[lang = "panic_fmt"]
-#[no_mangle]
-pub extern fn rust_begin_panic(_msg: core::fmt::Arguments,
-                               _file: &'static str,
-                               _line: u32) -> ! {
+#[panic_implementation]
+fn panic(_info: &core::panic::PanicInfo) -> ! {
     unsafe {
-        libc::abort()
+        libc::abort();
     }
 }
 
@@ -42,7 +42,9 @@ struct Newtype(u8);
 struct Tuple(u8, u8);
 
 #[derive(Serialize, Deserialize)]
-struct Struct { f: u8 }
+struct Struct {
+    f: u8,
+}
 
 #[derive(Serialize, Deserialize)]
 enum Enum {

test_suite/tests/bytes/mod.rs

@@ -0,0 +1,58 @@
+use serde::de::{Deserializer, Error, SeqAccess, Visitor};
+use std::fmt;
+
+pub fn deserialize<'de, D>(deserializer: D) -> Result<Vec<u8>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    deserializer.deserialize_byte_buf(ByteBufVisitor)
+}
+
+struct ByteBufVisitor;
+
+impl<'de> Visitor<'de> for ByteBufVisitor {
+    type Value = Vec<u8>;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str("byte array")
+    }
+
+    fn visit_seq<V>(self, mut visitor: V) -> Result<Self::Value, V::Error>
+    where
+        V: SeqAccess<'de>,
+    {
+        let mut values = Vec::new();
+        while let Some(value) = try!(visitor.next_element()) {
+            values.push(value);
+        }
+        Ok(values)
+    }
+
+    fn visit_bytes<E>(self, v: &[u8]) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.to_vec())
+    }
+
+    fn visit_byte_buf<E>(self, v: Vec<u8>) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v)
+    }
+
+    fn visit_str<E>(self, v: &str) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.as_bytes().to_vec())
+    }
+
+    fn visit_string<E>(self, v: String) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        Ok(v.into_bytes())
+    }
+}

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "zzz")] //~^^ HELP: failed to parse borrowed lifetimes: "zzz"
+    #[serde(borrow = "zzz")]
+    //~^^^ ERROR: failed to parse borrowed lifetimes: "zzz"
     s: &'a str,
 }
 

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "'a + 'a")] //~^^ HELP: duplicate borrowed lifetime `'a`
+    #[serde(borrow = "'a + 'a")]
+    //~^^^ ERROR: duplicate borrowed lifetime `'a`
     s: &'a str,
 }
 

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

@@ -0,0 +1,22 @@
+// 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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "")] //~^^ HELP: at least one lifetime must be borrowed
+    #[serde(borrow = "")]
+    //~^^^ ERROR: at least one lifetime must be borrowed
     s: &'a str,
 }
 

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test {
-    #[serde(borrow)] //~^^ HELP: field `s` has no lifetimes to borrow
+    #[serde(borrow)]
+    //~^^^ ERROR: field `s` has no lifetimes to borrow
     s: String,
 }
 

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

@@ -0,0 +1,22 @@
+// 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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 struct Test<'a> {
-    #[serde(borrow = "'b")] //~^^ HELP: field `s` does not have lifetime 'b
+    #[serde(borrow = "'b")]
+    //~^^^ ERROR: field `s` does not have lifetime 'b
     s: &'a str,
 }
 

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

@@ -0,0 +1,20 @@
+// 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

@@ -0,0 +1,16 @@
+// 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

@@ -0,0 +1,24 @@
+// 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

@@ -0,0 +1,24 @@
+// 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

@@ -0,0 +1,24 @@
+// 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

@@ -0,0 +1,16 @@
+// 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

@@ -0,0 +1,22 @@
+// 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

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

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

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

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename="x", serialize="y")] //~^^ HELP: unknown serde field attribute `serialize`
+    #[serde(rename = "x", serialize = "y")]
+    //~^^^ ERROR: unknown serde field attribute `serialize`
     x: (),
 }
 

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

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename="x")]
-    #[serde(rename(deserialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename = "x")]
+    #[serde(rename(deserialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"), rename(serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"), rename(serialize = "y"))]
+    //~^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

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

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"))]
-    #[serde(rename="y")] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"))]
+    #[serde(rename = "y")]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x", serialize="y"))] //~^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x", serialize = "y"))]
+    //~^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

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

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(rename(serialize="x"))]
-    #[serde(rename(serialize="y"))] //~^^^ HELP: duplicate serde attribute `rename`
+    #[serde(rename(serialize = "x"))]
+    #[serde(rename(serialize = "y"))]
+    //~^^^^ ERROR: duplicate serde attribute `rename`
     x: (),
 }
 

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 struct S {
-    #[serde(with = "w", serialize_with = "s")] //~^^ HELP: duplicate serde attribute `serialize_with`
+    #[serde(with = "w", serialize_with = "s")]
+    //~^^^ ERROR: duplicate serde attribute `serialize_with`
     x: (),
 }
 

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

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

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

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(tag = "type")] //~^ HELP: #[serde(tag = "...")] can only be used on enums
+#[derive(Serialize)]
+#[serde(tag = "type")]
+//~^^ ERROR: #[serde(tag = "...")] can only be used on enums
 struct S;
 
 fn main() {}

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

@@ -9,9 +9,10 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Serialize)]
 #[serde(untagged)]
-#[serde(tag = "type")] //~^^ HELP: enum cannot be both untagged and internally tagged
+#[serde(tag = "type")]
+//~^^^ ERROR: enum cannot be both untagged and internally tagged
 enum E {
     A(u8),
     B(String),

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

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Serialize)] //~ ERROR: proc-macro derive panicked
-#[serde(untagged)] //~^ HELP: #[serde(untagged)] can only be used on enums
+#[derive(Serialize)]
+#[serde(untagged)]
+//~^^ ERROR: #[serde(untagged)] can only be used on enums
 struct S;
 
 fn main() {}

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

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
-#[serde(field_identifier, variant_identifier)] //~^ HELP: `field_identifier` and `variant_identifier` cannot both be set
+#[derive(Deserialize)]
+#[serde(field_identifier, variant_identifier)]
+//~^^ ERROR: `field_identifier` and `variant_identifier` cannot both be set
 enum F {
     A,
     B,

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

@@ -9,8 +9,9 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
-struct S; //~^^ HELP: `field_identifier` can only be used on an enum
+//~^^ ERROR: `field_identifier` can only be used on an enum
+struct S;
 
 fn main() {}

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

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    B(u8, u8), //~^^^^ HELP: field_identifier may only contain unit variants
+    B(u8, u8),
+    //~^^^^^ ERROR: field_identifier may only contain unit variants
 }
 
 fn main() {}

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

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    Other(String), //~^^^^ HELP: `Other` must be the last variant
+    Other(String),
+    //~^^^^^ ERROR: `Other` must be the last variant
     B,
 }
 

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

@@ -9,10 +9,11 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 enum F {
     A,
-    #[serde(other)] //~^^^ HELP: #[serde(other)] may only be used inside a field_identifier
+    #[serde(other)]
+    //~^^^^ ERROR: #[serde(other)] may only be used inside a field_identifier
     B,
 }
 

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

@@ -9,11 +9,12 @@
 #[macro_use]
 extern crate serde_derive;
 
-#[derive(Deserialize)] //~ ERROR: proc-macro derive panicked
+#[derive(Deserialize)]
 #[serde(field_identifier)]
 enum F {
     A,
-    #[serde(other)] //~^^^^ HELP: #[serde(other)] must be on a unit variant
+    #[serde(other)]
+    //~^^^^^ ERROR: #[serde(other)] must be on a unit variant
     Other(u8, u8),
 }