Release 1.0.121

Touch up borrowed field identifiers PR

.github/ISSUE_TEMPLATE/4-discussion.md

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

.github/workflows/ci.yml

@@ -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

.travis.yml

@@ -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

CONTRIBUTING.md

@@ -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
@@ -63,4 +58,4 @@ 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.
 
-[Rust Code of Conduct]: https://www.rust-lang.org/conduct.html
+[Rust Code of Conduct]: https://www.rust-lang.org/policies/code-of-conduct

README.md

@@ -1,7 +1,7 @@
-# Serde   [![Build Status]][travis] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
+# Serde   [![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>
 

appveyor.yml

@@ -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

crates-io.md

@@ -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

rustfmt.toml

@@ -1 +0,0 @@
-error_on_line_overflow = false

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "1.0.105" # remember to update html_root_url and serde_derive dependency
+version = "1.0.121" # 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.105", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.121", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

serde/build.rs

@@ -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");
     }

serde/src/de/ignored_any.rs

@@ -130,12 +130,28 @@ impl<'de> Visitor<'de> for IgnoredAny {
         Ok(IgnoredAny)
     }
 
+    serde_if_integer128! {
+        #[inline]
+        fn visit_i128<E>(self, x: i128) -> Result<Self::Value, E> {
+            let _ = x;
+            Ok(IgnoredAny)
+        }
+    }
+
     #[inline]
     fn visit_u64<E>(self, x: u64) -> Result<Self::Value, E> {
         let _ = x;
         Ok(IgnoredAny)
     }
 
+    serde_if_integer128! {
+        #[inline]
+        fn visit_u128<E>(self, x: u128) -> Result<Self::Value, E> {
+            let _ = x;
+            Ok(IgnoredAny)
+        }
+    }
+
     #[inline]
     fn visit_f64<E>(self, x: f64) -> Result<Self::Value, E> {
         let _ = x;

serde/src/de/impls.rs

@@ -7,11 +7,11 @@ use de::{
 #[cfg(any(core_duration, feature = "std", feature = "alloc"))]
 use de::MapAccess;
 
+use __private::de::InPlaceSeed;
 use de::from_primitive::FromPrimitive;
-use private::de::InPlaceSeed;
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-use private::de::size_hint;
+use __private::de::size_hint;
 
 ////////////////////////////////////////////////////////////////////////////////
 
@@ -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 {
@@ -1257,24 +1260,7 @@ macro_rules! parse_ip_impl {
                 D: Deserializer<'de>,
             {
                 if deserializer.is_human_readable() {
-                    struct IpAddrVisitor;
-
-                    impl<'de> Visitor<'de> for IpAddrVisitor {
-                        type Value = $ty;
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str($expecting)
-                        }
-
-                        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                        where
-                            E: Error,
-                        {
-                            s.parse().map_err(Error::custom)
-                        }
-                    }
-
-                    deserializer.deserialize_str(IpAddrVisitor)
+                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
                 } else {
                     <[u8; $size]>::deserialize(deserializer).map(<$ty>::from)
                 }
@@ -1310,7 +1296,7 @@ macro_rules! variant_identifier {
                         formatter.write_str($expecting_message)
                     }
 
-                    fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
+                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                     where
                         E: Error,
                     {
@@ -1318,7 +1304,7 @@ macro_rules! variant_identifier {
                             $(
                                 $index => Ok($name_kind :: $variant),
                             )*
-                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value as u64), &self),),
+                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self),),
                         }
                     }
 
@@ -1402,24 +1388,7 @@ impl<'de> Deserialize<'de> for net::IpAddr {
         D: Deserializer<'de>,
     {
         if deserializer.is_human_readable() {
-            struct IpAddrVisitor;
-
-            impl<'de> Visitor<'de> for IpAddrVisitor {
-                type Value = net::IpAddr;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("IP address")
-                }
-
-                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    s.parse().map_err(Error::custom)
-                }
-            }
-
-            deserializer.deserialize_str(IpAddrVisitor)
+            deserializer.deserialize_str(FromStrVisitor::new("IP address"))
         } else {
             use lib::net::IpAddr;
             deserialize_enum! {
@@ -1446,24 +1415,7 @@ macro_rules! parse_socket_impl {
                 D: Deserializer<'de>,
             {
                 if deserializer.is_human_readable() {
-                    struct SocketAddrVisitor;
-
-                    impl<'de> Visitor<'de> for SocketAddrVisitor {
-                        type Value = $ty;
-
-                        fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                            formatter.write_str($expecting)
-                        }
-
-                        fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                        where
-                            E: Error,
-                        {
-                            s.parse().map_err(Error::custom)
-                        }
-                    }
-
-                    deserializer.deserialize_str(SocketAddrVisitor)
+                    deserializer.deserialize_str(FromStrVisitor::new($expecting))
                 } else {
                     <(_, u16)>::deserialize(deserializer).map(|(ip, port)| $new(ip, port))
                 }
@@ -1479,24 +1431,7 @@ impl<'de> Deserialize<'de> for net::SocketAddr {
         D: Deserializer<'de>,
     {
         if deserializer.is_human_readable() {
-            struct SocketAddrVisitor;
-
-            impl<'de> Visitor<'de> for SocketAddrVisitor {
-                type Value = net::SocketAddr;
-
-                fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
-                    formatter.write_str("socket address")
-                }
-
-                fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
-                where
-                    E: Error,
-                {
-                    s.parse().map_err(Error::custom)
-                }
-            }
-
-            deserializer.deserialize_str(SocketAddrVisitor)
+            deserializer.deserialize_str(FromStrVisitor::new("socket address"))
         } else {
             use lib::net::SocketAddr;
             deserialize_enum! {
@@ -1868,7 +1803,7 @@ impl<'de> Deserialize<'de> for Duration {
         enum Field {
             Secs,
             Nanos,
-        };
+        }
 
         impl<'de> Deserialize<'de> for Field {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -1903,7 +1838,7 @@ impl<'de> Deserialize<'de> for Duration {
                             b"secs" => Ok(Field::Secs),
                             b"nanos" => Ok(Field::Nanos),
                             _ => {
-                                let value = ::export::from_utf8_lossy(value);
+                                let value = ::__private::from_utf8_lossy(value);
                                 Err(Error::unknown_field(&value, FIELDS))
                             }
                         }
@@ -1914,6 +1849,17 @@ impl<'de> Deserialize<'de> for Duration {
             }
         }
 
+        fn check_overflow<E>(secs: u64, nanos: u32) -> Result<(), E>
+        where
+            E: Error,
+        {
+            static NANOS_PER_SEC: u32 = 1_000_000_000;
+            match secs.checked_add((nanos / NANOS_PER_SEC) as u64) {
+                Some(_) => Ok(()),
+                None => Err(E::custom("overflow deserializing Duration")),
+            }
+        }
+
         struct DurationVisitor;
 
         impl<'de> Visitor<'de> for DurationVisitor {
@@ -1939,6 +1885,7 @@ impl<'de> Deserialize<'de> for Duration {
                         return Err(Error::invalid_length(1, &self));
                     }
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
 
@@ -1972,6 +1919,7 @@ impl<'de> Deserialize<'de> for Duration {
                     Some(nanos) => nanos,
                     None => return Err(<A::Error as Error>::missing_field("nanos")),
                 };
+                try!(check_overflow(secs, nanos));
                 Ok(Duration::new(secs, nanos))
             }
         }
@@ -1993,7 +1941,7 @@ impl<'de> Deserialize<'de> for SystemTime {
         enum Field {
             Secs,
             Nanos,
-        };
+        }
 
         impl<'de> Deserialize<'de> for Field {
             fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>
@@ -2211,7 +2159,7 @@ mod range {
                         b"start" => Ok(Field::Start),
                         b"end" => Ok(Field::End),
                         _ => {
-                            let value = ::export::from_utf8_lossy(value);
+                            let value = ::__private::from_utf8_lossy(value);
                             Err(Error::unknown_field(&value, FIELDS))
                         }
                     }
@@ -2323,7 +2271,7 @@ where
                         formatter.write_str("`Unbounded`, `Included` or `Excluded`")
                     }
 
-                    fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
+                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                     where
                         E: Error,
                     {
@@ -2331,10 +2279,7 @@ where
                             0 => Ok(Field::Unbounded),
                             1 => Ok(Field::Included),
                             2 => Ok(Field::Excluded),
-                            _ => Err(Error::invalid_value(
-                                Unexpected::Unsigned(value as u64),
-                                &self,
-                            )),
+                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
                         }
                     }
 
@@ -2489,17 +2434,14 @@ where
                         formatter.write_str("`Ok` or `Err`")
                     }
 
-                    fn visit_u32<E>(self, value: u32) -> Result<Self::Value, E>
+                    fn visit_u64<E>(self, value: u64) -> Result<Self::Value, E>
                     where
                         E: Error,
                     {
                         match value {
                             0 => Ok(Field::Ok),
                             1 => Ok(Field::Err),
-                            _ => Err(Error::invalid_value(
-                                Unexpected::Unsigned(value as u64),
-                                &self,
-                            )),
+                            _ => Err(Error::invalid_value(Unexpected::Unsigned(value), &self)),
                         }
                     }
 
@@ -2567,7 +2509,6 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl<'de, T> Deserialize<'de> for Wrapping<T>
 where
     T: Deserialize<'de>,
@@ -2607,3 +2548,39 @@ atomic_impl! {
 atomic_impl! {
     AtomicI64 AtomicU64
 }
+
+#[cfg(feature = "std")]
+struct FromStrVisitor<T> {
+    expecting: &'static str,
+    ty: PhantomData<T>,
+}
+
+#[cfg(feature = "std")]
+impl<T> FromStrVisitor<T> {
+    fn new(expecting: &'static str) -> Self {
+        FromStrVisitor {
+            expecting: expecting,
+            ty: PhantomData,
+        }
+    }
+}
+
+#[cfg(feature = "std")]
+impl<'de, T> Visitor<'de> for FromStrVisitor<T>
+where
+    T: str::FromStr,
+    T::Err: fmt::Display,
+{
+    type Value = T;
+
+    fn expecting(&self, formatter: &mut fmt::Formatter) -> fmt::Result {
+        formatter.write_str(self.expecting)
+    }
+
+    fn visit_str<E>(self, s: &str) -> Result<Self::Value, E>
+    where
+        E: Error,
+    {
+        s.parse().map_err(Error::custom)
+    }
+}

serde/src/de/mod.rs

@@ -104,7 +104,7 @@
 //! [`Deserialize`]: ../trait.Deserialize.html
 //! [`Deserializer`]: ../trait.Deserializer.html
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
-//! [`bincode`]: https://github.com/TyOverby/bincode
+//! [`bincode`]: https://github.com/servo/bincode
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json

serde/src/de/value.rs

@@ -24,8 +24,8 @@
 use lib::*;
 
 use self::private::{First, Second};
-use de::{self, Expected, IntoDeserializer, SeqAccess};
-use private::de::size_hint;
+use __private::de::size_hint;
+use de::{self, Deserializer, Expected, IntoDeserializer, SeqAccess, Visitor};
 use ser;
 
 ////////////////////////////////////////////////////////////////////////////////
@@ -665,27 +665,26 @@ where
 
 ////////////////////////////////////////////////////////////////////////////////
 
-/// A deserializer holding a `&[u8]` with a lifetime tied to another
-/// deserializer.
+/// A deserializer holding a `&[u8]`. Always calls [`Visitor::visit_bytes`].
 #[derive(Debug)]
-pub struct BorrowedBytesDeserializer<'de, E> {
-    value: &'de [u8],
+pub struct BytesDeserializer<'a, E> {
+    value: &'a [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 {
+impl<'a, E> BytesDeserializer<'a, E> {
+    /// Create a new deserializer from the given bytes.
+    pub fn new(value: &'a [u8]) -> Self {
+        BytesDeserializer {
             value: value,
             marker: PhantomData,
         }
     }
 }
 
-impl<'de, E> de::Deserializer<'de> for BorrowedBytesDeserializer<'de, E>
+impl_copy_clone!(BytesDeserializer<'a>);
+
+impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
 where
     E: de::Error,
 {
@@ -693,7 +692,47 @@ where
 
     fn deserialize_any<V>(self, visitor: V) -> Result<V::Value, Self::Error>
     where
-        V: de::Visitor<'de>,
+        V: Visitor<'de>,
+    {
+        visitor.visit_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 enum identifier ignored_any
+    }
+}
+
+/// A deserializer holding a `&[u8]` with a lifetime tied to another
+/// deserializer. Always calls [`Visitor::visit_borrowed_bytes`].
+#[derive(Debug)]
+pub struct BorrowedBytesDeserializer<'de, E> {
+    value: &'de [u8],
+    marker: PhantomData<E>,
+}
+
+impl<'de, E> BorrowedBytesDeserializer<'de, E> {
+    /// Create a new borrowed deserializer from the given borrowed bytes.
+    pub fn new(value: &'de [u8]) -> Self {
+        BorrowedBytesDeserializer {
+            value: value,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl_copy_clone!(BorrowedBytesDeserializer<'de>);
+
+impl<'de, E> 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: Visitor<'de>,
     {
         visitor.visit_borrowed_bytes(self.value)
     }
@@ -701,7 +740,7 @@ where
     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
+        tuple_struct map struct enum identifier ignored_any
     }
 }
 
@@ -1034,7 +1073,7 @@ where
         let value = self.value.take();
         // Panic because this indicates a bug in the program rather than an
         // expected failure.
-        let value = value.expect("MapAccess::visit_value called before visit_key");
+        let value = value.expect("MapAccess::next_value called before next_key");
         seed.deserialize(value.into_deserializer())
     }
 

serde/src/export.rs

@@ -1,39 +0,0 @@
-pub use lib::clone::Clone;
-pub use lib::convert::{From, Into};
-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, Err, Ok};
-
-pub use self::string::from_utf8_lossy;
-
-#[cfg(any(feature = "alloc", feature = "std"))]
-pub use lib::{ToString, Vec};
-
-#[cfg(core_try_from)]
-pub use lib::convert::TryFrom;
-
-mod string {
-    use lib::*;
-
-    #[cfg(any(feature = "std", feature = "alloc"))]
-    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
-        String::from_utf8_lossy(bytes)
-    }
-
-    // The generated code calls this like:
-    //
-    //     let value = &_serde::export::from_utf8_lossy(bytes);
-    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
-    //
-    // 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 = "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
-        // UTF-8.
-        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
-    }
-}

serde/src/integer128.rs

@@ -10,7 +10,7 @@
 /// bother with this macro and may assume support for 128-bit integers.
 ///
 /// ```edition2018
-/// # use serde::private::ser::Error;
+/// # use serde::__private::ser::Error;
 /// #
 /// # struct MySerializer;
 /// #

serde/src/lib.rs

@@ -9,11 +9,9 @@
 //! these two groups interact with each other, allowing any supported data
 //! structure to be serialized and deserialized using any supported data format.
 //!
-//! See the Serde website [https://serde.rs/] for additional documentation and
+//! See the Serde website <https://serde.rs/> for additional documentation and
 //! usage examples.
 //!
-//! [https://serde.rs/]: https://serde.rs/
-//!
 //! ## Design
 //!
 //! Where many other languages rely on runtime reflection for serializing data,
@@ -37,8 +35,8 @@
 //!   used for IPC within the Servo rendering engine.
 //! - [CBOR], a Concise Binary Object Representation designed for small message
 //!   size without the need for version negotiation.
-//! - [YAML], a popular human-friendly configuration language that ain't markup
-//!   language.
+//! - [YAML], a self-proclaimed human-friendly configuration language that ain't
+//!   markup language.
 //! - [MessagePack], an efficient binary format that resembles a compact JSON.
 //! - [TOML], a minimal configuration format used by [Cargo].
 //! - [Pickle], a format common in the Python world.
@@ -48,14 +46,20 @@
 //!   definition.
 //! - [JSON5], A superset of JSON including some productions from ES5.
 //! - [Postcard], a no\_std and embedded-systems friendly compact binary format.
-//! - [URL], the x-www-form-urlencoded format.
+//! - [URL] query strings, in the x-www-form-urlencoded format.
 //! - [Envy], a way to deserialize environment variables into Rust structs.
 //!   *(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.
+//! - [DynamoDB Items], the format used by [rusoto_dynamodb] to transfer data to
+//!   and from DynamoDB.
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/TyOverby/bincode
+//! [Bincode]: https://github.com/servo/bincode
 //! [CBOR]: https://github.com/pyfisch/cbor
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
@@ -66,23 +70,28 @@
 //! [Avro]: https://github.com/flavray/avro-rs
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
 //! [Postcard]: https://github.com/jamesmunns/postcard
-//! [URL]: https://github.com/nox/serde_urlencoded
+//! [URL]: https://docs.rs/serde_qs
 //! [Envy]: https://github.com/softprops/envy
 //! [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
+//! [DynamoDB Items]: https://docs.rs/serde_dynamo
+//! [rusoto_dynamodb]: https://docs.rs/rusoto_dynamodb
 
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.105")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.121")]
 // 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 +99,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,
