Run test suite on wa-serde-derive

Update macrotest to 1.0.9 and enable in CI

.gitattributes

@@ -0,0 +1 @@
+test_suite/tests/expand/*.expanded.rs linguist-generated

.github/workflows/ci.yml

@@ -13,15 +13,19 @@ jobs:
     name: Test suite
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable
+      - uses: dtolnay/install@cargo-expand
+        if: github.event_name != 'pull_request'
+      - run: cd test_suite && cargo test --features expandtest --test expandtest -- --include-ignored
+        if: github.event_name != 'pull_request'
 
   windows:
     name: Test suite (windows)
     runs-on: windows-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd test_suite && cargo test --features unstable -- --skip ui --exact
 
@@ -33,7 +37,7 @@ jobs:
       matrix:
         rust: [stable, beta]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -50,7 +54,7 @@ jobs:
       matrix:
         os: [ubuntu, windows]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - run: cd serde && cargo build
       - run: cd serde && cargo build --no-default-features
@@ -59,12 +63,16 @@ jobs:
       - run: cd serde && cargo test --features derive,rc,unstable
       - run: cd test_suite/no_std && cargo build
         if: matrix.os != 'windows'
+      - run: cd serde_derive && cargo check --tests
+        env:
+          RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
+        if: matrix.os != 'windows'
 
   msrv:
     name: Rust 1.13.0
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.13.0
       - name: Get timestamp for cache
         id: date
@@ -85,7 +93,7 @@ jobs:
       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: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -100,7 +108,7 @@ jobs:
       matrix:
         rust: [1.27.0, 1.28.0]
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@master
         with:
           toolchain: ${{matrix.rust}}
@@ -113,7 +121,7 @@ jobs:
     name: Rust 1.31.0
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.31.0
       - run: cd serde && cargo check --no-default-features
       - run: cd serde && cargo check
@@ -123,7 +131,7 @@ jobs:
     name: Rust 1.36.0
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@1.36.0
       - run: cd serde && cargo build --no-default-features --features alloc
 
@@ -131,7 +139,7 @@ jobs:
     name: Emscripten
     runs-on: ubuntu-latest
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@nightly
       - uses: actions/setup-node@v1
         with:
@@ -154,7 +162,7 @@ jobs:
     runs-on: ubuntu-latest
     if: github.event_name != 'pull_request'
     steps:
-      - uses: actions/checkout@v2
+      - uses: actions/checkout@v3
       - uses: dtolnay/rust-toolchain@clippy
       - run: cd serde && cargo clippy --features rc,unstable -- -Dclippy::all -Dclippy::pedantic
       - run: cd serde_derive && cargo clippy -- -Dclippy::all -Dclippy::pedantic
@@ -162,3 +170,25 @@ jobs:
       - run: cd serde_test && cargo clippy -- -Dclippy::all -Dclippy::pedantic
       - run: cd test_suite && cargo clippy --tests --features unstable -- -Dclippy::all -Dclippy::pedantic
       - run: cd test_suite/no_std && cargo clippy -- -Dclippy::all -Dclippy::pedantic
+
+  miri:
+    name: Miri
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/rust-toolchain@miri
+      - run: cd serde && cargo miri test --features derive,rc,unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+      - run: cd test_suite && cargo miri test --features unstable
+        env:
+          MIRIFLAGS: -Zmiri-strict-provenance
+
+  outdated:
+    name: Outdated
+    runs-on: ubuntu-latest
+    if: github.event_name != 'pull_request'
+    steps:
+      - uses: actions/checkout@v3
+      - uses: dtolnay/install@cargo-outdated
+      - run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1

Cargo.toml

@@ -1,7 +1,6 @@
 [workspace]
 members = [
     "serde",
-    "serde_derive",
     "serde_derive_internals",
     "serde_test",
     "test_suite",

README.md

@@ -77,17 +77,20 @@ fn main() {
 
 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-questions] or [#rust-beginners] channels of the unofficial community
-[#rust-usage] channel of the official Rust Project Discord, or the
+Discord (invite: <https://discord.gg/rust-lang-community>), the [#rust-usage] or
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
+[#beginners] channels of the official Rust Project Discord (invite:
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
+<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
+asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
-acceptable to file a support issue in this repo but they tend not to get as many
+[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
-eyes as any of the above and may get closed without a response after some time.
+[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.
 
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [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

crates-io.md

@@ -45,17 +45,20 @@ fn main() {
 
 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-questions] or [#rust-beginners] channels of the unofficial community
-[#rust-usage] channel of the official Rust Project Discord, or the
+Discord (invite: <https://discord.gg/rust-lang-community>, the [#rust-usage] or
-[#general][zulip] stream in Zulip. For asynchronous, consider the [\[rust\] tag
+[#beginners] channels of the official Rust Project Discord (invite:
-on StackOverflow][stackoverflow], the [/r/rust] subreddit which has a pinned
+<https://discord.gg/rust-lang>), or the [#general][zulip] stream in Zulip. For
-weekly easy questions post, or the Rust [Discourse forum][discourse]. It's
+asynchronous, consider the [\[rust\] tag on StackOverflow][stackoverflow], the
-acceptable to file a support issue in this repo but they tend not to get as many
+[/r/rust] subreddit which has a pinned weekly easy questions post, or the Rust
-eyes as any of the above and may get closed without a response after some time.
+[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.
 
-[#general]: https://discord.com/channels/273534239310479360/274215136414400513
+[#rust-questions]: https://discord.com/channels/273534239310479360/274215136414400513
-[#beginners]: https://discord.com/channels/273534239310479360/273541522815713281
+[#rust-beginners]: https://discord.com/channels/273534239310479360/273541522815713281
 [#rust-usage]: https://discord.com/channels/442252698964721669/443150878111694848
+[#beginners]: https://discord.com/channels/442252698964721669/448238009733742612
 [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

serde/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.13.0"

serde/Cargo.toml

@@ -1,8 +1,8 @@
 [package]
 name = "serde"
-version = "1.0.134" # remember to update html_root_url and serde_derive dependency
+version = "1.0.137" # remember to update html_root_url and serde_derive dependency
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
-rust-version = "1.15"
+rust-version = "1.13"
 license = "MIT OR Apache-2.0"
 description = "A generic serialization/deserialization framework"
 homepage = "https://serde.rs"
@@ -15,7 +15,7 @@ include = ["build.rs", "src/**/*.rs", "crates-io.md", "README.md", "LICENSE-APAC
 build = "build.rs"
 
 [dependencies]
-serde_derive = { version = "=1.0.134", optional = true, path = "../serde_derive" }
+serde_derive = { version = "=1.0.137", optional = true, path = "../serde_derive" }
 
 [dev-dependencies]
 serde_derive = { version = "1.0", path = "../serde_derive" }

serde/src/de/format.rs

@@ -0,0 +1,30 @@
+use lib::fmt::{self, Write};
+use lib::str;
+
+pub struct Buf<'a> {
+    bytes: &'a mut [u8],
+    offset: usize,
+}
+
+impl<'a> Buf<'a> {
+    pub fn new(bytes: &'a mut [u8]) -> Self {
+        Buf { bytes, offset: 0 }
+    }
+
+    pub fn as_str(&self) -> &str {
+        let slice = &self.bytes[..self.offset];
+        unsafe { str::from_utf8_unchecked(slice) }
+    }
+}
+
+impl<'a> Write for Buf<'a> {
+    fn write_str(&mut self, s: &str) -> fmt::Result {
+        if self.offset + s.len() > self.bytes.len() {
+            Err(fmt::Error)
+        } else {
+            self.bytes[self.offset..self.offset + s.len()].copy_from_slice(s.as_bytes());
+            self.offset += s.len();
+            Ok(())
+        }
+    }
+}

serde/src/de/impls.rs

@@ -793,7 +793,6 @@ where
         T::deserialize(deserializer).map(Some)
     }
 
-    #[doc(hidden)]
     fn __private_visit_untagged_option<D>(self, deserializer: D) -> Result<Self::Value, ()>
     where
         D: Deserializer<'de>,
@@ -2012,7 +2011,7 @@ impl<'de> Deserialize<'de> for Duration {
                             b"nanos" => Ok(Field::Nanos),
                             _ => {
                                 let value = ::__private::from_utf8_lossy(value);
-                                Err(Error::unknown_field(&value, FIELDS))
+                                Err(Error::unknown_field(&*value, FIELDS))
                             }
                         }
                     }
@@ -2352,7 +2351,7 @@ mod range {
                         b"end" => Ok(Field::End),
                         _ => {
                             let value = ::__private::from_utf8_lossy(value);
-                            Err(Error::unknown_field(&value, FIELDS))
+                            Err(Error::unknown_field(&*value, FIELDS))
                         }
                     }
                 }

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/servo/bincode
+//! [`bincode`]: https://github.com/bincode-org/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
@@ -118,6 +118,8 @@ use lib::*;
 
 pub mod value;
 
