Release 1.0.114

Simplify search for packed repr attr
Remove error_on_line_overflow rustfmt setting
2026-04-23 18:48:03 +00:00 · 2020-06-21 17:31:02 -07:00 · 2020-06-21 17:22:07 -07:00 · 2020-06-21 16:48:22 -07:00 · 2020-06-21 16:46:27 -07:00 · 2020-06-21 16:46:27 -07:00
47 changed files with 783 additions and 442 deletions
@@ -0,0 +1,163 @@
+name: CI
+
+on:
+  push:
+  pull_request:
+  schedule: [cron: "40 1 * * *"]
+
+jobs:
+  test:
+    name: Test suite
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd test_suite && cargo test --features unstable
+
+  windows:
+    name: Test suite (windows)
+    runs-on: windows-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
+
+  stable:
+    name: Rust stable
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@stable
+      - run: cd serde && cargo build --features rc
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde_test && cargo build
+      - run: cd serde_test && cargo test --features serde/derive,serde/rc
+
+  beta:
+    name: Rust beta
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@beta
+      - run: cd serde && cargo build --features rc
+      - run: cd test_suite && cargo test
+
+  nightly:
+    name: Rust nightly ${{matrix.os == 'windows' && '(windows)' || ''}}
+    runs-on: ${{matrix.os}}-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu, windows]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@nightly
+      - run: cd serde && cargo build
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build --no-default-features --features alloc
+      - run: cd serde && cargo build --no-default-features --features rc,alloc
+      - run: cd serde && cargo test --features derive,rc,unstable
+      - run: cd test_suite/no_std && cargo build
+        if: matrix.os != 'windows'
+
+  msrv:
+    name: Rust 1.13.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@1.13.0
+      - name: Get timestamp for cache
+        id: date
+        run: echo ::set-output name=yearmo::$(date +%Y%m)
+      - uses: actions/cache@v1
+        with:
+          path: ~/.cargo/registry/index
+          key: cargo-registry-index-${{steps.date.outputs.yearmo}}
+      - run: cd serde && cargo build --features rc
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde_test && cargo build
+
+  build:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [1.19.0, 1.20.0, 1.21.0, 1.25.0, 1.26.0, 1.34.0]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build
+
+  more:
+    name: Rust ${{matrix.rust}}
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        rust: [1.27.0, 1.28.0]
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@master
+        with:
+          toolchain: ${{matrix.rust}}
+        # Work around failing to parse manifest because editions are unstable.
+      - run: sed -i /test_suite/d Cargo.toml
+      - run: cd serde && cargo build --no-default-features
+      - run: cd serde && cargo build
+
+  derive:
+    name: Rust 1.31.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@1.31.0
+      - run: cd serde_derive && cargo check
+
+  alloc:
+    name: Rust 1.36.0
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@1.36.0
+      - run: cd serde && cargo build --no-default-features --features alloc
+
+  emscripten:
+    name: Emscripten
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@nightly
+      - uses: actions/setup-node@v1
+        with:
+          node-version: 9
+      - name: Install cargo-web
+        run: |
+          CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
+          CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
+          CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
+          mkdir -p ~/.cargo/bin
+          curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
+          chmod +x ~/.cargo/bin/cargo-web
+      - run: cd test_suite && cargo web test --target=asmjs-unknown-emscripten --nodejs
+        continue-on-error: true
+      - run: cd test_suite && cargo web test --target=wasm32-unknown-emscripten --nodejs
+        continue-on-error: true
+
+  clippy:
+    name: Clippy
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v2
+      - uses: dtolnay/rust-toolchain@clippy
+        # The need for -Aredundant_field_names here is a Clippy bug.
+        # https://github.com/rust-lang/rust-clippy/issues/5356
+      - run: cd serde && cargo clippy --features rc,unstable -- -D clippy::all -A clippy::redundant_field_names
+      - run: cd serde_derive && cargo clippy -- -D clippy::all
+      - run: cd serde_test && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
+      - run: cd test_suite && cargo clippy --tests --features unstable -- -D clippy::all -A clippy::redundant_field_names
+      - run: cd test_suite/no_std && cargo clippy -- -D clippy::all -A clippy::redundant_field_names
@@ -1,107 +0,0 @@
-language: rust
-
-matrix:
-  include:
-    - rust: stable
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cargo build --no-default-features
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo build
-        - cargo test --features serde/derive,serde/rc
-
-    - rust: beta
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test
-
-    - rust: nightly
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build
-        - cargo build --no-default-features
-        - cargo build --no-default-features --features alloc
-        - cargo build --no-default-features --features rc,alloc
-        - cargo test --features derive,rc,unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo test --features unstable
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
-        - cargo build
-
-    - rust: 1.13.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --features rc
-        - cargo build --no-default-features
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo build
-
-    - rust: 1.19.0
-    - rust: 1.20.0
-    - rust: 1.21.0
-    - rust: 1.25.0
-    - rust: 1.26.0
-
-    # Work around failing to parse manifest because editions are unstable.
-    - rust: 1.27.0
-      before_script: sed -i /test_suite/d Cargo.toml
-    - rust: 1.28.0
-      before_script: sed -i /test_suite/d Cargo.toml
-
-    - rust: 1.31.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
-        - cargo build
-
-    - rust: 1.34.0
-
-    - rust: 1.36.0
-      script:
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo build --no-default-features --features alloc
-
-    - rust: nightly
-      name: Clippy
-      script:
-        - rustup component add clippy || travis_terminate 0
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde"
-        - cargo clippy --features rc,unstable -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde_derive"
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/serde_test"
-        - cargo clippy -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo clippy --tests --features unstable -- -D clippy::all
-        - cd "${TRAVIS_BUILD_DIR}/test_suite/no_std"
-        - cargo clippy -- -D clippy::all
-
-    - rust: nightly
-      name: Emscripten
-      script:
-        - CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
-        - CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
-        - CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
-
-        - nvm install 9
-        - mkdir -p ~/.cargo/bin
-        - curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
-        - chmod +x ~/.cargo/bin/cargo-web
-
-        - cd "${TRAVIS_BUILD_DIR}/test_suite"
-        - cargo web test --target=asmjs-unknown-emscripten --nodejs
-        - cargo web test --target=wasm32-unknown-emscripten --nodejs
-
-  allow_failures:
-    - rust: nightly
-      name: Clippy
-    - rust: nightly
-      name: Emscripten
-
-script:
-  - cd "${TRAVIS_BUILD_DIR}/serde"
-  - cargo build --no-default-features
-  - cargo build
@@ -4,11 +4,6 @@ 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.

-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.
-
-[`irc.mozilla.org`]: https://wiki.mozilla.org/IRC
-
 ## Submitting bug reports and feature requests

 Serde development is spread across lots of repositories, but this serde-rs/serde
@@ -1,7 +1,7 @@
-# Serde &emsp; [![Build Status]][travis] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde &emsp; [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]