@@ -102,12 +113,15 @@
         // things are often more readable this way
         cast_lossless,
         module_name_repetitions,
+        option_if_let_else,
         single_match_else,
         type_complexity,
         use_self,
         zero_prefixed_literal,
         // correctly used
         enum_glob_use,
+        map_err_ignore,
+        result_unit_err,
         wildcard_imports,
         // not practical
         needless_pass_by_value,
@@ -154,6 +168,7 @@ mod lib {
     pub use self::core::default::{self, Default};
     pub use self::core::fmt::{self, Debug, Display};
     pub use self::core::marker::{self, PhantomData};
+    pub use self::core::num::Wrapping;
     pub use self::core::ops::Range;
     pub use self::core::option::{self, Option};
     pub use self::core::result::{self, Result};
@@ -205,8 +220,6 @@ mod lib {
     #[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::sync::{Mutex, RwLock};
@@ -253,13 +266,15 @@ pub use de::{Deserialize, Deserializer};
 #[doc(inline)]
 pub use ser::{Serialize, Serializer};
 
-// Generated code uses these to support no_std. Not public API.
+// Used by generated code and doc tests. Not public API.
 #[doc(hidden)]
-pub mod export;
+#[path = "private/mod.rs"]
+pub mod __private;
 
-// Helpers used by generated code and doc tests. Not public API.
-#[doc(hidden)]
-pub mod private;
+#[allow(unused_imports)]
+use self::__private as export;
+#[allow(unused_imports)]
+use self::__private as private;
 
 #[cfg(not(feature = "std"))]
 mod std_error;

serde/src/macros.rs

@@ -124,7 +124,7 @@ macro_rules! forward_to_deserialize_any {
 macro_rules! forward_to_deserialize_any_method {
     ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
         #[inline]
-        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::export::Result<$v::Value, Self::Error>
+        fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
         where
             $v: $crate::de::Visitor<$l>,
         {

serde/src/private/de.rs

@@ -1,5 +1,6 @@
 use lib::*;
 
+use de::value::{BorrowedBytesDeserializer, BytesDeserializer};
 use de::{Deserialize, DeserializeSeed, Deserializer, Error, IntoDeserializer, Visitor};
 
 #[cfg(any(feature = "std", feature = "alloc"))]
@@ -183,7 +184,9 @@ where
         }
     }
 
-    deserializer.deserialize_bytes(CowBytesVisitor).map(From::from)
+    deserializer
+        .deserialize_bytes(CowBytesVisitor)
+        .map(From::from)
 }
 
 pub mod size_hint {
@@ -1560,7 +1563,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 +2253,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 +2475,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(())
         }
     }
@@ -2536,8 +2539,10 @@ mod content {
 //    }
 pub trait IdentifierDeserializer<'de, E: Error> {
     type Deserializer: Deserializer<'de, Error = E>;
+    type BorrowedDeserializer: Deserializer<'de, Error = E>;
 
     fn from(self) -> Self::Deserializer;
+    fn borrowed(self) -> Self::BorrowedDeserializer;
 }
 
 impl<'de, E> IdentifierDeserializer<'de, E> for u32
@@ -2545,10 +2550,15 @@ where
     E: Error,
 {
     type Deserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
+    type BorrowedDeserializer = <u32 as IntoDeserializer<'de, E>>::Deserializer;
 
     fn from(self) -> Self::Deserializer {
         self.into_deserializer()
     }
+
+    fn borrowed(self) -> Self::BorrowedDeserializer {
+        self.into_deserializer()
+    }
 }
 
 pub struct StrDeserializer<'a, E> {
@@ -2556,20 +2566,6 @@ pub struct StrDeserializer<'a, E> {
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
-where
-    E: Error,
-{
-    type Deserializer = StrDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        StrDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
 impl<'de, 'a, E> Deserializer<'de> for StrDeserializer<'a, E>
 where
     E: Error,
@@ -2590,26 +2586,12 @@ where
     }
 }
 