+#[cfg(not(no_integer128))]
+mod format;
 mod ignored_any;
 mod impls;
 mod utf8;
@@ -1366,8 +1368,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
+            let mut buf = [0u8; 58];
-            Err(Error::invalid_type(Unexpected::Other("i128"), &self))
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as i128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
         }
     }
 
@@ -1426,8 +1430,10 @@ pub trait Visitor<'de>: Sized {
         where
             E: Error,
         {
-            let _ = v;
+            let mut buf = [0u8; 57];
-            Err(Error::invalid_type(Unexpected::Other("u128"), &self))
+            let mut writer = format::Buf::new(&mut buf);
+            fmt::Write::write_fmt(&mut writer, format_args!("integer `{}` as u128", v)).unwrap();
+            Err(Error::invalid_type(Unexpected::Other(writer.as_str()), &self))
         }
     }
 

serde/src/de/value.rs

@@ -604,7 +604,7 @@ where
 }
 
 #[cfg(any(feature = "std", feature = "alloc"))]
-impl<'de, 'a, E> de::EnumAccess<'de> for StringDeserializer<E>
+impl<'de, E> de::EnumAccess<'de> for StringDeserializer<E>
 where
     E: de::Error,
 {

serde/src/lib.rs

@@ -59,14 +59,14 @@
 //!   and from DynamoDB.
 //!
 //! [JSON]: https://github.com/serde-rs/json
-//! [Bincode]: https://github.com/servo/bincode
+//! [Bincode]: https://github.com/bincode-org/bincode
 //! [CBOR]: https://github.com/enarx/ciborium
 //! [YAML]: https://github.com/dtolnay/serde-yaml
 //! [MessagePack]: https://github.com/3Hren/msgpack-rust
 //! [TOML]: https://github.com/alexcrichton/toml-rs
 //! [Pickle]: https://github.com/birkenfeld/serde-pickle
 //! [RON]: https://github.com/ron-rs/ron
-//! [BSON]: https://github.com/zonyitoo/bson-rs
+//! [BSON]: https://github.com/mongodb/bson-rust
 //! [Avro]: https://github.com/flavray/avro-rs
 //! [JSON5]: https://github.com/callum-oakley/json5-rs
 //! [Postcard]: https://github.com/jamesmunns/postcard
@@ -74,7 +74,7 @@
 //! [Envy]: https://github.com/softprops/envy
 //! [Envy Store]: https://github.com/softprops/envy-store
 //! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
-//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-paramstore.html
+//! [AWS Parameter Store]: https://docs.aws.amazon.com/systems-manager/latest/userguide/systems-manager-parameter-store.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
@@ -84,7 +84,7 @@
 ////////////////////////////////////////////////////////////////////////////////
 
 // Serde types in rustdoc of other crates get linked to here.
-#![doc(html_root_url = "https://docs.rs/serde/1.0.134")]
+#![doc(html_root_url = "https://docs.rs/serde/1.0.137")]
 // 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
@@ -103,10 +103,8 @@
         // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7768
         semicolon_if_nothing_returned,
         // not available in our oldest supported compiler
-        checked_conversions,
         empty_enum,
-        redundant_field_names,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
-        redundant_static_lifetimes,
         // integer and float ser/de requires these sorts of casts
         cast_possible_truncation,
         cast_possible_wrap,
@@ -120,6 +118,7 @@
         use_self,
         zero_prefixed_literal,
         // correctly used
+        derive_partial_eq_without_eq,
         enum_glob_use,
         let_underscore_drop,
         map_err_ignore,

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/servo/bincode
+//! [`bincode`]: https://github.com/bincode-org/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_derive/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.31.0"

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "1.0.134" # remember to update html_root_url
+version = "1.0.137" # remember to update html_root_url
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
 rust-version = "1.31"
 license = "MIT OR Apache-2.0"
@@ -17,16 +17,20 @@ default = []
 deserialize_in_place = []
 
 [lib]
-name = "serde_derive"
+crate-type = ["cdylib"]
-proc-macro = true
 
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = "1.0.60"
+syn = "1.0.90"
 
 [dev-dependencies]
 serde = { version = "1.0", path = "../serde" }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]
+
+[workspace]
+
+[patch.crates-io]
+proc-macro2 = { git = "https://github.com/dtolnay/watt" }

serde_derive/src/bound.rs

@@ -184,9 +184,7 @@ pub fn with_bound(
 
                 syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
 
-                #[cfg(test)]
+                #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-                syn::Type::__TestExhaustive(_) => unimplemented!(),
-                #[cfg(not(test))]
                 _ => {}
             }
         }

serde_derive/src/internals/attr.rs

@@ -1912,9 +1912,7 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
         | syn::Type::Infer(_)
         | syn::Type::Verbatim(_) => {}
 
-        #[cfg(test)]
+        #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-        syn::Type::__TestExhaustive(_) => unimplemented!(),
-        #[cfg(not(test))]
         _ => {}
     }
 }

serde_derive/src/internals/receiver.rs

@@ -147,9 +147,7 @@ impl ReplaceReceiver<'_> {
 
             Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
 
-            #[cfg(test)]
+            #[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
-            Type::__TestExhaustive(_) => unimplemented!(),
-            #[cfg(not(test))]
             _ => {}
         }
     }

serde_derive/src/lib.rs

@@ -13,7 +13,7 @@
 //!
 //! [https://serde.rs/derive.html]: https://serde.rs/derive.html
 
-#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.134")]
+#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.137")]
 #![allow(unknown_lints, bare_trait_objects)]
 // Ignored clippy lints
 #![allow(
@@ -22,6 +22,7 @@
     clippy::cognitive_complexity,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
     clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
     clippy::enum_variant_names,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
     clippy::manual_map,
@@ -60,18 +61,18 @@
     clippy::use_self,
     clippy::wildcard_imports
 )]
+#![cfg_attr(all(test, exhaustive), feature(non_exhaustive_omitted_patterns_lint))]
 
 #[macro_use]
 extern crate quote;
 #[macro_use]
 extern crate syn;
 
-extern crate proc_macro;
 extern crate proc_macro2;
 
 mod internals;
 
-use proc_macro::TokenStream;
+use proc_macro2::TokenStream;
 use syn::DeriveInput;
 
 #[macro_use]
@@ -85,23 +86,27 @@ mod pretend;
 mod ser;
 mod try;
 
-#[proc_macro_derive(Serialize, attributes(serde))]
+#[no_mangle]
-pub fn derive_serialize(input: TokenStream) -> TokenStream {
+pub extern "C" fn derive_serialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
+    let mut input: DeriveInput = match syn::parse2(input) {
-    ser::expand_derive_serialize(&mut input)
+        Ok(input) => input,
-        .unwrap_or_else(to_compile_errors)
+        Err(err) => return err.to_compile_error(),
-        .into()
+    };
+
+    ser::expand_derive_serialize(&mut input).unwrap_or_else(to_compile_errors)
 }
 
-#[proc_macro_derive(Deserialize, attributes(serde))]
+#[no_mangle]
-pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+pub extern "C" fn derive_deserialize(input: TokenStream) -> TokenStream {
-    let mut input = parse_macro_input!(input as DeriveInput);
+    let mut input: DeriveInput = match syn::parse2(input) {
-    de::expand_derive_deserialize(&mut input)
+        Ok(input) => input,
-        .unwrap_or_else(to_compile_errors)
+        Err(err) => return err.to_compile_error(),
-        .into()
+    };
+
+    de::expand_derive_deserialize(&mut input).unwrap_or_else(to_compile_errors)
 }
 
