mirror of
https://github.com/pezkuwichain/serde.git
synced 2026-04-23 03:38:00 +00:00
Compare commits
30 Commits
| Author | SHA1 | Date | |
|---|---|---|---|
 David Tolnay
|
6a5da85fcd | ||
|
David Tolnay
|
0750eee4ff | ||
|
David Tolnay
|
ef551a517c | ||
|
David Tolnay
|
1c5ea24f76 | ||
|
David Tolnay
|
88d73e5250 | ||
|
David Tolnay
|
1ff2a972c6 | ||
|
David Tolnay
|
bb72fe2726 | ||
|
David Tolnay
|
e50b14afee | ||
|
David Tolnay
|
cbd1cbef07 | ||
|
bebecue
|
01da3f79c9 | ||
|
bebecue
|
f5e0fbcb14 | ||
|
Mingun
|
38c130a303 | ||
|
Mingun
|
c7393614ff | ||
|
David Tolnay
|
a13c6382b6 | ||
|
David Tolnay
|
f85c4f2fa9 | ||
|
David Tolnay
|
a9a9903107 | ||
|
David Tolnay
|
35e5cf3e15 | ||
|
David Tolnay
|
07fc9f689e | ||
|
David Tolnay
|
14b0e18c57 | ||
|
David Tolnay
|
dd27ec8703 | ||
|
David Tolnay
|
db3f00c3b3 | ||
|
David Tolnay
|
adcb11ca18 | ||
|
David Tolnay
|
b7be637e8c | ||
|
David Tolnay
|
30c4aa2cf4 | ||
|
David Tolnay
|
a649190a4d | ||
|
David Tolnay
|
d81f0ef652 | ||
|
David Tolnay
|
1a3a49ce7c | ||
|
David Tolnay
|
6b948111ca | ||
|
Niki4tap
|
6adfdc56e5 | ||
|
David Tolnay
|
61531ddd9e |
@@ -20,10 +20,6 @@ jobs:
|
||||
- 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)
|
||||
@@ -75,24 +71,6 @@ jobs:
|
||||
RUSTFLAGS: --cfg exhaustive ${{env.RUSTFLAGS}}
|
||||
if: matrix.os != 'windows'
|
||||
|
||||
msrv:
|
||||
name: Rust 1.13.0
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: dtolnay/rust-toolchain@1.13.0
|
||||
- name: Get timestamp for cache
|
||||
id: date
|
||||
run: echo yearmo=$(date +%Y%m) >> $GITHUB_OUTPUT
|
||||
- uses: actions/cache@v1
|
||||
with:
|
||||
path: ~/.cargo/registry/index
|
||||
key: cargo-registry-index-${{steps.date.outputs.yearmo}}
|
||||
- run: cd serde && cargo build --features rc
|
||||
- run: cd serde && cargo build --no-default-features
|
||||
- run: cd serde_test && cargo build
|
||||
|
||||
build:
|
||||
name: Rust ${{matrix.rust}}
|
||||
runs-on: ubuntu-latest
|
||||
@@ -106,8 +84,10 @@ jobs:
|
||||
- uses: dtolnay/rust-toolchain@master
|
||||
with:
|
||||
toolchain: ${{matrix.rust}}
|
||||
- run: cd serde && cargo build --features rc
|
||||
- run: cd serde && cargo build --no-default-features
|
||||
- run: cd serde && cargo build
|
||||
- run: cd serde_test && cargo build
|
||||
|
||||
more:
|
||||
name: Rust ${{matrix.rust}}
|
||||
@@ -147,29 +127,6 @@ jobs:
|
||||
- uses: dtolnay/rust-toolchain@1.36.0
|
||||
- run: cd serde && cargo build --no-default-features --features alloc
|
||||
|
||||
emscripten:
|
||||
name: Emscripten
|
||||
runs-on: ubuntu-latest
|
||||
timeout-minutes: 45
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: dtolnay/rust-toolchain@nightly
|
||||
- uses: actions/setup-node@v1
|
||||
with:
|
||||
node-version: 9
|
||||
- name: Install cargo-web
|
||||
run: |
|
||||
CARGO_WEB_RELEASE=$(curl -L -s -H Accept:application/json https://github.com/koute/cargo-web/releases/latest)
|
||||
CARGO_WEB_VERSION=$(echo "${CARGO_WEB_RELEASE}" | jq -r .tag_name)
|
||||
CARGO_WEB_URL="https://github.com/koute/cargo-web/releases/download/${CARGO_WEB_VERSION}/cargo-web-x86_64-unknown-linux-gnu.gz"
|
||||
mkdir -p ~/.cargo/bin
|
||||
curl -L "${CARGO_WEB_URL}" | gzip -d > ~/.cargo/bin/cargo-web
|
||||
chmod +x ~/.cargo/bin/cargo-web
|
||||
- run: cd test_suite && cargo web test --target=asmjs-unknown-emscripten --nodejs
|
||||
continue-on-error: true
|
||||
- run: cd test_suite && cargo web test --target=wasm32-unknown-emscripten --nodejs
|
||||
continue-on-error: true
|
||||
|
||||
clippy:
|
||||
name: Clippy
|
||||
runs-on: ubuntu-latest
|
||||
@@ -207,4 +164,4 @@ jobs:
|
||||
steps:
|
||||
- uses: actions/checkout@v3
|
||||
- uses: dtolnay/install@cargo-outdated
|
||||
- run: cargo outdated --workspace --exclude macrotest,prettyplease --exit-code 1
|
||||
- run: cargo outdated --workspace --exit-code 1
|
||||
|
||||
@@ -174,28 +174,3 @@ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
|
||||
of your accepting any such warranty or additional liability.
|
||||
|
||||
END OF TERMS AND CONDITIONS
|
||||
|
||||
APPENDIX: How to apply the Apache License to your work.
|
||||
|
||||
To apply the Apache License to your work, attach the following
|
||||
boilerplate notice, with the fields enclosed by brackets "[]"
|
||||
replaced with your own identifying information. (Don't include
|
||||
the brackets!) The text should be enclosed in the appropriate
|
||||
comment syntax for the file format. We also recommend that a
|
||||
file or class name and description of purpose be included on the
|
||||
same "printed page" as the copyright notice for easier
|
||||
identification within third-party archives.
|
||||
|
||||
Copyright [yyyy] [name of copyright owner]
|
||||
|
||||
Licensed under the Apache License, Version 2.0 (the "License");
|
||||
you may not use this file except in compliance with the License.
|
||||
You may obtain a copy of the License at
|
||||
|
||||
http://www.apache.org/licenses/LICENSE-2.0
|
||||
|
||||
Unless required by applicable law or agreed to in writing, software
|
||||
distributed under the License is distributed on an "AS IS" BASIS,
|
||||
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
See the License for the specific language governing permissions and
|
||||
limitations under the License.
|
||||
|
||||
@@ -1,12 +1,12 @@
|
||||
# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.13+]][Rust 1.13] [![serde_derive: rustc 1.31+]][Rust 1.31]
|
||||
# Serde   [![Build Status]][actions] [![Latest Version]][crates.io] [![serde: rustc 1.19+]][Rust 1.19] [![serde_derive: rustc 1.31+]][Rust 1.31]
|
||||
|
||||
[Build Status]: https://img.shields.io/github/actions/workflow/status/serde-rs/serde/ci.yml?branch=master
|
||||
[actions]: https://github.com/serde-rs/serde/actions?query=branch%3Amaster
|
||||
[Latest Version]: https://img.shields.io/crates/v/serde.svg
|
||||
[crates.io]: https://crates.io/crates/serde
|
||||
[serde: rustc 1.13+]: https://img.shields.io/badge/serde-rustc_1.13+-lightgray.svg
|
||||
[serde: rustc 1.19+]: https://img.shields.io/badge/serde-rustc_1.19+-lightgray.svg
|
||||
[serde_derive: rustc 1.31+]: https://img.shields.io/badge/serde_derive-rustc_1.31+-lightgray.svg
|
||||
[Rust 1.13]: https://blog.rust-lang.org/2016/11/10/Rust-1.13.html
|
||||
[Rust 1.19]: https://blog.rust-lang.org/2017/07/20/Rust-1.19.html
|
||||
[Rust 1.31]: https://blog.rust-lang.org/2018/12/06/Rust-1.31-and-rust-2018.html
|
||||
|
||||
**Serde is a framework for *ser*ializing and *de*serializing Rust data structures efficiently and generically.**
|
||||
|
||||
+3
-3
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "serde"
|
||||
version = "1.0.152" # remember to update html_root_url and serde_derive dependency
|
||||
version = "1.0.154" # remember to update html_root_url and serde_derive dependency
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
|
||||
build = "build.rs"
|
||||
categories = ["encoding", "no-std"]
|
||||
@@ -12,10 +12,10 @@ keywords = ["serde", "serialization", "no_std"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
readme = "crates-io.md"
|
||||
repository = "https://github.com/serde-rs/serde"
|
||||
rust-version = "1.13"
|
||||
rust-version = "1.19"
|
||||
|
||||
[dependencies]
|
||||
serde_derive = { version = "=1.0.152", optional = true, path = "../serde_derive" }
|
||||
serde_derive = { version = "=1.0.154", optional = true, path = "../serde_derive" }
|
||||
|
||||
[dev-dependencies]
|
||||
serde_derive = { version = "1.0", path = "../serde_derive" }
|
||||
|
||||
+5
-1
@@ -45,6 +45,8 @@
|
||||
//! definition.
|
||||
//! - [JSON5], a superset of JSON including some productions from ES5.
|
||||
//! - [URL] query strings, in the x-www-form-urlencoded format.
|
||||
//! - [Starlark], the format used for describing build targets by the Bazel and
|
||||
//! Buck build systems. *(serialization only)*
|
||||
//! - [Envy], a way to deserialize environment variables into Rust structs.
|
||||
//! *(deserialization only)*
|
||||
//! - [Envy Store], a way to deserialize [AWS Parameter Store] parameters into
|
||||
@@ -74,6 +76,7 @@
|
||||
//! [Avro]: https://docs.rs/apache-avro
|
||||
//! [JSON5]: https://github.com/callum-oakley/json5-rs
|
||||
//! [URL]: https://docs.rs/serde_qs
|
||||
//! [Starlark]: https://github.com/dtolnay/serde-starlark
|
||||
//! [Envy]: https://github.com/softprops/envy
|
||||
//! [Envy Store]: https://github.com/softprops/envy-store
|
||||
//! [Cargo]: https://doc.rust-lang.org/cargo/reference/manifest.html
|
||||
@@ -90,7 +93,7 @@
|
||||
////////////////////////////////////////////////////////////////////////////////
|
||||
|
||||
// Serde types in rustdoc of other crates get linked to here.
|
||||
#![doc(html_root_url = "https://docs.rs/serde/1.0.152")]
|
||||
#![doc(html_root_url = "https://docs.rs/serde/1.0.154")]
|
||||
// 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
|
||||
@@ -127,6 +130,7 @@
|
||||
derive_partial_eq_without_eq,
|
||||
enum_glob_use,
|
||||
explicit_auto_deref,
|
||||
let_underscore_untyped,
|
||||
map_err_ignore,
|
||||
new_without_default,
|
||||
result_unit_err,
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "serde_derive"
|
||||
version = "1.0.152" # remember to update html_root_url
|
||||
version = "1.0.154" # remember to update html_root_url
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
|
||||
categories = ["no-std"]
|
||||
description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"
|
||||
|
||||
+10
-6
@@ -954,6 +954,7 @@ fn deserialize_struct(
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
}
|
||||
};
|
||||
let need_seed = deserializer.is_none();
|
||||
let dispatch = if let Some(deserializer) = deserializer {
|
||||
quote! {
|
||||
_serde::Deserializer::deserialize_any(#deserializer, #visitor_expr)
|
||||
@@ -999,14 +1000,14 @@ fn deserialize_struct(
|
||||
_ => None,
|
||||
};
|
||||
|
||||
let visitor_seed = if is_enum && cattrs.has_flatten() {
|
||||
let visitor_seed = if need_seed && is_enum && cattrs.has_flatten() {
|
||||
Some(quote! {
|
||||
impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
|
||||
type Value = #this_type #ty_generics;
|
||||
|
||||
fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
__D: _serde::Deserializer<#delife>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_map(__deserializer, self)
|
||||
}
|
||||
@@ -1256,7 +1257,7 @@ fn deserialize_externally_tagged_enum(
|
||||
// This is an empty enum like `enum Impossible {}` or an enum in which
|
||||
// all variants have `#[serde(skip_deserializing)]`.
|
||||
quote! {
|
||||
// FIXME: Once we drop support for Rust 1.15:
|
||||
// FIXME: Once feature(exhaustive_patterns) is stable:
|
||||
// let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
|
||||
// _serde::__private::Err(__err)
|
||||
_serde::__private::Result::map(
|
||||
@@ -2400,7 +2401,10 @@ fn deserialize_struct_as_struct_visitor(
|
||||
.collect();
|
||||
|
||||
let fields_stmt = {
|
||||
let field_names = field_names_idents.iter().map(|(name, _, _)| name);
|
||||
let field_names = field_names_idents
|
||||
.iter()
|
||||
.flat_map(|(_, _, aliases)| aliases);
|
||||
|
||||
quote_block! {
|
||||
const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
|
||||
}
|
||||
@@ -2535,7 +2539,7 @@ fn deserialize_map(
|
||||
let all_skipped = fields.iter().all(|field| field.attrs.skip_deserializing());
|
||||
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
|
||||
quote! {
|
||||
// FIXME: Once we drop support for Rust 1.15:
|
||||
// FIXME: Once feature(exhaustive_patterns) is stable:
|
||||
// let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
|
||||
_serde::__private::Option::map(
|
||||
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
|
||||
@@ -2768,7 +2772,7 @@ fn deserialize_map_in_place(
|
||||
|
||||
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
|
||||
quote! {
|
||||
// FIXME: Once we drop support for Rust 1.15:
|
||||
// FIXME: Once feature(exhaustive_patterns) is stable:
|
||||
// let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
|
||||
_serde::__private::Option::map(
|
||||
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
|
||||
|
||||
@@ -39,10 +39,6 @@ pub fn wrap_in_const(
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
fn unraw(ident: &Ident) -> String {
|
||||
// str::trim_start_matches was added in 1.30, trim_left_matches deprecated
|
||||
// in 1.33. We currently support rustc back to 1.15 so we need to continue
|
||||
// to use the deprecated one.
|
||||
ident.to_string().trim_left_matches("r#").to_owned()
|
||||
ident.to_string().trim_start_matches("r#").to_owned()
|
||||
}
|
||||
|
||||
@@ -141,12 +141,8 @@ pub struct Name {
|
||||
deserialize_aliases: Vec<String>,
|
||||
}
|
||||
|
||||
#[allow(deprecated)]
|
||||
fn unraw(ident: &Ident) -> String {
|
||||
// str::trim_start_matches was added in 1.30, trim_left_matches deprecated
|
||||
// in 1.33. We currently support rustc back to 1.15 so we need to continue
|
||||
// to use the deprecated one.
|
||||
ident.to_string().trim_left_matches("r#").to_owned()
|
||||
ident.to_string().trim_start_matches("r#").to_owned()
|
||||
}
|
||||
|
||||
impl Name {
|
||||
|
||||
@@ -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.152")]
|
||||
#![doc(html_root_url = "https://docs.rs/serde_derive/1.0.154")]
|
||||
#![allow(unknown_lints, bare_trait_objects)]
|
||||
// Ignored clippy lints
|
||||
#![allow(
|
||||
@@ -43,6 +43,7 @@
|
||||
clippy::enum_glob_use,
|
||||
clippy::indexing_slicing,
|
||||
clippy::items_after_statements,
|
||||
clippy::let_underscore_untyped,
|
||||
clippy::manual_assert,
|
||||
clippy::map_err_ignore,
|
||||
clippy::match_same_arms,
|
||||
|
||||
@@ -22,6 +22,7 @@
|
||||
clippy::doc_markdown,
|
||||
clippy::enum_glob_use,
|
||||
clippy::items_after_statements,
|
||||
clippy::let_underscore_untyped,
|
||||
clippy::manual_assert,
|
||||
clippy::match_same_arms,
|
||||
// clippy bug: https://github.com/rust-lang/rust-clippy/issues/6984
|
||||
|
||||
@@ -1,6 +1,6 @@
|
||||
[package]
|
||||
name = "serde_test"
|
||||
version = "1.0.152" # remember to update html_root_url
|
||||
version = "1.0.154" # remember to update html_root_url
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
|
||||
build = "build.rs"
|
||||
categories = ["development-tools::testing"]
|
||||
@@ -12,7 +12,7 @@ keywords = ["serde", "serialization", "testing", "dev-dependencies"]
|
||||
license = "MIT OR Apache-2.0"
|
||||
readme = "crates-io.md"
|
||||
repository = "https://github.com/serde-rs/serde"
|
||||
rust-version = "1.13"
|
||||
rust-version = "1.19"
|
||||
|
||||
[dependencies]
|
||||
serde = { version = "1.0.60", path = "../serde" }
|
||||
|
||||
@@ -140,7 +140,7 @@
|
||||
//! # }
|
||||
//! ```
|
||||
|
||||
#![doc(html_root_url = "https://docs.rs/serde_test/1.0.152")]
|
||||
#![doc(html_root_url = "https://docs.rs/serde_test/1.0.154")]
|
||||
#![cfg_attr(feature = "cargo-clippy", allow(renamed_and_removed_lints))]
|
||||
// Ignored clippy lints
|
||||
#![cfg_attr(feature = "cargo-clippy", allow(float_cmp, needless_doctest_main))]
|
||||
|
||||
@@ -2,24 +2,17 @@
|
||||
name = "serde_test_suite"
|
||||
version = "0.0.0"
|
||||
authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>", "David Tolnay <dtolnay@gmail.com>"]
|
||||
build = "build.rs"
|
||||
edition = "2018"
|
||||
publish = false
|
||||
|
||||
[features]
|
||||
expandtest = []
|
||||
unstable = ["serde/unstable"]
|
||||
|
||||
[dependencies]
|
||||
serde = { path = "../serde" }
|
||||
|
||||
[build-dependencies]
|
||||
toolchain_find = "0.2"
|
||||
|
||||
[dev-dependencies]
|
||||
fnv = "1.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"] }
|
||||
|
||||
@@ -1,27 +0,0 @@
|
||||
use std::process::{Command, ExitStatus, Stdio};
|
||||
|
||||
fn has_cargo_expand() -> bool {
|
||||
let cargo_expand = if cfg!(windows) {
|
||||
"cargo-expand.exe"
|
||||
} else {
|
||||
"cargo-expand"
|
||||
};
|
||||
|
||||
Command::new(cargo_expand)
|
||||
.arg("--version")
|
||||
.stdin(Stdio::null())
|
||||
.stdout(Stdio::null())
|
||||
.stderr(Stdio::null())
|
||||
.status()
|
||||
.as_ref()
|
||||
.map(ExitStatus::success)
|
||||
.unwrap_or(false)
|
||||
}
|
||||
|
||||
fn main() {
|
||||
println!("cargo:rerun-if-changed=build.rs");
|
||||
|
||||
if cfg!(feature = "expandtest") && has_cargo_expand() {
|
||||
println!("cargo:rustc-cfg=expandtest");
|
||||
}
|
||||
}
|
||||
-1415
File diff suppressed because it is too large
Load Diff
@@ -1,13 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
enum DeEnum<B, C, D> {
|
||||
Unit,
|
||||
Seq(i8, B, C, D),
|
||||
Map { a: i8, b: B, c: C, d: D },
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(i8, B, C, D),
|
||||
_Map2 { a: i8, b: B, c: C, d: D },
|
||||
}
|
||||
-448
@@ -1,448 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
trait AssociatedType {
|
||||
type X;
|
||||
}
|
||||
impl AssociatedType for i32 {
|
||||
type X = i32;
|
||||
}
|
||||
struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
|
||||
phantom: PhantomData<T>,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct(
|
||||
__serializer,
|
||||
"DefaultTyParam",
|
||||
false as usize + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
"phantom",
|
||||
&self.phantom,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStruct::end(__serde_state)
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[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>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"phantom" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"phantom" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_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> {
|
||||
type Value = DefaultTyParam<T>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct DefaultTyParam",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
PhantomData<T>,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct DefaultTyParam with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(DefaultTyParam {
|
||||
phantom: __field0,
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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) {
|
||||
_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(
|
||||
"phantom",
|
||||
),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<
|
||||
PhantomData<T>,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("phantom") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(DefaultTyParam {
|
||||
phantom: __field0,
|
||||
})
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["phantom"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"DefaultTyParam",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<DefaultTyParam<T>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"phantom" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"phantom" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_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> {
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct DefaultTyParam",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
match __key {
|
||||
__Field::__field0 => {
|
||||
if __field0 {
|
||||
return _serde::__private::Err(
|
||||
<__A::Error as _serde::de::Error>::duplicate_field(
|
||||
"phantom",
|
||||
),
|
||||
);
|
||||
}
|
||||
match _serde::de::MapAccess::next_value_seed(
|
||||
&mut __map,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.phantom),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
__field0 = true;
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
if !__field0 {
|
||||
self
|
||||
.place
|
||||
.phantom = match _serde::__private::de::missing_field(
|
||||
"phantom",
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["phantom"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"DefaultTyParam",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,14 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
trait AssociatedType {
|
||||
type X;
|
||||
}
|
||||
|
||||
impl AssociatedType for i32 {
|
||||
type X = i32;
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct DefaultTyParam<T: AssociatedType<X = i32> = i32> {
|
||||
phantom: PhantomData<T>,
|
||||
}
|
||||
-621
@@ -1,621 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
pub enum GenericEnum<T, U> {
|
||||
Unit,
|
||||
NewType(T),
|
||||
Seq(T, U),
|
||||
Map { x: T, y: U },
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<T, U> _serde::Serialize for GenericEnum<T, U>
|
||||
where
|
||||
T: _serde::Serialize,
|
||||
U: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {
|
||||
GenericEnum::Unit => {
|
||||
_serde::Serializer::serialize_unit_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
0u32,
|
||||
"Unit",
|
||||
)
|
||||
}
|
||||
GenericEnum::NewType(ref __field0) => {
|
||||
_serde::Serializer::serialize_newtype_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
1u32,
|
||||
"NewType",
|
||||
__field0,
|
||||
)
|
||||
}
|
||||
GenericEnum::Seq(ref __field0, ref __field1) => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
2u32,
|
||||
"Seq",
|
||||
0 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field0,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeTupleVariant::end(__serde_state)
|
||||
}
|
||||
GenericEnum::Map { ref x, ref y } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"GenericEnum",
|
||||
3u32,
|
||||
"Map",
|
||||
0 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"x",
|
||||
x,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"y",
|
||||
y,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStructVariant::end(__serde_state)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, T, U> _serde::Deserialize<'de> for GenericEnum<T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__field1,
|
||||
__field2,
|
||||
__field3,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"variant identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
1u64 => _serde::__private::Ok(__Field::__field1),
|
||||
2u64 => _serde::__private::Ok(__Field::__field2),
|
||||
3u64 => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::invalid_value(
|
||||
_serde::de::Unexpected::Unsigned(__value),
|
||||
&"variant index 0 <= i < 4",
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"Unit" => _serde::__private::Ok(__Field::__field0),
|
||||
"NewType" => _serde::__private::Ok(__Field::__field1),
|
||||
"Seq" => _serde::__private::Ok(__Field::__field2),
|
||||
"Map" => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"Unit" => _serde::__private::Ok(__Field::__field0),
|
||||
b"NewType" => _serde::__private::Ok(__Field::__field1),
|
||||
b"Seq" => _serde::__private::Ok(__Field::__field2),
|
||||
b"Map" => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
let __value = &_serde::__private::from_utf8_lossy(__value);
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericEnum<T, U>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"enum GenericEnum",
|
||||
)
|
||||
}
|
||||
fn visit_enum<__A>(
|
||||
self,
|
||||
__data: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::EnumAccess<'de>,
|
||||
{
|
||||
match match _serde::de::EnumAccess::variant(__data) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
(__Field::__field0, __variant) => {
|
||||
match _serde::de::VariantAccess::unit_variant(__variant) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericEnum::Unit)
|
||||
}
|
||||
(__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
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T, U> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericEnum<T, U>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple variant GenericEnum::Seq",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
T,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple variant GenericEnum::Seq with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
let __field1 = match match _serde::de::SeqAccess::next_element::<
|
||||
U,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple variant GenericEnum::Seq with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
|
||||
}
|
||||
}
|
||||
_serde::de::VariantAccess::tuple_variant(
|
||||
__variant,
|
||||
2usize,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
(__Field::__field3, __variant) => {
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__field1,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
1u64 => _serde::__private::Ok(__Field::__field1),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"x" => _serde::__private::Ok(__Field::__field0),
|
||||
"y" => _serde::__private::Ok(__Field::__field1),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"x" => _serde::__private::Ok(__Field::__field0),
|
||||
b"y" => _serde::__private::Ok(__Field::__field1),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T, U> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericEnum<T, U>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct variant GenericEnum::Map",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
T,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct variant GenericEnum::Map with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
let __field1 = match match _serde::de::SeqAccess::next_element::<
|
||||
U,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"struct variant GenericEnum::Map with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericEnum::Map {
|
||||
x: __field0,
|
||||
y: __field1,
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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) {
|
||||
_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"),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<T>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
__Field::__field1 => {
|
||||
if _serde::__private::Option::is_some(&__field1) {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("x") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let __field1 = match __field1 {
|
||||
_serde::__private::Some(__field1) => __field1,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("y") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericEnum::Map {
|
||||
x: __field0,
|
||||
y: __field1,
|
||||
})
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["x", "y"];
|
||||
_serde::de::VariantAccess::struct_variant(
|
||||
__variant,
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const VARIANTS: &'static [&'static str] = &["Unit", "NewType", "Seq", "Map"];
|
||||
_serde::Deserializer::deserialize_enum(
|
||||
__deserializer,
|
||||
"GenericEnum",
|
||||
VARIANTS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,9 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub enum GenericEnum<T, U> {
|
||||
Unit,
|
||||
NewType(T),
|
||||
Seq(T, U),
|
||||
Map { x: T, y: U },
|
||||
}
|
||||
-640
@@ -1,640 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
pub struct GenericStruct<T> {
|
||||
x: T,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<T> _serde::Serialize for GenericStruct<T>
|
||||
where
|
||||
T: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct(
|
||||
__serializer,
|
||||
"GenericStruct",
|
||||
false as usize + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
"x",
|
||||
&self.x,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStruct::end(__serde_state)
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, T> _serde::Deserialize<'de> for GenericStruct<T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"x" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"x" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericStruct<T>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericStruct<T>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct GenericStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
T,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct GenericStruct with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericStruct { x: __field0 })
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__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) {
|
||||
_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"),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<T>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("x") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericStruct { x: __field0 })
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["x"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"GenericStruct",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericStruct<T>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"x" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"x" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, 'place, T: 'place>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
place: &'place mut GenericStruct<T>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, 'place, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct GenericStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
match __key {
|
||||
__Field::__field0 => {
|
||||
if __field0 {
|
||||
return _serde::__private::Err(
|
||||
<__A::Error as _serde::de::Error>::duplicate_field("x"),
|
||||
);
|
||||
}
|
||||
match _serde::de::MapAccess::next_value_seed(
|
||||
&mut __map,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.x),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
__field0 = true;
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
if !__field0 {
|
||||
self
|
||||
.place
|
||||
.x = match _serde::__private::de::missing_field("x") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["x"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"GenericStruct",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
pub struct GenericNewTypeStruct<T>(T);
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<T> _serde::Serialize for GenericNewTypeStruct<T>
|
||||
where
|
||||
T: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
_serde::Serializer::serialize_newtype_struct(
|
||||
__serializer,
|
||||
"GenericNewTypeStruct",
|
||||
&self.0,
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, T> _serde::Deserialize<'de> for GenericNewTypeStruct<T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericNewTypeStruct<T>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct GenericNewTypeStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_newtype_struct<__E>(
|
||||
self,
|
||||
__e: __E,
|
||||
) -> _serde::__private::Result<Self::Value, __E::Error>
|
||||
where
|
||||
__E: _serde::Deserializer<'de>,
|
||||
{
|
||||
let __field0: T = match <T as _serde::Deserialize>::deserialize(
|
||||
__e,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericNewTypeStruct(__field0))
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
T,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"tuple struct GenericNewTypeStruct with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericNewTypeStruct(__field0))
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_newtype_struct(
|
||||
__deserializer,
|
||||
"GenericNewTypeStruct",
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, 'place, T: 'place>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
place: &'place mut GenericNewTypeStruct<T>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, 'place, T: 'place> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, 'place, T>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct GenericNewTypeStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_newtype_struct<__E>(
|
||||
self,
|
||||
__e: __E,
|
||||
) -> _serde::__private::Result<Self::Value, __E::Error>
|
||||
where
|
||||
__E: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserialize::deserialize_in_place(__e, &mut self.place.0)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_newtype_struct(
|
||||
__deserializer,
|
||||
"GenericNewTypeStruct",
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,9 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct GenericStruct<T> {
|
||||
x: T,
|
||||
}
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
pub struct GenericNewTypeStruct<T>(T);
|
||||
@@ -1,187 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
pub struct GenericTupleStruct<T, U>(T, U);
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, T, U> _serde::Deserialize<'de> for GenericTupleStruct<T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<GenericTupleStruct<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = GenericTupleStruct<T, U>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct GenericTupleStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
T,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
1usize,
|
||||
&"tuple struct GenericTupleStruct with 2 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(GenericTupleStruct(__field0, __field1))
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_tuple_struct(
|
||||
__deserializer,
|
||||
"GenericTupleStruct",
|
||||
2usize,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<GenericTupleStruct<T, U>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, 'place, T: 'place, U: 'place>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
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>
|
||||
where
|
||||
T: _serde::Deserialize<'de>,
|
||||
U: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct GenericTupleStruct",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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.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(())
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_tuple_struct(
|
||||
__deserializer,
|
||||
"GenericTupleStruct",
|
||||
2usize,
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,4 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct GenericTupleStruct<T, U>(T, U);
|
||||
-643
@@ -1,643 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
enum Lifetimes<'a> {
|
||||
LifetimeSeq(&'a i32),
|
||||
NoLifetimeSeq(i32),
|
||||
LifetimeMap { a: &'a i32 },
|
||||
NoLifetimeMap { a: i32 },
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'a> _serde::Serialize for Lifetimes<'a> {
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {
|
||||
Lifetimes::LifetimeSeq(ref __field0) => {
|
||||
_serde::Serializer::serialize_newtype_variant(
|
||||
__serializer,
|
||||
"Lifetimes",
|
||||
0u32,
|
||||
"LifetimeSeq",
|
||||
__field0,
|
||||
)
|
||||
}
|
||||
Lifetimes::NoLifetimeSeq(ref __field0) => {
|
||||
_serde::Serializer::serialize_newtype_variant(
|
||||
__serializer,
|
||||
"Lifetimes",
|
||||
1u32,
|
||||
"NoLifetimeSeq",
|
||||
__field0,
|
||||
)
|
||||
}
|
||||
Lifetimes::LifetimeMap { ref a } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"Lifetimes",
|
||||
2u32,
|
||||
"LifetimeMap",
|
||||
0 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"a",
|
||||
a,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStructVariant::end(__serde_state)
|
||||
}
|
||||
Lifetimes::NoLifetimeMap { ref a } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"Lifetimes",
|
||||
3u32,
|
||||
"NoLifetimeMap",
|
||||
0 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"a",
|
||||
a,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStructVariant::end(__serde_state)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__field1,
|
||||
__field2,
|
||||
__field3,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"variant identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
1u64 => _serde::__private::Ok(__Field::__field1),
|
||||
2u64 => _serde::__private::Ok(__Field::__field2),
|
||||
3u64 => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::invalid_value(
|
||||
_serde::de::Unexpected::Unsigned(__value),
|
||||
&"variant index 0 <= i < 4",
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
|
||||
"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
|
||||
"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
|
||||
"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
|
||||
b"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
|
||||
b"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
|
||||
b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
|
||||
_ => {
|
||||
let __value = &_serde::__private::from_utf8_lossy(__value);
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, 'a> {
|
||||
marker: _serde::__private::PhantomData<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
|
||||
type Value = Lifetimes<'a>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"enum Lifetimes",
|
||||
)
|
||||
}
|
||||
fn visit_enum<__A>(
|
||||
self,
|
||||
__data: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::EnumAccess<'de>,
|
||||
{
|
||||
match match _serde::de::EnumAccess::variant(__data) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
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::__field2, __variant) => {
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"a" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"a" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, 'a> {
|
||||
marker: _serde::__private::PhantomData<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, 'a> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, 'a> {
|
||||
type Value = Lifetimes<'a>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct variant Lifetimes::LifetimeMap",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
&'a i32,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct variant Lifetimes::LifetimeMap with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(Lifetimes::LifetimeMap {
|
||||
a: __field0,
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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) {
|
||||
_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"),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<
|
||||
&'a i32,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("a") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(Lifetimes::LifetimeMap {
|
||||
a: __field0,
|
||||
})
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["a"];
|
||||
_serde::de::VariantAccess::struct_variant(
|
||||
__variant,
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
(__Field::__field3, __variant) => {
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"a" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"a" => _serde::__private::Ok(__Field::__field0),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, 'a> {
|
||||
marker: _serde::__private::PhantomData<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, 'a> _serde::de::Visitor<'de>
|
||||
for __Visitor<'de, 'a> {
|
||||
type Value = Lifetimes<'a>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct variant Lifetimes::NoLifetimeMap",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
i32,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
0usize,
|
||||
&"struct variant Lifetimes::NoLifetimeMap with 1 element",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(Lifetimes::NoLifetimeMap {
|
||||
a: __field0,
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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) {
|
||||
_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"),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<i32>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("a") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(Lifetimes::NoLifetimeMap {
|
||||
a: __field0,
|
||||
})
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["a"];
|
||||
_serde::de::VariantAccess::struct_variant(
|
||||
__variant,
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
const VARIANTS: &'static [&'static str] = &[
|
||||
"LifetimeSeq",
|
||||
"NoLifetimeSeq",
|
||||
"LifetimeMap",
|
||||
"NoLifetimeMap",
|
||||
];
|
||||
_serde::Deserializer::deserialize_enum(
|
||||
__deserializer,
|
||||
"Lifetimes",
|
||||
VARIANTS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,9 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
enum Lifetimes<'a> {
|
||||
LifetimeSeq(&'a i32),
|
||||
NoLifetimeSeq(i32),
|
||||
LifetimeMap { a: &'a i32 },
|
||||
NoLifetimeMap { a: i32 },
|
||||
}
|
||||
-686
@@ -1,686 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
|
||||
a: &'a A,
|
||||
b: &'b mut B,
|
||||
c: C,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedMap<'a, 'b, A, B, C>
|
||||
where
|
||||
A: _serde::Serialize,
|
||||
B: _serde::Serialize,
|
||||
C: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct(
|
||||
__serializer,
|
||||
"SerNamedMap",
|
||||
false as usize + 1 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
"a",
|
||||
&self.a,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
"b",
|
||||
&self.b,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
"c",
|
||||
&self.c,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStruct::end(__serde_state)
|
||||
}
|
||||
}
|
||||
};
|
||||
struct DeNamedMap<A, B, C> {
|
||||
a: A,
|
||||
b: B,
|
||||
c: C,
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedMap<A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__field1,
|
||||
__field2,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
1u64 => _serde::__private::Ok(__Field::__field1),
|
||||
2u64 => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"a" => _serde::__private::Ok(__Field::__field0),
|
||||
"b" => _serde::__private::Ok(__Field::__field1),
|
||||
"c" => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"a" => _serde::__private::Ok(__Field::__field0),
|
||||
b"b" => _serde::__private::Ok(__Field::__field1),
|
||||
b"c" => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<DeNamedMap<A, B, C>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = DeNamedMap<A, B, C>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct DeNamedMap",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
A,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
2usize,
|
||||
&"struct DeNamedMap with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(DeNamedMap {
|
||||
a: __field0,
|
||||
b: __field1,
|
||||
c: __field2,
|
||||
})
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::MapAccess<'de>,
|
||||
{
|
||||
let mut __field0: _serde::__private::Option<A> = _serde::__private::None;
|
||||
let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
|
||||
let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
|
||||
while let _serde::__private::Some(__key)
|
||||
= match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
|
||||
_serde::__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"),
|
||||
);
|
||||
}
|
||||
__field0 = _serde::__private::Some(
|
||||
match _serde::de::MapAccess::next_value::<A>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
__Field::__field1 => {
|
||||
if _serde::__private::Option::is_some(&__field1) {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
__Field::__field2 => {
|
||||
if _serde::__private::Option::is_some(&__field2) {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
},
|
||||
);
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
let __field0 = match __field0 {
|
||||
_serde::__private::Some(__field0) => __field0,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("a") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let __field1 = match __field1 {
|
||||
_serde::__private::Some(__field1) => __field1,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("b") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
let __field2 = match __field2 {
|
||||
_serde::__private::Some(__field2) => __field2,
|
||||
_serde::__private::None => {
|
||||
match _serde::__private::de::missing_field("c") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(DeNamedMap {
|
||||
a: __field0,
|
||||
b: __field1,
|
||||
c: __field2,
|
||||
})
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["a", "b", "c"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"DeNamedMap",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<DeNamedMap<A, B, C>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {
|
||||
__field0,
|
||||
__field1,
|
||||
__field2,
|
||||
__ignore,
|
||||
}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"field identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
0u64 => _serde::__private::Ok(__Field::__field0),
|
||||
1u64 => _serde::__private::Ok(__Field::__field1),
|
||||
2u64 => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
"a" => _serde::__private::Ok(__Field::__field0),
|
||||
"b" => _serde::__private::Ok(__Field::__field1),
|
||||
"c" => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
b"a" => _serde::__private::Ok(__Field::__field0),
|
||||
b"b" => _serde::__private::Ok(__Field::__field1),
|
||||
b"c" => _serde::__private::Ok(__Field::__field2),
|
||||
_ => _serde::__private::Ok(__Field::__ignore),
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
place: &'place mut DeNamedMap<A, B, C>,
|
||||
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>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"struct DeNamedMap",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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.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",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
#[inline]
|
||||
fn visit_map<__A>(
|
||||
self,
|
||||
mut __map: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::MapAccess<'de>,
|
||||
{
|
||||
let mut __field0: bool = false;
|
||||
let mut __field1: bool = false;
|
||||
let mut __field2: bool = false;
|
||||
while let _serde::__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 {
|
||||
return _serde::__private::Err(
|
||||
<__A::Error as _serde::de::Error>::duplicate_field("a"),
|
||||
);
|
||||
}
|
||||
match _serde::de::MapAccess::next_value_seed(
|
||||
&mut __map,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.a),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
__field0 = true;
|
||||
}
|
||||
__Field::__field1 => {
|
||||
if __field1 {
|
||||
return _serde::__private::Err(
|
||||
<__A::Error as _serde::de::Error>::duplicate_field("b"),
|
||||
);
|
||||
}
|
||||
match _serde::de::MapAccess::next_value_seed(
|
||||
&mut __map,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.b),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
__field1 = true;
|
||||
}
|
||||
__Field::__field2 => {
|
||||
if __field2 {
|
||||
return _serde::__private::Err(
|
||||
<__A::Error as _serde::de::Error>::duplicate_field("c"),
|
||||
);
|
||||
}
|
||||
match _serde::de::MapAccess::next_value_seed(
|
||||
&mut __map,
|
||||
_serde::__private::de::InPlaceSeed(&mut self.place.c),
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
__field2 = true;
|
||||
}
|
||||
_ => {
|
||||
let _ = match _serde::de::MapAccess::next_value::<
|
||||
_serde::de::IgnoredAny,
|
||||
>(&mut __map) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
}
|
||||
}
|
||||
if !__field0 {
|
||||
self
|
||||
.place
|
||||
.a = match _serde::__private::de::missing_field("a") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
if !__field1 {
|
||||
self
|
||||
.place
|
||||
.b = match _serde::__private::de::missing_field("b") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
if !__field2 {
|
||||
self
|
||||
.place
|
||||
.c = match _serde::__private::de::missing_field("c") {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
}
|
||||
const FIELDS: &'static [&'static str] = &["a", "b", "c"];
|
||||
_serde::Deserializer::deserialize_struct(
|
||||
__deserializer,
|
||||
"DeNamedMap",
|
||||
FIELDS,
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,15 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct SerNamedMap<'a, 'b, A: 'a, B: 'b, C> {
|
||||
a: &'a A,
|
||||
b: &'b mut B,
|
||||
c: C,
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct DeNamedMap<A, B, C> {
|
||||
a: A,
|
||||
b: B,
|
||||
c: C,
|
||||
}
|
||||
-288
@@ -1,288 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'a, 'b, A: 'a, B: 'b, C> _serde::Serialize for SerNamedTuple<'a, 'b, A, B, C>
|
||||
where
|
||||
A: _serde::Serialize,
|
||||
B: _serde::Serialize,
|
||||
C: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
let mut __serde_state = match _serde::Serializer::serialize_tuple_struct(
|
||||
__serializer,
|
||||
"SerNamedTuple",
|
||||
0 + 1 + 1 + 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.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,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleStruct::serialize_field(
|
||||
&mut __serde_state,
|
||||
&self.2,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeTupleStruct::end(__serde_state)
|
||||
}
|
||||
}
|
||||
};
|
||||
struct DeNamedTuple<A, B, C>(A, B, C);
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'de, A, B, C> _serde::Deserialize<'de> for DeNamedTuple<A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
marker: _serde::__private::PhantomData<DeNamedTuple<A, B, C>>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = DeNamedTuple<A, B, C>;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct DeNamedTuple",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::SeqAccess<'de>,
|
||||
{
|
||||
let __field0 = match match _serde::de::SeqAccess::next_element::<
|
||||
A,
|
||||
>(&mut __seq) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
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) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
} {
|
||||
_serde::__private::Some(__value) => __value,
|
||||
_serde::__private::None => {
|
||||
return _serde::__private::Err(
|
||||
_serde::de::Error::invalid_length(
|
||||
2usize,
|
||||
&"tuple struct DeNamedTuple with 3 elements",
|
||||
),
|
||||
);
|
||||
}
|
||||
};
|
||||
_serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_tuple_struct(
|
||||
__deserializer,
|
||||
"DeNamedTuple",
|
||||
3usize,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<DeNamedTuple<A, B, C>>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
fn deserialize_in_place<__D>(
|
||||
__deserializer: __D,
|
||||
__place: &mut Self,
|
||||
) -> _serde::__private::Result<(), __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor<'de, 'place, A: 'place, B: 'place, C: 'place>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
place: &'place mut DeNamedTuple<A, B, C>,
|
||||
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>
|
||||
where
|
||||
A: _serde::Deserialize<'de>,
|
||||
B: _serde::Deserialize<'de>,
|
||||
C: _serde::Deserialize<'de>,
|
||||
{
|
||||
type Value = ();
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"tuple struct DeNamedTuple",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_seq<__A>(
|
||||
self,
|
||||
mut __seq: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
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.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",
|
||||
),
|
||||
);
|
||||
}
|
||||
_serde::__private::Ok(())
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_tuple_struct(
|
||||
__deserializer,
|
||||
"DeNamedTuple",
|
||||
3usize,
|
||||
__Visitor {
|
||||
place: __place,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,7 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize)]
|
||||
struct SerNamedTuple<'a, 'b, A: 'a, B: 'b, C>(&'a A, &'b mut B, C);
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct DeNamedTuple<A, B, C>(A, B, C);
|
||||
-61
@@ -1,61 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
struct NamedUnit;
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl _serde::Serialize for NamedUnit {
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
_serde::Serializer::serialize_unit_struct(__serializer, "NamedUnit")
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
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>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
struct __Visitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __Visitor {
|
||||
type Value = NamedUnit;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"unit struct NamedUnit",
|
||||
)
|
||||
}
|
||||
#[inline]
|
||||
fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
_serde::__private::Ok(NamedUnit)
|
||||
}
|
||||
}
|
||||
_serde::Deserializer::deserialize_unit_struct(
|
||||
__deserializer,
|
||||
"NamedUnit",
|
||||
__Visitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,4 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
struct NamedUnit;
|
||||
-270
@@ -1,270 +0,0 @@
|
||||
use serde::Serialize;
|
||||
enum SerEnum<'a, B: 'a, C: 'a, D>
|
||||
where
|
||||
D: 'a,
|
||||
{
|
||||
Unit,
|
||||
Seq(i8, B, &'a C, &'a mut D),
|
||||
Map { a: i8, b: B, c: &'a C, d: &'a mut D },
|
||||
_Unit2,
|
||||
_Seq2(i8, B, &'a C, &'a mut D),
|
||||
_Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
|
||||
}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl<'a, B: 'a, C: 'a, D> _serde::Serialize for SerEnum<'a, B, C, D>
|
||||
where
|
||||
D: 'a,
|
||||
B: _serde::Serialize,
|
||||
C: _serde::Serialize,
|
||||
D: _serde::Serialize,
|
||||
{
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {
|
||||
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,
|
||||
"SerEnum",
|
||||
1u32,
|
||||
"Seq",
|
||||
0 + 1 + 1 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field0,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field2,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field3,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeTupleVariant::end(__serde_state)
|
||||
}
|
||||
SerEnum::Map { ref a, ref b, ref c, ref d } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
2u32,
|
||||
"Map",
|
||||
0 + 1 + 1 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"a",
|
||||
a,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"b",
|
||||
b,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"c",
|
||||
c,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"d",
|
||||
d,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_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,
|
||||
) => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_tuple_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
4u32,
|
||||
"_Seq2",
|
||||
0 + 1 + 1 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field0,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field2,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeTupleVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
__field3,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeTupleVariant::end(__serde_state)
|
||||
}
|
||||
SerEnum::_Map2 { ref a, ref b, ref c, ref d } => {
|
||||
let mut __serde_state = match _serde::Serializer::serialize_struct_variant(
|
||||
__serializer,
|
||||
"SerEnum",
|
||||
5u32,
|
||||
"_Map2",
|
||||
0 + 1 + 1 + 1 + 1,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"a",
|
||||
a,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"b",
|
||||
b,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"c",
|
||||
c,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
match _serde::ser::SerializeStructVariant::serialize_field(
|
||||
&mut __serde_state,
|
||||
"d",
|
||||
d,
|
||||
) {
|
||||
_serde::__private::Ok(__val) => __val,
|
||||
_serde::__private::Err(__err) => {
|
||||
return _serde::__private::Err(__err);
|
||||
}
|
||||
};
|
||||
_serde::ser::SerializeStructVariant::end(__serde_state)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,16 +0,0 @@
|
||||
use serde::Serialize;
|
||||
|
||||
#[derive(Serialize)]
|
||||
enum SerEnum<'a, B: 'a, C: 'a, D>
|
||||
where
|
||||
D: 'a,
|
||||
{
|
||||
Unit,
|
||||
Seq(i8, B, &'a C, &'a mut D),
|
||||
Map { a: i8, b: B, c: &'a C, d: &'a mut D },
|
||||
|
||||
// Make sure we can support more than one variant.
|
||||
_Unit2,
|
||||
_Seq2(i8, B, &'a C, &'a mut D),
|
||||
_Map2 { a: i8, b: B, c: &'a C, d: &'a mut D },
|
||||
}
|
||||
Generated
-149
@@ -1,149 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
enum Void {}
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
extern crate serde as _serde;
|
||||
#[automatically_derived]
|
||||
impl _serde::Serialize for Void {
|
||||
fn serialize<__S>(
|
||||
&self,
|
||||
__serializer: __S,
|
||||
) -> _serde::__private::Result<__S::Ok, __S::Error>
|
||||
where
|
||||
__S: _serde::Serializer,
|
||||
{
|
||||
match *self {}
|
||||
}
|
||||
}
|
||||
};
|
||||
#[doc(hidden)]
|
||||
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
|
||||
const _: () = {
|
||||
#[allow(unused_extern_crates, clippy::useless_attribute)]
|
||||
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>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
#[allow(non_camel_case_types)]
|
||||
enum __Field {}
|
||||
struct __FieldVisitor;
|
||||
impl<'de> _serde::de::Visitor<'de> for __FieldVisitor {
|
||||
type Value = __Field;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(
|
||||
__formatter,
|
||||
"variant identifier",
|
||||
)
|
||||
}
|
||||
fn visit_u64<__E>(
|
||||
self,
|
||||
__value: u64,
|
||||
) -> _serde::__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",
|
||||
),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_str<__E>(
|
||||
self,
|
||||
__value: &str,
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
_ => {
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
fn visit_bytes<__E>(
|
||||
self,
|
||||
__value: &[u8],
|
||||
) -> _serde::__private::Result<Self::Value, __E>
|
||||
where
|
||||
__E: _serde::de::Error,
|
||||
{
|
||||
match __value {
|
||||
_ => {
|
||||
let __value = &_serde::__private::from_utf8_lossy(__value);
|
||||
_serde::__private::Err(
|
||||
_serde::de::Error::unknown_variant(__value, VARIANTS),
|
||||
)
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
impl<'de> _serde::Deserialize<'de> for __Field {
|
||||
#[inline]
|
||||
fn deserialize<__D>(
|
||||
__deserializer: __D,
|
||||
) -> _serde::__private::Result<Self, __D::Error>
|
||||
where
|
||||
__D: _serde::Deserializer<'de>,
|
||||
{
|
||||
_serde::Deserializer::deserialize_identifier(
|
||||
__deserializer,
|
||||
__FieldVisitor,
|
||||
)
|
||||
}
|
||||
}
|
||||
struct __Visitor<'de> {
|
||||
marker: _serde::__private::PhantomData<Void>,
|
||||
lifetime: _serde::__private::PhantomData<&'de ()>,
|
||||
}
|
||||
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
|
||||
type Value = Void;
|
||||
fn expecting(
|
||||
&self,
|
||||
__formatter: &mut _serde::__private::Formatter,
|
||||
) -> _serde::__private::fmt::Result {
|
||||
_serde::__private::Formatter::write_str(__formatter, "enum Void")
|
||||
}
|
||||
fn visit_enum<__A>(
|
||||
self,
|
||||
__data: __A,
|
||||
) -> _serde::__private::Result<Self::Value, __A::Error>
|
||||
where
|
||||
__A: _serde::de::EnumAccess<'de>,
|
||||
{
|
||||
_serde::__private::Result::map(
|
||||
_serde::de::EnumAccess::variant::<__Field>(__data),
|
||||
|(__impossible, _)| match __impossible {},
|
||||
)
|
||||
}
|
||||
}
|
||||
const VARIANTS: &'static [&'static str] = &[];
|
||||
_serde::Deserializer::deserialize_enum(
|
||||
__deserializer,
|
||||
"Void",
|
||||
VARIANTS,
|
||||
__Visitor {
|
||||
marker: _serde::__private::PhantomData::<Void>,
|
||||
lifetime: _serde::__private::PhantomData,
|
||||
},
|
||||
)
|
||||
}
|
||||
}
|
||||
};
|
||||
@@ -1,4 +0,0 @@
|
||||
use serde::{Deserialize, Serialize};
|
||||
|
||||
#[derive(Serialize, Deserialize)]
|
||||
enum Void {}
|
||||
@@ -1,9 +0,0 @@
|
||||
#[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() {
|
||||
macrotest::expand("tests/expand/*.rs");
|
||||
}
|
||||
@@ -6,7 +6,8 @@
|
||||
clippy::nonstandard_macro_braces,
|
||||
clippy::too_many_lines,
|
||||
clippy::trivially_copy_pass_by_ref,
|
||||
clippy::type_repetition_in_bounds
|
||||
clippy::type_repetition_in_bounds,
|
||||
clippy::uninlined_format_args,
|
||||
)]
|
||||
|
||||
use serde::de::{self, MapAccess, Unexpected, Visitor};
|
||||
@@ -641,7 +642,7 @@ fn test_unknown_field_rename_struct() {
|
||||
Token::Str("a4"),
|
||||
Token::I32(3),
|
||||
],
|
||||
"unknown field `a4`, expected one of `a1`, `a2`, `a6`",
|
||||
"unknown field `a4`, expected one of `a1`, `a3`, `a2`, `a5`, `a6`",
|
||||
);
|
||||
}
|
||||
|
||||
@@ -779,7 +780,7 @@ fn test_rename_enum() {
|
||||
Token::StructVariant {
|
||||
name: "AliasEnum",
|
||||
variant: "sailor_moon",
|
||||
len: 3,
|
||||
len: 5,
|
||||
},
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
@@ -797,7 +798,7 @@ fn test_rename_enum() {
|
||||
Token::StructVariant {
|
||||
name: "AliasEnum",
|
||||
variant: "usagi_tsukino",
|
||||
len: 3,
|
||||
len: 5,
|
||||
},
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
@@ -826,7 +827,7 @@ fn test_unknown_field_rename_enum() {
|
||||
Token::StructVariant {
|
||||
name: "AliasEnum",
|
||||
variant: "usagi_tsukino",
|
||||
len: 3,
|
||||
len: 5,
|
||||
},
|
||||
Token::Str("a"),
|
||||
Token::I8(0),
|
||||
@@ -835,7 +836,7 @@ fn test_unknown_field_rename_enum() {
|
||||
Token::Str("d"),
|
||||
Token::I8(2),
|
||||
],
|
||||
"unknown field `d`, expected one of `a`, `b`, `f`",
|
||||
"unknown field `d`, expected one of `a`, `c`, `b`, `e`, `f`",
|
||||
);
|
||||
}
|
||||
|
||||
@@ -1235,7 +1236,7 @@ fn serialize_variant_as_string<S>(f1: &str, f2: &u8, serializer: S) -> Result<S:
|
||||
where
|
||||
S: Serializer,
|
||||
{
|
||||
serializer.serialize_str(format!("{f1};{f2:?}").as_str())
|
||||
serializer.collect_str(&format_args!("{};{:?}", f1, f2))
|
||||
}
|
||||
|
||||
fn deserialize_string_as_variant<'de, D>(deserializer: D) -> Result<(String, u8), D::Error>
|
||||
@@ -2657,6 +2658,68 @@ fn test_flatten_any_after_flatten_struct() {
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_alias_in_flatten_context() {
|
||||
#[derive(Debug, PartialEq, Deserialize)]
|
||||
struct Outer {
|
||||
#[serde(flatten)]
|
||||
a: AliasStruct,
|
||||
b: i32,
|
||||
}
|
||||
|
||||
assert_de_tokens(
|
||||
&Outer {
|
||||
a: AliasStruct {
|
||||
a1: 1,
|
||||
a2: 2,
|
||||
a4: 4,
|
||||
},
|
||||
b: 7,
|
||||
},
|
||||
&[
|
||||
Token::Struct {
|
||||
name: "Outer",
|
||||
len: 4,
|
||||
},
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
Token::Str("a2"),
|
||||
Token::I32(2),
|
||||
Token::Str("a5"),
|
||||
Token::I32(4),
|
||||
Token::Str("b"),
|
||||
Token::I32(7),
|
||||
Token::StructEnd,
|
||||
],
|
||||
);
|
||||
|
||||
assert_de_tokens(
|
||||
&Outer {
|
||||
a: AliasStruct {
|
||||
a1: 1,
|
||||
a2: 2,
|
||||
a4: 4,
|
||||
},
|
||||
b: 7,
|
||||
},
|
||||
&[
|
||||
Token::Struct {
|
||||
name: "Outer",
|
||||
len: 4,
|
||||
},
|
||||
Token::Str("a1"),
|
||||
Token::I32(1),
|
||||
Token::Str("a2"),
|
||||
Token::I32(2),
|
||||
Token::Str("a6"),
|
||||
Token::I32(4),
|
||||
Token::Str("b"),
|
||||
Token::I32(7),
|
||||
Token::StructEnd,
|
||||
],
|
||||
);
|
||||
}
|
||||
|
||||
#[test]
|
||||
fn test_expecting_message() {
|
||||
#[derive(Deserialize, PartialEq, Debug)]
|
||||
|
||||
@@ -7,6 +7,7 @@
|
||||
unknown_lints,
|
||||
mixed_script_confusables,
|
||||
clippy::derive_partial_eq_without_eq,
|
||||
clippy::extra_unused_type_parameters,
|
||||
clippy::items_after_statements,
|
||||
clippy::missing_errors_doc,
|
||||
clippy::missing_panics_doc,
|
||||
@@ -891,3 +892,53 @@ pub struct RemotePackedNonCopyDef {
|
||||
impl Drop for RemotePackedNonCopyDef {
|
||||
fn drop(&mut self) {}
|
||||
}
|
||||
|
||||
//////////////////////////////////////////////////////////////////////////
|
||||
|
||||
/// Regression tests for <https://github.com/serde-rs/serde/issues/2371>
|
||||
#[allow(dead_code)]
|
||||
mod static_and_flatten {
|
||||
use super::*;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
struct Nested;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
enum ExternallyTagged {
|
||||
Flatten {
|
||||
#[serde(flatten)]
|
||||
nested: Nested,
|
||||
string: &'static str,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "tag")]
|
||||
enum InternallyTagged {
|
||||
Flatten {
|
||||
#[serde(flatten)]
|
||||
nested: Nested,
|
||||
string: &'static str,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(tag = "tag", content = "content")]
|
||||
enum AdjacentlyTagged {
|
||||
Flatten {
|
||||
#[serde(flatten)]
|
||||
nested: Nested,
|
||||
string: &'static str,
|
||||
},
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
#[serde(untagged)]
|
||||
enum UntaggedWorkaround {
|
||||
Flatten {
|
||||
#[serde(flatten)]
|
||||
nested: Nested,
|
||||
string: &'static str,
|
||||
},
|
||||
}
|
||||
}
|
||||
|
||||
@@ -1928,7 +1928,6 @@ fn test_internally_tagged_newtype_variant_containing_unit_struct() {
|
||||
);
|
||||
}
|
||||
|
||||
#[deny(unaligned_references)]
|
||||
#[test]
|
||||
fn test_packed_struct_can_derive_serialize() {
|
||||
#[derive(Copy, Clone, Serialize)]
|
||||
|
||||
@@ -1,4 +1,7 @@
|
||||
#![allow(clippy::type_repetition_in_bounds)]
|
||||
#![allow(
|
||||
clippy::extra_unused_type_parameters,
|
||||
clippy::type_repetition_in_bounds
|
||||
)]
|
||||
|
||||
#[test]
|
||||
fn test_gen_custom_serde() {
|
||||
|
||||
@@ -4,7 +4,7 @@ error[E0308]: mismatched types
|
||||
15 | #[derive(Serialize)]
|
||||
| ^^^^^^^^^
|
||||
| |
|
||||
| expected `u8`, found `u16`
|
||||
| expected `&u8`, found `&u16`
|
||||
| arguments to this function are incorrect
|
||||
|
|
||||
= note: expected reference `&u8`
|
||||
|
||||
@@ -4,7 +4,7 @@ error[E0308]: mismatched types
|
||||
9 | #[derive(Serialize)]
|
||||
| ^^^^^^^^^
|
||||
| |
|
||||
| expected `u8`, found `u16`
|
||||
| expected `&u8`, found `&u16`
|
||||
| arguments to this function are incorrect
|
||||
|
|
||||
= note: expected reference `&u8`
|
||||
|
||||
Reference in New Issue
Block a user