-pub struct BytesDeserializer<'a, E> {
-    value: &'a [u8],
+pub struct BorrowedStrDeserializer<'de, E> {
+    value: &'de str,
     marker: PhantomData<E>,
 }
 
-impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
-where
-    E: Error,
-{
-    type Deserializer = BytesDeserializer<'a, E>;
-
-    fn from(self) -> Self::Deserializer {
-        BytesDeserializer {
-            value: self,
-            marker: PhantomData,
-        }
-    }
-}
-
-impl<'de, 'a, E> Deserializer<'de> for BytesDeserializer<'a, E>
+impl<'de, E> Deserializer<'de> for BorrowedStrDeserializer<'de, E>
 where
     E: Error,
 {
@@ -2619,7 +2601,7 @@ where
     where
         V: Visitor<'de>,
     {
-        visitor.visit_bytes(self.value)
+        visitor.visit_borrowed_str(self.value)
     }
 
     forward_to_deserialize_any! {
@@ -2629,6 +2611,44 @@ where
     }
 }
 
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a str
+where
+    E: Error,
+{
+    type Deserializer = StrDeserializer<'a, E>;
+    type BorrowedDeserializer = BorrowedStrDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        StrDeserializer {
+            value: self,
+            marker: PhantomData,
+        }
+    }
+
+    fn borrowed(self) -> Self::BorrowedDeserializer {
+        BorrowedStrDeserializer {
+            value: self,
+            marker: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> IdentifierDeserializer<'a, E> for &'a [u8]
+where
+    E: Error,
+{
+    type Deserializer = BytesDeserializer<'a, E>;
+    type BorrowedDeserializer = BorrowedBytesDeserializer<'a, E>;
+
+    fn from(self) -> Self::Deserializer {
+        BytesDeserializer::new(self)
+    }
+
+    fn borrowed(self) -> Self::BorrowedDeserializer {
+        BorrowedBytesDeserializer::new(self)
+    }
+}
+
 /// A DeserializeSeed helper for implementing deserialize_in_place Visitors.
 ///
 /// Wraps a mutable reference and calls deserialize_in_place on it.
@@ -2761,6 +2781,13 @@ where
         }
     }
 
+    fn deserialize_unit<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        visitor.visit_unit()
+    }
+
     forward_to_deserialize_other! {
         deserialize_bool()
         deserialize_i8()
@@ -2778,7 +2805,6 @@ where
         deserialize_string()
         deserialize_bytes()
         deserialize_byte_buf()
-        deserialize_unit()
         deserialize_unit_struct(&'static str)
         deserialize_seq()
         deserialize_tuple(usize)

serde/src/private/macros.rs

@@ -37,7 +37,7 @@ macro_rules! __serialize_unimplemented {
 #[macro_export]
 macro_rules! __serialize_unimplemented_method {
     ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
-        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::export::Result<Self::$ret, Self::Error> {
+        fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
             unimplemented!()
         }
     };

serde/src/private/mod.rs

@@ -2,3 +2,43 @@ mod macros;
 
 pub mod de;
 pub mod ser;
+
+pub use lib::clone::Clone;
+pub use lib::convert::{From, Into};
+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, Err, Ok};
+
+pub use self::string::from_utf8_lossy;
+
+#[cfg(any(feature = "alloc", feature = "std"))]
+pub use lib::{ToString, Vec};
+
+#[cfg(core_try_from)]
+pub use lib::convert::TryFrom;
+
+mod string {
+    use lib::*;
+
+    #[cfg(any(feature = "std", feature = "alloc"))]
+    pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
+        String::from_utf8_lossy(bytes)
+    }
+
+    // The generated code calls this like:
+    //
+    //     let value = &_serde::__private::from_utf8_lossy(bytes);
+    //     Err(_serde::de::Error::unknown_variant(value, VARIANTS))
+    //
+    // 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 = "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
+        // UTF-8.
+        str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
+    }
+}

serde/src/private/ser.rs

@@ -1124,7 +1124,7 @@ where
     }
 
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Err(Self::bad_type(Unsupported::Unit))
+        Ok(())
     }
 
     fn serialize_unit_struct(self, _: &'static str) -> Result<Self::Ok, Self::Error> {
@@ -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(())
     }

serde/src/ser/fmt.rs

@@ -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)
+    }
+}

serde/src/ser/impls.rs

@@ -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()));
@@ -753,10 +753,10 @@ impl Serialize for net::SocketAddrV6 {
         S: Serializer,
     {
         if serializer.is_human_readable() {
-            const MAX_LEN: usize = 47;
+            const MAX_LEN: usize = 58;
             debug_assert_eq!(
                 MAX_LEN,
-                "[1001:1002:1003:1004:1005:1006:1007:1008]:65000".len()
+                "[1001:1002:1003:1004:1005:1006:1007:1008%4294967295]:65000".len()
             );
             serialize_display_bounded_length!(self, MAX_LEN, serializer)
         } else {
@@ -824,7 +824,6 @@ impl Serialize for OsString {
 
 ////////////////////////////////////////////////////////////////////////////////
 
-#[cfg(feature = "std")]
 impl<T> Serialize for Wrapping<T>
 where
     T: Serialize,

serde/src/ser/impossible.rs

@@ -17,7 +17,7 @@ use ser::{
 ///
 /// ```edition2018
 /// # use serde::ser::{Serializer, Impossible};
-/// # use serde::private::ser::Error;
+/// # use serde::__private::ser::Error;
 /// #
 /// # struct MySerializer;
 /// #

serde/src/ser/mod.rs

@@ -99,7 +99,7 @@
 //! [`LinkedHashMap<K, V>`]: https://docs.rs/linked-hash-map/*/linked_hash_map/struct.LinkedHashMap.html
 //! [`Serialize`]: ../trait.Serialize.html
 //! [`Serializer`]: ../trait.Serializer.html
-//! [`bincode`]: https://github.com/TyOverby/bincode
+//! [`bincode`]: https://github.com/servo/bincode
 //! [`linked-hash-map`]: https://crates.io/crates/linked-hash-map
 //! [`serde_derive`]: https://crates.io/crates/serde_derive
 //! [`serde_json`]: https://github.com/serde-rs/json
@@ -109,6 +109,7 @@
 
 use lib::*;
 
+mod fmt;
 mod impls;
 mod impossible;
 
@@ -710,7 +711,7 @@ pub trait Serializer: Sized {
     ///
     /// ```edition2018
     /// # use serde::ser::{Serializer, SerializeSeq};
-    /// # use serde::private::ser::Error;
+    /// # use serde::__private::ser::Error;
     /// #
     /// # struct MySerializer;
     /// #
@@ -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));
         }
@@ -1359,10 +1360,7 @@ pub trait Serializer: Sized {
     where
         T: Display,
     {
-        use lib::fmt::Write;
-        let mut string = String::new();
-        write!(string, "{}", value).unwrap();
-        self.serialize_str(&string)
+        self.serialize_str(&value.to_string())
     }
 
     /// Serialize a string produced by an implementation of `Display`.
@@ -1955,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,

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.105" # remember to update html_root_url
+version = "1.0.121" # 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.58", features = ["visit"] }
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }

serde_derive/build.rs

@@ -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()
+}

serde_derive/src/bound.rs

@@ -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()
     }
 }

serde_derive/src/dummy.rs

@@ -1,4 +1,5 @@
-use proc_macro2::{Ident, Span, TokenStream};
+use proc_macro2::{Ident, TokenStream};
+use quote::format_ident;
 
 use syn;
 use try;
@@ -11,24 +12,24 @@ 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;
         },
     };
 
     quote! {
+        #[doc(hidden)]
         #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
         const #dummy_const: () = {
             #use_serde

serde_derive/src/internals/ast.rs

@@ -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,
             }
         })

serde_derive/src/internals/attr.rs

@@ -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,
@@ -1376,14 +1393,14 @@ impl Field {
                 };
                 let span = Span::call_site();
                 path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_str", span).into());
                 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) {
@@ -1393,14 +1410,14 @@ impl Field {
                 };
                 let span = Span::call_site();
                 path.segments.push(Ident::new("_serde", span).into());
-                path.segments.push(Ident::new("private", span).into());
+                path.segments.push(Ident::new("__private", span).into());
                 path.segments.push(Ident::new("de", span).into());
                 path.segments
                     .push(Ident::new("borrow_cow_bytes", span).into());
                 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,
     }

serde_derive/src/internals/check.rs

@@ -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;

serde_derive/src/internals/mod.rs

@@ -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
+}

serde_derive/src/lib.rs

@@ -13,49 +13,44 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.105")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.121")]
 #![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::match_like_matches_macro,
+    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::map_err_ignore,
+    clippy::match_same_arms,
+    clippy::module_name_repetitions,
+    clippy::must_use_candidate,
+    clippy::option_if_let_else,
+    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"]
 
 #[macro_use]
 extern crate quote;

serde_derive/src/pretend.rs