-fn to_compile_errors(errors: Vec<syn::Error>) -> proc_macro2::TokenStream {
+fn to_compile_errors(errors: Vec<syn::Error>) -> TokenStream {
     let compile_errors = errors.iter().map(syn::Error::to_compile_error);
     quote!(#(#compile_errors)*)
 }

serde_derive_internals/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.31.0"

serde_derive_internals/Cargo.toml

@@ -17,7 +17,7 @@ path = "lib.rs"
 [dependencies]
 proc-macro2 = "1.0"
 quote = "1.0"
-syn = { version = "1.0.60", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
+syn = { version = "1.0.90", default-features = false, features = ["derive", "parsing", "printing", "clone-impls"] }
 
 [package.metadata.docs.rs]
 targets = ["x86_64-unknown-linux-gnu"]

serde_derive_internals/lib.rs

@@ -5,6 +5,7 @@
     clippy::cognitive_complexity,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/7575
     clippy::collapsible_match,
+    clippy::derive_partial_eq_without_eq,
     // clippy bug: https://github.com/rust-lang/rust-clippy/issues/6797
     clippy::manual_map,
     clippy::missing_panics_doc,

serde_test/.clippy.toml

@@ -0,0 +1 @@
+msrv = "1.13.0"

serde_test/Cargo.toml

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

serde_test/src/lib.rs

@@ -144,7 +144,7 @@
 //! # }
 //! ```
 
-#![doc(html_root_url = "https://docs.rs/serde_test/1.0.134")]
+#![doc(html_root_url = "https://docs.rs/serde_test/1.0.137")]
 #![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
 // Ignored clippy lints
 #![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
@@ -153,6 +153,7 @@
     feature = "cargo-clippy",
     allow(
         cloned_instead_of_copied,
+        doc_link_with_quotes, // https://github.com/rust-lang/rust-clippy/issues/8961
         empty_line_after_outer_attr,
         manual_assert,
         missing_docs_in_private_items,
@@ -161,6 +162,7 @@
         must_use_candidate,
         redundant_field_names,
         too_many_lines,
+        type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
         use_debug,
         use_self
     )

test_suite/Cargo.toml

@@ -14,13 +14,16 @@ unstable = ["serde/unstable"]
 serde = { path = "../serde" }
 
 [build-dependencies]
-toolchain_find = "0.1"
+toolchain_find = "0.2"
 
 [dev-dependencies]
 fnv = "1.0"
-macrotest = "=1.0.0"
+macrotest = "=1.0.9"
+prettyplease = "=0.1.14"
 rustversion = "1.0"
-serde = { path = "../serde", features = ["rc", "derive"] }
+serde = { path = "../serde", features = ["rc"] }
-serde_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
+wa-serde-derive = { path = "../wa-serde-derive" }
 serde_test = { path = "../serde_test" }
 trybuild = { version = "1.0.49", features = ["diff"] }
+
+[workspace]

test_suite/build.rs

@@ -18,12 +18,8 @@ fn has_cargo_expand() -> bool {
         .unwrap_or(false)
 }
 
-fn has_rustfmt() -> bool {
-    toolchain_find::find_installed_component("rustfmt").is_some()
-}
-
 fn main() {
-    if cfg!(feature = "expandtest") && has_cargo_expand() && has_rustfmt() {
+    if cfg!(feature = "expandtest") && has_cargo_expand() {
         println!("cargo:rustc-cfg=expandtest");
     }
 }

test_suite/tests/compiletest.rs

@@ -1,5 +1,9 @@
+#![cfg(any())]
+
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
+#[allow(unused_attributes)]
 #[test]
 fn ui() {
     let t = trybuild::TestCases::new();

test_suite/tests/expand/de_enum.expanded.rs

@@ -28,7 +28,12 @@ const _: () = {
         {
             match *self {
                 DeEnum::Unit => {
-                    _serde::Serializer::serialize_unit_variant(__serializer, "DeEnum", 0u32, "Unit")
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        "DeEnum",
+                        0u32,
+                        "Unit",
+                    )
                 }
                 DeEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
@@ -81,12 +86,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                DeEnum::Map {
+                DeEnum::Map { ref a, ref b, ref c, ref d } => {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "DeEnum",
@@ -141,13 +141,20 @@ const _: () = {
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
                 }
-                DeEnum::_Unit2 => _serde::Serializer::serialize_unit_variant(
+                DeEnum::_Unit2 => {
-                    __serializer,
+                    _serde::Serializer::serialize_unit_variant(
-                    "DeEnum",
+                        __serializer,
-                    3u32,
+                        "DeEnum",
-                    "_Unit2",
+                        3u32,
-                ),
+                        "_Unit2",
-                DeEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
+                    )
+                }
+                DeEnum::_Seq2(
+                    ref __field0,
+                    ref __field1,
+                    ref __field2,
+                    ref __field3,
+                ) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
                         "DeEnum",
@@ -198,12 +205,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                DeEnum::_Map2 {
+                DeEnum::_Map2 { ref a, ref b, ref c, ref d } => {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "DeEnum",
@@ -274,7 +276,9 @@ const _: () = {
         C: _serde::Deserialize<'de>,
         D: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -294,9 +298,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -307,10 +317,14 @@ const _: () = {
                         3u64 => _serde::__private::Ok(__Field::__field3),
                         4u64 => _serde::__private::Ok(__Field::__field4),
                         5u64 => _serde::__private::Ok(__Field::__field5),
-                        _ => _serde::__private::Err(_serde::de::Error::invalid_value(
+                        _ => {
-                            _serde::de::Unexpected::Unsigned(__value),
+                            _serde::__private::Err(
-                            &"variant index 0 <= i < 6",
+                                _serde::de::Error::invalid_value(
-                        )),
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 6",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -327,9 +341,11 @@ const _: () = {
                         "_Unit2" => _serde::__private::Ok(__Field::__field3),
                         "_Seq2" => _serde::__private::Ok(__Field::__field4),
                         "_Map2" => _serde::__private::Ok(__Field::__field5),
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
+                        _ => {
-                            __value, VARIANTS,
+                            _serde::__private::Err(
-                        )),
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -348,9 +364,9 @@ const _: () = {
                         b"_Map2" => _serde::__private::Ok(__Field::__field5),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(
-                                __value, VARIANTS,
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            ))
+                            )
                         }
                     }
                 }
@@ -363,7 +379,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, B, C, D>
@@ -420,7 +439,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -430,8 +450,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant DeEnum::Seq",
@@ -447,9 +466,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -467,9 +484,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -487,9 +502,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -507,9 +520,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -525,9 +536,9 @@ const _: () = {
                                             );
                                         }
                                     };
-                                    _serde::__private::Ok(DeEnum::Seq(
+                                    _serde::__private::Ok(
-                                        __field0, __field1, __field2, __field3,
+                                        DeEnum::Seq(__field0, __field1, __field2, __field3),
-                                    ))
+                                    )
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
@@ -554,8 +565,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -630,7 +640,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -640,8 +651,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant DeEnum::Map",
@@ -657,9 +667,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -677,9 +685,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -697,9 +703,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -717,9 +721,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -750,32 +752,28 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i8> =
+                                    let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<B> =
+                                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
-                                    let mut __field2: _serde::__private::Option<C> =
+                                    while let _serde::__private::Some(__key)
-                                        _serde::__private::None;
+                                        = match _serde::de::MapAccess::next_key::<
-                                    let mut __field3: _serde::__private::Option<D> =
+                                            __Field,
-                                        _serde::__private::None;
+                                        >(&mut __map) {
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
+                                        } {
-                                    {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i8>(
+                                                    match _serde::de::MapAccess::next_value::<i8>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -785,12 +783,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("b")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<B>(
+                                                    match _serde::de::MapAccess::next_value::<B>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -800,12 +798,12 @@ const _: () = {
                                             }
                                             __Field::__field2 => {
                                                 if _serde::__private::Option::is_some(&__field2) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("c")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
+                                                    );
                                                 }
                                                 __field2 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<C>(
+                                                    match _serde::de::MapAccess::next_value::<C>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -815,12 +813,12 @@ const _: () = {
                                             }
                                             __Field::__field3 => {
                                                 if _serde::__private::Option::is_some(&__field3) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("d")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("d"),
+                                                    );
                                                 }
                                                 __field3 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<D>(
+                                                    match _serde::de::MapAccess::next_value::<D>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -831,9 +829,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
+                                                >(&mut __map) {
-                                                    &mut __map
-                                                ) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -894,7 +890,12 @@ const _: () = {
                                     })
                                 }
                             }
-                            const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"];
+                            const FIELDS: &'static [&'static str] = &[
+                                "a",
+                                "b",
+                                "c",
+                                "d",
+                            ];
                             _serde::de::VariantAccess::struct_variant(
                                 __variant,
                                 FIELDS,
@@ -923,7 +924,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -933,8 +935,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant DeEnum::_Seq2",
@@ -950,9 +951,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -970,9 +969,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -990,9 +987,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1010,9 +1005,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1028,9 +1021,9 @@ const _: () = {
                                             );
                                         }
                                     };
-                                    _serde::__private::Ok(DeEnum::_Seq2(
+                                    _serde::__private::Ok(
-                                        __field0, __field1, __field2, __field3,
+                                        DeEnum::_Seq2(__field0, __field1, __field2, __field3),
-                                    ))
+                                    )
                                 }
                             }
                             _serde::de::VariantAccess::tuple_variant(
@@ -1057,8 +1050,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -1133,7 +1125,8 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<DeEnum<B, C, D>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, B, C, D> _serde::de::Visitor<'de> for __Visitor<'de, B, C, D>
+                            impl<'de, B, C, D> _serde::de::Visitor<'de>
+                            for __Visitor<'de, B, C, D>
                             where
                                 B: _serde::Deserialize<'de>,
                                 C: _serde::Deserialize<'de>,
@@ -1143,8 +1136,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant DeEnum::_Map2",
@@ -1160,9 +1152,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i8,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1180,9 +1170,7 @@ const _: () = {
                                     };
                                     let __field1 = match match _serde::de::SeqAccess::next_element::<
                                         B,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1200,9 +1188,7 @@ const _: () = {
                                     };
                                     let __field2 = match match _serde::de::SeqAccess::next_element::<
                                         C,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1220,9 +1206,7 @@ const _: () = {
                                     };
                                     let __field3 = match match _serde::de::SeqAccess::next_element::<
                                         D,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -1253,32 +1237,28 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i8> =
+                                    let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<B> =
+                                    let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
-                                    let mut __field2: _serde::__private::Option<C> =
+                                    while let _serde::__private::Some(__key)
-                                        _serde::__private::None;
+                                        = match _serde::de::MapAccess::next_key::<
-                                    let mut __field3: _serde::__private::Option<D> =
+                                            __Field,
-                                        _serde::__private::None;
+                                        >(&mut __map) {
-                                    while let _serde::__private::Some(__key) =
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
-                                        {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
+                                        } {
-                                    {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i8>(
+                                                    match _serde::de::MapAccess::next_value::<i8>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1288,12 +1268,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("b")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("b"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<B>(
+                                                    match _serde::de::MapAccess::next_value::<B>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1303,12 +1283,12 @@ const _: () = {
                                             }
                                             __Field::__field2 => {
                                                 if _serde::__private::Option::is_some(&__field2) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("c")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("c"),
+                                                    );
                                                 }
                                                 __field2 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<C>(
+                                                    match _serde::de::MapAccess::next_value::<C>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1318,12 +1298,12 @@ const _: () = {
                                             }
                                             __Field::__field3 => {
                                                 if _serde::__private::Option::is_some(&__field3) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("d")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("d"),
+                                                    );
                                                 }
                                                 __field3 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<D>(
+                                                    match _serde::de::MapAccess::next_value::<D>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -1334,9 +1314,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
+                                                >(&mut __map) {
-                                                    &mut __map
-                                                ) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -1397,7 +1375,12 @@ const _: () = {
                                     })
                                 }
                             }
-                            const FIELDS: &'static [&'static str] = &["a", "b", "c", "d"];
+                            const FIELDS: &'static [&'static str] = &[
+                                "a",
+                                "b",
+                                "c",
+                                "d",
+                            ];
                             _serde::de::VariantAccess::struct_variant(
                                 __variant,
                                 FIELDS,
@@ -1410,8 +1393,14 @@ const _: () = {
                     }
                 }
             }
-            const VARIANTS: &'static [&'static str] =
+            const VARIANTS: &'static [&'static str] = &[
-                &["Unit", "Seq", "Map", "_Unit2", "_Seq2", "_Map2"];
+                "Unit",
+                "Seq",
+                "Map",
+                "_Unit2",
+                "_Seq2",
+                "_Map2",
+            ];
             _serde::Deserializer::deserialize_enum(
                 __deserializer,
                 "DeEnum",

test_suite/tests/expand/default_ty_param.expanded.rs

@@ -52,8 +52,11 @@ const _: () = {
     #[allow(unused_extern_crates, clippy::useless_attribute)]
     extern crate serde as _serde;
     #[automatically_derived]
-    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> {
+    impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de>
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+    for DefaultTyParam<T> {
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -69,9 +72,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -113,20 +122,27 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T: AssociatedType<X = i32>> {
                 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> {
+            impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de>
+            for __Visitor<'de, T> {
                 type Value = DefaultTyParam<T>;
                 fn expecting(
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DefaultTyParam",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -136,9 +152,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>(
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                        &mut __seq,
+                        PhantomData<T>,
-                    ) {
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -146,13 +162,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"struct DefaultTyParam with 1 element",
+                                    0usize,
-                            ));
+                                    &"struct DefaultTyParam with 1 element",
+                                ),
+                            );
                         }
                     };
-                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam {
+                        phantom: __field0,
+                    })
                 }
                 #[inline]
                 fn visit_map<__A>(
@@ -162,16 +182,14 @@ const _: () = {
                 where
                     __A: _serde::de::MapAccess<'de>,
                 {
-                    let mut __field0: _serde::__private::Option<PhantomData<T>> =
+                    let mut __field0: _serde::__private::Option<PhantomData<T>> = _serde::__private::None;
-                        _serde::__private::None;
+                    while let _serde::__private::Some(__key)
-                    while let _serde::__private::Some(__key) =
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -182,9 +200,9 @@ const _: () = {
                                     );
                                 }
                                 __field0 = _serde::__private::Some(
-                                    match _serde::de::MapAccess::next_value::<PhantomData<T>>(
+                                    match _serde::de::MapAccess::next_value::<
-                                        &mut __map,
+                                        PhantomData<T>,
-                                    ) {
+                                    >(&mut __map) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -195,8 +213,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -216,7 +233,9 @@ const _: () = {
                             }
                         }
                     };
-                    _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
+                    _serde::__private::Ok(DefaultTyParam {
+                        phantom: __field0,
+                    })
                 }
             }
             const FIELDS: &'static [&'static str] = &["phantom"];
@@ -249,9 +268,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -293,22 +318,30 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> {
                 place: &'place mut DefaultTyParam<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de>
+            impl<
-                for __Visitor<'de, 'place, T>
+                'de,
-            {
+                'place,
+                T: AssociatedType<X = i32> + 'place,
+            > _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> {
                 type Value = ();
                 fn expecting(
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DefaultTyParam",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -318,19 +351,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"struct DefaultTyParam with 1 element",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"struct DefaultTyParam with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -343,14 +379,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::__private::Some(__key) =
+                    while let _serde::__private::Some(__key)
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -374,8 +409,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -385,13 +419,17 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.phantom = match _serde::__private::de::missing_field("phantom") {
+                        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::__private::Ok(())
                 }
             }

test_suite/tests/expand/generic_enum.expanded.rs

@@ -24,12 +24,14 @@ const _: () = {
             __S: _serde::Serializer,
         {
             match *self {
-                GenericEnum::Unit => _serde::Serializer::serialize_unit_variant(
+                GenericEnum::Unit => {
-                    __serializer,
+                    _serde::Serializer::serialize_unit_variant(
-                    "GenericEnum",
+                        __serializer,
-                    0u32,
+                        "GenericEnum",
-                    "Unit",
+                        0u32,
-                ),
+                        "Unit",
+                    )
+                }
                 GenericEnum::NewType(ref __field0) => {
                     _serde::Serializer::serialize_newtype_variant(
                         __serializer,
@@ -122,7 +124,9 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -140,9 +144,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -151,10 +161,14 @@ const _: () = {
                         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),
+                            _serde::__private::Err(
-                            &"variant index 0 <= i < 4",
+                                _serde::de::Error::invalid_value(
-                        )),
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 4",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -169,9 +183,11 @@ const _: () = {
                         "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,
+                            _serde::__private::Err(
-                        )),
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -188,9 +204,9 @@ const _: () = {
                         b"Map" => _serde::__private::Ok(__Field::__field3),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(
-                                __value, VARIANTS,
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            ))
+                            )
                         }
                     }
                 }
@@ -203,7 +219,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T, U>
@@ -224,7 +243,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "enum GenericEnum")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "enum GenericEnum",
+                    )
                 }
                 fn visit_enum<__A>(
                     self,
@@ -248,10 +270,12 @@ const _: () = {
                             };
                             _serde::__private::Ok(GenericEnum::Unit)
                         }
-                        (__Field::__field1, __variant) => _serde::__private::Result::map(
+                        (__Field::__field1, __variant) => {
-                            _serde::de::VariantAccess::newtype_variant::<T>(__variant),
+                            _serde::__private::Result::map(
-                            GenericEnum::NewType,
+                                _serde::de::VariantAccess::newtype_variant::<T>(__variant),
-                        ),
+                                GenericEnum::NewType,
+                            )
+                        }
                         (__Field::__field2, __variant) => {
                             struct __Visitor<'de, T, U>
                             where
@@ -261,7 +285,8 @@ const _: () = {
                                 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>
+                            impl<'de, T, U> _serde::de::Visitor<'de>
+                            for __Visitor<'de, T, U>
                             where
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
@@ -270,8 +295,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "tuple variant GenericEnum::Seq",
@@ -287,9 +311,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         T,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -297,14 +319,17 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            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::<
                                         U,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -312,7 +337,12 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    1usize,
+                                                    &"tuple variant GenericEnum::Seq with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
@@ -340,8 +370,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -409,7 +438,8 @@ const _: () = {
                                 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>
+                            impl<'de, T, U> _serde::de::Visitor<'de>
+                            for __Visitor<'de, T, U>
                             where
                                 T: _serde::Deserialize<'de>,
                                 U: _serde::Deserialize<'de>,
@@ -418,8 +448,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant GenericEnum::Map",
@@ -435,9 +464,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         T,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -445,14 +472,17 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            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::<
                                         U,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -460,7 +490,12 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    1usize,
+                                                    &"struct variant GenericEnum::Map with 2 elements",
+                                                ),
+                                            );
                                         }
                                     };
                                     _serde::__private::Ok(GenericEnum::Map {
@@ -476,28 +511,26 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<T> =
+                                    let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    let mut __field1: _serde::__private::Option<U> = _serde::__private::None;
-                                    let mut __field1: _serde::__private::Option<U> =
+                                    while let _serde::__private::Some(__key)
-                                        _serde::__private::None;
+                                        = match _serde::de::MapAccess::next_key::<
-                                    while let _serde::__private::Some(__key) =
+                                            __Field,
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
+                                        >(&mut __map) {
-                                        {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
+                                        } {
-                                    {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("x"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<T>(
+                                                    match _serde::de::MapAccess::next_value::<T>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -507,12 +540,12 @@ const _: () = {
                                             }
                                             __Field::__field1 => {
                                                 if _serde::__private::Option::is_some(&__field1) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("y"),
+                                                    );
                                                 }
                                                 __field1 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<U>(
+                                                    match _serde::de::MapAccess::next_value::<U>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -523,9 +556,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
+                                                >(&mut __map) {
-                                                    &mut __map
-                                                ) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);

test_suite/tests/expand/generic_struct.expanded.rs

@@ -29,7 +29,11 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "x",
+                &self.x,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -49,7 +53,9 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -65,9 +71,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -109,7 +121,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, T>
@@ -128,7 +143,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct GenericStruct",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -138,8 +156,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -147,10 +166,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"struct GenericStruct with 1 element",
+                                    0usize,
-                            ));
+                                    &"struct GenericStruct with 1 element",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericStruct { x: __field0 })
@@ -164,14 +185,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
-                    while let _serde::__private::Some(__key) =
+                    while let _serde::__private::Some(__key)
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -191,8 +211,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -245,9 +264,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -289,7 +314,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, T: 'place>
@@ -299,7 +327,8 @@ const _: () = {
                 place: &'place mut GenericStruct<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
+            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T>
             where
                 T: _serde::Deserialize<'de>,
             {
@@ -308,7 +337,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct GenericStruct",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -318,19 +350,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.x),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.x),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"struct GenericStruct with 1 element",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"struct GenericStruct with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -343,14 +378,13 @@ const _: () = {
                     __A: _serde::de::MapAccess<'de>,
                 {
                     let mut __field0: bool = false;
-                    while let _serde::__private::Some(__key) =
+                    while let _serde::__private::Some(__key)
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -372,8 +406,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -383,13 +416,15 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.x = match _serde::__private::de::missing_field("x") {
+                        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::__private::Ok(())
                 }
             }
@@ -442,7 +477,9 @@ const _: () = {
     where
         T: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -475,7 +512,9 @@ const _: () = {
                 where
                     __E: _serde::Deserializer<'de>,
                 {
-                    let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
+                    let __field0: T = match <T as _serde::Deserialize>::deserialize(
+                        __e,
+                    ) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -491,8 +530,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -500,10 +540,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct GenericNewTypeStruct with 1 element",
+                                    0usize,
-                            ));
+                                    &"tuple struct GenericNewTypeStruct with 1 element",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericNewTypeStruct(__field0))
@@ -532,7 +574,8 @@ const _: () = {
                 place: &'place mut GenericNewTypeStruct<T>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
+            impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T>
             where
                 T: _serde::Deserialize<'de>,
             {
@@ -564,19 +607,22 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"tuple struct GenericNewTypeStruct with 1 element",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"tuple struct GenericNewTypeStruct with 1 element",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/generic_tuple_struct.expanded.rs

@@ -11,7 +11,9 @@ const _: () = {
         T: _serde::Deserialize<'de>,
         U: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -46,8 +48,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        T,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -55,14 +58,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct GenericTupleStruct with 2 elements",
+                                    0usize,
-                            ));
+                                    &"tuple struct GenericTupleStruct with 2 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq)
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        U,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -70,10 +76,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                1usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct GenericTupleStruct with 2 elements",
+                                    1usize,
-                            ));
+                                    &"tuple struct GenericTupleStruct with 2 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
@@ -104,7 +112,8 @@ const _: () = {
                 place: &'place mut GenericTupleStruct<T, U>,
                 lifetime: _serde::__private::PhantomData<&'de ()>,
             }
-            impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U>
+            impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de>
+            for __Visitor<'de, 'place, T, U>
             where
                 T: _serde::Deserialize<'de>,
                 U: _serde::Deserialize<'de>,
@@ -127,33 +136,39 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"tuple struct GenericTupleStruct with 2 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"tuple struct GenericTupleStruct with 2 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.1),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            1usize,
+                        return _serde::__private::Err(
-                            &"tuple struct GenericTupleStruct with 2 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                1usize,
+                                &"tuple struct GenericTupleStruct with 2 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/lifetimes.expanded.rs

@@ -99,7 +99,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -117,9 +119,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -128,10 +136,14 @@ const _: () = {
                         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),
+                            _serde::__private::Err(
-                            &"variant index 0 <= i < 4",
+                                _serde::de::Error::invalid_value(
-                        )),
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 4",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -146,9 +158,11 @@ const _: () = {
                         "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,
+                            _serde::__private::Err(
-                        )),
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -165,9 +179,9 @@ const _: () = {
                         b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(
-                                __value, VARIANTS,
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            ))
+                            )
                         }
                     }
                 }
@@ -180,7 +194,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'a> {
@@ -193,7 +210,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "enum Lifetimes")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "enum Lifetimes",
+                    )
                 }
                 fn visit_enum<__A>(
                     self,
@@ -208,14 +228,22 @@ const _: () = {
                             return _serde::__private::Err(__err);
                         }
                     } {
-                        (__Field::__field0, __variant) => _serde::__private::Result::map(
+                        (__Field::__field0, __variant) => {
-                            _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
+                            _serde::__private::Result::map(
-                            Lifetimes::LifetimeSeq,
+                                _serde::de::VariantAccess::newtype_variant::<
-                        ),
+                                    &'a i32,
-                        (__Field::__field1, __variant) => _serde::__private::Result::map(
+                                >(__variant),
-                            _serde::de::VariantAccess::newtype_variant::<i32>(__variant),
+                                Lifetimes::LifetimeSeq,
-                            Lifetimes::NoLifetimeSeq,
+                            )
-                        ),
+                        }
+                        (__Field::__field1, __variant) => {
+                            _serde::__private::Result::map(
+                                _serde::de::VariantAccess::newtype_variant::<
+                                    i32,
+                                >(__variant),
+                                Lifetimes::NoLifetimeSeq,
+                            )
+                        }
                         (__Field::__field2, __variant) => {
                             #[allow(non_camel_case_types)]
                             enum __Field {
@@ -228,8 +256,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -290,13 +317,13 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<Lifetimes<'a>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
+                            impl<'de, 'a> _serde::de::Visitor<'de>
+                            for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::LifetimeMap",
@@ -312,9 +339,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         &'a i32,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -322,10 +347,17 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"struct variant Lifetimes::LifetimeMap with 1 element",
+                                                ),
+                                            );
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
@@ -335,26 +367,27 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<&'a i32> =
+                                    let mut __field0: _serde::__private::Option<&'a i32> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
-                                    while let _serde::__private::Some(__key) =
+                                        = match _serde::de::MapAccess::next_key::<
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
+                                            __Field,
-                                        {
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
+                                        } {
-                                    {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<&'a i32>(
+                                                    match _serde::de::MapAccess::next_value::<
-                                                        &mut __map,
+                                                        &'a i32,
-                                                    ) {
+                                                    >(&mut __map) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -365,9 +398,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
+                                                >(&mut __map) {
-                                                    &mut __map
-                                                ) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -387,7 +418,9 @@ const _: () = {
                                             }
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::LifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];
@@ -412,8 +445,7 @@ const _: () = {
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "field identifier",
@@ -474,13 +506,13 @@ const _: () = {
                                 marker: _serde::__private::PhantomData<Lifetimes<'a>>,
                                 lifetime: _serde::__private::PhantomData<&'de ()>,
                             }
-                            impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
+                            impl<'de, 'a> _serde::de::Visitor<'de>
+                            for __Visitor<'de, 'a> {
                                 type Value = Lifetimes<'a>;
                                 fn expecting(
                                     &self,
                                     __formatter: &mut _serde::__private::Formatter,
-                                ) -> _serde::__private::fmt::Result
+                                ) -> _serde::__private::fmt::Result {
-                                {
                                     _serde::__private::Formatter::write_str(
                                         __formatter,
                                         "struct variant Lifetimes::NoLifetimeMap",
@@ -496,9 +528,7 @@ const _: () = {
                                 {
                                     let __field0 = match match _serde::de::SeqAccess::next_element::<
                                         i32,
-                                    >(
+                                    >(&mut __seq) {
-                                        &mut __seq
-                                    ) {
                                         _serde::__private::Ok(__val) => __val,
                                         _serde::__private::Err(__err) => {
                                             return _serde::__private::Err(__err);
@@ -506,10 +536,17 @@ const _: () = {
                                     } {
                                         _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")) ;
+                                            return _serde::__private::Err(
+                                                _serde::de::Error::invalid_length(
+                                                    0usize,
+                                                    &"struct variant Lifetimes::NoLifetimeMap with 1 element",
+                                                ),
+                                            );
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                                 #[inline]
                                 fn visit_map<__A>(
@@ -519,26 +556,25 @@ const _: () = {
                                 where
                                     __A: _serde::de::MapAccess<'de>,
                                 {
-                                    let mut __field0: _serde::__private::Option<i32> =
+                                    let mut __field0: _serde::__private::Option<i32> = _serde::__private::None;
-                                        _serde::__private::None;
+                                    while let _serde::__private::Some(__key)
-                                    while let _serde::__private::Some(__key) =
+                                        = match _serde::de::MapAccess::next_key::<
-                                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
+                                            __Field,
-                                        {
+                                        >(&mut __map) {
                                             _serde::__private::Ok(__val) => __val,
                                             _serde::__private::Err(__err) => {
                                                 return _serde::__private::Err(__err);
                                             }
-                                        }
+                                        } {
-                                    {
                                         match __key {
                                             __Field::__field0 => {
                                                 if _serde::__private::Option::is_some(&__field0) {
-                                                    return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
+                                                    return _serde::__private::Err(
+                                                        <__A::Error as _serde::de::Error>::duplicate_field("a"),
+                                                    );
                                                 }
                                                 __field0 = _serde::__private::Some(
-                                                    match _serde::de::MapAccess::next_value::<i32>(
+                                                    match _serde::de::MapAccess::next_value::<i32>(&mut __map) {
-                                                        &mut __map,
-                                                    ) {
                                                         _serde::__private::Ok(__val) => __val,
                                                         _serde::__private::Err(__err) => {
                                                             return _serde::__private::Err(__err);
@@ -549,9 +585,7 @@ const _: () = {
                                             _ => {
                                                 let _ = match _serde::de::MapAccess::next_value::<
                                                     _serde::de::IgnoredAny,
-                                                >(
+                                                >(&mut __map) {
-                                                    &mut __map
-                                                ) {
                                                     _serde::__private::Ok(__val) => __val,
                                                     _serde::__private::Err(__err) => {
                                                         return _serde::__private::Err(__err);
@@ -571,7 +605,9 @@ const _: () = {
                                             }
                                         }
                                     };
-                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
+                                    _serde::__private::Ok(Lifetimes::NoLifetimeMap {
+                                        a: __field0,
+                                    })
                                 }
                             }
                             const FIELDS: &'static [&'static str] = &["a"];

test_suite/tests/expand/named_map.expanded.rs

@@ -33,19 +33,31 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "a",
+                &self.a,
+            ) {
                 _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) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "b",
+                &self.b,
+            ) {
                 _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) {
+            match _serde::ser::SerializeStruct::serialize_field(
+                &mut __serde_state,
+                "c",
+                &self.c,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -72,7 +84,9 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -90,9 +104,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -140,7 +160,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, A, B, C>
@@ -163,7 +186,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DeNamedMap",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -173,8 +199,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        A,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -182,14 +209,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"struct DeNamedMap with 3 elements",
+                                    0usize,
-                            ));
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        B,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -197,14 +227,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                1usize,
+                                _serde::de::Error::invalid_length(
-                                &"struct DeNamedMap with 3 elements",
+                                    1usize,
-                            ));
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
+                    let __field2 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        C,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -212,10 +245,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                2usize,
+                                _serde::de::Error::invalid_length(
-                                &"struct DeNamedMap with 3 elements",
+                                    2usize,
-                            ));
+                                    &"struct DeNamedMap with 3 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(DeNamedMap {
@@ -235,14 +270,13 @@ const _: () = {
                     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) =
+                    while let _serde::__private::Some(__key)
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if _serde::__private::Option::is_some(&__field0) {
@@ -292,8 +326,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -374,9 +407,15 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "field identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "field identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
+                fn visit_u64<__E>(
+                    self,
+                    __value: u64,
+                ) -> _serde::__private::Result<Self::Value, __E>
                 where
                     __E: _serde::de::Error,
                 {
@@ -424,7 +463,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
@@ -437,7 +479,7 @@ const _: () = {
                 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>
+            for __Visitor<'de, 'place, A, B, C>
             where
                 A: _serde::Deserialize<'de>,
                 B: _serde::Deserialize<'de>,
@@ -448,7 +490,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "struct DeNamedMap",
+                    )
                 }
                 #[inline]
                 fn visit_seq<__A>(
@@ -458,47 +503,56 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.a),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.a),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"struct DeNamedMap with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.b),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.b),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            1usize,
+                        return _serde::__private::Err(
-                            &"struct DeNamedMap with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                1usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.c),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.c),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            2usize,
+                        return _serde::__private::Err(
-                            &"struct DeNamedMap with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                2usize,
+                                &"struct DeNamedMap with 3 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }
@@ -513,14 +567,13 @@ const _: () = {
                     let mut __field0: bool = false;
                     let mut __field1: bool = false;
                     let mut __field2: bool = false;
-                    while let _serde::__private::Some(__key) =
+                    while let _serde::__private::Some(__key)
-                        match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
+                        = match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
                             _serde::__private::Ok(__val) => __val,
                             _serde::__private::Err(__err) => {
                                 return _serde::__private::Err(__err);
                             }
-                        }
+                        } {
-                    {
                         match __key {
                             __Field::__field0 => {
                                 if __field0 {
@@ -576,8 +629,7 @@ const _: () = {
                             _ => {
                                 let _ = match _serde::de::MapAccess::next_value::<
                                     _serde::de::IgnoredAny,
-                                >(&mut __map)
+                                >(&mut __map) {
-                                {
                                     _serde::__private::Ok(__val) => __val,
                                     _serde::__private::Err(__err) => {
                                         return _serde::__private::Err(__err);
@@ -587,29 +639,35 @@ const _: () = {
                         }
                     }
                     if !__field0 {
-                        self.place.a = match _serde::__private::de::missing_field("a") {
+                        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") {
+                        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") {
+                        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::__private::Ok(())
                 }
             }

test_suite/tests/expand/named_tuple.expanded.rs

@@ -29,19 +29,28 @@ const _: () = {
                     return _serde::__private::Err(__err);
                 }
             };
-            match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.0,
+            ) {
                 _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) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.1,
+            ) {
                 _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) {
+            match _serde::ser::SerializeTupleStruct::serialize_field(
+                &mut __serde_state,
+                &self.2,
+            ) {
                 _serde::__private::Ok(__val) => __val,
                 _serde::__private::Err(__err) => {
                     return _serde::__private::Err(__err);
@@ -64,7 +73,9 @@ const _: () = {
         B: _serde::Deserialize<'de>,
         C: _serde::Deserialize<'de>,
     {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -101,8 +112,9 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
+                    let __field0 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        A,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -110,14 +122,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                0usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct DeNamedTuple with 3 elements",
+                                    0usize,
-                            ));
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
+                    let __field1 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        B,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -125,14 +140,17 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                1usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct DeNamedTuple with 3 elements",
+                                    1usize,
-                            ));
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
-                    let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
+                    let __field2 = match match _serde::de::SeqAccess::next_element::<
-                    {
+                        C,
+                    >(&mut __seq) {
                         _serde::__private::Ok(__val) => __val,
                         _serde::__private::Err(__err) => {
                             return _serde::__private::Err(__err);
@@ -140,10 +158,12 @@ const _: () = {
                     } {
                         _serde::__private::Some(__value) => __value,
                         _serde::__private::None => {
-                            return _serde::__private::Err(_serde::de::Error::invalid_length(
+                            return _serde::__private::Err(
-                                2usize,
+                                _serde::de::Error::invalid_length(
-                                &"tuple struct DeNamedTuple with 3 elements",
+                                    2usize,
-                            ));
+                                    &"tuple struct DeNamedTuple with 3 elements",
+                                ),
+                            );
                         }
                     };
                     _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
@@ -176,7 +196,7 @@ const _: () = {
                 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>
+            for __Visitor<'de, 'place, A, B, C>
             where
                 A: _serde::Deserialize<'de>,
                 B: _serde::Deserialize<'de>,
@@ -200,47 +220,56 @@ const _: () = {
                 where
                     __A: _serde::de::SeqAccess<'de>,
                 {
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.0),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.0),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            0usize,
+                        return _serde::__private::Err(
-                            &"tuple struct DeNamedTuple with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                0usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.1),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.1),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            1usize,
+                        return _serde::__private::Err(
-                            &"tuple struct DeNamedTuple with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                1usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
-                    if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
+                    if let _serde::__private::None
-                        &mut __seq,
+                        = match _serde::de::SeqAccess::next_element_seed(
-                        _serde::__private::de::InPlaceSeed(&mut self.place.2),
+                            &mut __seq,
-                    ) {
+                            _serde::__private::de::InPlaceSeed(&mut self.place.2),
-                        _serde::__private::Ok(__val) => __val,
+                        ) {
-                        _serde::__private::Err(__err) => {
+                            _serde::__private::Ok(__val) => __val,
-                            return _serde::__private::Err(__err);
+                            _serde::__private::Err(__err) => {
-                        }
+                                return _serde::__private::Err(__err);
-                    } {
+                            }
-                        return _serde::__private::Err(_serde::de::Error::invalid_length(
+                        } {
-                            2usize,
+                        return _serde::__private::Err(
-                            &"tuple struct DeNamedTuple with 3 elements",
+                            _serde::de::Error::invalid_length(
-                        ));
+                                2usize,
+                                &"tuple struct DeNamedTuple with 3 elements",
+                            ),
+                        );
                     }
                     _serde::__private::Ok(())
                 }

test_suite/tests/expand/named_unit.expanded.rs

@@ -25,7 +25,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for NamedUnit {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -36,7 +38,10 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "unit struct NamedUnit")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "unit struct NamedUnit",
+                    )
                 }
                 #[inline]
                 fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
@@ -46,7 +51,11 @@ const _: () = {
                     _serde::__private::Ok(NamedUnit)
                 }
             }
-            _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)
+            _serde::Deserializer::deserialize_unit_struct(
+                __deserializer,
+                "NamedUnit",
+                __Visitor,
+            )
         }
     }
 };

test_suite/tests/expand/ser_enum.expanded.rs

@@ -31,12 +31,14 @@ const _: () = {
             __S: _serde::Serializer,
         {
             match *self {
-                SerEnum::Unit => _serde::Serializer::serialize_unit_variant(
+                SerEnum::Unit => {
-                    __serializer,
+                    _serde::Serializer::serialize_unit_variant(
-                    "SerEnum",
+                        __serializer,
-                    0u32,
+                        "SerEnum",
-                    "Unit",
+                        0u32,
-                ),
+                        "Unit",
+                    )
+                }
                 SerEnum::Seq(ref __field0, ref __field1, ref __field2, ref __field3) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
@@ -88,12 +90,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                SerEnum::Map {
+                SerEnum::Map { ref a, ref b, ref c, ref d } => {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "SerEnum",
@@ -148,13 +145,20 @@ const _: () = {
                     };
                     _serde::ser::SerializeStructVariant::end(__serde_state)
                 }
-                SerEnum::_Unit2 => _serde::Serializer::serialize_unit_variant(
+                SerEnum::_Unit2 => {
-                    __serializer,
+                    _serde::Serializer::serialize_unit_variant(
-                    "SerEnum",
+                        __serializer,
-                    3u32,
+                        "SerEnum",
-                    "_Unit2",
+                        3u32,
-                ),
+                        "_Unit2",
-                SerEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
+                    )
+                }
+                SerEnum::_Seq2(
+                    ref __field0,
+                    ref __field1,
+                    ref __field2,
+                    ref __field3,
+                ) => {
                     let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
                         __serializer,
                         "SerEnum",
@@ -205,12 +209,7 @@ const _: () = {
                     };
                     _serde::ser::SerializeTupleVariant::end(__serde_state)
                 }
-                SerEnum::_Map2 {
+                SerEnum::_Map2 { ref a, ref b, ref c, ref d } => {
-                    ref a,
-                    ref b,
-                    ref c,
-                    ref d,
-                } => {
                     let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
                         __serializer,
                         "SerEnum",

test_suite/tests/expand/void.expanded.rs

@@ -25,7 +25,9 @@ const _: () = {
     extern crate serde as _serde;
     #[automatically_derived]
     impl<'de> _serde::Deserialize<'de> for Void {
-        fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
+        fn deserialize<__D>(
+            __deserializer: __D,
+        ) -> _serde::__private::Result<Self, __D::Error>
         where
             __D: _serde::Deserializer<'de>,
         {
@@ -38,17 +40,27 @@ const _: () = {
                     &self,
                     __formatter: &mut _serde::__private::Formatter,
                 ) -> _serde::__private::fmt::Result {
-                    _serde::__private::Formatter::write_str(__formatter, "variant identifier")
+                    _serde::__private::Formatter::write_str(
+                        __formatter,
+                        "variant identifier",
+                    )
                 }
-                fn visit_u64<__E>(self, __value: u64) -> _serde::__private::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::__private::Err(_serde::de::Error::invalid_value(
+                        _ => {
-                            _serde::de::Unexpected::Unsigned(__value),
+                            _serde::__private::Err(
-                            &"variant index 0 <= i < 0",
+                                _serde::de::Error::invalid_value(
-                        )),
+                                    _serde::de::Unexpected::Unsigned(__value),
+                                    &"variant index 0 <= i < 0",
+                                ),
+                            )
+                        }
                     }
                 }
                 fn visit_str<__E>(
@@ -59,9 +71,11 @@ const _: () = {
                     __E: _serde::de::Error,
                 {
                     match __value {
-                        _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
+                        _ => {
-                            __value, VARIANTS,
+                            _serde::__private::Err(
-                        )),
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
+                            )
+                        }
                     }
                 }
                 fn visit_bytes<__E>(
@@ -74,9 +88,9 @@ const _: () = {
                     match __value {
                         _ => {
                             let __value = &_serde::__private::from_utf8_lossy(__value);
-                            _serde::__private::Err(_serde::de::Error::unknown_variant(
+                            _serde::__private::Err(
-                                __value, VARIANTS,
+                                _serde::de::Error::unknown_variant(__value, VARIANTS),
-                            ))
+                            )
                         }
                     }
                 }
@@ -89,7 +103,10 @@ const _: () = {
                 where
                     __D: _serde::Deserializer<'de>,
                 {
-                    _serde::Deserializer::deserialize_identifier(__deserializer, __FieldVisitor)
+                    _serde::Deserializer::deserialize_identifier(
+                        __deserializer,
+                        __FieldVisitor,
+                    )
                 }
             }
             struct __Visitor<'de> {

test_suite/tests/expandtest.rs

@@ -1,6 +1,7 @@
 #[cfg_attr(target_os = "emscripten", ignore)]
 #[cfg_attr(not(expandtest), ignore)]
 #[rustversion::attr(not(nightly), ignore)]
+#[cfg_attr(miri, ignore)]
 #[allow(unused_attributes)]
 #[test]
 fn expandtest() {

test_suite/tests/macros/mod.rs

@@ -1,3 +1,5 @@
+#![allow(unused_macro_rules)]
+
 use serde_test::Token;
 use std::iter;
 

test_suite/tests/test_annotations.rs

@@ -1,14 +1,17 @@
 #![allow(
     clippy::cast_lossless,
+    clippy::derive_partial_eq_without_eq,
     clippy::from_over_into,
     // Clippy bug: https://github.com/rust-lang/rust-clippy/issues/7422
     clippy::nonstandard_macro_braces,
     clippy::too_many_lines,
-    clippy::trivially_copy_pass_by_ref
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]
 
 use serde::de::{self, MapAccess, Unexpected, Visitor};
 use serde::{Deserialize, Deserializer, Serialize, Serializer};
+use serde_derive::{Deserialize, Serialize};
 
 use std::collections::{BTreeMap, HashMap};
 use std::convert::TryFrom;

test_suite/tests/test_borrow.rs

@@ -1,6 +1,11 @@
-#![allow(clippy::items_after_statements, clippy::used_underscore_binding)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::items_after_statements,
+    clippy::used_underscore_binding
+)]
 
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, assert_de_tokens_error, Token};
 
 use std::borrow::Cow;

test_suite/tests/test_de.rs

@@ -1,6 +1,7 @@
 #![allow(
     clippy::cast_lossless,
     clippy::decimal_literal_representation,
+    clippy::derive_partial_eq_without_eq,
     clippy::empty_enum,
     clippy::manual_assert,
     clippy::needless_pass_by_value,
@@ -33,6 +34,7 @@ use std::sync::atomic::{AtomicI64, AtomicU64};
 use fnv::FnvHasher;
 use serde::de::DeserializeOwned;
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Configure, Token};
 
 #[macro_use]

test_suite/tests/test_de_error.rs

@@ -1,7 +1,13 @@
-#![allow(clippy::empty_enum, clippy::unreadable_literal)]
+#![allow(
+    clippy::derive_partial_eq_without_eq,
+    clippy::empty_enum,
+    clippy::unreadable_literal
+)]
 #![cfg_attr(feature = "unstable", feature(never_type))]
 
+use serde::de::IntoDeserializer;
 use serde::Deserialize;
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens_error, Token};
 use std::collections::{BTreeMap, BTreeSet, HashMap, HashSet};
 use std::ffi::{CStr, CString};
@@ -185,6 +191,16 @@ fn test_i64() {
     );
 }
 
+#[test]
+fn test_i128() {
+    let deserializer = <i128 as IntoDeserializer>::into_deserializer(1);
+    let error = <&str>::deserialize(deserializer).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "invalid type: integer `1` as i128, expected a borrowed string",
+    );
+}
+
 #[test]
 fn test_u8() {
     let test = assert_de_tokens_error::<u8>;
@@ -326,6 +342,13 @@ fn test_u64() {
         &[Token::I64(-1)],
         "invalid value: integer `-1`, expected u64",
     );
+
+    let deserializer = <u64 as IntoDeserializer>::into_deserializer(1);
+    let error = <&str>::deserialize(deserializer).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "invalid type: integer `1`, expected a borrowed string",
+    );
 }
 
 #[test]
@@ -349,6 +372,13 @@ fn test_u128() {
         &[Token::I64(-1)],
         "invalid value: integer `-1`, expected u128",
     );
+
+    let deserializer = <u128 as IntoDeserializer>::into_deserializer(1);
+    let error = <&str>::deserialize(deserializer).unwrap_err();
+    assert_eq!(
+        error.to_string(),
+        "invalid type: integer `1` as u128, expected a borrowed string",
+    );
 }
 
 #[test]

test_suite/tests/test_gen.rs

@@ -2,10 +2,12 @@
 // successfully when there are a variety of generics and non-(de)serializable
 // types involved.
 
+#![cfg(any())]
 #![deny(warnings)]
 #![allow(
     unknown_lints,
     mixed_script_confusables,
+    clippy::derive_partial_eq_without_eq,
     clippy::items_after_statements,
     clippy::missing_errors_doc,
     clippy::missing_panics_doc,
@@ -14,7 +16,8 @@
     clippy::nonstandard_macro_braces,
     clippy::ptr_arg,
     clippy::too_many_lines,
-    clippy::trivially_copy_pass_by_ref
+    clippy::trivially_copy_pass_by_ref,
+    clippy::type_repetition_in_bounds
 )]
 
 use serde::de::DeserializeOwned;

test_suite/tests/test_identifier.rs

@@ -1,5 +1,8 @@
 //! Tests for `#[serde(field_identifier)]` and `#[serde(variant_identifier)]`
-use serde::Deserialize;
+
+#![allow(clippy::derive_partial_eq_without_eq)]
+
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 
 #[test]

test_suite/tests/test_ignored_any.rs

@@ -1,8 +1,11 @@
+#![allow(clippy::derive_partial_eq_without_eq)]
+
 use serde::de::value::{Error, MapDeserializer, SeqDeserializer};
 use serde::de::{
     DeserializeSeed, EnumAccess, IgnoredAny, IntoDeserializer, VariantAccess, Visitor,
 };
 use serde::{forward_to_deserialize_any, Deserialize, Deserializer};
+use serde_derive::Deserialize;
 
 #[derive(PartialEq, Debug, Deserialize)]
 enum Target {

test_suite/tests/test_macros.rs

@@ -1,5 +1,6 @@
 #![deny(trivial_numeric_casts)]
 #![allow(
+    clippy::derive_partial_eq_without_eq,
     clippy::enum_variant_names,
     clippy::redundant_field_names,
     clippy::too_many_lines
@@ -7,7 +8,7 @@
 
 mod bytes;
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 use serde_test::{
     assert_de_tokens, assert_de_tokens_error, assert_ser_tokens, assert_tokens, Token,
 };

test_suite/tests/test_remote.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::redundant_field_names)]
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 
 mod remote {
     pub struct Unit;

test_suite/tests/test_self.rs

@@ -1,6 +1,6 @@
 #![allow(clippy::used_underscore_binding)]
 
-use serde::{Deserialize, Serialize};
+use serde_derive::{Deserialize, Serialize};
 
 #[test]
 fn test_self() {

test_suite/tests/test_ser.rs

@@ -1,4 +1,4 @@
-#![allow(clippy::unreadable_literal)]
+#![allow(clippy::derive_partial_eq_without_eq, clippy::unreadable_literal)]
 #![cfg_attr(feature = "unstable", feature(never_type))]
 
 use std::cell::RefCell;
@@ -22,7 +22,7 @@ use std::str;
 use std::sync::atomic::{AtomicI64, AtomicU64};
 
 use fnv::FnvHasher;
-use serde::Serialize;
+use serde_derive::Serialize;
 use serde_test::{assert_ser_tokens, assert_ser_tokens_error, Configure, Token};
 
 #[macro_use]

test_suite/tests/test_serde_path.rs

@@ -2,7 +2,7 @@
 
 #[test]
 fn test_gen_custom_serde() {
-    #[derive(serde::Serialize, serde::Deserialize)]
+    #[derive(serde_derive::Serialize, serde_derive::Deserialize)]
     #[serde(crate = "fake_serde")]
     struct Foo;
 

test_suite/tests/test_unstable.rs

@@ -1,4 +1,5 @@
 #![deny(warnings)]
+#![allow(clippy::derive_partial_eq_without_eq)]
 
 // This test target is convoluted with the actual #[test] in a separate file to
 // get it so that the stable compiler does not need to parse the code of the

test_suite/tests/test_value.rs

@@ -1,8 +1,9 @@
-#![allow(clippy::similar_names)]
+#![allow(clippy::derive_partial_eq_without_eq, clippy::similar_names)]
 
 use serde::de::value::{self, MapAccessDeserializer};
 use serde::de::{IntoDeserializer, MapAccess, Visitor};
 use serde::{Deserialize, Deserializer};
+use serde_derive::Deserialize;
 use serde_test::{assert_de_tokens, Token};
 use std::fmt;
 

test_suite/tests/ui/remote/wrong_de.stderr

@@ -3,7 +3,14 @@ error[E0308]: mismatched types
   |
 7 | #[derive(Deserialize)]
   |          ^^^^^^^^^^^ expected `u16`, found `u8`
+8 | #[serde(remote = "remote::S")]
+  |                  ----------- arguments to this struct are incorrect
   |
+note: tuple struct defined here
+ --> tests/ui/remote/wrong_de.rs:4:16
+  |
+4 |     pub struct S(pub u16);
+  |                ^
   = note: this error originates in the derive macro `Deserialize` (in Nightly builds, run with -Z macro-backtrace for more info)
 help: you can convert a `u8` to a `u16`
   |

test_suite/tests/ui/remote/wrong_getter.stderr

@@ -2,8 +2,16 @@ error[E0308]: mismatched types
   --> tests/ui/remote/wrong_getter.rs:15:10
    |
 15 | #[derive(Serialize)]
-   |          ^^^^^^^^^ expected `u8`, found `u16`
+   |          ^^^^^^^^^
+   |          |
+   |          expected `u8`, found `u16`
+   |          arguments to this function are incorrect
    |
    = note: expected reference `&u8`
               found reference `&u16`
+note: function defined here
+  --> $WORKSPACE/serde/src/private/ser.rs
+   |
+   | pub fn constrain<T: ?Sized>(t: &T) -> &T {
+   |        ^^^^^^^^^
    = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

test_suite/tests/ui/remote/wrong_ser.stderr

@@ -1,9 +1,17 @@
 error[E0308]: mismatched types
- --> tests/ui/remote/wrong_ser.rs:9:10
+  --> tests/ui/remote/wrong_ser.rs:9:10
-  |
+   |
-9 | #[derive(Serialize)]
+9  | #[derive(Serialize)]
-  |          ^^^^^^^^^ expected `u8`, found `u16`
+   |          ^^^^^^^^^
-  |
+   |          |
-  = note: expected reference `&u8`
+   |          expected `u8`, found `u16`
-             found reference `&u16`
+   |          arguments to this function are incorrect
-  = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)
+   |
+   = note: expected reference `&u8`
+              found reference `&u16`
+note: function defined here
+  --> $WORKSPACE/serde/src/private/ser.rs
+   |
+   | pub fn constrain<T: ?Sized>(t: &T) -> &T {
+   |        ^^^^^^^^^
+   = note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)

wa-serde-derive/.gitignore

@@ -0,0 +1 @@
+*.wasm

wa-serde-derive/Cargo.toml

@@ -0,0 +1,17 @@
+[package]
+name = "wa-serde-derive"
+version = "0.1.137"
+authors = ["David Tolnay <dtolnay@gmail.com>"]
+license = "MIT OR Apache-2.0"
+description = "serde_derive compiled to wasm"
+repository = "https://github.com/dtolnay/watt"
+include = ["src"]
+
+[lib]
+name = "serde_derive"
+proc-macro = true
+
+[dependencies]
+watt = "0.4"
+
+[workspace]

wa-serde-derive/src/lib.rs

@@ -0,0 +1,18 @@
+extern crate proc_macro;
+extern crate watt;
+
+use proc_macro::TokenStream;
+use watt::WasmMacro;
+
+static MACRO: WasmMacro = WasmMacro::new(WASM);
+static WASM: &[u8] = include_bytes!("serde_derive.wasm");
+
+#[proc_macro_derive(Serialize, attributes(serde))]
+pub fn derive_serialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_serialize", input)
+}
+
+#[proc_macro_derive(Deserialize, attributes(serde))]
+pub fn derive_deserialize(input: TokenStream) -> TokenStream {
+    MACRO.proc_macro_derive("derive_deserialize", input)
+}