mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-23 05:58:01 +00:00
Compare commits
34 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 David Tolnay
|
af31449cb1 | ||
|
David Tolnay
|
1afae183b0 | ||
|
David Tolnay
|
845b900fd5 | ||
|
David Tolnay
|
7891ae7184 | ||
|
David Tolnay
|
bac90d19b9 | ||
|
David Tolnay
|
227bf3023a | ||
|
David Tolnay
|
f4535f68c1 | ||
|
David Tolnay
|
c6c35b5a31 | ||
|
David Tolnay
|
31e51324e2 | ||
|
David Tolnay
|
bc3f24e0e9 | ||
|
David Tolnay
|
2e38e2bf2f | ||
|
David Tolnay
|
819f90d9f6 | ||
|
David Tolnay
|
2eed86cd67 | ||
|
David Tolnay
|
3921b57435 | ||
|
David Tolnay
|
68069d734a | ||
|
David Tolnay
|
dc84693507 | ||
|
David Tolnay
|
4cf012c5be | ||
|
David Tolnay
|
17c3c0cf86 | ||
|
David Tolnay
|
210e6c354e | ||
|
David Tolnay
|
41823a96df | ||
|
David Tolnay
|
7ca13ff240 | ||
|
David Tolnay
|
52391fd868 | ||
|
David Tolnay
|
9b2d8dfc6b | ||
|
David Tolnay
|
07ba7ea8dd | ||
|
David Tolnay
|
9f29f6bb4a | ||
|
David Tolnay
|
f6c104fd1d | ||
|
David Tolnay
|
8a3a6fb101 | ||
|
David Tolnay
|
b5c3b5e8e5 | ||
|
David Tolnay
|
996d171461 | ||
|
Alex Touchet
|
e1c4517335 | ||
|
David Tolnay
|
6e94a27c76 | ||
|
David Tolnay
|
b23a768414 | ||
|
David Tolnay
|
7e19ae8c94 | ||
|
David Tolnay
|
404a1d142a |
@@ -0,0 +1 @@
|
||||
test_suite/tests/expand/*.expanded.rs linguist-generated
|
||||
+41
-11
@@ -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
|
||||
|
||||
@@ -1,7 +1,6 @@
|
||||
[workspace]
|
||||
members = [
|
||||
"serde",
|
||||
"serde_derive",
|
||||
"serde_derive_internals",
|
||||
"serde_test",
|
||||
"test_suite",
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
msrv = "1.13.0"
|
||||
+3
-3
@@ -1,8 +1,8 @@
|
||||
[package]
|
||||
name = "serde"
|
||||
version = "1.0.136" # 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.136", 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" }
|
||||
|
||||
@@ -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))
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
+1
-1
@@ -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
|
||||
|
||||
@@ -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,
|
||||
{
|
||||
|
||||
+6
-7
@@ -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.136")]
|
||||
#![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,
|
||||
redundant_static_lifetimes,
|
||||
type_repetition_in_bounds, // https://github.com/rust-lang/rust-clippy/issues/8772
|
||||
// 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,
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
msrv = "1.31.0"
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "serde_derive"
|
||||
version = "1.0.136" # 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"
|
||||
proc-macro = true
|
||||
crate-type = ["cdylib"]
|
||||
|
||||
[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" }
|
||||
|
||||
@@ -184,9 +184,7 @@ pub fn with_bound(
|
||||
|
||||
syn::Type::Infer(_) | syn::Type::Never(_) | syn::Type::Verbatim(_) => {}
|
||||
|
||||
#[cfg(test)]
|
||||
syn::Type::__TestExhaustive(_) => unimplemented!(),
|
||||
#[cfg(not(test))]
|
||||
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1912,9 +1912,7 @@ fn collect_lifetimes(ty: &syn::Type, out: &mut BTreeSet<syn::Lifetime>) {
|
||||
| syn::Type::Infer(_)
|
||||
| syn::Type::Verbatim(_) => {}
|
||||
|
||||
#[cfg(test)]
|
||||
syn::Type::__TestExhaustive(_) => unimplemented!(),
|
||||
#[cfg(not(test))]
|
||||
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -147,9 +147,7 @@ impl ReplaceReceiver<'_> {
|
||||
|
||||
Type::Infer(_) | Type::Never(_) | Type::Verbatim(_) => {}
|
||||
|
||||
#[cfg(test)]
|
||||
Type::__TestExhaustive(_) => unimplemented!(),
|
||||
#[cfg(not(test))]
|
||||
#[cfg_attr(all(test, exhaustive), deny(non_exhaustive_omitted_patterns))]
|
||||
_ => {}
|
||||
}
|
||||
}
|
||||
|
||||
+21
-16
@@ -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.136")]
|
||||
#![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))]
|
||||
pub fn derive_serialize(input: TokenStream) -> TokenStream {
|
||||
let mut input = parse_macro_input!(input as DeriveInput);
|
||||
ser::expand_derive_serialize(&mut input)
|
||||
.unwrap_or_else(to_compile_errors)
|
||||
.into()
|
||||
#[no_mangle]
|
||||
pub extern "C" fn derive_serialize(input: TokenStream) -> TokenStream {
|
||||
let mut input: DeriveInput = match syn::parse2(input) {
|
||||
Ok(input) => input,
|
||||
Err(err) => return err.to_compile_error(),
|
||||
};
|
||||
|
||||
ser::expand_derive_serialize(&mut input).unwrap_or_else(to_compile_errors)
|
||||
}
|
||||
|
||||
#[proc_macro_derive(Deserialize, attributes(serde))]
|
||||
pub fn derive_deserialize(input: TokenStream) -> TokenStream {
|
||||
let mut input = parse_macro_input!(input as DeriveInput);
|
||||
de::expand_derive_deserialize(&mut input)
|
||||
.unwrap_or_else(to_compile_errors)
|
||||
.into()
|
||||
#[no_mangle]
|
||||
pub extern "C" fn derive_deserialize(input: TokenStream) -> TokenStream {
|
||||
let mut input: DeriveInput = match syn::parse2(input) {
|
||||
Ok(input) => input,
|
||||
Err(err) => return err.to_compile_error(),
|
||||
};
|
||||
|
||||
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)*)
|
||||
}
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
msrv = "1.31.0"
|
||||
@@ -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"]
|
||||
|
||||
@@ -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,
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
msrv = "1.13.0"
|
||||
@@ -1,8 +1,8 @@
|
||||
[package]
|
||||
name = "serde_test"
|
||||
version = "1.0.136" # 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"
|
||||
|
||||
@@ -144,7 +144,7 @@
|
||||
//! # }
|
||||
//! ```
|
||||
|
||||
#![doc(html_root_url = "https://docs.rs/serde_test/1.0.136")]
|
||||
#![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
|
||||
)
|
||||
|
||||
@@ -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_derive = { path = "../serde_derive", features = ["deserialize_in_place"] }
|
||||
serde = { path = "../serde", features = ["rc"] }
|
||||
wa-serde-derive = { path = "../wa-serde-derive" }
|
||||
serde_test = { path = "../serde_test" }
|
||||
trybuild = { version = "1.0.49", features = ["diff"] }
|
||||
|
||||
[workspace]
|
||||
|
||||
+1
-5
@@ -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");
|
||||
}
|
||||
}
|
||||
|
||||
@@ -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();
|
||||
|
||||
+161
-172
@@ -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 {
|
||||
ref a,
|
||||
ref b,
|
||||
ref c,
|
||||
ref d,
|
||||
} => {
|
||||
DeEnum::Map { 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(
|
||||
__serializer,
|
||||
"DeEnum",
|
||||
3u32,
|
||||
"_Unit2",
|
||||
),
|
||||
DeEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
|
||||
DeEnum::_Unit2 => {
|
||||
_serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"DeEnum",
|
||||
3u32,
|
||||
"_Unit2",
|
||||
)
|
||||
}
|
||||
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 {
|
||||
ref a,
|
||||
ref b,
|
||||
ref c,
|
||||
ref d,
|
||||
} => {
|
||||
DeEnum::_Map2 { 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),
|
||||
&"variant index 0 <= i < 6",
|
||||
)),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
__value, VARIANTS,
|
||||
))
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
__field0, __field1, __field2, __field3,
|
||||
))
|
||||
_serde::__private::Ok(
|
||||
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> =
|
||||
_serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<B> =
|
||||
_serde::__private::None;
|
||||
let mut __field2: _serde::__private::Option<C> =
|
||||
_serde::__private::None;
|
||||
let mut __field3: _serde::__private::Option<D> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
|
||||
let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
|
||||
let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
|
||||
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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<i8>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<B>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<C>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<D>(&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(
|
||||
__field0, __field1, __field2, __field3,
|
||||
))
|
||||
_serde::__private::Ok(
|
||||
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> =
|
||||
_serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<B> =
|
||||
_serde::__private::None;
|
||||
let mut __field2: _serde::__private::Option<C> =
|
||||
_serde::__private::None;
|
||||
let mut __field3: _serde::__private::Option<D> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<i8> = _serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
|
||||
let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
|
||||
let mut __field3: _serde::__private::Option<D> = _serde::__private::None;
|
||||
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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<i8>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<B>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<C>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<D>(&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] =
|
||||
&["Unit", "Seq", "Map", "_Unit2", "_Seq2", "_Map2"];
|
||||
const VARIANTS: &'static [&'static str] = &[
|
||||
"Unit",
|
||||
"Seq",
|
||||
"Map",
|
||||
"_Unit2",
|
||||
"_Seq2",
|
||||
"_Map2",
|
||||
];
|
||||
_serde::Deserializer::deserialize_enum(
|
||||
__deserializer,
|
||||
"DeEnum",
|
||||
|
||||
+93
-55
@@ -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> {
|
||||
fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
|
||||
impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de>
|
||||
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>>(
|
||||
&mut __seq,
|
||||
) {
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
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(
|
||||
0usize,
|
||||
&"struct DefaultTyParam with 1 element",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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>> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
|
||||
let mut __field0: _serde::__private::Option<PhantomData<T>> = _serde::__private::None;
|
||||
while let _serde::__private::Some(__key)
|
||||
= match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
|
||||
_serde::__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>>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<
|
||||
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>
|
||||
for __Visitor<'de, 'place, T>
|
||||
{
|
||||
impl<
|
||||
'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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.phantom),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct DefaultTyParam with 1 element",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.phantom),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_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) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&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 __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(())
|
||||
}
|
||||
}
|
||||
|
||||
+100
-69
@@ -24,12 +24,14 @@ const _: () = {
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {
|
||||
GenericEnum::Unit => _serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
0u32,
|
||||
"Unit",
|
||||
),
|
||||
GenericEnum::Unit => {
|
||||
_serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
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),
|
||||
&"variant index 0 <= i < 4",
|
||||
)),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
__value, VARIANTS,
|
||||
))
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
_serde::de::VariantAccess::newtype_variant::<T>(__variant),
|
||||
GenericEnum::NewType,
|
||||
),
|
||||
(__Field::__field1, __variant) => {
|
||||
_serde::__private::Result::map(
|
||||
_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> =
|
||||
_serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<U> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<U> = _serde::__private::None;
|
||||
while let _serde::__private::Some(__key)
|
||||
= match _serde::de::MapAccess::next_key::<
|
||||
__Field,
|
||||
>(&mut __map) {
|
||||
_serde::__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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<T>(&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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<U>(&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);
|
||||
|
||||
+112
-66
@@ -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(
|
||||
0usize,
|
||||
&"struct GenericStruct with 1 element",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&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) {
|
||||
@@ -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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.x),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct GenericStruct with 1 element",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.x),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_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) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&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 __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(
|
||||
0usize,
|
||||
&"tuple struct GenericNewTypeStruct with 1 element",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct GenericNewTypeStruct with 1 element",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct GenericNewTypeStruct with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
|
||||
+55
-40
@@ -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(
|
||||
0usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
1usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.1),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.1),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
|
||||
+109
-73
@@ -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),
|
||||
&"variant index 0 <= i < 4",
|
||||
)),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
__value, VARIANTS,
|
||||
))
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
_serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
|
||||
Lifetimes::LifetimeSeq,
|
||||
),
|
||||
(__Field::__field1, __variant) => _serde::__private::Result::map(
|
||||
_serde::de::VariantAccess::newtype_variant::<i32>(__variant),
|
||||
Lifetimes::NoLifetimeSeq,
|
||||
),
|
||||
(__Field::__field0, __variant) => {
|
||||
_serde::__private::Result::map(
|
||||
_serde::de::VariantAccess::newtype_variant::<
|
||||
&'a i32,
|
||||
>(__variant),
|
||||
Lifetimes::LifetimeSeq,
|
||||
)
|
||||
}
|
||||
(__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> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<&'a i32> = _serde::__private::None;
|
||||
while let _serde::__private::Some(__key)
|
||||
= match _serde::de::MapAccess::next_key::<
|
||||
__Field,
|
||||
>(&mut __map) {
|
||||
_serde::__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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<
|
||||
&'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> =
|
||||
_serde::__private::None;
|
||||
while let _serde::__private::Some(__key) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<i32> = _serde::__private::None;
|
||||
while let _serde::__private::Some(__key)
|
||||
= match _serde::de::MapAccess::next_key::<
|
||||
__Field,
|
||||
>(&mut __map) {
|
||||
_serde::__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>(
|
||||
&mut __map,
|
||||
) {
|
||||
match _serde::de::MapAccess::next_value::<i32>(&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"];
|
||||
|
||||
+146
-88
@@ -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(
|
||||
0usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
1usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
2usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&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) {
|
||||
@@ -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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.a),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.a),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.b),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.b),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.c),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
2usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.c),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_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) =
|
||||
match _serde::de::MapAccess::next_key::<__Field>(&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 __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(())
|
||||
}
|
||||
}
|
||||
|
||||
+91
-62
@@ -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(
|
||||
0usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
1usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
2usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
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(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.0),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.1),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.1),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.2),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(_serde::de::Error::invalid_length(
|
||||
2usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
));
|
||||
if let _serde::__private::None
|
||||
= match _serde::de::SeqAccess::next_element_seed(
|
||||
&mut __seq,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.2),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
2usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
|
||||
+12
-3
@@ -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,
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
|
||||
+24
-25
@@ -31,12 +31,14 @@ const _: () = {
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {
|
||||
SerEnum::Unit => _serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
0u32,
|
||||
"Unit",
|
||||
),
|
||||
SerEnum::Unit => {
|
||||
_serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
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 {
|
||||
ref a,
|
||||
ref b,
|
||||
ref c,
|
||||
ref d,
|
||||
} => {
|
||||
SerEnum::Map { 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(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
3u32,
|
||||
"_Unit2",
|
||||
),
|
||||
SerEnum::_Seq2(ref __field0, ref __field1, ref __field2, ref __field3) => {
|
||||
SerEnum::_Unit2 => {
|
||||
_serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
3u32,
|
||||
"_Unit2",
|
||||
)
|
||||
}
|
||||
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 {
|
||||
ref a,
|
||||
ref b,
|
||||
ref c,
|
||||
ref d,
|
||||
} => {
|
||||
SerEnum::_Map2 { ref a, ref b, ref c, ref d } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
|
||||
Generated
+31
-14
@@ -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),
|
||||
&"variant index 0 <= i < 0",
|
||||
)),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_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(
|
||||
__value, VARIANTS,
|
||||
))
|
||||
_serde::__private::Err(
|
||||
_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> {
|
||||
|
||||
@@ -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() {
|
||||
|
||||
@@ -1,3 +1,5 @@
|
||||
#![allow(unused_macro_rules)]
|
||||
|
||||
use serde_test::Token;
|
||||
use std::iter;
|
||||
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -1,8 +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};
|
||||
|
||||
@@ -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;
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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 {
|
||||
|
||||
@@ -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,
|
||||
};
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::redundant_field_names)]
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
|
||||
mod remote {
|
||||
pub struct Unit;
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
#![allow(clippy::used_underscore_binding)]
|
||||
|
||||
use serde::{Deserialize, Serialize};
|
||||
use serde_derive::{Deserialize, Serialize};
|
||||
|
||||
#[test]
|
||||
fn test_self() {
|
||||
|
||||
@@ -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]
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -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
|
||||
|
||||
@@ -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;
|
||||
|
||||
|
||||
@@ -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`
|
||||
|
|
||||
|
||||
@@ -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)
|
||||
|
||||
@@ -1,9 +1,17 @@
|
||||
error[E0308]: mismatched types
|
||||
--> tests/ui/remote/wrong_ser.rs:9:10
|
||||
|
|
||||
9 | #[derive(Serialize)]
|
||||
| ^^^^^^^^^ expected `u8`, found `u16`
|
||||
|
|
||||
= note: expected reference `&u8`
|
||||
found reference `&u16`
|
||||
= note: this error originates in the derive macro `Serialize` (in Nightly builds, run with -Z macro-backtrace for more info)
|
||||
--> tests/ui/remote/wrong_ser.rs:9:10
|
||||
|
|
||||
9 | #[derive(Serialize)]
|
||||
| ^^^^^^^^^
|
||||
| |
|
||||
| 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)
|
||||
|
||||
@@ -0,0 +1 @@
|
||||
*.wasm
|
||||
@@ -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]
|
||||
@@ -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)
|
||||
}
|
||||
Reference in New Issue
Block a user