-[Build Status]: https://api.travis-ci.org/serde-rs/serde.svg?branch=master
-[travis]: https://travis-ci.org/serde-rs/serde
+[Build Status]: https://img.shields.io/github/workflow/status/serde-rs/serde/CI/master
+[actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
 [Latest Version]: https://img.shields.io/crates/v/serde.svg
 [crates.io]: https://crates.io/crates/serde
 [serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
@@ -75,13 +75,23 @@ fn main() {

 ## 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.
+Serde is one of the most widely used Rust libraries so any place that Rustaceans
+congregate will be able to help you out. For chat, consider trying the
+[#general] or [#beginners] channels of the unofficial community Discord, the
+[#rust-usage] channel of the official Rust Project Discord, or the
+[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
+on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
+weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
+acceptable to file a support issue in this repo but they tend not to get as many
+eyes as any of the above and may get closed without a response after some time.

-[irc]: https://wiki.mozilla.org/IRC
-[issues]: https://github.com/serde-rs/serde/issues/new/choose
+[#general]: https://discord.com/channels/273534239310479360/274215136414400513
+[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
+[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
+[/r/rust]: https://www.reddit.com/r/rust
+[discourse]: https://users.rust-lang.org

 <br>

@@ -1,39 +0,0 @@
-environment:
-  matrix:
-    - APPVEYOR_RUST_CHANNEL: stable
-    - APPVEYOR_RUST_CHANNEL: nightly
-
-install:
-  # Install rust, x86_64-pc-windows-msvc host
-  - 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
-  - cargo -vV
-
-build: false
-
-for:
-  - matrix:
-      only:
-        - APPVEYOR_RUST_CHANNEL: stable
-    test_script:
-      - cd %APPVEYOR_BUILD_FOLDER%\serde
-      - cargo build --features rc
-      - cargo build --no-default-features
-      - cd %APPVEYOR_BUILD_FOLDER%\serde_test
-      - cargo build
-      - cargo test --features serde/derive,serde/rc
-
-  - matrix:
-      only:
-        - APPVEYOR_RUST_CHANNEL: nightly
-    test_script:
-      - cd %APPVEYOR_BUILD_FOLDER%\serde
-      - cargo build
-      - cargo build --no-default-features
-      - cargo build --no-default-features --features alloc
-      - cargo build --no-default-features --features rc,alloc
-      - cargo test --features derive,rc,unstable
-      - cd %APPVEYOR_BUILD_FOLDER%\test_suite
-      - cargo test --features unstable
@@ -43,10 +43,20 @@ fn main() {

 ## 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.
+Serde is one of the most widely used Rust libraries so any place that Rustaceans
+congregate will be able to help you out. For chat, consider trying the
+[#general] or [#beginners] channels of the unofficial community Discord, the
+[#rust-usage] channel of the official Rust Project Discord, or the
+[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
+on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
+weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
+acceptable to file a support issue in this repo but they tend not to get as many
+eyes as any of the above and may get closed without a response after some time.

-[irc]: https://wiki.mozilla.org/IRC
-[issues]: https://github.com/serde-rs/serde/issues/new/choose
+[#general]: https://discord.com/channels/273534239310479360/274215136414400513
+[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[zulip]: https://rust-lang.zulipchat.com/#narrow/stream/122651-general
+[stackoverflow]: https://stackoverflow.com/questions/tagged/rust
+[/r/rust]: https://www.reddit.com/r/rust
+[discourse]: https://users.rust-lang.org
@@ -1 +0,0 @@
-error_on_line_overflow = false
@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.106" # remember to update html_root_url and serde_derive dependency
+version = "1.0.114" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
@@ -10,15 +10,11 @@ documentation = "https://docs.serde.rs/serde/"
 keywords = ["serde", "serialization", "no_std"]
 categories = ["encoding"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
 build = "build.rs"

-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
-
 [dependencies]
-serde_derive = { version = "=1.0.106", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.114", optional = true, path = "../serde_derive" }

 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }
@@ -66,7 +66,7 @@ fn main() {
    }

    // Non-zero integers stabilized in Rust 1.28:
-    // https://github.com/rust-lang/rust/pull/50808
+    // https://blog.rust-lang.org/2018/08/02/Rust-1.28.html#library-stabilizations
    if minor >= 28 {
        println!("cargo:rustc-cfg=num_nonzero");
    }
@@ -90,10 +90,13 @@ macro_rules! visit_integer_method {
        {
            match FromPrimitive::$from_method(v) {
                Some(v) => Ok(v),
-                None => Err(Error::invalid_value(Unexpected::$group(v as $group_ty), &self)),
+                None => Err(Error::invalid_value(
+                    Unexpected::$group(v as $group_ty),
+                    &self,
+                )),
            }
        }
-    }
+    };
 }

 macro_rules! visit_float_method {
@@ -105,7 +108,7 @@ macro_rules! visit_float_method {
        {
            Ok(v as Self::Value)
        }
-    }
+    };
 }

 macro_rules! impl_deserialize_num {
@@ -53,6 +53,10 @@
 //!   *(deserialization only)*
 //! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
 //!   Rust structs. *(deserialization only)*
+//! - [S-expressions], the textual representation of code and data used by the
+//!   Lisp language family.
+//! - [D-Bus]'s binary wire format.
+//! - [FlexBuffers], the schemaless cousin of Google's FlatBuffers zero-copy serialization format.
 //!
 //! [JSON]: https://github.com/serde-rs/json
 //! [Bincode]: https://github.com/TyOverby/bincode
@@ -71,18 +75,21 @@
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: http://doc.crates.io/manifest.html
 //! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [S-expressions]: https://github.com/rotty/lexpr-rs
+//! [D-Bus]: https://docs.rs/zvariant
+//! [FlexBuffers]: https://github.com/google/flatbuffers/tree/master/rust/flexbuffers

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

 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.106")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.114")]
 // Support using Serde without the standard library!
 #![cfg_attr(not(feature = "std"), no_std)]
 // Unstable functionality only if the user asks for it. For tracking and
 // discussion of these features please refer to this issue:
 //
 //    https://github.com/serde-rs/serde/issues/812
-#![cfg_attr(feature = "unstable", feature(specialization, never_type))]
+#![cfg_attr(feature = "unstable", feature(never_type))]
 #![allow(unknown_lints, bare_trait_objects, deprecated)]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
@@ -90,6 +97,8 @@
 #![cfg_attr(
    feature = "cargo-clippy",
    allow(
+        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+        unnested_or_patterns,
        // not available in our oldest supported compiler
        checked_conversions,
        empty_enum,
@@ -183,7 +183,9 @@ where
        }
    }

-    deserializer.deserialize_bytes(CowBytesVisitor).map(From::from)
+    deserializer
+        .deserialize_bytes(CowBytesVisitor)
+        .map(From::from)
 }

 pub mod size_hint {
@@ -1560,7 +1562,7 @@ mod content {
                    other.unexpected(),
                    &"struct variant",
                )),
-                _ => Err(de::Error::invalid_type(
+                None => Err(de::Error::invalid_type(
                    de::Unexpected::UnitVariant,
                    &"struct variant",
                )),
@@ -2250,7 +2252,7 @@ mod content {
                    other.unexpected(),
                    &"struct variant",
                )),
-                _ => Err(de::Error::invalid_type(
+                None => Err(de::Error::invalid_type(
                    de::Unexpected::UnitVariant,
                    &"struct variant",
                )),
@@ -2472,7 +2474,7 @@ mod content {
        where
            M: MapAccess<'de>,
        {
-            while let Some(_) = try!(access.next_entry::<IgnoredAny, IgnoredAny>()) {}
+            while try!(access.next_entry::<IgnoredAny, IgnoredAny>()).is_some() {}
            Ok(())
        }
    }
@@ -1243,6 +1243,18 @@ where
        self.0.serialize_value(value)
    }

+    fn serialize_entry<K: ?Sized, V: ?Sized>(
+        &mut self,
+        key: &K,
+        value: &V,
+    ) -> Result<(), Self::Error>
+    where
+        K: Serialize,
+        V: Serialize,
+    {
+        self.0.serialize_entry(key, value)
+    }
+
    fn end(self) -> Result<(), Self::Error> {
        Ok(())
    }
@@ -0,0 +1,174 @@
+use lib::*;
+use ser::{Error, Impossible, Serialize, Serializer};
+
+impl Error for fmt::Error {
+    fn custom<T: Display>(_msg: T) -> Self {
+        fmt::Error
+    }
+}
+
+macro_rules! fmt_primitives {
+    ($($f:ident: $t:ty,)*) => {
+        $(
+            fn $f(self, v: $t) -> fmt::Result {
+                Display::fmt(&v, self)
+            }
+        )*
+    };
+}
+
+/// ```edition2018
+/// use serde::Serialize;
+/// use std::fmt::{self, Display};
+///
+/// #[derive(Serialize)]
+/// #[serde(rename_all = "kebab-case")]
+/// pub enum MessageType {
+///     StartRequest,
+///     EndRequest,
+/// }
+///
+/// impl Display for MessageType {
+///     fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
+///         self.serialize(f)
+///     }
+/// }
+/// ```
+impl<'a, 'b> Serializer for &'a mut fmt::Formatter<'b> {
+    type Ok = ();
+    type Error = fmt::Error;
+    type SerializeSeq = Impossible<(), fmt::Error>;
+    type SerializeTuple = Impossible<(), fmt::Error>;
+    type SerializeTupleStruct = Impossible<(), fmt::Error>;
+    type SerializeTupleVariant = Impossible<(), fmt::Error>;
+    type SerializeMap = Impossible<(), fmt::Error>;
+    type SerializeStruct = Impossible<(), fmt::Error>;
+    type SerializeStructVariant = Impossible<(), fmt::Error>;
+
+    fmt_primitives! {
+        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_unit_struct: &'static str,
+    }
+
+    serde_if_integer128! {
+        fmt_primitives! {
+            serialize_i128: i128,
+            serialize_u128: u128,
+        }
+    }
+
+    fn serialize_unit_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        variant: &'static str,
+    ) -> fmt::Result {
+        Display::fmt(variant, self)
+    }
+
+    fn serialize_newtype_struct<T: ?Sized>(self, _name: &'static str, value: &T) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Serialize::serialize(value, self)
+    }
+
+    fn serialize_bytes(self, _v: &[u8]) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_none(self) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_some<T: ?Sized>(self, _value: &T) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Err(fmt::Error)
+    }
+
+    fn serialize_unit(self) -> fmt::Result {
+        Err(fmt::Error)
+    }
+
+    fn serialize_newtype_variant<T: ?Sized>(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _value: &T,
+    ) -> fmt::Result
+    where
+        T: Serialize,
+    {
+        Err(fmt::Error)
+    }
+
+    fn serialize_seq(self, _len: Option<usize>) -> Result<Self::SerializeSeq, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple(self, _len: usize) -> Result<Self::SerializeTuple, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleStruct, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_tuple_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeTupleVariant, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_map(self, _len: Option<usize>) -> Result<Self::SerializeMap, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_struct(
+        self,
+        _name: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStruct, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn serialize_struct_variant(
+        self,
+        _name: &'static str,
+        _variant_index: u32,
+        _variant: &'static str,
+        _len: usize,
+    ) -> Result<Self::SerializeStructVariant, fmt::Error> {
+        Err(fmt::Error)
+    }
+
+    fn collect_str<T: ?Sized>(self, value: &T) -> fmt::Result
+    where
+        T: Display,
+    {
+        Display::fmt(value, self)
+    }
+}
@@ -616,7 +616,7 @@ impl Serialize for SystemTime {
        use super::SerializeStruct;
        let duration_since_epoch = self
            .duration_since(UNIX_EPOCH)
-            .expect("SystemTime must be later than UNIX_EPOCH");
+            .map_err(|_| S::Error::custom("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()));
@@ -109,6 +109,7 @@

 use lib::*;

+mod fmt;
 mod impls;
 mod impossible;

@@ -1277,7 +1278,7 @@ pub trait Serializer: Sized {
        <I as IntoIterator>::Item: Serialize,
    {
        let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_seq(iter.len_hint()));
+        let mut serializer = try!(self.serialize_seq(iterator_len_hint(&iter)));
        for item in iter {
            try!(serializer.serialize_element(&item));
        }
@@ -1317,7 +1318,7 @@ pub trait Serializer: Sized {
        I: IntoIterator<Item = (K, V)>,
    {
        let iter = iter.into_iter();
-        let mut serializer = try!(self.serialize_map(iter.len_hint()));
+        let mut serializer = try!(self.serialize_map(iterator_len_hint(&iter)));
        for (key, value) in iter {
            try!(serializer.serialize_entry(&key, &value));
        }
@@ -1952,35 +1953,6 @@ pub trait SerializeStructVariant {
    fn end(self) -> Result<Self::Ok, Self::Error>;
 }

-trait LenHint: Iterator {
-    fn len_hint(&self) -> Option<usize>;
-}
-
-impl<I> LenHint for I
-where
-    I: Iterator,
-{
-    #[cfg(not(feature = "unstable"))]
-    fn len_hint(&self) -> Option<usize> {
-        iterator_len_hint(self)
-    }
-
-    #[cfg(feature = "unstable")]
-    default fn len_hint(&self) -> Option<usize> {
-        iterator_len_hint(self)
-    }
-}
-
-#[cfg(feature = "unstable")]
-impl<I> LenHint for I
-where
-    I: ExactSizeIterator,
-{
-    fn len_hint(&self) -> Option<usize> {
-        Some(self.len())
-    }
-}
-
 fn iterator_len_hint<I>(iter: &I) -> Option<usize>
 where
    I: Iterator,
@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.106" # remember to update html_root_url
+version = "1.0.114" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
@@ -9,11 +9,7 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://serde.rs/derive.html"
 keywords = ["serde", "serialization", "no_std"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
-
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
+include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]

 [features]
 default = []
@@ -26,7 +22,7 @@ proc-macro = true
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0", features = ["visit"] }
+syn = { version = "1.0.33", features = ["visit"] }

 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }
@@ -0,0 +1,30 @@
+use std::env;
+use std::process::Command;
+use std::str;
+
+// 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,
+    };
+
+    // Underscore const names stabilized in Rust 1.37:
+    // https://blog.rust-lang.org/2019/08/15/Rust-1.37.0.html#using-unnamed-const-items-for-macros
+    if minor >= 37 {
+        println!("cargo:rustc-cfg=underscore_consts");
+    }
+}
+
+fn rustc_minor_version() -> Option<u32> {
+    let rustc = env::var_os("RUSTC")?;
+    let output = Command::new(rustc).arg("--version").output().ok()?;
+    let version = str::from_utf8(&output.stdout).ok()?;
+    let mut pieces = version.split('.');
+    if pieces.next() != Some("rustc 1") {
+        return None;
+    }
+    pieces.next()?.parse().ok()
+}
@@ -5,7 +5,7 @@ use syn::punctuated::{Pair, Punctuated};
 use syn::visit::{self, Visit};

 use internals::ast::{Container, Data};
-use internals::attr;
+use internals::{attr, ungroup};

 use proc_macro2::Span;

@@ -114,7 +114,7 @@ pub fn with_bound(
    }
    impl<'ast> Visit<'ast> for FindTyParams<'ast> {
        fn visit_field(&mut self, field: &'ast syn::Field) {
-            if let syn::Type::Path(ty) = &field.ty {
+            if let syn::Type::Path(ty) = ungroup(&field.ty) {
                if let Some(Pair::Punctuated(t, _)) = ty.path.segments.pairs().next() {
                    if self.all_type_params.contains(&t.ident) {
                        self.associated_type_usage.push(ty);
@@ -156,7 +156,7 @@ pub fn with_bound(
        .collect();

    let mut visitor = FindTyParams {
-        all_type_params: all_type_params,
+        all_type_params,
        relevant_type_params: HashSet::new(),
        associated_type_usage: Vec::new(),
    };
@@ -271,7 +271,7 @@ pub fn with_lifetime_bound(generics: &syn::Generics, lifetime: &str) -> syn::Gen
        .collect();

    syn::Generics {
-        params: params,
+        params,
        ..generics.clone()
    }
 }
@@ -8,7 +8,7 @@ use bound;
 use dummy;
 use fragment::{Expr, Fragment, Match, Stmts};
 use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt, Derive};
+use internals::{attr, ungroup, Ctxt, Derive};
 use pretend;

 use std::collections::BTreeSet;
@@ -77,7 +77,7 @@ fn precondition(cx: &Ctxt, cont: &Container) {
 fn precondition_sized(cx: &Ctxt, cont: &Container) {
    if let Data::Struct(_, fields) = &cont.data {
        if let Some(last) = fields.last() {
-            if let syn::Type::Slice(_) = *last.ty {
+            if let syn::Type::Slice(_) = ungroup(last.ty) {
                cx.error_spanned_by(
                    cont.original,
                    "cannot deserialize a dynamically sized struct",
@@ -134,11 +134,11 @@ impl Parameters {
        let has_getter = cont.data.has_getter();

        Parameters {
-            local: local,
-            this: this,
-            generics: generics,
-            borrowed: borrowed,
-            has_getter: has_getter,
+            local,
+            this,
+            generics,
+            borrowed,
+            has_getter,
        }
    }

@@ -1153,10 +1153,13 @@ fn prepare_enum_variant_enum(
    variants: &[Variant],
    cattrs: &attr::Container,
 ) -> (TokenStream, Stmts) {
-    let variant_names_idents: Vec<_> = variants
+    let mut deserialized_variants = variants
        .iter()
        .enumerate()
-        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
+        .filter(|&(_, variant)| !variant.attrs.skip_deserializing());
+
+    let variant_names_idents: Vec<_> = deserialized_variants
+        .clone()
        .map(|(i, variant)| {
            (
                variant.attrs.name().deserialize_name(),
@@ -1166,7 +1169,7 @@ fn prepare_enum_variant_enum(
        })
        .collect();

-    let other_idx = variants.iter().position(|variant| variant.attrs.other());
+    let other_idx = deserialized_variants.position(|(_, variant)| variant.attrs.other());

    let variants_stmt = {
        let variant_names = variant_names_idents.iter().map(|(name, _, _)| name);
@@ -1374,39 +1377,44 @@ fn deserialize_adjacently_tagged_enum(
        }
    };

-    fn is_unit(variant: &Variant) -> bool {
-        match variant.style {
-            Style::Unit => true,
-            Style::Struct | Style::Tuple | Style::Newtype => false,
-        }
-    }
-
    let mut missing_content = quote! {
        _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
    };
-    if variants.iter().any(is_unit) {
-        let fallthrough = if variants.iter().all(is_unit) {
-            None
-        } else {
-            Some(quote! {
-                _ => #missing_content
-            })
-        };
-        let arms = variants
-            .iter()
-            .enumerate()
-            .filter(|&(_, variant)| !variant.attrs.skip_deserializing() && is_unit(variant))
-            .map(|(i, variant)| {
-                let variant_index = field_i(i);
-                let variant_ident = &variant.ident;
-                quote! {
-                    __Field::#variant_index => _serde::export::Ok(#this::#variant_ident),
+    let mut missing_content_fallthrough = quote!();
+    let missing_content_arms = variants
+        .iter()
+        .enumerate()
+        .filter(|&(_, variant)| !variant.attrs.skip_deserializing())
+        .filter_map(|(i, variant)| {
+            let variant_index = field_i(i);
+            let variant_ident = &variant.ident;
+
+            let arm = match variant.style {
+                Style::Unit => quote! {
+                    _serde::export::Ok(#this::#variant_ident)
+                },
+                Style::Newtype if variant.attrs.deserialize_with().is_none() => {
+                    let span = variant.original.span();
+                    let func = quote_spanned!(span=> _serde::private::de::missing_field);
+                    quote! {
+                        #func(#content).map(#this::#variant_ident)
+                    }
                }
-            });
+                _ => {
+                    missing_content_fallthrough = quote!(_ => #missing_content);
+                    return None;
+                }
+            };
+            Some(quote! {
+                __Field::#variant_index => #arm,
+            })
+        })
+        .collect::<Vec<_>>();
+    if !missing_content_arms.is_empty() {
        missing_content = quote! {
            match __field {
-                #(#arms)*
-                #fallthrough
+                #(#missing_content_arms)*
+                #missing_content_fallthrough
            }
        };
    }
@@ -1,4 +1,5 @@
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, TokenStream};
+use quote::format_ident;

 use syn;
 use try;
@@ -11,19 +12,18 @@ pub fn wrap_in_const(
 ) -> TokenStream {
    let try_replacement = try::replacement();

-    let dummy_const = Ident::new(
-        &format!("_IMPL_{}_FOR_{}", trait_, unraw(ty)),
-        Span::call_site(),
-    );
+    let dummy_const = if cfg!(underscore_consts) {
+        format_ident!("_")
+    } else {
+        format_ident!("_IMPL_{}_FOR_{}", trait_, unraw(ty))
+    };

    let use_serde = match serde_path {
        Some(path) => quote! {
            use #path as _serde;
        },
        None => quote! {
-            #[allow(unknown_lints)]
-            #[cfg_attr(feature = "cargo-clippy", allow(useless_attribute))]
-            #[allow(rust_2018_idioms)]
+            #[allow(rust_2018_idioms, clippy::useless_attribute)]
            extern crate serde as _serde;
        },
    };
@@ -110,8 +110,8 @@ impl<'a> Container<'a> {

        let mut item = Container {
            ident: item.ident.clone(),
-            attrs: attrs,
-            data: data,
+            attrs,
+            data,
            generics: &item.generics,
            original: item,
        };
@@ -148,9 +148,9 @@ fn enum_from_ast<'a>(
                struct_from_ast(cx, &variant.fields, Some(&attrs), container_default);
            Variant {
                ident: variant.ident.clone(),
-                attrs: attrs,
-                style: style,
-                fields: fields,
+                attrs,
+                style,
+                fields,
                original: variant,
            }
        })
@@ -1,5 +1,5 @@
 use internals::symbol::*;
-use internals::Ctxt;
+use internals::{ungroup, Ctxt};
 use proc_macro2::{Group, Span, TokenStream, TokenTree};
 use quote::ToTokens;
 use std::borrow::Cow;
@@ -32,8 +32,8 @@ struct Attr<'c, T> {
 impl<'c, T> Attr<'c, T> {
    fn none(cx: &'c Ctxt, name: Symbol) -> Self {
        Attr {
-            cx: cx,
-            name: name,
+            cx,
+            name,
            tokens: TokenStream::new(),
            value: None,
        }
@@ -101,8 +101,8 @@ struct VecAttr<'c, T> {
 impl<'c, T> VecAttr<'c, T> {
    fn none(cx: &'c Ctxt, name: Symbol) -> Self {
        VecAttr {
-            cx: cx,
-            name: name,
+            cx,
+            name,
            first_dup_tokens: TokenStream::new(),
            values: Vec::new(),
        }
@@ -176,7 +176,7 @@ impl Name {
            serialize_renamed: ser_renamed,
            deserialize: de_name.unwrap_or(source_name),
            deserialize_renamed: de_renamed,
-            deserialize_aliases: deserialize_aliases,
+            deserialize_aliases,
        }
    }

@@ -222,6 +222,7 @@ pub struct Container {
    identifier: Identifier,
    has_flatten: bool,
    serde_path: Option<syn::Path>,
+    is_packed: bool,
 }

 /// Styles of representing an enum.
@@ -592,6 +593,20 @@ impl Container {
            }
        }

+        let mut is_packed = false;
+        for attr in &item.attrs {
+            if attr.path.is_ident("repr") {
+                let _ = attr.parse_args_with(|input: ParseStream| {
+                    while let Some(token) = input.parse()? {
+                        if let TokenTree::Ident(ident) = token {
+                            is_packed |= ident == "packed";
+                        }
+                    }
+                    Ok(())
+                });
+            }
+        }
+
        Container {
            name: Name::from_attrs(unraw(&item.ident), ser_name, de_name, None),
            transparent: transparent.get(),
@@ -611,6 +626,7 @@ impl Container {
            identifier: decide_identifier(cx, item, field_identifier, variant_identifier),
            has_flatten: false,
            serde_path: serde_path.get(),
+            is_packed,
        }
    }

@@ -662,6 +678,10 @@ impl Container {
        self.remote.as_ref()
    }

+    pub fn is_packed(&self) -> bool {
+        self.is_packed
+    }
+
    pub fn identifier(&self) -> Identifier {
        self.identifier
    }
@@ -716,7 +736,7 @@ fn decide_tag(
                    }
                }
            }
-            TagType::Internal { tag: tag }
+            TagType::Internal { tag }
        }
        (Some((untagged_tokens, _)), Some((tag_tokens, _)), None) => {
            cx.error_spanned_by(
@@ -747,10 +767,7 @@ fn decide_tag(
            );
            TagType::External
        }
-        (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent {
-            tag: tag,
-            content: content,
-        },
+        (None, Some((_, tag)), Some((_, content))) => TagType::Adjacent { tag, content },
        (Some((untagged_tokens, _)), Some((tag_tokens, _)), Some((content_tokens, _))) => {
            cx.error_spanned_by(
                untagged_tokens,
@@ -1383,7 +1400,7 @@ impl Field {
                let expr = syn::ExprPath {
                    attrs: Vec::new(),
                    qself: None,
-                    path: path,
+                    path,
                };
                deserialize_with.set_if_none(expr);
            } else if is_cow(&field.ty, is_slice_u8) {
@@ -1400,7 +1417,7 @@ impl Field {
                let expr = syn::ExprPath {
                    attrs: Vec::new(),
                    qself: None,
-                    path: path,
+                    path,
                };
                deserialize_with.set_if_none(expr);
            }
@@ -1420,7 +1437,7 @@ impl Field {
            deserialize_with: deserialize_with.get(),
            ser_bound: ser_bound.get(),
            de_bound: de_bound.get(),
-            borrowed_lifetimes: borrowed_lifetimes,
+            borrowed_lifetimes,
            getter: getter.get(),
            flatten: flatten.get(),
            transparent: false,
@@ -1724,7 +1741,7 @@ fn is_implicitly_borrowed_reference(ty: &syn::Type) -> bool {
 //         cow: Cow<'a, str>,
 //     }
 fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    let path = match ty {
+    let path = match ungroup(ty) {
        syn::Type::Path(ty) => &ty.path,
        _ => {
            return false;
@@ -1751,7 +1768,7 @@ fn is_cow(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
 }

 fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    let path = match ty {
+    let path = match ungroup(ty) {
        syn::Type::Path(ty) => &ty.path,
        _ => {
            return false;
@@ -1798,7 +1815,7 @@ fn is_option(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
 //         r: &'a str,
 //     }
 fn is_reference(ty: &syn::Type, elem: fn(&syn::Type) -> bool) -> bool {
-    match ty {
+    match ungroup(ty) {
        syn::Type::Reference(ty) => ty.mutability.is_none() && elem(&ty.elem),
        _ => false,
    }
@@ -1809,14 +1826,14 @@ fn is_str(ty: &syn::Type) -> bool {
 }

 fn is_slice_u8(ty: &syn::Type) -> bool {
-    match ty {
+    match ungroup(ty) {
        syn::Type::Slice(ty) => is_primitive_type(&ty.elem, "u8"),
        _ => false,
    }
 }

 fn is_primitive_type(ty: &syn::Type, primitive: &str) -> bool {
-    match ty {
+    match ungroup(ty) {
        syn::Type::Path(ty) => ty.qself.is_none() && is_primitive_path(&ty.path, primitive),
        _ => false,
    }
@@ -1,6 +1,6 @@
 use internals::ast::{Container, Data, Field, Style};
 use internals::attr::{Identifier, TagType};
-use internals::{Ctxt, Derive};
+use internals::{ungroup, Ctxt, Derive};
 use syn::{Member, Type};

 /// Cross-cutting checks that require looking at more than a single attrs
@@ -396,7 +396,7 @@ fn member_message(member: &Member) -> String {
 }

 fn allow_transparent(field: &Field, derive: Derive) -> bool {
-    if let Type::Path(ty) = field.ty {
+    if let Type::Path(ty) = ungroup(&field.ty) {
        if let Some(seg) = ty.path.segments.last() {
            if seg.ident == "PhantomData" {
                return false;
@@ -8,8 +8,17 @@ mod case;
 mod check;
 mod symbol;

+use syn::Type;
+
 #[derive(Copy, Clone)]
 pub enum Derive {
    Serialize,
    Deserialize,
 }
+
+pub fn ungroup(mut ty: &Type) -> &Type {
+    while let Type::Group(group) = ty {
+        ty = &group.elem;
+    }
+    ty
+}
@@ -13,46 +13,40 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html

-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.106")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.114")]
 #![allow(unknown_lints, bare_trait_objects)]
-#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
-#![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
+#![deny(clippy::all, clippy::pedantic)]
 // Ignored clippy lints
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        cognitive_complexity,
-        enum_variant_names,
-        needless_pass_by_value,
-        redundant_field_names,
-        too_many_arguments,
-        trivially_copy_pass_by_ref,
-        used_underscore_binding,
-        wildcard_in_or_patterns,
-    )
+#![allow(
+    clippy::cognitive_complexity,
+    clippy::enum_variant_names,
+    clippy::needless_pass_by_value,
+    clippy::too_many_arguments,
+    clippy::trivially_copy_pass_by_ref,
+    clippy::used_underscore_binding,
+    clippy::wildcard_in_or_patterns,
+    // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+    clippy::unnested_or_patterns,
 )]
 // Ignored clippy_pedantic lints
-#![cfg_attr(
-    feature = "cargo-clippy",
-    allow(
-        cast_possible_truncation,
-        checked_conversions,
-        doc_markdown,
-        enum_glob_use,
-        filter_map,
-        indexing_slicing,
-        items_after_statements,
-        match_same_arms,
-        module_name_repetitions,
-        must_use_candidate,
-        similar_names,
-        single_match_else,
-        struct_excessive_bools,
-        too_many_lines,
-        unseparated_literal_suffix,
-        use_self,
-        wildcard_imports,
-    )
+#![allow(
+    clippy::cast_possible_truncation,
+    clippy::checked_conversions,
+    clippy::doc_markdown,
+    clippy::enum_glob_use,
+    clippy::filter_map,
+    clippy::indexing_slicing,
+    clippy::items_after_statements,
+    clippy::match_same_arms,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::similar_names,
+    clippy::single_match_else,
+    clippy::struct_excessive_bools,
+    clippy::too_many_lines,
+    clippy::unseparated_literal_suffix,
+    clippy::use_self,
+    clippy::wildcard_imports
 )]
 // The `quote!` macro requires deep recursion.
 #![recursion_limit = "512"]
@@ -87,6 +87,9 @@ struct Parameters {

    /// Type has a `serde(remote = "...")` attribute.
    is_remote: bool,
+
+    /// Type has a repr(packed) attribute.
+    is_packed: bool,
 }

 impl Parameters {
@@ -103,13 +106,16 @@ impl Parameters {
            None => cont.ident.clone().into(),
        };

+        let is_packed = cont.attrs.is_packed();
+
        let generics = build_generics(cont);

        Parameters {
-            self_var: self_var,
-            this: this,
-            generics: generics,
-            is_remote: is_remote,
+            self_var,
+            this,
+            generics,
+            is_remote,
+            is_packed,
        }
    }

@@ -538,17 +544,17 @@ fn serialize_externally_tagged_variant(
        }
        Style::Tuple => serialize_tuple_variant(
            TupleVariant::ExternallyTagged {
-                type_name: type_name,
-                variant_index: variant_index,
-                variant_name: variant_name,
+                type_name,
+                variant_index,
+                variant_name,
            },
            params,
            &variant.fields,
        ),
        Style::Struct => serialize_struct_variant(
            StructVariant::ExternallyTagged {
-                variant_index: variant_index,
-                variant_name: variant_name,
+                variant_index,
+                variant_name,
            },
            params,
            &variant.fields,
@@ -614,10 +620,7 @@ fn serialize_internally_tagged_variant(
            }
        }
        Style::Struct => serialize_struct_variant(
-            StructVariant::InternallyTagged {
-                tag: tag,
-                variant_name: variant_name,
-            },
+            StructVariant::InternallyTagged { tag, variant_name },
            params,
            &variant.fields,
            &type_name,
@@ -1241,9 +1244,19 @@ fn mut_if(is_mut: bool) -> Option<TokenStream> {
 fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStream {
    let self_var = &params.self_var;
    match (params.is_remote, field.attrs.getter()) {
-        (false, None) => quote!(&#self_var.#member),
+        (false, None) => {
+            if params.is_packed {
+                quote!(&{#self_var.#member})
+            } else {
+                quote!(&#self_var.#member)
+            }
+        }
        (true, None) => {
-            let inner = quote!(&#self_var.#member);
+            let inner = if params.is_packed {
+                quote!(&{#self_var.#member})
+            } else {
+                quote!(&#self_var.#member)
+            };
            let ty = field.ty;
            quote!(_serde::private::ser::constrain::<#ty>(#inner))
        }
@@ -8,7 +8,7 @@ homepage = "https://serde.rs"
 repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.rs/serde_derive_internals"
 keywords = ["serde", "serialization"]
-include = ["Cargo.toml", "lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["lib.rs", "src/**/*.rs", "LICENSE-APACHE", "LICENSE-MIT"]

 [lib]
 path = "lib.rs"
@@ -16,11 +16,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
-
-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
+syn = { version = "1.0.33", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }

 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -7,7 +7,9 @@
        cognitive_complexity,
        redundant_field_names,
        trivially_copy_pass_by_ref,
-        wildcard_in_or_patterns
+        wildcard_in_or_patterns,
+        // clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704
+        unnested_or_patterns,
    )
 )]

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.106" # remember to update html_root_url
+version = "1.0.114" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 license = "MIT OR Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"
@@ -9,7 +9,7 @@ repository = "https://github.com/serde-rs/serde"
 documentation = "https://docs.serde.rs/serde_test/"
 keywords = ["serde", "serialization"]
 readme = "crates-io.md"
-include = ["Cargo.toml", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]
+include = ["src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APACHE", "LICENSE-MIT"]

 [dependencies]
 serde = { version = "1.0.60", path = "../serde" }
@@ -18,9 +18,5 @@ serde = { version = "1.0.60", path = "../serde" }
 serde = { version = "1.0", path = "../serde" }
 serde_derive = { version = "1.0", path = "../serde_derive" }

-[badges]
-travis-ci = { repository = "serde-rs/serde" }
-appveyor = { repository = "serde-rs/serde" }
-
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
@@ -144,7 +144,7 @@
 //! # }
 //! ```

-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.106")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.114")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 #![cfg_attr(feature = "cargo-clippy", deny(clippy, clippy_pedantic))]
 // Ignored clippy lints
@@ -7,16 +7,20 @@ publish = false
 build = "build.rs"

 [features]
+expandtest = []
 unstable = ["serde/unstable"]

 [dependencies]
 serde = { path = "../serde" }

+[build-dependencies]
+toolchain_find = "0.1"
+
 [dev-dependencies]
 fnv = "1.0"
-rustversion = "0.1"
+macrotest = "=1.0.0"
+rustversion = "1.0"
 serde = { path = "../serde", features = ["rc", "derive"] }
 serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
 serde_test = { path = "../serde_test" }
 trybuild = "1.0"
-macrotest = "0.1"
@@ -1,13 +1,13 @@
 use std::process::{Command, ExitStatus, Stdio};

-#[cfg(not(windows))]
-const CARGO_EXPAND: &str = "cargo-expand";
+fn has_cargo_expand() -> bool {
+    let cargo_expand = if cfg!(windows) {
+        "cargo-expand.exe"
+    } else {
+        "cargo-expand"
+    };

-#[cfg(windows)]
-const CARGO_EXPAND: &str = "cargo-expand.exe";
-
-fn main() {
-    if Command::new(CARGO_EXPAND)
+    Command::new(cargo_expand)
        .arg("--version")
        .stdin(Stdio::null())
        .stdout(Stdio::null())
@@ -16,7 +16,14 @@ fn main() {
        .as_ref()
        .map(ExitStatus::success)
        .unwrap_or(false)
-    {
-        println!("cargo:rustc-cfg=cargo_expand");
+}
+
+fn has_rustfmt() -> bool {
+    toolchain_find::find_installed_component("rustfmt").is_some()
+}
+
+fn main() {
+    if cfg!(feature = "expandtest") && has_cargo_expand() && has_rustfmt() {
+        println!("cargo:rustc-cfg=expandtest");
    }
 }
@@ -7,10 +7,10 @@ enum DeEnum<B, C, D> {
    _Seq2(i8, B, C, D),
    _Map2 { a: i8, b: B, c: C, d: D },
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_DeEnum: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<B, C, D> _serde::Serialize for DeEnum<B, C, D>
@@ -259,10 +259,10 @@ const _IMPL_SERIALIZE_FOR_DeEnum: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeEnum: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, B, C, D> _serde::Deserialize<'de> for DeEnum<B, C, D>
@@ -8,10 +8,10 @@ impl AssociatedType for i32 {
 struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
    phantom: PhantomData<T>,
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
@@ -43,10 +43,10 @@ const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> {
@@ -5,10 +5,10 @@ pub enum GenericEnum<T, U> {
    Seq(T, U),
    Map { x: T, y: U },
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<T, U> _serde::Serialize for GenericEnum<T, U>
@@ -108,10 +108,10 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, T, U> _serde::Deserialize<'de> for GenericEnum<T, U>
@@ -2,10 +2,10 @@ use serde::{Deserialize, Serialize};
 pub struct GenericStruct<T> {
    x: T,
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericStruct: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<T> _serde::Serialize for GenericStruct<T>
@@ -36,10 +36,10 @@ const _IMPL_SERIALIZE_FOR_GenericStruct: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, T> _serde::Deserialize<'de> for GenericStruct<T>
@@ -398,10 +398,10 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
    }
 };
 pub struct GenericNewTypeStruct<T>(T);
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_GenericNewTypeStruct: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<T> _serde::Serialize for GenericNewTypeStruct<T>
@@ -420,10 +420,10 @@ const _IMPL_SERIALIZE_FOR_GenericNewTypeStruct: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, T> _serde::Deserialize<'de> for GenericNewTypeStruct<T>
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Serialize};
 pub struct GenericTupleStruct<T, U>(T, U);
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, T, U> _serde::Deserialize<'de> for GenericTupleStruct<T, U>
@@ -5,10 +5,10 @@ enum Lifetimes<'a> {
    LifetimeMap { a: &'a i32 },
    NoLifetimeMap { a: i32 },
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'a> _serde::Serialize for Lifetimes<'a> {
@@ -89,10 +89,10 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
@@ -4,10 +4,10 @@ struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
    b: &'b mut B,
    c: C,
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerNamedMap: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedMap<'a, 'b, A, B, C>
@@ -57,10 +57,10 @@ struct DeNamedMap<A, B, C> {
    b: B,
    c: C,
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedMap<A, B, C>
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Serialize};
 struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedTuple<'a, 'b, A, B, C>
@@ -49,10 +49,10 @@ const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
    }
 };
 struct DeNamedTuple<A, B, C>(A, B, C);
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedTuple<A, B, C>
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Serialize};
 struct NamedUnit;
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_NamedUnit: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl _serde::Serialize for NamedUnit {
@@ -15,10 +15,10 @@ const _IMPL_SERIALIZE_FOR_NamedUnit: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_NamedUnit: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de> _serde::Deserialize<'de> for NamedUnit {
@@ -10,10 +10,10 @@ where
    _Seq2(i8, B, &'a C, &'a mut D),
    _Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
 }
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_SerEnum: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'a, B: 'a, C: 'a, D> _serde::Serialize for SerEnum<'a, B, C, D>
@@ -1,9 +1,9 @@
 use serde::{Deserialize, Serialize};
 enum Void {}
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_SERIALIZE_FOR_Void: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl _serde::Serialize for Void {
@@ -15,10 +15,10 @@ const _IMPL_SERIALIZE_FOR_Void: () = {
        }
    }
 };
+#[doc(hidden)]
 #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
-const _IMPL_DESERIALIZE_FOR_Void: () = {
-    #[allow(unknown_lints)]
-    #[allow(rust_2018_idioms)]
+const _: () = {
+    #[allow(rust_2018_idioms, clippy::useless_attribute)]
    extern crate serde as _serde;
    #[automatically_derived]
    impl<'de> _serde::Deserialize<'de> for Void {
@@ -1,5 +1,5 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
-#[cfg_attr(not(cargo_expand), ignore)]
+#[cfg_attr(not(expandtest), ignore)]
 #[rustversion::attr(not(nightly), ignore)]
 #[test]
 fn expandtest() {
@@ -265,7 +265,7 @@ fn test_gen() {
    #[cfg(feature = "unstable")]
    #[derive(Serialize, Deserialize)]
    struct NonAsciiIdents {
-        σ:  f64,
+        σ: f64,
    }

    #[derive(Serialize, Deserialize)]
@@ -691,6 +691,34 @@ fn test_gen() {
        #[serde(flatten, skip_deserializing)]
        flat: T,
    }
+
+    // https://github.com/serde-rs/serde/issues/1804
+    #[derive(Serialize, Deserialize)]
+    enum Message {
+        #[serde(skip)]
+        #[allow(dead_code)]
+        String(String),
+        #[serde(other)]
+        Unknown,
+    }
+
+    #[derive(Serialize)]
+    #[repr(packed)]
+    struct Packed {
+        x: u8,
+        y: u16,
+    }
+
+    macro_rules! deriving {
+        ($field:ty) => {
+            #[derive(Deserialize)]
+            struct MacroRules<'a> {
+                field: $field,
+            }
+        };
+    }
+
+    deriving!(&'a str);
 }

 //////////////////////////////////////////////////////////////////////////
@@ -1145,6 +1145,20 @@ fn test_adjacently_tagged_enum() {
        ],
    );

+    // optional newtype with no content field
+    assert_de_tokens(
+        &AdjacentlyTagged::Newtype::<Option<u8>>(None),
+        &[
+            Token::Struct {
+                name: "AdjacentlyTagged",
+                len: 1,
+            },
+            Token::Str("t"),
+            Token::Str("Newtype"),
+            Token::StructEnd,
+        ],
+    );
+
    // tuple with tag first
    assert_tokens(
        &AdjacentlyTagged::Tuple::<u8>(1, 1),
@@ -1864,3 +1878,31 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
        ],
    );
 }
+
+#[deny(safe_packed_borrows)]
+#[test]
+fn test_packed_struct_can_derive_serialize() {
+    #[derive(Copy, Clone, Serialize)]
+    #[repr(packed, C)]
+    struct PackedC {
+        t: f32,
+    }
+
+    #[derive(Copy, Clone, Serialize)]
+    #[repr(C, packed)]
+    struct CPacked {
+        t: f32,
+    }
+
+    #[derive(Copy, Clone, Serialize)]
+    #[repr(C, packed(2))]
+    struct CPacked2 {
+        t: f32,
+    }
+
+    #[derive(Copy, Clone, Serialize)]
+    #[repr(packed(2), C)]
+    struct Packed2C {
+        t: f32,
+    }
+}
Author	SHA1	Message	Date
David Tolnay	9c6f0c3a0e	Release 1.0.114	2020-06-21 17:31:02 -07:00
David Tolnay	a9f8ea0a1e	Simplify search for packed repr attr	2020-06-21 17:22:07 -07:00
David Tolnay	04faac962a	Remove error_on_line_overflow rustfmt setting No longer seeing warnings on this from rustfmt.	2020-06-21 16:48:22 -07:00
Tanner Rogalsky	7e5701ad2b	add alignment specific packed repr tests	2020-06-21 16:46:27 -07:00
Tanner Rogalsky	1cd10a7d09	Improved packed repr matching.	2020-06-21 16:46:27 -07:00
Tanner Rogalsky	d5e6436b28	Add tests validating Serialize derivation for packed structs.	2020-06-21 16:46:27 -07:00
David Tolnay	8ff11dc234	Merge pull request #1841 from dtolnay/lenhint Remove len hint specialization	2020-06-20 19:08:34 -07:00
David Tolnay	6b3777b617	Remove len hint specialization	2020-06-20 19:02:26 -07:00
David Tolnay	7350b58f5c	Release 1.0.113	2020-06-19 13:31:38 -07:00
David Tolnay	7351e0e55a	Link to feature announcements where available	2020-06-19 13:30:14 -07:00
David Tolnay	b3ff7e43ef	Merge pull request #1827 from taiki-e/underscore_consts Use underscore consts on Rust 1.37+	2020-06-19 13:27:33 -07:00
Taiki Endo	a50e1c20e9	Use underscore consts on Rust 1.37+	2020-06-19 15:55:43 +09:00
David Tolnay	6980727d74	Merge pull request #1840 from rw/patch-1 Add FlexBuffers to serde ecosystem list	2020-06-18 22:57:59 -07:00
Robert Winslow	bb1dedf04d	Add FlexBuffers to serde ecosystem list Add FlexBuffers to serde ecosystem list	2020-06-16 13:36:14 -07:00
David Tolnay	f3520e526b	Release 1.0.112	2020-06-14 11:16:04 -07:00
David Tolnay	e8fd2c85c3	Merge pull request #1839 from dtolnay/entry Forward serialize_entry on flattened maps	2020-06-14 11:15:26 -07:00
David Tolnay	97962d51e2	Forward serialize_entry on flattened maps	2020-06-14 11:10:18 -07:00
David Tolnay	95b1a5d3d9	Ignore unnested_or_patterns suggesting unstable code Clippy bug: https://github.com/rust-lang/rust-clippy/issues/5704	2020-06-10 19:41:16 -07:00
David Tolnay	0856a2c101	No need to specify Cargo.toml in package.include Cargo.toml is always included in the published crate.	2020-06-10 01:21:19 -07:00
David Tolnay	9f331cc257	Release 1.0.111	2020-05-29 18:53:07 -07:00
David Tolnay	ef16c815f6	Merge pull request #1821 from dtolnay/ungroup Look inside of None-delimited groups when examining types	2020-05-29 18:11:14 -07:00
David Tolnay	c45a809d5c	Look inside of None-delimited groups when examining types	2020-05-29 17:58:34 -07:00
David Tolnay	f7d06cae4c	Add failing test involving macro_rules metavariable	2020-05-29 17:58:10 -07:00
David Tolnay	31fe82a215	Resolve match_wildcard_for_single_variants pedantic lint	2020-05-29 17:46:40 -07:00
David Tolnay	ef6ed1d1be	Copy some new links from serde.rs to the crate-level doc	2020-05-22 12:49:15 -07:00
David Tolnay	9d1251548b	Mirror 'Getting help' from github readme to crates.io readme	2020-05-15 23:09:48 -07:00
David Tolnay	c20730ee39	Remove reference to mozilla irc	2020-05-15 23:07:35 -07:00
David Tolnay	afd51ef0f4	Merge pull request #1808 from dtolnay/help Update 'Getting help' section	2020-05-09 23:38:40 -07:00
David Tolnay	3167f98689	Update 'Getting help' section	2020-05-09 23:34:38 -07:00
David Tolnay	078b171c1b	Release 1.0.110	2020-05-09 23:06:56 -07:00
David Tolnay	da8d6f678e	Simplify finding of repr(packed) attributes	2020-05-09 23:02:49 -07:00
David Tolnay	548eb8f667	Format PR 1791 with rustfmt	2020-05-09 22:54:42 -07:00
David Tolnay	1fe39043ee	Simplify access of packed struct fields in derived Serialize impls	2020-05-09 22:53:38 -07:00
David Tolnay	c2114491ca	Add test of Serialize impl for packed struct	2020-05-09 22:52:49 -07:00
alvardes	9f47c47cad	Add support for packed structs.	2020-05-09 22:45:44 -07:00
David Tolnay	d6b39fd2c1	Merge pull request #1807 from dtolnay/31 Add a CI builder on 1.31.0	2020-05-09 22:44:41 -07:00
David Tolnay	4d6d0ae539	Add a CI builder on 1.31.0	2020-05-09 22:38:26 -07:00
David Tolnay	dda070f45c	Fix borrow error on pre-NLL compilers error[E0506]: cannot assign to `missing_content` because it is borrowed --> serde_derive/src/de.rs:1414:9 \| 1388 \| .filter_map(\|(i, variant)\| { \| -------------- borrow of `missing_content` occurs here ... 1414 \| / missing_content = quote! { 1415 \| \| match __field { 1416 \| \| #(#missing_content_arms)* 1417 \| \| #missing_content_fallthrough 1418 \| \| } 1419 \| \| }; \| \|_________^ assignment to borrowed `missing_content` occurs here error[E0502]: cannot borrow `missing_content_fallthrough` as immutable because it is also borrowed as mutable --> serde_derive/src/de.rs:1414:27 \| 1388 \| .filter_map(\|(i, variant)\| { \| -------------- mutable borrow occurs here ... 1404 \| missing_content_fallthrough = quote!(_ => #missing_content); \| --------------------------- previous borrow occurs due to use of `missing_content_fallthrough` in closure ... 1414 \| missing_content = quote! { \| ___________________________^ 1415 \| \| match __field { 1416 \| \| #(#missing_content_arms)* 1417 \| \| #missing_content_fallthrough 1418 \| \| } 1419 \| \| }; \| \|_________^ immutable borrow occurs here ... 1622 \| } \| - mutable borrow ends here \| = note: this error originates in a macro outside of the current crate (in Nightly builds, run with -Z external-macro-backtrace for more info)	2020-05-09 22:37:31 -07:00
David Tolnay	b97a183e82	Release 1.0.109	2020-05-09 21:00:51 -07:00
David Tolnay	9433004307	Omit missing content match if not needed	2020-05-09 20:59:01 -07:00
David Tolnay	9476838264	Omit missing content fallthrough arm if not needed	2020-05-09 20:59:00 -07:00
asdsad	172edc4cf4	Allow optional content field for adjacently tagged newtype variants * Deserialize adjacently tagged newtype variants with optional content as None instead of erroring when content field is missing * refactor to remove duplicate code and remove panic	2020-05-09 20:58:28 -07:00
David Tolnay	3c97e1b9a9	Format PR 1702 with rustfmt	2020-05-09 18:24:05 -07:00
ppc	a81968af3c	Turn panic to error in SystemTime serialization	2020-05-09 18:22:29 -07:00
David Tolnay	ea2789df0f	Release 1.0.108	2020-05-09 17:53:23 -07:00
David Tolnay	b7cfe33101	Add example usage to Formatter Serializer impl	2020-05-09 17:48:27 -07:00
David Tolnay	1b8ebf6b64	Add 128-bit integer support for Formatter	2020-05-09 17:48:27 -07:00
David Tolnay	35ad468780	Allow serializing newtype struct to Formatter Serialize_newtype_struct is typically expected to just pass through the wrapped value.	2020-05-09 17:48:27 -07:00
David Tolnay	850a29beb1	Directly display to the Formatter This allows formatter flags to take effect.	2020-05-09 17:48:26 -07:00
David Tolnay	16bf9871cd	Remove serialize_unit from Formatter's impl	2020-05-09 17:48:26 -07:00
David Tolnay	6182eceed1	Move the Formatter Serializer to a module Let's keep impls.rs for Serialize impls, which there are enough of already.	2020-05-09 17:48:26 -07:00
David Tolnay	99bc52f685	Support no-default-features mode in Formatter's impl	2020-05-09 17:48:26 -07:00
Jethro Beekman	726ff5ed31	impl Serializer for &mut fmt::Formatter	2020-05-09 17:48:13 -07:00
David Tolnay	f63acb52dc	Release 1.0.107	2020-05-08 15:45:36 -07:00
David Tolnay	36a66873cc	Merge pull request #1805 from dtolnay/skip Fix indexing bug when `skip` and `other` are combined	2020-05-08 15:43:51 -07:00
David Tolnay	63809e69c7	Fix indexing bug when `skip` and `other` are combined	2020-05-08 15:39:07 -07:00
David Tolnay	f44402e224	Add regression test for issue 1804	2020-05-08 15:38:44 -07:00
David Tolnay	099fa25b86	Fix unused matrix component in name of clippy job	2020-05-06 01:53:58 -07:00
David Tolnay	c120c4518b	Move clippy to ci.yml gated with github.event_name != 'pull_request'	2020-05-05 22:09:35 -07:00
David Tolnay	115c1b4830	Exclude expansion tests from test suite by default This test isn't high enough signal to have all contributors run it.	2020-05-05 21:52:37 -07:00
David Tolnay	23db3a41e7	Run expansion tests only if rustfmt is present	2020-05-05 21:50:14 -07:00
David Tolnay	e2ff603587	Add Actions job to run macrotest	2020-05-05 17:41:35 -07:00
David Tolnay	19a11237b8	Regenerate macrotest *.expanded.rs files This picks up changes from `a135199ab1` and `1b35c9e27e`.	2020-05-05 17:23:30 -07:00
David Tolnay	732544aed6	Update to macrotest 1.0	2020-05-05 17:23:30 -07:00
David Tolnay	65dfa607c8	Update to rustversion 1.0	2020-05-05 17:23:30 -07:00
David Tolnay	59104bbc24	Remove AppVeyor configuration	2020-05-05 17:08:09 -07:00
David Tolnay	38ad09aeb7	Add Windows CI in GitHub Actions	2020-05-05 17:08:09 -07:00
David Tolnay	02631cef42	Remove clippy from main CI workflow We don't run clippy on PRs. It is covered by a separate clippy.yml workflow.	2020-05-05 17:04:51 -07:00
David Tolnay	f369707dc5	Update build status badge to GitHub Actions	2020-05-05 16:43:36 -07:00
David Tolnay	e16e924c21	Split test suite to its own Actions job Since this step takes the longest.	2020-05-05 16:39:36 -07:00
David Tolnay	8b52ddd5b9	Add GitHub Actions workflow to run Clippy	2020-05-05 16:34:27 -07:00
David Tolnay	112f2040ea	Remove Travis configuration	2020-05-05 11:33:56 -07:00
David Tolnay	cd836eb3ca	Try caching Cargo index to speed up 1.13 build This one build always took several (10+) minutes on: Updating registry `https://github.com/rust-lang/crates.io-index`	2020-05-03 17:59:26 -07:00
David Tolnay	2b4355724e	Merge pull request #1795 from serde-rs/actions Enable GitHub Actions	2020-05-03 02:38:48 -07:00
David Tolnay	5534bf4df1	Enable GitHub Actions	2020-05-03 02:23:04 -07:00
David Tolnay	60522937af	Remove CI badge from Cargo.toml Support for badges has been deprecated by crates.io.	2020-05-01 21:11:02 -07:00
David Tolnay	29be721f79	Work around clippy redundant_field_names bug	2020-04-23 11:21:28 -07:00
David Tolnay	0c4ffad9ec	Run clippy on latest nightly that has clippy	2020-04-23 10:44:12 -07:00
David Tolnay	03addbae55	Format with rustfmt 2020-03-11	2020-04-19 17:32:11 -07:00
David Tolnay	0bab6be124	Resolve redundant_pattern_matching lint	2020-04-19 17:31:15 -07:00
David Tolnay	b6def5300a	Resolve redundant_field_names lint in serde_derive	2020-04-05 21:07:52 -07:00
David Tolnay	1b35c9e27e	Update serde_derive to tool attrs	2020-04-05 21:00:58 -07:00