@@ -74,9 +74,9 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
     };
 
     quote! {
-        match _serde::export::None::<#type_ident #ty_generics> {
+        match _serde::__private::None::<#type_ident #ty_generics> {
             #(
-                _serde::export::Some(#patterns) => {}
+                _serde::__private::Some(#patterns) => {}
             )*
             _ => {}
         }
@@ -120,8 +120,8 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
         };
 
         quote! {
-            match _serde::export::None {
-                _serde::export::Some((#(#placeholders,)*)) => {
+            match _serde::__private::None {
+                _serde::__private::Some((#(#placeholders,)*)) => {
                     let _ = #type_ident::#variant_ident #turbofish #pat;
                 }
                 _ => {}

serde_derive/src/ser.rs

@@ -29,7 +29,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         let used = pretend::pretend_used(&cont);
         quote! {
             impl #impl_generics #ident #ty_generics #where_clause {
-                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                 where
                     __S: #serde::Serializer,
                 {
@@ -42,7 +42,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
         quote! {
             #[automatically_derived]
             impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
-                fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error>
+                fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
                 where
                     __S: #serde::Serializer,
                 {
@@ -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,
         }
     }
 
@@ -205,7 +211,7 @@ fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
     let self_var = &params.self_var;
     quote_block! {
         _serde::Serialize::serialize(
-            &_serde::export::Into::<#type_into>::into(_serde::export::Clone::clone(#self_var)),
+            &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
             __serializer)
     }
 }
@@ -366,7 +372,7 @@ fn serialize_struct_as_map(
     let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
 
     let len = if cattrs.has_flatten() {
-        quote!(_serde::export::None)
+        quote!(_serde::__private::None)
     } else {
         let len = serialized_fields
             .map(|field| match field.attrs.skip_serializing_if() {
@@ -380,7 +386,7 @@ fn serialize_struct_as_map(
                 quote!(#tag_field_exists as usize),
                 |sum, expr| quote!(#sum + #expr),
             );
-        quote!(_serde::export::Some(#len))
+        quote!(_serde::__private::Some(#len))
     };
 
     quote_block! {
@@ -427,7 +433,7 @@ fn serialize_variant(
             variant_ident
         );
         let skipped_err = quote! {
-            _serde::export::Err(_serde::ser::Error::custom(#skipped_msg))
+            _serde::__private::Err(_serde::ser::Error::custom(#skipped_msg))
         };
         let fields_pat = match variant.style {
             Style::Unit => quote!(),
@@ -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,
@@ -572,7 +578,7 @@ fn serialize_internally_tagged_variant(
     if let Some(path) = variant.attrs.serialize_with() {
         let ser = wrap_serialize_variant_with(params, path, variant);
         return quote_expr! {
-            _serde::private::ser::serialize_tagged_newtype(
+            _serde::__private::ser::serialize_tagged_newtype(
                 __serializer,
                 #enum_ident_str,
                 #variant_ident_str,
@@ -601,7 +607,7 @@ fn serialize_internally_tagged_variant(
             }
 
             let span = field.original.span();
-            let func = quote_spanned!(span=> _serde::private::ser::serialize_tagged_newtype);
+            let func = quote_spanned!(span=> _serde::__private::ser::serialize_tagged_newtype);
             quote_expr! {
                 #func(
                     __serializer,
@@ -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,
@@ -712,11 +715,11 @@ fn serialize_adjacently_tagged_variant(
     quote_block! {
         struct __AdjacentlyTagged #wrapper_generics #where_clause {
             data: (#(&'__a #fields_ty,)*),
-            phantom: _serde::export::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -734,7 +737,7 @@ fn serialize_adjacently_tagged_variant(
         try!(_serde::ser::SerializeStruct::serialize_field(
             &mut __struct, #content, &__AdjacentlyTagged {
                 data: (#(#fields_ident,)*),
-                phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                phantom: _serde::__private::PhantomData::<#this #ty_generics>,
             }));
         _serde::ser::SerializeStruct::end(__struct)
     }
@@ -975,18 +978,18 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 struct __EnumFlatten #wrapper_generics #where_clause {
                     data: (#(&'__a #fields_ty,)*),
-                    phantom: _serde::export::PhantomData<#this #ty_generics>,
+                    phantom: _serde::__private::PhantomData<#this #ty_generics>,
                 }
 
                 impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
-                    fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                    fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
                     where
                         __S: _serde::Serializer,
                     {
                         let (#(#members,)*) = self.data;
                         let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                             __serializer,
-                            _serde::export::None));
+                            _serde::__private::None));
                         #(#serialize_fields)*
                         _serde::ser::SerializeMap::end(__serde_state)
                     }
@@ -999,7 +1002,7 @@ fn serialize_struct_variant_with_flatten<'a>(
                     #variant_name,
                     &__EnumFlatten {
                         data: (#(#members,)*),
-                        phantom: _serde::export::PhantomData::<#this #ty_generics>,
+                        phantom: _serde::__private::PhantomData::<#this #ty_generics>,
                     })
             }
         }
@@ -1007,7 +1010,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                 try!(_serde::ser::SerializeMap::serialize_entry(
                     &mut __serde_state,
                     #tag,
@@ -1021,7 +1024,7 @@ fn serialize_struct_variant_with_flatten<'a>(
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
                     __serializer,
-                    _serde::export::None));
+                    _serde::__private::None));
                 #(#serialize_fields)*
                 _serde::ser::SerializeMap::end(__serde_state)
             }
@@ -1110,7 +1113,7 @@ fn serialize_struct_visitor(
             let ser = if field.attrs.flatten() {
                 let func = quote_spanned!(span=> _serde::Serialize::serialize);
                 quote! {
-                    try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+                    try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
                 }
             } else {
                 let func = struct_trait.serialize_field(span);
@@ -1205,11 +1208,11 @@ fn wrap_serialize_with(
     quote!({
         struct __SerializeWith #wrapper_impl_generics #where_clause {
             values: (#(&'__a #field_tys, )*),
-            phantom: _serde::export::PhantomData<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData<#this #ty_generics>,
         }
 
         impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
-            fn serialize<__S>(&self, __s: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+            fn serialize<__S>(&self, __s: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
             where
                 __S: _serde::Serializer,
             {
@@ -1219,7 +1222,7 @@ fn wrap_serialize_with(
 
         &__SerializeWith {
             values: (#(#field_exprs, )*),
-            phantom: _serde::export::PhantomData::<#this #ty_generics>,
+            phantom: _serde::__private::PhantomData::<#this #ty_generics>,
         }
     })
 }
@@ -1241,15 +1244,25 @@ 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))
+            quote!(_serde::__private::ser::constrain::<#ty>(#inner))
         }
         (true, Some(getter)) => {
             let ty = field.ty;
-            quote!(_serde::private::ser::constrain::<#ty>(&#getter(#self_var)))
+            quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
         }
         (false, Some(_)) => {
             unreachable!("getter is only allowed for remote impls");

serde_derive/src/try.rs

@@ -13,9 +13,9 @@ pub fn replacement() -> TokenStream {
         macro_rules! try {
             (#dollar __expr:expr) => {
                 match #dollar __expr {
-                    _serde::export::Ok(__val) => __val,
-                    _serde::export::Err(__err) => {
-                        return _serde::export::Err(__err);
+                    _serde::__private::Ok(__val) => __val,
+                    _serde::__private::Err(__err) => {
+                        return _serde::__private::Err(__err);
                     }
                 }
             }

serde_derive_internals/Cargo.toml

@@ -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"]

serde_derive_internals/lib.rs

@@ -6,8 +6,11 @@
     allow(
         cognitive_complexity,
         redundant_field_names,
+        result_unit_err,
         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,
     )
 )]
 

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "1.0.105" # remember to update html_root_url
+version = "1.0.121" # 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"]

serde_test/src/lib.rs

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

test_suite/Cargo.toml

@@ -7,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"
+trybuild = { version = "1.0.19", features = ["diff"] }

test_suite/build.rs

@@ -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");
     }
 }

test_suite/tests/expand/default_ty_param.expanded.rs

@@ -8,14 +8,17 @@ 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> {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -24,9 +27,9 @@ const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
                 "DefaultTyParam",
                 false as usize + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(
@@ -34,23 +37,23 @@ const _IMPL_SERIALIZE_FOR_DefaultTyParam: () = {
                 "phantom",
                 &self.phantom,
             ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
         }
     }
 };
+#[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> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -64,47 +67,52 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 1",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "phantom" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"phantom" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -112,76 +120,77 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 }
             }
             struct __Visitor<'de, T: AssociatedType<X = i32>> {
-                marker: _serde::export::PhantomData<DefaultTyParam<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<DefaultTyParam<T>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> {
                 type Value = DefaultTyParam<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>(
                         &mut __seq,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct DefaultTyParam with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<PhantomData<T>> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
+                    let mut __field0: _serde::__private::Option<PhantomData<T>> =
+                        _serde::__private::None;
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                if _serde::__private::Option::is_some(&__field0) {
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field(
                                             "phantom",
                                         ),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<PhantomData<T>>(
                                         &mut __map,
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -191,25 +200,26 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("phantom")
-                        {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        _serde::__private::Some(__field0) => __field0,
+                        _serde::__private::None => {
+                            match _serde::__private::de::missing_field("phantom") {
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -218,15 +228,15 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 "DefaultTyParam",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DefaultTyParam<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<DefaultTyParam<T>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -240,47 +250,52 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 1",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "phantom" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"phantom" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"phantom" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -289,7 +304,7 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
             }
             struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> {
                 place: &'place mut DefaultTyParam<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, T>
@@ -297,55 +312,55 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.phantom),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct DefaultTyParam with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field(
                                             "phantom",
                                         ),
@@ -353,11 +368,11 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.phantom),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
@@ -367,23 +382,23 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.phantom = match _serde::private::de::missing_field("phantom") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        self.place.phantom = match _serde::__private::de::missing_field("phantom") {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -393,7 +408,7 @@ const _IMPL_DESERIALIZE_FOR_DefaultTyParam: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_enum.expanded.rs

@@ -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>
@@ -16,7 +16,10 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
         T: _serde::Serialize,
         U: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -44,27 +47,27 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
                         "Seq",
                         0 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -77,9 +80,9 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
                         "Map",
                         0 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -87,9 +90,9 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
                         "x",
                         x,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -97,9 +100,9 @@ const _IMPL_SERIALIZE_FOR_GenericEnum: () = {
                         "y",
                         y,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -108,10 +111,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>
@@ -119,7 +122,7 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -135,35 +138,38 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
+                        3u64 => _serde::__private::Ok(__Field::__field3),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"variant index 0 <= i < 4",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "Unit" => _serde::export::Ok(__Field::__field0),
-                        "NewType" => _serde::export::Ok(__Field::__field1),
-                        "Seq" => _serde::export::Ok(__Field::__field2),
-                        "Map" => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        "Unit" => _serde::__private::Ok(__Field::__field0),
+                        "NewType" => _serde::__private::Ok(__Field::__field1),
+                        "Seq" => _serde::__private::Ok(__Field::__field2),
+                        "Map" => _serde::__private::Ok(__Field::__field3),
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -171,18 +177,18 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"Unit" => _serde::export::Ok(__Field::__field0),
-                        b"NewType" => _serde::export::Ok(__Field::__field1),
-                        b"Seq" => _serde::export::Ok(__Field::__field2),
-                        b"Map" => _serde::export::Ok(__Field::__field3),
+                        b"Unit" => _serde::__private::Ok(__Field::__field0),
+                        b"NewType" => _serde::__private::Ok(__Field::__field1),
+                        b"Seq" => _serde::__private::Ok(__Field::__field2),
+                        b"Map" => _serde::__private::Ok(__Field::__field3),
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -191,7 +197,9 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -203,8 +211,8 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
             where
@@ -214,33 +222,33 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                 type Value = GenericEnum<T, U>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum GenericEnum")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "enum GenericEnum")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
                     match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
                         (__Field::__field0, __variant) => {
                             match _serde::de::VariantAccess::unit_variant(__variant) {
-                                _serde::export::Ok(__val) => __val,
-                                _serde::export::Err(__err) => {
-                                    return _serde::export::Err(__err);
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
                                 }
                             };
-                            _serde::export::Ok(GenericEnum::Unit)
+                            _serde::__private::Ok(GenericEnum::Unit)
                         }
-                        (__Field::__field1, __variant) => _serde::export::Result::map(
+                        (__Field::__field1, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<T>(__variant),
                             GenericEnum::NewType,
                         ),
@@ -250,8 +258,8 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
                             {
-                                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
                             where
@@ -261,9 +269,10 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 type Value = GenericEnum<T, U>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant GenericEnum::Seq",
                                     )
@@ -272,7 +281,7 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -281,14 +290,14 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -296,25 +305,25 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "tuple variant GenericEnum::Seq with 2 elements" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Seq(__field0, __field1))
+                                    _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
                                 __variant,
                                 2usize,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -330,9 +339,10 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -340,43 +350,45 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        1u64 => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 2",
-                                        )),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
+                                        1u64 => _serde::__private::Ok(__Field::__field1),
+                                        _ => _serde::__private::Err(
+                                            _serde::de::Error::invalid_value(
+                                                _serde::de::Unexpected::Unsigned(__value),
+                                                &"field index 0 <= i < 2",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "x" => _serde::export::Ok(__Field::__field0),
-                                        "y" => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        "x" => _serde::__private::Ok(__Field::__field0),
+                                        "y" => _serde::__private::Ok(__Field::__field1),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"x" => _serde::export::Ok(__Field::__field0),
-                                        b"y" => _serde::export::Ok(__Field::__field1),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        b"x" => _serde::__private::Ok(__Field::__field0),
+                                        b"y" => _serde::__private::Ok(__Field::__field1),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -384,7 +396,7 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -399,8 +411,8 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
                             {
-                                marker: _serde::export::PhantomData<GenericEnum<T, U>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
                             where
@@ -410,9 +422,10 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 type Value = GenericEnum<T, U>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant GenericEnum::Map",
                                     )
@@ -421,7 +434,7 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -430,14 +443,14 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant GenericEnum::Map with 2 elements")) ;
                                         }
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -445,17 +458,17 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 1usize , & "struct variant GenericEnum::Map with 2 elements" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "struct variant GenericEnum::Map with 2 elements")) ;
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Map {
+                                    _serde::__private::Ok(GenericEnum::Map {
                                         x: __field0,
                                         y: __field1,
                                     })
@@ -464,50 +477,50 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<T> =
-                                        _serde::export::None;
-                                    let mut __field1: _serde::export::Option<U> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
+                                    let mut __field0: _serde::__private::Option<T> =
+                                        _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<U> =
+                                        _serde::__private::None;
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                            _serde::__private::Ok(__val) => __val,
+                                            _serde::__private::Err(__err) => {
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "x" ) ) ;
+                                                if _serde::__private::Option::is_some(&__field0) {
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<T>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                        _serde::__private::Ok(__val) => __val,
+                                                        _serde::__private::Err(__err) => {
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
                                             }
                                             __Field::__field1 => {
-                                                if _serde::export::Option::is_some(&__field1) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "y" ) ) ;
+                                                if _serde::__private::Option::is_some(&__field1) {
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ;
                                                 }
-                                                __field1 = _serde::export::Some(
+                                                __field1 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<U>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                        _serde::__private::Ok(__val) => __val,
+                                                        _serde::__private::Err(__err) => {
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -518,37 +531,37 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                    _serde::__private::Ok(__val) => __val,
+                                                    _serde::__private::Err(__err) => {
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("x") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                        _serde::__private::Some(__field0) => __field0,
+                                        _serde::__private::None => {
+                                            match _serde::__private::de::missing_field("x") {
+                                                _serde::__private::Ok(__val) => __val,
+                                                _serde::__private::Err(__err) => {
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
                                     let __field1 = match __field1 {
-                                        _serde::export::Some(__field1) => __field1,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("y") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                        _serde::__private::Some(__field1) => __field1,
+                                        _serde::__private::None => {
+                                            match _serde::__private::de::missing_field("y") {
+                                                _serde::__private::Ok(__val) => __val,
+                                                _serde::__private::Err(__err) => {
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(GenericEnum::Map {
+                                    _serde::__private::Ok(GenericEnum::Map {
                                         x: __field0,
                                         y: __field1,
                                     })
@@ -559,8 +572,8 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -573,8 +586,8 @@ const _IMPL_DESERIALIZE_FOR_GenericEnum: () = {
                 "GenericEnum",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericEnum<T, U>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_struct.expanded.rs

@@ -2,17 +2,20 @@ 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>
     where
         T: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -21,32 +24,32 @@ const _IMPL_SERIALIZE_FOR_GenericStruct: () = {
                 "GenericStruct",
                 false as usize + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
         }
     }
 };
+#[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>
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -60,47 +63,52 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 1",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "x" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"x" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -111,8 +119,8 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
             where
                 T: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericStruct<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<GenericStruct<T>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
             where
@@ -121,64 +129,64 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 type Value = GenericStruct<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct GenericStruct with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
+                    _serde::__private::Ok(GenericStruct { x: __field0 })
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<T> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
+                    let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                if _serde::__private::Option::is_some(&__field0) {
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("x"),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -188,24 +196,26 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("x") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        _serde::__private::Some(__field0) => __field0,
+                        _serde::__private::None => {
+                            match _serde::__private::de::missing_field("x") {
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(GenericStruct { x: __field0 })
+                    _serde::__private::Ok(GenericStruct { x: __field0 })
                 }
             }
             const FIELDS: &'static [&'static str] = &["x"];
@@ -214,15 +224,15 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 "GenericStruct",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<GenericStruct<T>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -236,47 +246,52 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 1",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "x" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"x" => _serde::export::Ok(__Field::__field0),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"x" => _serde::__private::Ok(__Field::__field0),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -288,7 +303,7 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 T: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericStruct<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
             where
@@ -297,65 +312,65 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct GenericStruct")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.x),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.x),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct GenericStruct with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("x"),
                                     );
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.x),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.x),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
@@ -365,23 +380,23 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.x = match _serde::private::de::missing_field("x") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        self.place.x = match _serde::__private::de::missing_field("x") {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["x"];
@@ -391,24 +406,27 @@ const _IMPL_DESERIALIZE_FOR_GenericStruct: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
     }
 };
 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>
     where
         T: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -420,17 +438,17 @@ 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>
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -438,8 +456,8 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
             where
                 T: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericNewTypeStruct<T>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
             where
@@ -448,9 +466,9 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 type Value = GenericNewTypeStruct<T>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericNewTypeStruct",
                     )
@@ -459,57 +477,57 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 fn visit_newtype_struct<__E>(
                     self,
                     __e: __E,
-                ) -> _serde::export::Result<Self::Value, __E::Error>
+                ) -> _serde::__private::Result<Self::Value, __E::Error>
                 where
                     __E: _serde::Deserializer<'de>,
                 {
                     let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
+                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct GenericNewTypeStruct with 1 element",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericNewTypeStruct(__field0))
+                    _serde::__private::Ok(GenericNewTypeStruct(__field0))
                 }
             }
             _serde::Deserializer::deserialize_newtype_struct(
                 __deserializer,
                 "GenericNewTypeStruct",
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericNewTypeStruct<T>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -518,7 +536,7 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 T: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericNewTypeStruct<T>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
             where
@@ -527,9 +545,9 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericNewTypeStruct",
                     )
@@ -538,7 +556,7 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 fn visit_newtype_struct<__E>(
                     self,
                     __e: __E,
-                ) -> _serde::export::Result<Self::Value, __E::Error>
+                ) -> _serde::__private::Result<Self::Value, __E::Error>
                 where
                     __E: _serde::Deserializer<'de>,
                 {
@@ -548,25 +566,25 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"tuple struct GenericNewTypeStruct with 1 element",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_newtype_struct(
@@ -574,7 +592,7 @@ const _IMPL_DESERIALIZE_FOR_GenericNewTypeStruct: () = {
                 "GenericNewTypeStruct",
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/generic_tuple_struct.expanded.rs

@@ -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>
@@ -11,7 +11,7 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -20,8 +20,8 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<GenericTupleStruct<T, U>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<GenericTupleStruct<T, U>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
             where
@@ -31,9 +31,9 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 type Value = GenericTupleStruct<T, U>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericTupleStruct",
                     )
@@ -42,20 +42,20 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct GenericTupleStruct with 2 elements",
                             ));
@@ -63,20 +63,20 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"tuple struct GenericTupleStruct with 2 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(GenericTupleStruct(__field0, __field1))
+                    _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -84,15 +84,15 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 "GenericTupleStruct",
                 2usize,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<GenericTupleStruct<T, U>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<GenericTupleStruct<T, U>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -102,7 +102,7 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 U: _serde::Deserialize<'de>,
             {
                 place: &'place mut GenericTupleStruct<T, U>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U>
             where
@@ -112,9 +112,9 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
                         __formatter,
                         "tuple struct GenericTupleStruct",
                     )
@@ -123,39 +123,39 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"tuple struct GenericTupleStruct with 2 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             1usize,
                             &"tuple struct GenericTupleStruct with 2 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -164,7 +164,7 @@ const _IMPL_DESERIALIZE_FOR_GenericTupleStruct: () = {
                 2usize,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/lifetimes.expanded.rs

@@ -5,14 +5,17 @@ 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> {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -43,9 +46,9 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
                         "LifetimeMap",
                         0 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -53,9 +56,9 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -68,9 +71,9 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
                         "NoLifetimeMap",
                         0 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -78,9 +81,9 @@ const _IMPL_SERIALIZE_FOR_Lifetimes: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -89,14 +92,14 @@ 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> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -112,35 +115,38 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        3u64 => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
+                        3u64 => _serde::__private::Ok(__Field::__field3),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"variant index 0 <= i < 4",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "LifetimeSeq" => _serde::export::Ok(__Field::__field0),
-                        "NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
-                        "LifetimeMap" => _serde::export::Ok(__Field::__field2),
-                        "NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        "LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
+                        "NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
+                        "LifetimeMap" => _serde::__private::Ok(__Field::__field2),
+                        "NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -148,18 +154,18 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"LifetimeSeq" => _serde::export::Ok(__Field::__field0),
-                        b"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1),
-                        b"LifetimeMap" => _serde::export::Ok(__Field::__field2),
-                        b"NoLifetimeMap" => _serde::export::Ok(__Field::__field3),
+                        b"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
+                        b"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
+                        b"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
+                        b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -168,7 +174,9 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -176,35 +184,35 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                 }
             }
             struct __Visitor<'de, 'a> {
-                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
                 type Value = Lifetimes<'a>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Lifetimes")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "enum Lifetimes")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
                     match match _serde::de::EnumAccess::variant(__data) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        (__Field::__field0, __variant) => _serde::export::Result::map(
+                        (__Field::__field0, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
                             Lifetimes::LifetimeSeq,
                         ),
-                        (__Field::__field1, __variant) => _serde::export::Result::map(
+                        (__Field::__field1, __variant) => _serde::__private::Result::map(
                             _serde::de::VariantAccess::newtype_variant::<i32>(__variant),
                             Lifetimes::NoLifetimeSeq,
                         ),
@@ -219,9 +227,10 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -229,40 +238,42 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 1",
-                                        )),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Err(
+                                            _serde::de::Error::invalid_value(
+                                                _serde::de::Unexpected::Unsigned(__value),
+                                                &"field index 0 <= i < 1",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        "a" => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        b"a" => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -270,7 +281,7 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -281,16 +292,17 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 }
                             }
                             struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::LifetimeMap",
                                     )
@@ -299,7 +311,7 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -308,49 +320,49 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::LifetimeMap with 1 element" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::LifetimeMap with 1 element")) ;
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<&'a i32> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
+                                    let mut __field0: _serde::__private::Option<&'a i32> =
+                                        _serde::__private::None;
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                            _serde::__private::Ok(__val) => __val,
+                                            _serde::__private::Err(__err) => {
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
+                                                if _serde::__private::Option::is_some(&__field0) {
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<&'a i32>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                        _serde::__private::Ok(__val) => __val,
+                                                        _serde::__private::Err(__err) => {
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -361,26 +373,26 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                    _serde::__private::Ok(__val) => __val,
+                                                    _serde::__private::Err(__err) => {
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                        _serde::__private::Some(__field0) => __field0,
+                                        _serde::__private::None => {
+                                            match _serde::__private::de::missing_field("a") {
+                                                _serde::__private::Ok(__val) => __val,
+                                                _serde::__private::Err(__err) => {
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -388,8 +400,8 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -404,9 +416,10 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 type Value = __Field;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
                                     )
@@ -414,40 +427,42 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 fn visit_u64<__E>(
                                     self,
                                     __value: u64,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        0u64 => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
-                                            _serde::de::Unexpected::Unsigned(__value),
-                                            &"field index 0 <= i < 1",
-                                        )),
+                                        0u64 => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Err(
+                                            _serde::de::Error::invalid_value(
+                                                _serde::de::Unexpected::Unsigned(__value),
+                                                &"field index 0 <= i < 1",
+                                            ),
+                                        ),
                                     }
                                 }
                                 fn visit_str<__E>(
                                     self,
                                     __value: &str,
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        "a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        "a" => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                                 fn visit_bytes<__E>(
                                     self,
                                     __value: &[u8],
-                                ) -> _serde::export::Result<Self::Value, __E>
+                                ) -> _serde::__private::Result<Self::Value, __E>
                                 where
                                     __E: _serde::de::Error,
                                 {
                                     match __value {
-                                        b"a" => _serde::export::Ok(__Field::__field0),
-                                        _ => _serde::export::Ok(__Field::__ignore),
+                                        b"a" => _serde::__private::Ok(__Field::__field0),
+                                        _ => _serde::__private::Ok(__Field::__ignore),
                                     }
                                 }
                             }
@@ -455,7 +470,7 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 #[inline]
                                 fn deserialize<__D>(
                                     __deserializer: __D,
-                                ) -> _serde::export::Result<Self, __D::Error>
+                                ) -> _serde::__private::Result<Self, __D::Error>
                                 where
                                     __D: _serde::Deserializer<'de>,
                                 {
@@ -466,16 +481,17 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 }
                             }
                             struct __Visitor<'de, 'a> {
-                                marker: _serde::export::PhantomData<Lifetimes<'a>>,
-                                lifetime: _serde::export::PhantomData<&'de ()>,
+                                marker: _serde::__private::PhantomData<Lifetimes<'a>>,
+                                lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
                             impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
-                                    __formatter: &mut _serde::export::Formatter,
-                                ) -> _serde::export::fmt::Result {
-                                    _serde::export::Formatter::write_str(
+                                    __formatter: &mut _serde::__private::Formatter,
+                                ) -> _serde::__private::fmt::Result
+                                {
+                                    _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::NoLifetimeMap",
                                     )
@@ -484,7 +500,7 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 fn visit_seq<__A>(
                                     self,
                                     mut __seq: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::SeqAccess<'de>,
                                 {
@@ -493,49 +509,49 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                     >(
                                         &mut __seq
                                     ) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     } {
-                                        _serde::export::Some(__value) => __value,
-                                        _serde::export::None => {
-                                            return _serde :: export :: Err ( _serde :: de :: Error :: invalid_length ( 0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element" ) ) ;
+                                        _serde::__private::Some(__value) => __value,
+                                        _serde::__private::None => {
+                                            return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element")) ;
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
                                     self,
                                     mut __map: __A,
-                                ) -> _serde::export::Result<Self::Value, __A::Error>
+                                ) -> _serde::__private::Result<Self::Value, __A::Error>
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::export::Option<i32> =
-                                        _serde::export::None;
-                                    while let _serde::export::Some(__key) =
+                                    let mut __field0: _serde::__private::Option<i32> =
+                                        _serde::__private::None;
+                                    while let _serde::__private::Some(__key) =
                                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
                                         {
-                                            _serde::export::Ok(__val) => __val,
-                                            _serde::export::Err(__err) => {
-                                                return _serde::export::Err(__err);
+                                            _serde::__private::Ok(__val) => __val,
+                                            _serde::__private::Err(__err) => {
+                                                return _serde::__private::Err(__err);
                                             }
                                         }
                                     {
                                         match __key {
                                             __Field::__field0 => {
-                                                if _serde::export::Option::is_some(&__field0) {
-                                                    return _serde :: export :: Err ( < __A :: Error as _serde :: de :: Error > :: duplicate_field ( "a" ) ) ;
+                                                if _serde::__private::Option::is_some(&__field0) {
+                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
                                                 }
-                                                __field0 = _serde::export::Some(
+                                                __field0 = _serde::__private::Some(
                                                     match _serde::de::MapAccess::next_value::<i32>(
                                                         &mut __map,
                                                     ) {
-                                                        _serde::export::Ok(__val) => __val,
-                                                        _serde::export::Err(__err) => {
-                                                            return _serde::export::Err(__err);
+                                                        _serde::__private::Ok(__val) => __val,
+                                                        _serde::__private::Err(__err) => {
+                                                            return _serde::__private::Err(__err);
                                                         }
                                                     },
                                                 );
@@ -546,26 +562,26 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                                 >(
                                                     &mut __map
                                                 ) {
-                                                    _serde::export::Ok(__val) => __val,
-                                                    _serde::export::Err(__err) => {
-                                                        return _serde::export::Err(__err);
+                                                    _serde::__private::Ok(__val) => __val,
+                                                    _serde::__private::Err(__err) => {
+                                                        return _serde::__private::Err(__err);
                                                     }
                                                 };
                                             }
                                         }
                                     }
                                     let __field0 = match __field0 {
-                                        _serde::export::Some(__field0) => __field0,
-                                        _serde::export::None => {
-                                            match _serde::private::de::missing_field("a") {
-                                                _serde::export::Ok(__val) => __val,
-                                                _serde::export::Err(__err) => {
-                                                    return _serde::export::Err(__err);
+                                        _serde::__private::Some(__field0) => __field0,
+                                        _serde::__private::None => {
+                                            match _serde::__private::de::missing_field("a") {
+                                                _serde::__private::Ok(__val) => __val,
+                                                _serde::__private::Err(__err) => {
+                                                    return _serde::__private::Err(__err);
                                                 }
                                             }
                                         }
                                     };
-                                    _serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -573,8 +589,8 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                                 __variant,
                                 FIELDS,
                                 __Visitor {
-                                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                                    lifetime: _serde::export::PhantomData,
+                                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
+                                    lifetime: _serde::__private::PhantomData,
                                 },
                             )
                         }
@@ -592,8 +608,8 @@ const _IMPL_DESERIALIZE_FOR_Lifetimes: () = {
                 "Lifetimes",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<Lifetimes<'a>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_map.expanded.rs

@@ -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>
@@ -16,7 +16,10 @@ const _IMPL_SERIALIZE_FOR_SerNamedMap: () = {
         B: _serde::Serialize,
         C: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -25,27 +28,27 @@ const _IMPL_SERIALIZE_FOR_SerNamedMap: () = {
                 "SerNamedMap",
                 false as usize + 1 + 1 + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeStruct::end(__serde_state)
@@ -57,10 +60,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>
@@ -69,7 +72,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -85,53 +88,58 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 3",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "a" => _serde::__private::Ok(__Field::__field0),
+                        "b" => _serde::__private::Ok(__Field::__field1),
+                        "c" => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"a" => _serde::__private::Ok(__Field::__field0),
+                        b"b" => _serde::__private::Ok(__Field::__field1),
+                        b"c" => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -144,8 +152,8 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 B: _serde::Deserialize<'de>,
                 C: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<DeNamedMap<A, B, C>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<DeNamedMap<A, B, C>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
             where
@@ -156,28 +164,28 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 type Value = DeNamedMap<A, B, C>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
@@ -185,14 +193,14 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
@@ -200,20 +208,20 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                     };
                     let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 2usize,
                                 &"struct DeNamedMap with 3 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(DeNamedMap {
+                    _serde::__private::Ok(DeNamedMap {
                         a: __field0,
                         b: __field1,
                         c: __field2,
@@ -223,63 +231,63 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::export::Option<A> = _serde::export::None;
-                    let mut __field1: _serde::export::Option<B> = _serde::export::None;
-                    let mut __field2: _serde::export::Option<C> = _serde::export::None;
-                    while let _serde::export::Some(__key) =
+                    let mut __field0: _serde::__private::Option<A> = _serde::__private::None;
+                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
+                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
-                                if _serde::export::Option::is_some(&__field0) {
-                                    return _serde::export::Err(
+                                if _serde::__private::Option::is_some(&__field0) {
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("a"),
                                     );
                                 }
-                                __field0 = _serde::export::Some(
+                                __field0 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<A>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
                             }
                             __Field::__field1 => {
-                                if _serde::export::Option::is_some(&__field1) {
-                                    return _serde::export::Err(
+                                if _serde::__private::Option::is_some(&__field1) {
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("b"),
                                     );
                                 }
-                                __field1 = _serde::export::Some(
+                                __field1 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<B>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
                             }
                             __Field::__field2 => {
-                                if _serde::export::Option::is_some(&__field2) {
-                                    return _serde::export::Err(
+                                if _serde::__private::Option::is_some(&__field2) {
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("c"),
                                     );
                                 }
-                                __field2 = _serde::export::Some(
+                                __field2 = _serde::__private::Some(
                                     match _serde::de::MapAccess::next_value::<C>(&mut __map) {
-                                        _serde::export::Ok(__val) => __val,
-                                        _serde::export::Err(__err) => {
-                                            return _serde::export::Err(__err);
+                                        _serde::__private::Ok(__val) => __val,
+                                        _serde::__private::Err(__err) => {
+                                            return _serde::__private::Err(__err);
                                         }
                                     },
                                 );
@@ -289,42 +297,48 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     let __field0 = match __field0 {
-                        _serde::export::Some(__field0) => __field0,
-                        _serde::export::None => match _serde::private::de::missing_field("a") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        _serde::__private::Some(__field0) => __field0,
+                        _serde::__private::None => {
+                            match _serde::__private::de::missing_field("a") {
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
                     let __field1 = match __field1 {
-                        _serde::export::Some(__field1) => __field1,
-                        _serde::export::None => match _serde::private::de::missing_field("b") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        _serde::__private::Some(__field1) => __field1,
+                        _serde::__private::None => {
+                            match _serde::__private::de::missing_field("b") {
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
                     let __field2 = match __field2 {
-                        _serde::export::Some(__field2) => __field2,
-                        _serde::export::None => match _serde::private::de::missing_field("c") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        _serde::__private::Some(__field2) => __field2,
+                        _serde::__private::None => {
+                            match _serde::__private::de::missing_field("c") {
+                                _serde::__private::Ok(__val) => __val,
+                                _serde::__private::Err(__err) => {
+                                    return _serde::__private::Err(__err);
+                                }
                             }
-                        },
+                        }
                     };
-                    _serde::export::Ok(DeNamedMap {
+                    _serde::__private::Ok(DeNamedMap {
                         a: __field0,
                         b: __field1,
                         c: __field2,
@@ -337,15 +351,15 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 "DeNamedMap",
                 FIELDS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DeNamedMap<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<DeNamedMap<A, B, C>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -361,53 +375,58 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "field identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        0u64 => _serde::export::Ok(__Field::__field0),
-                        1u64 => _serde::export::Ok(__Field::__field1),
-                        2u64 => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        0u64 => _serde::__private::Ok(__Field::__field0),
+                        1u64 => _serde::__private::Ok(__Field::__field1),
+                        2u64 => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"field index 0 <= i < 3",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        "a" => _serde::export::Ok(__Field::__field0),
-                        "b" => _serde::export::Ok(__Field::__field1),
-                        "c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        "a" => _serde::__private::Ok(__Field::__field0),
+                        "b" => _serde::__private::Ok(__Field::__field1),
+                        "c" => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        b"a" => _serde::export::Ok(__Field::__field0),
-                        b"b" => _serde::export::Ok(__Field::__field1),
-                        b"c" => _serde::export::Ok(__Field::__field2),
-                        _ => _serde::export::Ok(__Field::__ignore),
+                        b"a" => _serde::__private::Ok(__Field::__field0),
+                        b"b" => _serde::__private::Ok(__Field::__field1),
+                        b"c" => _serde::__private::Ok(__Field::__field2),
+                        _ => _serde::__private::Ok(__Field::__ignore),
                     }
                 }
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -421,7 +440,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 C: _serde::Deserialize<'de>,
             {
                 place: &'place mut DeNamedMap<A, B, C>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, A, B, C>
@@ -433,129 +452,129 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.a),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.a),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.b),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.b),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             1usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.c),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.c),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             2usize,
                             &"struct DeNamedMap with 3 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
                 #[inline]
                 fn visit_map<__A>(
                     self,
                     mut __map: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
                     let mut __field1: bool = false;
                     let mut __field2: bool = false;
-                    while let _serde::export::Some(__key) =
+                    while let _serde::__private::Some(__key) =
                         match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         }
                     {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("a"),
                                     );
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.a),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.a),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field0 = true;
                             }
                             __Field::__field1 => {
                                 if __field1 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("b"),
                                     );
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.b),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.b),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field1 = true;
                             }
                             __Field::__field2 => {
                                 if __field2 {
-                                    return _serde::export::Err(
+                                    return _serde::__private::Err(
                                         <__A::Error as _serde::de::Error>::duplicate_field("c"),
                                     );
                                 }
                                 match _serde::de::MapAccess::next_value_seed(
                                     &mut __map,
-                                    _serde::private::de::InPlaceSeed(&mut self.place.c),
+                                    _serde::__private::de::InPlaceSeed(&mut self.place.c),
                                 ) {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                                 __field2 = true;
@@ -565,39 +584,39 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                                     _serde::de::IgnoredAny,
                                 >(&mut __map)
                                 {
-                                    _serde::export::Ok(__val) => __val,
-                                    _serde::export::Err(__err) => {
-                                        return _serde::export::Err(__err);
+                                    _serde::__private::Ok(__val) => __val,
+                                    _serde::__private::Err(__err) => {
+                                        return _serde::__private::Err(__err);
                                     }
                                 };
                             }
                         }
                     }
                     if !__field0 {
-                        self.place.a = match _serde::private::de::missing_field("a") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        self.place.a = match _serde::__private::de::missing_field("a") {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
                     if !__field1 {
-                        self.place.b = match _serde::private::de::missing_field("b") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        self.place.b = match _serde::__private::de::missing_field("b") {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
                     if !__field2 {
-                        self.place.c = match _serde::private::de::missing_field("c") {
-                            _serde::export::Ok(__val) => __val,
-                            _serde::export::Err(__err) => {
-                                return _serde::export::Err(__err);
+                        self.place.c = match _serde::__private::de::missing_field("c") {
+                            _serde::__private::Ok(__val) => __val,
+                            _serde::__private::Err(__err) => {
+                                return _serde::__private::Err(__err);
                             }
                         };
                     };
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             const FIELDS: &'static [&'static str] = &["a", "b", "c"];
@@ -607,7 +626,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedMap: () = {
                 FIELDS,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_tuple.expanded.rs

@@ -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>
@@ -12,7 +12,10 @@ const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
         B: _serde::Serialize,
         C: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -21,27 +24,27 @@ const _IMPL_SERIALIZE_FOR_SerNamedTuple: () = {
                 "SerNamedTuple",
                 0 + 1 + 1 + 1,
             ) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) {
-                _serde::export::Ok(__val) => __val,
-                _serde::export::Err(__err) => {
-                    return _serde::export::Err(__err);
+                _serde::__private::Ok(__val) => __val,
+                _serde::__private::Err(__err) => {
+                    return _serde::__private::Err(__err);
                 }
             };
             _serde::ser::SerializeTupleStruct::end(__serde_state)
@@ -49,10 +52,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>
@@ -61,7 +64,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -71,8 +74,8 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 B: _serde::Deserialize<'de>,
                 C: _serde::Deserialize<'de>,
             {
-                marker: _serde::export::PhantomData<DeNamedTuple<A, B, C>>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<DeNamedTuple<A, B, C>>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
             where
@@ -83,28 +86,31 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 type Value = DeNamedTuple<A, B, C>;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "tuple struct DeNamedTuple",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
                     let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 0usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
@@ -112,14 +118,14 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                     };
                     let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 1usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
@@ -127,20 +133,20 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                     };
                     let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
                     {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        _serde::export::Some(__value) => __value,
-                        _serde::export::None => {
-                            return _serde::export::Err(_serde::de::Error::invalid_length(
+                        _serde::__private::Some(__value) => __value,
+                        _serde::__private::None => {
+                            return _serde::__private::Err(_serde::de::Error::invalid_length(
                                 2usize,
                                 &"tuple struct DeNamedTuple with 3 elements",
                             ));
                         }
                     };
-                    _serde::export::Ok(DeNamedTuple(__field0, __field1, __field2))
+                    _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -148,15 +154,15 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 "DeNamedTuple",
                 3usize,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<DeNamedTuple<A, B, C>>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<DeNamedTuple<A, B, C>>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }
         fn deserialize_in_place<__D>(
             __deserializer: __D,
             __place: &mut Self,
-        ) -> _serde::export::Result<(), __D::Error>
+        ) -> _serde::__private::Result<(), __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -167,7 +173,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 C: _serde::Deserialize<'de>,
             {
                 place: &'place mut DeNamedTuple<A, B, C>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
                 for __Visitor<'de, 'place, A, B, C>
@@ -179,61 +185,64 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 type Value = ();
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "tuple struct DeNamedTuple",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
                     self,
                     mut __seq: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.0),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             0usize,
                             &"tuple struct DeNamedTuple with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.1),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             1usize,
                             &"tuple struct DeNamedTuple with 3 elements",
                         ));
                     }
-                    if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
                         &mut __seq,
-                        _serde::private::de::InPlaceSeed(&mut self.place.2),
+                        _serde::__private::de::InPlaceSeed(&mut self.place.2),
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     } {
-                        return _serde::export::Err(_serde::de::Error::invalid_length(
+                        return _serde::__private::Err(_serde::de::Error::invalid_length(
                             2usize,
                             &"tuple struct DeNamedTuple with 3 elements",
                         ));
                     }
-                    _serde::export::Ok(())
+                    _serde::__private::Ok(())
                 }
             }
             _serde::Deserializer::deserialize_tuple_struct(
@@ -242,7 +251,7 @@ const _IMPL_DESERIALIZE_FOR_DeNamedTuple: () = {
                 3usize,
                 __Visitor {
                     place: __place,
-                    lifetime: _serde::export::PhantomData,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expand/named_unit.expanded.rs

@@ -1,13 +1,16 @@
 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 {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -15,14 +18,14 @@ 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 {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -31,16 +34,16 @@ const _IMPL_DESERIALIZE_FOR_NamedUnit: () = {
                 type Value = NamedUnit;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "unit struct NamedUnit")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "unit struct NamedUnit")
                 }
                 #[inline]
-                fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
+                fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
-                    _serde::export::Ok(NamedUnit)
+                    _serde::__private::Ok(NamedUnit)
                 }
             }
             _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)

test_suite/tests/expand/ser_enum.expanded.rs

@@ -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>
@@ -23,7 +23,10 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
         C: _serde::Serialize,
         D: _serde::Serialize,
     {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -42,45 +45,45 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "Seq",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field2,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field3,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -98,9 +101,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "Map",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -108,9 +111,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -118,9 +121,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "b",
                         b,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -128,9 +131,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "c",
                         c,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -138,9 +141,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "d",
                         d,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -159,45 +162,45 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "_Seq2",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field0,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field2,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeTupleVariant::serialize_field(
                         &mut __serde_state,
                         __field3,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -215,9 +218,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "_Map2",
                         0 + 1 + 1 + 1 + 1,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -225,9 +228,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "a",
                         a,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -235,9 +238,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "b",
                         b,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -245,9 +248,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "c",
                         c,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     match _serde::ser::SerializeStructVariant::serialize_field(
@@ -255,9 +258,9 @@ const _IMPL_SERIALIZE_FOR_SerEnum: () = {
                         "d",
                         d,
                     ) {
-                        _serde::export::Ok(__val) => __val,
-                        _serde::export::Err(__err) => {
-                            return _serde::export::Err(__err);
+                        _serde::__private::Ok(__val) => __val,
+                        _serde::__private::Err(__err) => {
+                            return _serde::__private::Err(__err);
                         }
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)

test_suite/tests/expand/void.expanded.rs

@@ -1,13 +1,16 @@
 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 {
-        fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+        fn serialize<__S>(
+            &self,
+            __serializer: __S,
+        ) -> _serde::__private::Result<__S::Ok, __S::Error>
         where
             __S: _serde::Serializer,
         {
@@ -15,14 +18,14 @@ 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 {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -33,27 +36,30 @@ const _IMPL_DESERIALIZE_FOR_Void: () = {
                 type Value = __Field;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "variant identifier")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::export::Err(_serde::de::Error::invalid_value(
+                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
                             _serde::de::Unexpected::Unsigned(__value),
                             &"variant index 0 <= i < 0",
                         )),
                     }
                 }
-                fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+                fn visit_str<__E>(
+                    self,
+                    __value: &str,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::export::Err(_serde::de::Error::unknown_variant(
+                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
                             __value, VARIANTS,
                         )),
                     }
@@ -61,14 +67,14 @@ const _IMPL_DESERIALIZE_FOR_Void: () = {
                 fn visit_bytes<__E>(
                     self,
                     __value: &[u8],
-                ) -> _serde::export::Result<Self::Value, __E>
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
                     match __value {
                         _ => {
-                            let __value = &_serde::export::from_utf8_lossy(__value);
-                            _serde::export::Err(_serde::de::Error::unknown_variant(
+                            let __value = &_serde::__private::from_utf8_lossy(__value);
+                            _serde::__private::Err(_serde::de::Error::unknown_variant(
                                 __value, VARIANTS,
                             ))
                         }
@@ -77,7 +83,9 @@ const _IMPL_DESERIALIZE_FOR_Void: () = {
             }
             impl<'de> _serde::Deserialize<'de> for __Field {
                 #[inline]
-                fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+                fn deserialize<__D>(
+                    __deserializer: __D,
+                ) -> _serde::__private::Result<Self, __D::Error>
                 where
                     __D: _serde::Deserializer<'de>,
                 {
@@ -85,25 +93,25 @@ const _IMPL_DESERIALIZE_FOR_Void: () = {
                 }
             }
             struct __Visitor<'de> {
-                marker: _serde::export::PhantomData<Void>,
-                lifetime: _serde::export::PhantomData<&'de ()>,
+                marker: _serde::__private::PhantomData<Void>,
+                lifetime: _serde::__private::PhantomData<&'de ()>,
             }
             impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
                 type Value = Void;
                 fn expecting(
                     &self,
-                    __formatter: &mut _serde::export::Formatter,
-                ) -> _serde::export::fmt::Result {
-                    _serde::export::Formatter::write_str(__formatter, "enum Void")
+                    __formatter: &mut _serde::__private::Formatter,
+                ) -> _serde::__private::fmt::Result {
+                    _serde::__private::Formatter::write_str(__formatter, "enum Void")
                 }
                 fn visit_enum<__A>(
                     self,
                     __data: __A,
-                ) -> _serde::export::Result<Self::Value, __A::Error>
+                ) -> _serde::__private::Result<Self::Value, __A::Error>
                 where
                     __A: _serde::de::EnumAccess<'de>,
                 {
-                    _serde::export::Result::map(
+                    _serde::__private::Result::map(
                         _serde::de::EnumAccess::variant::<__Field>(__data),
                         |(__impossible, _)| match __impossible {},
                     )
@@ -115,8 +123,8 @@ const _IMPL_DESERIALIZE_FOR_Void: () = {
                 "Void",
                 VARIANTS,
                 __Visitor {
-                    marker: _serde::export::PhantomData::<Void>,
-                    lifetime: _serde::export::PhantomData,
+                    marker: _serde::__private::PhantomData::<Void>,
+                    lifetime: _serde::__private::PhantomData,
                 },
             )
         }

test_suite/tests/expandtest.rs

@@ -1,6 +1,7 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
-#[cfg_attr(not(cargo_expand), ignore)]
+#[cfg_attr(not(expandtest), ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[allow(unused_attributes)]
 #[test]
 fn expandtest() {
     macrotest::expand("tests/expand/*.rs");

test_suite/tests/test_annotations.rs

@@ -1,4 +1,8 @@
-#![allow(clippy::cast_lossless, clippy::trivially_copy_pass_by_ref)]
+#![allow(
+    clippy::cast_lossless,
+    clippy::from_over_into,
+    clippy::trivially_copy_pass_by_ref
+)]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -1967,6 +1971,29 @@ fn test_flatten_map_twice() {
     );
 }
 
+#[test]
+fn test_flatten_unit() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    struct Response<T> {
+        #[serde(flatten)]
+        data: T,
+        status: usize,
+    }
+
+    assert_tokens(
+        &Response {
+            data: (),
+            status: 0,
+        },
+        &[
+            Token::Map { len: None },
+            Token::Str("status"),
+            Token::U64(0),
+            Token::MapEnd,
+        ],
+    );
+}
+
 #[test]
 fn test_flatten_unsupported_type() {
     #[derive(Debug, PartialEq, Serialize, Deserialize)]

test_suite/tests/test_borrow.rs

@@ -90,6 +90,30 @@ fn test_struct() {
     );
 }
 
+#[test]
+fn test_field_identifier() {
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldStr<'a> {
+        #[serde(borrow)]
+        Str(&'a str),
+    }
+
+    assert_de_tokens(&FieldStr::Str("value"), &[Token::BorrowedStr("value")]);
+
+    #[derive(Deserialize, Debug, PartialEq)]
+    #[serde(field_identifier)]
+    enum FieldBytes<'a> {
+        #[serde(borrow)]
+        Bytes(&'a [u8]),
+    }
+
+    assert_de_tokens(
+        &FieldBytes::Bytes(b"value"),
+        &[Token::BorrowedBytes(b"value")],
+    );
+}
+
 #[test]
 fn test_cow() {
     #[derive(Deserialize)]

test_suite/tests/test_de.rs

@@ -1452,4 +1452,25 @@ declare_error_tests! {
         ],
         "invalid value: integer `65536`, expected u16",
     }
+    test_duration_overflow_seq<Duration> {
+        &[
+            Token::Seq { len: Some(2) },
+                Token::U64(u64::max_value()),
+                Token::U32(1_000_000_000),
+            Token::SeqEnd,
+        ],
+        "overflow deserializing Duration",
+    }
+    test_duration_overflow_struct<Duration> {
+        &[
+            Token::Struct { name: "Duration", len: 2 },
+                Token::Str("secs"),
+                Token::U64(u64::max_value()),
+
+                Token::Str("nanos"),
+                Token::U32(1_000_000_000),
+            Token::StructEnd,
+        ],
+        "overflow deserializing Duration",
+    }
 }

test_suite/tests/test_gen.rs

@@ -4,7 +4,11 @@
 
 #![deny(warnings)]
 #![cfg_attr(feature = "unstable", feature(non_ascii_idents))]
-#![allow(clippy::trivially_copy_pass_by_ref)]
+#![allow(
+    unknown_lints,
+    mixed_script_confusables,
+    clippy::trivially_copy_pass_by_ref
+)]
 
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
@@ -265,7 +269,7 @@ fn test_gen() {
     #[cfg(feature = "unstable")]
     #[derive(Serialize, Deserialize)]
     struct NonAsciiIdents {
-        σ:  f64,
+        σ: f64,
     }
 
     #[derive(Serialize, Deserialize)]
@@ -691,6 +695,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);
 }
 
 //////////////////////////////////////////////////////////////////////////

test_suite/tests/test_macros.rs

@@ -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,
+    }
+}

test_suite/tests/ui/remote/wrong_de.stderr

@@ -5,6 +5,6 @@ error[E0308]: mismatched types
   |          ^^^^^^^^^^^
   |          |
   |          expected `u16`, found `u8`
-  |          help: you can convert an `u8` to `u16`: `Deserialize.into()`
+  |          help: you can convert a `u8` to a `u16`: `Deserialize.into()`
   |
   = note: this error originates in a derive macro (in Nightly builds, run with -Z macro-backtrace for more info)