pezkuwichain/serde
1
0
Fork 0
mirror of https://github.com/pezkuwichain/serde.git synced 2026-06-19 02:01:01 +00:00
Code Issues Packages Projects Releases Wiki Activity

Make it clearer that the private implementation details are private

Browse Source 
Both of these modules are doc(hidden) and commented "Not public API",
but incorrect downstream code sometimes still references them. Naming
the module __private will make it more likely to be noticed in code
review.
This commit is contained in:
David Tolnay
2021-01-08 19:35:52 -08:00
parent 91bfa8f947
commit dd1f4b483e
25 changed files with 1832 additions and 1704 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde/src/de/impls.rs
+2 -2
View File
@@ -1906,7 +1906,7 @@ impl<'de> Deserialize<'de> for Duration {
b"secs" => Ok(Field::Secs), b"secs" => Ok(Field::Secs),
b"nanos" => Ok(Field::Nanos), b"nanos" => Ok(Field::Nanos),
_ => { _ => {
let value = ::export::from_utf8_lossy(value); let value = ::__private::from_utf8_lossy(value);
Err(Error::unknown_field(&value, FIELDS)) Err(Error::unknown_field(&value, FIELDS))
} }
} }
@@ -2214,7 +2214,7 @@ mod range {
b"start" => Ok(Field::Start), b"start" => Ok(Field::Start),
b"end" => Ok(Field::End), b"end" => Ok(Field::End),
_ => { _ => {
let value = ::export::from_utf8_lossy(value); let value = ::__private::from_utf8_lossy(value);
Err(Error::unknown_field(&value, FIELDS)) Err(Error::unknown_field(&value, FIELDS))
} }
} }
serde/src/export.rs
-39
View File
@@ -1,39 +0,0 @@
pub use lib::clone::Clone;
pub use lib::convert::{From, Into};
pub use lib::default::Default;
pub use lib::fmt::{self, Formatter};
pub use lib::marker::PhantomData;
pub use lib::option::Option::{self, None, Some};
pub use lib::result::Result::{self, Err, Ok};
pub use self::string::from_utf8_lossy;
#[cfg(any(feature = "alloc", feature = "std"))]
pub use lib::{ToString, Vec};
#[cfg(core_try_from)]
pub use lib::convert::TryFrom;
mod string {
use lib::*;
#[cfg(any(feature = "std", feature = "alloc"))]
pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
String::from_utf8_lossy(bytes)
}
// The generated code calls this like:
//
// let value = &_serde::export::from_utf8_lossy(bytes);
// Err(_serde::de::Error::unknown_variant(value, VARIANTS))
//
// so it is okay for the return type to be different from the std case as long
// as the above works.
#[cfg(not(any(feature = "std", feature = "alloc")))]
pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
// Three unicode replacement characters if it fails. They look like a
// white-on-black question mark. The user will recognize it as invalid
// UTF-8.
str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
}
}
serde/src/integer128.rs
+1 -1
View File
@@ -10,7 +10,7 @@
/// bother with this macro and may assume support for 128-bit integers. /// bother with this macro and may assume support for 128-bit integers.
/// ///
/// ```edition2018 /// ```edition2018
/// # use serde::private::ser::Error; /// # use serde::__private::ser::Error;
/// # /// #
/// # struct MySerializer; /// # struct MySerializer;
/// # /// #
serde/src/lib.rs
+6 -5
View File
@@ -266,13 +266,14 @@ pub use de::{Deserialize, Deserializer};
#[doc(inline)] #[doc(inline)]
pub use ser::{Serialize, Serializer}; pub use ser::{Serialize, Serializer};
// Generated code uses these to support no_std. Not public API. // Used by generated code and doc tests. Not public API.
#[doc(hidden)] #[doc(hidden)]
pub mod export; #[path = "private/mod.rs"]
pub mod __private;
// Helpers used by generated code and doc tests. Not public API. #[allow(unused_imports)]
#[doc(hidden)] use self::__private as export;
pub mod private; use self::__private as private;
#[cfg(not(feature = "std"))] #[cfg(not(feature = "std"))]
mod std_error; mod std_error;
serde/src/macros.rs
+1 -1
View File
@@ -124,7 +124,7 @@ macro_rules! forward_to_deserialize_any {
macro_rules! forward_to_deserialize_any_method { macro_rules! forward_to_deserialize_any_method {
($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => { ($func:ident<$l:tt, $v:ident>($($arg:ident : $ty:ty),*)) => {
#[inline] #[inline]
fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::export::Result<$v::Value, Self::Error> fn $func<$v>(self, $($arg: $ty,)* visitor: $v) -> $crate::__private::Result<$v::Value, Self::Error>
where where
$v: $crate::de::Visitor<$l>, $v: $crate::de::Visitor<$l>,
{ {
serde/src/private/macros.rs
+1 -1
View File
@@ -37,7 +37,7 @@ macro_rules! __serialize_unimplemented {
#[macro_export] #[macro_export]
macro_rules! __serialize_unimplemented_method { macro_rules! __serialize_unimplemented_method {
($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => { ($func:ident $(<$t:ident>)* ($($arg:ty),*) -> $ret:ident) => {
fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::export::Result<Self::$ret, Self::Error> { fn $func $(<$t: ?Sized + $crate::Serialize>)* (self $(, _: $arg)*) -> $crate::__private::Result<Self::$ret, Self::Error> {
unimplemented!() unimplemented!()
} }
}; };
serde/src/private/mod.rs
+40
View File
@@ -2,3 +2,43 @@ mod macros;
pub mod de; pub mod de;
pub mod ser; pub mod ser;
pub use lib::clone::Clone;
pub use lib::convert::{From, Into};
pub use lib::default::Default;
pub use lib::fmt::{self, Formatter};
pub use lib::marker::PhantomData;
pub use lib::option::Option::{self, None, Some};
pub use lib::result::Result::{self, Err, Ok};
pub use self::string::from_utf8_lossy;
#[cfg(any(feature = "alloc", feature = "std"))]
pub use lib::{ToString, Vec};
#[cfg(core_try_from)]
pub use lib::convert::TryFrom;
mod string {
use lib::*;
#[cfg(any(feature = "std", feature = "alloc"))]
pub fn from_utf8_lossy(bytes: &[u8]) -> Cow<str> {
String::from_utf8_lossy(bytes)
}
// The generated code calls this like:
//
// let value = &_serde::__private::from_utf8_lossy(bytes);
// Err(_serde::de::Error::unknown_variant(value, VARIANTS))
//
// so it is okay for the return type to be different from the std case as long
// as the above works.
#[cfg(not(any(feature = "std", feature = "alloc")))]
pub fn from_utf8_lossy(bytes: &[u8]) -> &str {
// Three unicode replacement characters if it fails. They look like a
// white-on-black question mark. The user will recognize it as invalid
// UTF-8.
str::from_utf8(bytes).unwrap_or("\u{fffd}\u{fffd}\u{fffd}")
}
}
serde/src/ser/impossible.rs
+1 -1
View File
@@ -17,7 +17,7 @@ use ser::{
/// ///
/// ```edition2018 /// ```edition2018
/// # use serde::ser::{Serializer, Impossible}; /// # use serde::ser::{Serializer, Impossible};
/// # use serde::private::ser::Error; /// # use serde::__private::ser::Error;
/// # /// #
/// # struct MySerializer; /// # struct MySerializer;
/// # /// #
serde/src/ser/mod.rs
+1 -1
View File
@@ -711,7 +711,7 @@ pub trait Serializer: Sized {
/// ///
/// ```edition2018 /// ```edition2018
/// # use serde::ser::{Serializer, SerializeSeq}; /// # use serde::ser::{Serializer, SerializeSeq};
/// # use serde::private::ser::Error; /// # use serde::__private::ser::Error;
/// # /// #
/// # struct MySerializer; /// # struct MySerializer;
/// # /// #
serde_derive/src/de.rs
+256 -252
View File
File diff suppressed because it is too large Load Diff
serde_derive/src/internals/attr.rs
+2 -2
View File
@@ -1393,7 +1393,7 @@ impl Field {
}; };
let span = Span::call_site(); let span = Span::call_site();
path.segments.push(Ident::new("_serde", span).into()); path.segments.push(Ident::new("_serde", span).into());
path.segments.push(Ident::new("private", span).into()); path.segments.push(Ident::new("__private", span).into());
path.segments.push(Ident::new("de", span).into()); path.segments.push(Ident::new("de", span).into());
path.segments path.segments
.push(Ident::new("borrow_cow_str", span).into()); .push(Ident::new("borrow_cow_str", span).into());
@@ -1410,7 +1410,7 @@ impl Field {
}; };
let span = Span::call_site(); let span = Span::call_site();
path.segments.push(Ident::new("_serde", span).into()); path.segments.push(Ident::new("_serde", span).into());
path.segments.push(Ident::new("private", span).into()); path.segments.push(Ident::new("__private", span).into());
path.segments.push(Ident::new("de", span).into()); path.segments.push(Ident::new("de", span).into());
path.segments path.segments
.push(Ident::new("borrow_cow_bytes", span).into()); .push(Ident::new("borrow_cow_bytes", span).into());
serde_derive/src/pretend.rs
+4 -4
View File
@@ -74,9 +74,9 @@ fn pretend_fields_used(cont: &Container) -> TokenStream {
}; };
quote! { quote! {
match _serde::export::None::<#type_ident #ty_generics> { match _serde::__private::None::<#type_ident #ty_generics> {
#( #(
_serde::export::Some(#patterns) => {} _serde::__private::Some(#patterns) => {}
)* )*
_ => {} _ => {}
} }
@@ -120,8 +120,8 @@ fn pretend_variants_used(cont: &Container) -> TokenStream {
}; };
quote! { quote! {
match _serde::export::None { match _serde::__private::None {
_serde::export::Some((#(#placeholders,)*)) => { _serde::__private::Some((#(#placeholders,)*)) => {
let _ = #type_ident::#variant_ident #turbofish #pat; let _ = #type_ident::#variant_ident #turbofish #pat;
} }
_ => {} _ => {}
serde_derive/src/ser.rs
+23 -23
View File
@@ -29,7 +29,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
let used = pretend::pretend_used(&cont); let used = pretend::pretend_used(&cont);
quote! { quote! {
impl #impl_generics #ident #ty_generics #where_clause { impl #impl_generics #ident #ty_generics #where_clause {
#vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error> #vis fn serialize<__S>(__self: &#remote #ty_generics, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
where where
__S: #serde::Serializer, __S: #serde::Serializer,
{ {
@@ -42,7 +42,7 @@ pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream,
quote! { quote! {
#[automatically_derived] #[automatically_derived]
impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause { impl #impl_generics #serde::Serialize for #ident #ty_generics #where_clause {
fn serialize<__S>(&self, __serializer: __S) -> #serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(&self, __serializer: __S) -> #serde::__private::Result<__S::Ok, __S::Error>
where where
__S: #serde::Serializer, __S: #serde::Serializer,
{ {
@@ -211,7 +211,7 @@ fn serialize_into(params: &Parameters, type_into: &syn::Type) -> Fragment {
let self_var = &params.self_var; let self_var = &params.self_var;
quote_block! { quote_block! {
_serde::Serialize::serialize( _serde::Serialize::serialize(
&_serde::export::Into::<#type_into>::into(_serde::export::Clone::clone(#self_var)), &_serde::__private::Into::<#type_into>::into(_serde::__private::Clone::clone(#self_var)),
__serializer) __serializer)
} }
} }
@@ -372,7 +372,7 @@ fn serialize_struct_as_map(
let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists); let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
let len = if cattrs.has_flatten() { let len = if cattrs.has_flatten() {
quote!(_serde::export::None) quote!(_serde::__private::None)
} else { } else {
let len = serialized_fields let len = serialized_fields
.map(|field| match field.attrs.skip_serializing_if() { .map(|field| match field.attrs.skip_serializing_if() {
@@ -386,7 +386,7 @@ fn serialize_struct_as_map(
quote!(#tag_field_exists as usize), quote!(#tag_field_exists as usize),
|sum, expr| quote!(#sum + #expr), |sum, expr| quote!(#sum + #expr),
); );
quote!(_serde::export::Some(#len)) quote!(_serde::__private::Some(#len))
}; };
quote_block! { quote_block! {
@@ -433,7 +433,7 @@ fn serialize_variant(
variant_ident variant_ident
); );
let skipped_err = quote! { let skipped_err = quote! {
_serde::export::Err(_serde::ser::Error::custom(#skipped_msg)) _serde::__private::Err(_serde::ser::Error::custom(#skipped_msg))
}; };
let fields_pat = match variant.style { let fields_pat = match variant.style {
Style::Unit => quote!(), Style::Unit => quote!(),
@@ -578,7 +578,7 @@ fn serialize_internally_tagged_variant(
if let Some(path) = variant.attrs.serialize_with() { if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, variant); let ser = wrap_serialize_variant_with(params, path, variant);
return quote_expr! { return quote_expr! {
_serde::private::ser::serialize_tagged_newtype( _serde::__private::ser::serialize_tagged_newtype(
__serializer, __serializer,
#enum_ident_str, #enum_ident_str,
#variant_ident_str, #variant_ident_str,
@@ -607,7 +607,7 @@ fn serialize_internally_tagged_variant(
} }
let span = field.original.span(); let span = field.original.span();
let func = quote_spanned!(span=> _serde::private::ser::serialize_tagged_newtype); let func = quote_spanned!(span=> _serde::__private::ser::serialize_tagged_newtype);
quote_expr! { quote_expr! {
#func( #func(
__serializer, __serializer,
@@ -715,11 +715,11 @@ fn serialize_adjacently_tagged_variant(
quote_block! { quote_block! {
struct __AdjacentlyTagged #wrapper_generics #where_clause { struct __AdjacentlyTagged #wrapper_generics #where_clause {
data: (#(&'__a #fields_ty,)*), data: (#(&'__a #fields_ty,)*),
phantom: _serde::export::PhantomData<#this #ty_generics>, phantom: _serde::__private::PhantomData<#this #ty_generics>,
} }
impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause { impl #wrapper_impl_generics _serde::Serialize for __AdjacentlyTagged #wrapper_ty_generics #where_clause {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -737,7 +737,7 @@ fn serialize_adjacently_tagged_variant(
try!(_serde::ser::SerializeStruct::serialize_field( try!(_serde::ser::SerializeStruct::serialize_field(
&mut __struct, #content, &__AdjacentlyTagged { &mut __struct, #content, &__AdjacentlyTagged {
data: (#(#fields_ident,)*), data: (#(#fields_ident,)*),
phantom: _serde::export::PhantomData::<#this #ty_generics>, phantom: _serde::__private::PhantomData::<#this #ty_generics>,
})); }));
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
} }
@@ -978,18 +978,18 @@ fn serialize_struct_variant_with_flatten<'a>(
quote_block! { quote_block! {
struct __EnumFlatten #wrapper_generics #where_clause { struct __EnumFlatten #wrapper_generics #where_clause {
data: (#(&'__a #fields_ty,)*), data: (#(&'__a #fields_ty,)*),
phantom: _serde::export::PhantomData<#this #ty_generics>, phantom: _serde::__private::PhantomData<#this #ty_generics>,
} }
impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause { impl #wrapper_impl_generics _serde::Serialize for __EnumFlatten #wrapper_ty_generics #where_clause {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(&self, __serializer: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
let (#(#members,)*) = self.data; let (#(#members,)*) = self.data;
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::export::None)); _serde::__private::None));
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
} }
@@ -1002,7 +1002,7 @@ fn serialize_struct_variant_with_flatten<'a>(
#variant_name, #variant_name,
&__EnumFlatten { &__EnumFlatten {
data: (#(#members,)*), data: (#(#members,)*),
phantom: _serde::export::PhantomData::<#this #ty_generics>, phantom: _serde::__private::PhantomData::<#this #ty_generics>,
}) })
} }
} }
@@ -1010,7 +1010,7 @@ fn serialize_struct_variant_with_flatten<'a>(
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::export::None)); _serde::__private::None));
try!(_serde::ser::SerializeMap::serialize_entry( try!(_serde::ser::SerializeMap::serialize_entry(
&mut __serde_state, &mut __serde_state,
#tag, #tag,
@@ -1024,7 +1024,7 @@ fn serialize_struct_variant_with_flatten<'a>(
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::export::None)); _serde::__private::None));
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
} }
@@ -1113,7 +1113,7 @@ fn serialize_struct_visitor(
let ser = if field.attrs.flatten() { let ser = if field.attrs.flatten() {
let func = quote_spanned!(span=> _serde::Serialize::serialize); let func = quote_spanned!(span=> _serde::Serialize::serialize);
quote! { quote! {
try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state))); try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
} }
} else { } else {
let func = struct_trait.serialize_field(span); let func = struct_trait.serialize_field(span);
@@ -1208,11 +1208,11 @@ fn wrap_serialize_with(
quote!({ quote!({
struct __SerializeWith #wrapper_impl_generics #where_clause { struct __SerializeWith #wrapper_impl_generics #where_clause {
values: (#(&'__a #field_tys, )*), values: (#(&'__a #field_tys, )*),
phantom: _serde::export::PhantomData<#this #ty_generics>, phantom: _serde::__private::PhantomData<#this #ty_generics>,
} }
impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause { impl #wrapper_impl_generics _serde::Serialize for __SerializeWith #wrapper_ty_generics #where_clause {
fn serialize<__S>(&self, __s: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(&self, __s: __S) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -1222,7 +1222,7 @@ fn wrap_serialize_with(
&__SerializeWith { &__SerializeWith {
values: (#(#field_exprs, )*), values: (#(#field_exprs, )*),
phantom: _serde::export::PhantomData::<#this #ty_generics>, phantom: _serde::__private::PhantomData::<#this #ty_generics>,
} }
}) })
} }
@@ -1258,11 +1258,11 @@ fn get_member(params: &Parameters, field: &Field, member: &Member) -> TokenStrea
quote!(&#self_var.#member) quote!(&#self_var.#member)
}; };
let ty = field.ty; let ty = field.ty;
quote!(_serde::private::ser::constrain::<#ty>(#inner)) quote!(_serde::__private::ser::constrain::<#ty>(#inner))
} }
(true, Some(getter)) => { (true, Some(getter)) => {
let ty = field.ty; let ty = field.ty;
quote!(_serde::private::ser::constrain::<#ty>(&#getter(#self_var))) quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
} }
(false, Some(_)) => { (false, Some(_)) => {
unreachable!("getter is only allowed for remote impls"); unreachable!("getter is only allowed for remote impls");
serde_derive/src/try.rs
+3 -3
View File
@@ -13,9 +13,9 @@ pub fn replacement() -> TokenStream {
macro_rules! try { macro_rules! try {
(#dollar __expr:expr) => { (#dollar __expr:expr) => {
match #dollar __expr { match #dollar __expr {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
} }
test_suite/tests/expand/de_enum.expanded.rs
+440 -422
View File
File diff suppressed because it is too large Load Diff
test_suite/tests/expand/default_ty_param.expanded.rs
+119 -104
View File
@@ -15,7 +15,10 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> { impl<T: AssociatedType<X = i32>> _serde::Serialize for DefaultTyParam<T> {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -24,9 +27,9 @@ const _: () = {
"DefaultTyParam", "DefaultTyParam",
false as usize + 1, false as usize + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStruct::serialize_field( match _serde::ser::SerializeStruct::serialize_field(
@@ -34,9 +37,9 @@ const _: () = {
"phantom", "phantom",
&self.phantom, &self.phantom,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
@@ -50,7 +53,7 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> { impl<'de, T: AssociatedType<X = i32>> _serde::Deserialize<'de> for DefaultTyParam<T> {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -64,47 +67,52 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1", &"field index 0 <= i < 1",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"phantom" => _serde::export::Ok(__Field::__field0), "phantom" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"phantom" => _serde::export::Ok(__Field::__field0), b"phantom" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -112,76 +120,77 @@ const _: () = {
} }
} }
struct __Visitor<'de, T: AssociatedType<X = i32>> { struct __Visitor<'de, T: AssociatedType<X = i32>> {
marker: _serde::export::PhantomData<DefaultTyParam<T>>, marker: _serde::__private::PhantomData<DefaultTyParam<T>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> { impl<'de, T: AssociatedType<X = i32>> _serde::de::Visitor<'de> for __Visitor<'de, T> {
type Value = DefaultTyParam<T>; type Value = DefaultTyParam<T>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam") _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>( let __field0 = match match _serde::de::SeqAccess::next_element::<PhantomData<T>>(
&mut __seq, &mut __seq,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct DefaultTyParam with 1 element", &"struct DefaultTyParam with 1 element",
)); ));
} }
}; };
_serde::export::Ok(DefaultTyParam { phantom: __field0 }) _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<PhantomData<T>> = _serde::export::None; let mut __field0: _serde::__private::Option<PhantomData<T>> =
while let _serde::export::Some(__key) = _serde::__private::None;
while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field( <__A::Error as _serde::de::Error>::duplicate_field(
"phantom", "phantom",
), ),
); );
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<PhantomData<T>>( match _serde::de::MapAccess::next_value::<PhantomData<T>>(
&mut __map, &mut __map,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -191,25 +200,26 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("phantom") _serde::__private::None => {
{ match _serde::__private::de::missing_field("phantom") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
}
} }
}, }
}; };
_serde::export::Ok(DefaultTyParam { phantom: __field0 }) _serde::__private::Ok(DefaultTyParam { phantom: __field0 })
} }
} }
const FIELDS: &'static [&'static str] = &["phantom"]; const FIELDS: &'static [&'static str] = &["phantom"];
@@ -218,15 +228,15 @@ const _: () = {
"DefaultTyParam", "DefaultTyParam",
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<DefaultTyParam<T>>, marker: _serde::__private::PhantomData::<DefaultTyParam<T>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -240,47 +250,52 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1", &"field index 0 <= i < 1",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"phantom" => _serde::export::Ok(__Field::__field0), "phantom" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"phantom" => _serde::export::Ok(__Field::__field0), b"phantom" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -289,7 +304,7 @@ const _: () = {
} }
struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> { struct __Visitor<'de, 'place, T: AssociatedType<X = i32> + 'place> {
place: &'place mut DefaultTyParam<T>, place: &'place mut DefaultTyParam<T>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de> impl<'de, 'place, T: AssociatedType<X = i32> + 'place> _serde::de::Visitor<'de>
for __Visitor<'de, 'place, T> for __Visitor<'de, 'place, T>
@@ -297,55 +312,55 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DefaultTyParam") _serde::__private::Formatter::write_str(__formatter, "struct DefaultTyParam")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.phantom), _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct DefaultTyParam with 1 element", &"struct DefaultTyParam with 1 element",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: bool = false; let mut __field0: bool = false;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if __field0 { if __field0 {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field( <__A::Error as _serde::de::Error>::duplicate_field(
"phantom", "phantom",
), ),
@@ -353,11 +368,11 @@ const _: () = {
} }
match _serde::de::MapAccess::next_value_seed( match _serde::de::MapAccess::next_value_seed(
&mut __map, &mut __map,
_serde::private::de::InPlaceSeed(&mut self.place.phantom), _serde::__private::de::InPlaceSeed(&mut self.place.phantom),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
__field0 = true; __field0 = true;
@@ -367,23 +382,23 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
if !__field0 { if !__field0 {
self.place.phantom = match _serde::private::de::missing_field("phantom") { self.place.phantom = match _serde::__private::de::missing_field("phantom") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
}; };
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
const FIELDS: &'static [&'static str] = &["phantom"]; const FIELDS: &'static [&'static str] = &["phantom"];
@@ -393,7 +408,7 @@ const _: () = {
FIELDS, FIELDS,
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/generic_enum.expanded.rs
+170 -157
View File
@@ -16,7 +16,10 @@ const _: () = {
T: _serde::Serialize, T: _serde::Serialize,
U: _serde::Serialize, U: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -44,27 +47,27 @@ const _: () = {
"Seq", "Seq",
0 + 1 + 1, 0 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field0, __field0,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field1, __field1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeTupleVariant::end(__serde_state) _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -77,9 +80,9 @@ const _: () = {
"Map", "Map",
0 + 1 + 1, 0 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -87,9 +90,9 @@ const _: () = {
"x", "x",
x, x,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -97,9 +100,9 @@ const _: () = {
"y", "y",
y, y,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -119,7 +122,7 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -135,35 +138,38 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier") _serde::__private::Formatter::write_str(__formatter, "variant identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1), 1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2), 2u64 => _serde::__private::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3), 3u64 => _serde::__private::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 4", &"variant index 0 <= i < 4",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"Unit" => _serde::export::Ok(__Field::__field0), "Unit" => _serde::__private::Ok(__Field::__field0),
"NewType" => _serde::export::Ok(__Field::__field1), "NewType" => _serde::__private::Ok(__Field::__field1),
"Seq" => _serde::export::Ok(__Field::__field2), "Seq" => _serde::__private::Ok(__Field::__field2),
"Map" => _serde::export::Ok(__Field::__field3), "Map" => _serde::__private::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::unknown_variant( _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)), )),
} }
@@ -171,18 +177,18 @@ const _: () = {
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"Unit" => _serde::export::Ok(__Field::__field0), b"Unit" => _serde::__private::Ok(__Field::__field0),
b"NewType" => _serde::export::Ok(__Field::__field1), b"NewType" => _serde::__private::Ok(__Field::__field1),
b"Seq" => _serde::export::Ok(__Field::__field2), b"Seq" => _serde::__private::Ok(__Field::__field2),
b"Map" => _serde::export::Ok(__Field::__field3), b"Map" => _serde::__private::Ok(__Field::__field3),
_ => { _ => {
let __value = &_serde::export::from_utf8_lossy(__value); let __value = &_serde::__private::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant( _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)) ))
} }
@@ -191,7 +197,9 @@ const _: () = {
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -203,8 +211,8 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericEnum<T, U>>, marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
where where
@@ -214,33 +222,33 @@ const _: () = {
type Value = GenericEnum<T, U>; type Value = GenericEnum<T, U>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum GenericEnum") _serde::__private::Formatter::write_str(__formatter, "enum GenericEnum")
} }
fn visit_enum<__A>( fn visit_enum<__A>(
self, self,
__data: __A, __data: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::EnumAccess<'de>, __A: _serde::de::EnumAccess<'de>,
{ {
match match _serde::de::EnumAccess::variant(__data) { match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
(__Field::__field0, __variant) => { (__Field::__field0, __variant) => {
match _serde::de::VariantAccess::unit_variant(__variant) { match _serde::de::VariantAccess::unit_variant(__variant) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::export::Ok(GenericEnum::Unit) _serde::__private::Ok(GenericEnum::Unit)
} }
(__Field::__field1, __variant) => _serde::export::Result::map( (__Field::__field1, __variant) => _serde::__private::Result::map(
_serde::de::VariantAccess::newtype_variant::<T>(__variant), _serde::de::VariantAccess::newtype_variant::<T>(__variant),
GenericEnum::NewType, GenericEnum::NewType,
), ),
@@ -250,8 +258,8 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericEnum<T, U>>, marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
where where
@@ -261,9 +269,10 @@ const _: () = {
type Value = GenericEnum<T, U>; type Value = GenericEnum<T, U>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"tuple variant GenericEnum::Seq", "tuple variant GenericEnum::Seq",
) )
@@ -272,7 +281,7 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
@@ -281,14 +290,14 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (0usize , & "tuple variant GenericEnum::Seq with 2 elements")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
} }
}; };
let __field1 = match match _serde::de::SeqAccess::next_element::< let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -296,25 +305,25 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (1usize , & "tuple variant GenericEnum::Seq with 2 elements")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "tuple variant GenericEnum::Seq with 2 elements")) ;
} }
}; };
_serde::export::Ok(GenericEnum::Seq(__field0, __field1)) _serde::__private::Ok(GenericEnum::Seq(__field0, __field1))
} }
} }
_serde::de::VariantAccess::tuple_variant( _serde::de::VariantAccess::tuple_variant(
__variant, __variant,
2usize, 2usize,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericEnum<T, U>>, marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
@@ -330,9 +339,10 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"field identifier", "field identifier",
) )
@@ -340,43 +350,45 @@ const _: () = {
fn visit_u64<__E>( fn visit_u64<__E>(
self, self,
__value: u64, __value: u64,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1), 1u64 => _serde::__private::Ok(__Field::__field1),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Error::invalid_value(
&"field index 0 <= i < 2", _serde::de::Unexpected::Unsigned(__value),
)), &"field index 0 <= i < 2",
),
),
} }
} }
fn visit_str<__E>( fn visit_str<__E>(
self, self,
__value: &str, __value: &str,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"x" => _serde::export::Ok(__Field::__field0), "x" => _serde::__private::Ok(__Field::__field0),
"y" => _serde::export::Ok(__Field::__field1), "y" => _serde::__private::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"x" => _serde::export::Ok(__Field::__field0), b"x" => _serde::__private::Ok(__Field::__field0),
b"y" => _serde::export::Ok(__Field::__field1), b"y" => _serde::__private::Ok(__Field::__field1),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
@@ -384,7 +396,7 @@ const _: () = {
#[inline] #[inline]
fn deserialize<__D>( fn deserialize<__D>(
__deserializer: __D, __deserializer: __D,
) -> _serde::export::Result<Self, __D::Error> ) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -399,8 +411,8 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericEnum<T, U>>, marker: _serde::__private::PhantomData<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
where where
@@ -410,9 +422,10 @@ const _: () = {
type Value = GenericEnum<T, U>; type Value = GenericEnum<T, U>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"struct variant GenericEnum::Map", "struct variant GenericEnum::Map",
) )
@@ -421,7 +434,7 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
@@ -430,14 +443,14 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant GenericEnum::Map with 2 elements")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant GenericEnum::Map with 2 elements")) ;
} }
}; };
let __field1 = match match _serde::de::SeqAccess::next_element::< let __field1 = match match _serde::de::SeqAccess::next_element::<
@@ -445,17 +458,17 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (1usize , & "struct variant GenericEnum::Map with 2 elements")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (1usize , & "struct variant GenericEnum::Map with 2 elements")) ;
} }
}; };
_serde::export::Ok(GenericEnum::Map { _serde::__private::Ok(GenericEnum::Map {
x: __field0, x: __field0,
y: __field1, y: __field1,
}) })
@@ -464,50 +477,50 @@ const _: () = {
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<T> = let mut __field0: _serde::__private::Option<T> =
_serde::export::None; _serde::__private::None;
let mut __field1: _serde::export::Option<U> = let mut __field1: _serde::__private::Option<U> =
_serde::export::None; _serde::__private::None;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde :: export :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ; return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("x")) ;
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<T>( match _serde::de::MapAccess::next_value::<T>(
&mut __map, &mut __map,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
} }
__Field::__field1 => { __Field::__field1 => {
if _serde::export::Option::is_some(&__field1) { if _serde::__private::Option::is_some(&__field1) {
return _serde :: export :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ; return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("y")) ;
} }
__field1 = _serde::export::Some( __field1 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<U>( match _serde::de::MapAccess::next_value::<U>(
&mut __map, &mut __map,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -518,37 +531,37 @@ const _: () = {
>( >(
&mut __map &mut __map
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => { _serde::__private::None => {
match _serde::private::de::missing_field("x") { match _serde::__private::de::missing_field("x") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
} }
}; };
let __field1 = match __field1 { let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1, _serde::__private::Some(__field1) => __field1,
_serde::export::None => { _serde::__private::None => {
match _serde::private::de::missing_field("y") { match _serde::__private::de::missing_field("y") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
} }
}; };
_serde::export::Ok(GenericEnum::Map { _serde::__private::Ok(GenericEnum::Map {
x: __field0, x: __field0,
y: __field1, y: __field1,
}) })
@@ -559,8 +572,8 @@ const _: () = {
__variant, __variant,
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericEnum<T, U>>, marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
@@ -573,8 +586,8 @@ const _: () = {
"GenericEnum", "GenericEnum",
VARIANTS, VARIANTS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericEnum<T, U>>, marker: _serde::__private::PhantomData::<GenericEnum<T, U>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/generic_struct.expanded.rs
+158 -140
View File
@@ -12,7 +12,10 @@ const _: () = {
where where
T: _serde::Serialize, T: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -21,15 +24,15 @@ const _: () = {
"GenericStruct", "GenericStruct",
false as usize + 1, false as usize + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) { match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "x", &self.x) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
@@ -46,7 +49,7 @@ const _: () = {
where where
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -60,47 +63,52 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1", &"field index 0 <= i < 1",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"x" => _serde::export::Ok(__Field::__field0), "x" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"x" => _serde::export::Ok(__Field::__field0), b"x" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -111,8 +119,8 @@ const _: () = {
where where
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericStruct<T>>, marker: _serde::__private::PhantomData<GenericStruct<T>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T> impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
where where
@@ -121,64 +129,64 @@ const _: () = {
type Value = GenericStruct<T>; type Value = GenericStruct<T>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct GenericStruct") _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq) let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct GenericStruct with 1 element", &"struct GenericStruct with 1 element",
)); ));
} }
}; };
_serde::export::Ok(GenericStruct { x: __field0 }) _serde::__private::Ok(GenericStruct { x: __field0 })
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<T> = _serde::export::None; let mut __field0: _serde::__private::Option<T> = _serde::__private::None;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("x"), <__A::Error as _serde::de::Error>::duplicate_field("x"),
); );
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<T>(&mut __map) { match _serde::de::MapAccess::next_value::<T>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -188,24 +196,26 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("x") { _serde::__private::None => {
_serde::export::Ok(__val) => __val, match _serde::__private::de::missing_field("x") {
_serde::export::Err(__err) => { _serde::__private::Ok(__val) => __val,
return _serde::export::Err(__err); _serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} }
}, }
}; };
_serde::export::Ok(GenericStruct { x: __field0 }) _serde::__private::Ok(GenericStruct { x: __field0 })
} }
} }
const FIELDS: &'static [&'static str] = &["x"]; const FIELDS: &'static [&'static str] = &["x"];
@@ -214,15 +224,15 @@ const _: () = {
"GenericStruct", "GenericStruct",
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericStruct<T>>, marker: _serde::__private::PhantomData::<GenericStruct<T>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -236,47 +246,52 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 1", &"field index 0 <= i < 1",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"x" => _serde::export::Ok(__Field::__field0), "x" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"x" => _serde::export::Ok(__Field::__field0), b"x" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -288,7 +303,7 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
place: &'place mut GenericStruct<T>, place: &'place mut GenericStruct<T>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
where where
@@ -297,65 +312,65 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct GenericStruct") _serde::__private::Formatter::write_str(__formatter, "struct GenericStruct")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.x), _serde::__private::de::InPlaceSeed(&mut self.place.x),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct GenericStruct with 1 element", &"struct GenericStruct with 1 element",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: bool = false; let mut __field0: bool = false;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if __field0 { if __field0 {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("x"), <__A::Error as _serde::de::Error>::duplicate_field("x"),
); );
} }
match _serde::de::MapAccess::next_value_seed( match _serde::de::MapAccess::next_value_seed(
&mut __map, &mut __map,
_serde::private::de::InPlaceSeed(&mut self.place.x), _serde::__private::de::InPlaceSeed(&mut self.place.x),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
__field0 = true; __field0 = true;
@@ -365,23 +380,23 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
if !__field0 { if !__field0 {
self.place.x = match _serde::private::de::missing_field("x") { self.place.x = match _serde::__private::de::missing_field("x") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
}; };
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
const FIELDS: &'static [&'static str] = &["x"]; const FIELDS: &'static [&'static str] = &["x"];
@@ -391,7 +406,7 @@ const _: () = {
FIELDS, FIELDS,
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
@@ -408,7 +423,10 @@ const _: () = {
where where
T: _serde::Serialize, T: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -430,7 +448,7 @@ const _: () = {
where where
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -438,8 +456,8 @@ const _: () = {
where where
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericNewTypeStruct<T>>, marker: _serde::__private::PhantomData<GenericNewTypeStruct<T>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T> impl<'de, T> _serde::de::Visitor<'de> for __Visitor<'de, T>
where where
@@ -448,9 +466,9 @@ const _: () = {
type Value = GenericNewTypeStruct<T>; type Value = GenericNewTypeStruct<T>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str( _serde::__private::Formatter::write_str(
__formatter, __formatter,
"tuple struct GenericNewTypeStruct", "tuple struct GenericNewTypeStruct",
) )
@@ -459,57 +477,57 @@ const _: () = {
fn visit_newtype_struct<__E>( fn visit_newtype_struct<__E>(
self, self,
__e: __E, __e: __E,
) -> _serde::export::Result<Self::Value, __E::Error> ) -> _serde::__private::Result<Self::Value, __E::Error>
where where
__E: _serde::Deserializer<'de>, __E: _serde::Deserializer<'de>,
{ {
let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) { let __field0: T = match <T as _serde::Deserialize>::deserialize(__e) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::export::Ok(GenericNewTypeStruct(__field0)) _serde::__private::Ok(GenericNewTypeStruct(__field0))
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq) let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct GenericNewTypeStruct with 1 element", &"tuple struct GenericNewTypeStruct with 1 element",
)); ));
} }
}; };
_serde::export::Ok(GenericNewTypeStruct(__field0)) _serde::__private::Ok(GenericNewTypeStruct(__field0))
} }
} }
_serde::Deserializer::deserialize_newtype_struct( _serde::Deserializer::deserialize_newtype_struct(
__deserializer, __deserializer,
"GenericNewTypeStruct", "GenericNewTypeStruct",
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericNewTypeStruct<T>>, marker: _serde::__private::PhantomData::<GenericNewTypeStruct<T>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -518,7 +536,7 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
{ {
place: &'place mut GenericNewTypeStruct<T>, place: &'place mut GenericNewTypeStruct<T>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T> impl<'de, 'place, T: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T>
where where
@@ -527,9 +545,9 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str( _serde::__private::Formatter::write_str(
__formatter, __formatter,
"tuple struct GenericNewTypeStruct", "tuple struct GenericNewTypeStruct",
) )
@@ -538,7 +556,7 @@ const _: () = {
fn visit_newtype_struct<__E>( fn visit_newtype_struct<__E>(
self, self,
__e: __E, __e: __E,
) -> _serde::export::Result<Self::Value, __E::Error> ) -> _serde::__private::Result<Self::Value, __E::Error>
where where
__E: _serde::Deserializer<'de>, __E: _serde::Deserializer<'de>,
{ {
@@ -548,25 +566,25 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.0), _serde::__private::de::InPlaceSeed(&mut self.place.0),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct GenericNewTypeStruct with 1 element", &"tuple struct GenericNewTypeStruct with 1 element",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
_serde::Deserializer::deserialize_newtype_struct( _serde::Deserializer::deserialize_newtype_struct(
@@ -574,7 +592,7 @@ const _: () = {
"GenericNewTypeStruct", "GenericNewTypeStruct",
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/generic_tuple_struct.expanded.rs
+42 -42
View File
@@ -11,7 +11,7 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -20,8 +20,8 @@ const _: () = {
T: _serde::Deserialize<'de>, T: _serde::Deserialize<'de>,
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<GenericTupleStruct<T, U>>, marker: _serde::__private::PhantomData<GenericTupleStruct<T, U>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U> impl<'de, T, U> _serde::de::Visitor<'de> for __Visitor<'de, T, U>
where where
@@ -31,9 +31,9 @@ const _: () = {
type Value = GenericTupleStruct<T, U>; type Value = GenericTupleStruct<T, U>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str( _serde::__private::Formatter::write_str(
__formatter, __formatter,
"tuple struct GenericTupleStruct", "tuple struct GenericTupleStruct",
) )
@@ -42,20 +42,20 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq) let __field0 = match match _serde::de::SeqAccess::next_element::<T>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct GenericTupleStruct with 2 elements", &"tuple struct GenericTupleStruct with 2 elements",
)); ));
@@ -63,20 +63,20 @@ const _: () = {
}; };
let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq) let __field1 = match match _serde::de::SeqAccess::next_element::<U>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"tuple struct GenericTupleStruct with 2 elements", &"tuple struct GenericTupleStruct with 2 elements",
)); ));
} }
}; };
_serde::export::Ok(GenericTupleStruct(__field0, __field1)) _serde::__private::Ok(GenericTupleStruct(__field0, __field1))
} }
} }
_serde::Deserializer::deserialize_tuple_struct( _serde::Deserializer::deserialize_tuple_struct(
@@ -84,15 +84,15 @@ const _: () = {
"GenericTupleStruct", "GenericTupleStruct",
2usize, 2usize,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<GenericTupleStruct<T, U>>, marker: _serde::__private::PhantomData::<GenericTupleStruct<T, U>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -102,7 +102,7 @@ const _: () = {
U: _serde::Deserialize<'de>, U: _serde::Deserialize<'de>,
{ {
place: &'place mut GenericTupleStruct<T, U>, place: &'place mut GenericTupleStruct<T, U>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U> impl<'de, 'place, T: 'place, U: 'place> _serde::de::Visitor<'de> for __Visitor<'de, 'place, T, U>
where where
@@ -112,9 +112,9 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str( _serde::__private::Formatter::write_str(
__formatter, __formatter,
"tuple struct GenericTupleStruct", "tuple struct GenericTupleStruct",
) )
@@ -123,39 +123,39 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.0), _serde::__private::de::InPlaceSeed(&mut self.place.0),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct GenericTupleStruct with 2 elements", &"tuple struct GenericTupleStruct with 2 elements",
)); ));
} }
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.1), _serde::__private::de::InPlaceSeed(&mut self.place.1),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"tuple struct GenericTupleStruct with 2 elements", &"tuple struct GenericTupleStruct with 2 elements",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
_serde::Deserializer::deserialize_tuple_struct( _serde::Deserializer::deserialize_tuple_struct(
@@ -164,7 +164,7 @@ const _: () = {
2usize, 2usize,
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/lifetimes.expanded.rs
+174 -158
View File
@@ -12,7 +12,10 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<'a> _serde::Serialize for Lifetimes<'a> { impl<'a> _serde::Serialize for Lifetimes<'a> {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -43,9 +46,9 @@ const _: () = {
"LifetimeMap", "LifetimeMap",
0 + 1, 0 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -53,9 +56,9 @@ const _: () = {
"a", "a",
a, a,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -68,9 +71,9 @@ const _: () = {
"NoLifetimeMap", "NoLifetimeMap",
0 + 1, 0 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -78,9 +81,9 @@ const _: () = {
"a", "a",
a, a,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -96,7 +99,7 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> { impl<'de, 'a> _serde::Deserialize<'de> for Lifetimes<'a> {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -112,35 +115,38 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier") _serde::__private::Formatter::write_str(__formatter, "variant identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1), 1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2), 2u64 => _serde::__private::Ok(__Field::__field2),
3u64 => _serde::export::Ok(__Field::__field3), 3u64 => _serde::__private::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 4", &"variant index 0 <= i < 4",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"LifetimeSeq" => _serde::export::Ok(__Field::__field0), "LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1), "NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
"LifetimeMap" => _serde::export::Ok(__Field::__field2), "LifetimeMap" => _serde::__private::Ok(__Field::__field2),
"NoLifetimeMap" => _serde::export::Ok(__Field::__field3), "NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
_ => _serde::export::Err(_serde::de::Error::unknown_variant( _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)), )),
} }
@@ -148,18 +154,18 @@ const _: () = {
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"LifetimeSeq" => _serde::export::Ok(__Field::__field0), b"LifetimeSeq" => _serde::__private::Ok(__Field::__field0),
b"NoLifetimeSeq" => _serde::export::Ok(__Field::__field1), b"NoLifetimeSeq" => _serde::__private::Ok(__Field::__field1),
b"LifetimeMap" => _serde::export::Ok(__Field::__field2), b"LifetimeMap" => _serde::__private::Ok(__Field::__field2),
b"NoLifetimeMap" => _serde::export::Ok(__Field::__field3), b"NoLifetimeMap" => _serde::__private::Ok(__Field::__field3),
_ => { _ => {
let __value = &_serde::export::from_utf8_lossy(__value); let __value = &_serde::__private::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant( _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)) ))
} }
@@ -168,7 +174,9 @@ const _: () = {
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -176,35 +184,35 @@ const _: () = {
} }
} }
struct __Visitor<'de, 'a> { struct __Visitor<'de, 'a> {
marker: _serde::export::PhantomData<Lifetimes<'a>>, marker: _serde::__private::PhantomData<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
type Value = Lifetimes<'a>; type Value = Lifetimes<'a>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum Lifetimes") _serde::__private::Formatter::write_str(__formatter, "enum Lifetimes")
} }
fn visit_enum<__A>( fn visit_enum<__A>(
self, self,
__data: __A, __data: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::EnumAccess<'de>, __A: _serde::de::EnumAccess<'de>,
{ {
match match _serde::de::EnumAccess::variant(__data) { match match _serde::de::EnumAccess::variant(__data) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
(__Field::__field0, __variant) => _serde::export::Result::map( (__Field::__field0, __variant) => _serde::__private::Result::map(
_serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant), _serde::de::VariantAccess::newtype_variant::<&'a i32>(__variant),
Lifetimes::LifetimeSeq, Lifetimes::LifetimeSeq,
), ),
(__Field::__field1, __variant) => _serde::export::Result::map( (__Field::__field1, __variant) => _serde::__private::Result::map(
_serde::de::VariantAccess::newtype_variant::<i32>(__variant), _serde::de::VariantAccess::newtype_variant::<i32>(__variant),
Lifetimes::NoLifetimeSeq, Lifetimes::NoLifetimeSeq,
), ),
@@ -219,9 +227,10 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"field identifier", "field identifier",
) )
@@ -229,40 +238,42 @@ const _: () = {
fn visit_u64<__E>( fn visit_u64<__E>(
self, self,
__value: u64, __value: u64,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Error::invalid_value(
&"field index 0 <= i < 1", _serde::de::Unexpected::Unsigned(__value),
)), &"field index 0 <= i < 1",
),
),
} }
} }
fn visit_str<__E>( fn visit_str<__E>(
self, self,
__value: &str, __value: &str,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"a" => _serde::export::Ok(__Field::__field0), "a" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"a" => _serde::export::Ok(__Field::__field0), b"a" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
@@ -270,7 +281,7 @@ const _: () = {
#[inline] #[inline]
fn deserialize<__D>( fn deserialize<__D>(
__deserializer: __D, __deserializer: __D,
) -> _serde::export::Result<Self, __D::Error> ) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -281,16 +292,17 @@ const _: () = {
} }
} }
struct __Visitor<'de, 'a> { struct __Visitor<'de, 'a> {
marker: _serde::export::PhantomData<Lifetimes<'a>>, marker: _serde::__private::PhantomData<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
type Value = Lifetimes<'a>; type Value = Lifetimes<'a>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"struct variant Lifetimes::LifetimeMap", "struct variant Lifetimes::LifetimeMap",
) )
@@ -299,7 +311,7 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
@@ -308,49 +320,49 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::LifetimeMap with 1 element")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::LifetimeMap with 1 element")) ;
} }
}; };
_serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 }) _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<&'a i32> = let mut __field0: _serde::__private::Option<&'a i32> =
_serde::export::None; _serde::__private::None;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde :: export :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ; return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<&'a i32>( match _serde::de::MapAccess::next_value::<&'a i32>(
&mut __map, &mut __map,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -361,26 +373,26 @@ const _: () = {
>( >(
&mut __map &mut __map
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => { _serde::__private::None => {
match _serde::private::de::missing_field("a") { match _serde::__private::de::missing_field("a") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
} }
}; };
_serde::export::Ok(Lifetimes::LifetimeMap { a: __field0 }) _serde::__private::Ok(Lifetimes::LifetimeMap { a: __field0 })
} }
} }
const FIELDS: &'static [&'static str] = &["a"]; const FIELDS: &'static [&'static str] = &["a"];
@@ -388,8 +400,8 @@ const _: () = {
__variant, __variant,
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<Lifetimes<'a>>, marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
@@ -404,9 +416,10 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"field identifier", "field identifier",
) )
@@ -414,40 +427,42 @@ const _: () = {
fn visit_u64<__E>( fn visit_u64<__E>(
self, self,
__value: u64, __value: u64,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Error::invalid_value(
&"field index 0 <= i < 1", _serde::de::Unexpected::Unsigned(__value),
)), &"field index 0 <= i < 1",
),
),
} }
} }
fn visit_str<__E>( fn visit_str<__E>(
self, self,
__value: &str, __value: &str,
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"a" => _serde::export::Ok(__Field::__field0), "a" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"a" => _serde::export::Ok(__Field::__field0), b"a" => _serde::__private::Ok(__Field::__field0),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
@@ -455,7 +470,7 @@ const _: () = {
#[inline] #[inline]
fn deserialize<__D>( fn deserialize<__D>(
__deserializer: __D, __deserializer: __D,
) -> _serde::export::Result<Self, __D::Error> ) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -466,16 +481,17 @@ const _: () = {
} }
} }
struct __Visitor<'de, 'a> { struct __Visitor<'de, 'a> {
marker: _serde::export::PhantomData<Lifetimes<'a>>, marker: _serde::__private::PhantomData<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> { impl<'de, 'a> _serde::de::Visitor<'de> for __Visitor<'de, 'a> {
type Value = Lifetimes<'a>; type Value = Lifetimes<'a>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result
_serde::export::Formatter::write_str( {
_serde::__private::Formatter::write_str(
__formatter, __formatter,
"struct variant Lifetimes::NoLifetimeMap", "struct variant Lifetimes::NoLifetimeMap",
) )
@@ -484,7 +500,7 @@ const _: () = {
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
@@ -493,49 +509,49 @@ const _: () = {
>( >(
&mut __seq &mut __seq
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde :: export :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element")) ; return _serde :: __private :: Err (_serde :: de :: Error :: invalid_length (0usize , & "struct variant Lifetimes::NoLifetimeMap with 1 element")) ;
} }
}; };
_serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 }) _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<i32> = let mut __field0: _serde::__private::Option<i32> =
_serde::export::None; _serde::__private::None;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) match _serde::de::MapAccess::next_key::<__Field>(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde :: export :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ; return _serde :: __private :: Err (< __A :: Error as _serde :: de :: Error > :: duplicate_field ("a")) ;
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<i32>( match _serde::de::MapAccess::next_value::<i32>(
&mut __map, &mut __map,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -546,26 +562,26 @@ const _: () = {
>( >(
&mut __map &mut __map
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => { _serde::__private::None => {
match _serde::private::de::missing_field("a") { match _serde::__private::de::missing_field("a") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
} }
}; };
_serde::export::Ok(Lifetimes::NoLifetimeMap { a: __field0 }) _serde::__private::Ok(Lifetimes::NoLifetimeMap { a: __field0 })
} }
} }
const FIELDS: &'static [&'static str] = &["a"]; const FIELDS: &'static [&'static str] = &["a"];
@@ -573,8 +589,8 @@ const _: () = {
__variant, __variant,
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<Lifetimes<'a>>, marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
@@ -592,8 +608,8 @@ const _: () = {
"Lifetimes", "Lifetimes",
VARIANTS, VARIANTS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<Lifetimes<'a>>, marker: _serde::__private::PhantomData::<Lifetimes<'a>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/named_map.expanded.rs
+208 -189
View File
@@ -16,7 +16,10 @@ const _: () = {
B: _serde::Serialize, B: _serde::Serialize,
C: _serde::Serialize, C: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -25,27 +28,27 @@ const _: () = {
"SerNamedMap", "SerNamedMap",
false as usize + 1 + 1 + 1, false as usize + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) { match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "a", &self.a) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) { match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "b", &self.b) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) { match _serde::ser::SerializeStruct::serialize_field(&mut __serde_state, "c", &self.c) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
@@ -69,7 +72,7 @@ const _: () = {
B: _serde::Deserialize<'de>, B: _serde::Deserialize<'de>,
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -85,53 +88,58 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1), 1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2), 2u64 => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3", &"field index 0 <= i < 3",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"a" => _serde::export::Ok(__Field::__field0), "a" => _serde::__private::Ok(__Field::__field0),
"b" => _serde::export::Ok(__Field::__field1), "b" => _serde::__private::Ok(__Field::__field1),
"c" => _serde::export::Ok(__Field::__field2), "c" => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"a" => _serde::export::Ok(__Field::__field0), b"a" => _serde::__private::Ok(__Field::__field0),
b"b" => _serde::export::Ok(__Field::__field1), b"b" => _serde::__private::Ok(__Field::__field1),
b"c" => _serde::export::Ok(__Field::__field2), b"c" => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -144,8 +152,8 @@ const _: () = {
B: _serde::Deserialize<'de>, B: _serde::Deserialize<'de>,
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<DeNamedMap<A, B, C>>, marker: _serde::__private::PhantomData<DeNamedMap<A, B, C>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C> impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
where where
@@ -156,28 +164,28 @@ const _: () = {
type Value = DeNamedMap<A, B, C>; type Value = DeNamedMap<A, B, C>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DeNamedMap") _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq) let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
@@ -185,14 +193,14 @@ const _: () = {
}; };
let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq) let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
@@ -200,20 +208,20 @@ const _: () = {
}; };
let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq) let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize, 2usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
} }
}; };
_serde::export::Ok(DeNamedMap { _serde::__private::Ok(DeNamedMap {
a: __field0, a: __field0,
b: __field1, b: __field1,
c: __field2, c: __field2,
@@ -223,63 +231,63 @@ const _: () = {
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: _serde::export::Option<A> = _serde::export::None; let mut __field0: _serde::__private::Option<A> = _serde::__private::None;
let mut __field1: _serde::export::Option<B> = _serde::export::None; let mut __field1: _serde::__private::Option<B> = _serde::__private::None;
let mut __field2: _serde::export::Option<C> = _serde::export::None; let mut __field2: _serde::__private::Option<C> = _serde::__private::None;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if _serde::export::Option::is_some(&__field0) { if _serde::__private::Option::is_some(&__field0) {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("a"), <__A::Error as _serde::de::Error>::duplicate_field("a"),
); );
} }
__field0 = _serde::export::Some( __field0 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<A>(&mut __map) { match _serde::de::MapAccess::next_value::<A>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
} }
__Field::__field1 => { __Field::__field1 => {
if _serde::export::Option::is_some(&__field1) { if _serde::__private::Option::is_some(&__field1) {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("b"), <__A::Error as _serde::de::Error>::duplicate_field("b"),
); );
} }
__field1 = _serde::export::Some( __field1 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<B>(&mut __map) { match _serde::de::MapAccess::next_value::<B>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
} }
__Field::__field2 => { __Field::__field2 => {
if _serde::export::Option::is_some(&__field2) { if _serde::__private::Option::is_some(&__field2) {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("c"), <__A::Error as _serde::de::Error>::duplicate_field("c"),
); );
} }
__field2 = _serde::export::Some( __field2 = _serde::__private::Some(
match _serde::de::MapAccess::next_value::<C>(&mut __map) { match _serde::de::MapAccess::next_value::<C>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}, },
); );
@@ -289,42 +297,48 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
let __field0 = match __field0 { let __field0 = match __field0 {
_serde::export::Some(__field0) => __field0, _serde::__private::Some(__field0) => __field0,
_serde::export::None => match _serde::private::de::missing_field("a") { _serde::__private::None => {
_serde::export::Ok(__val) => __val, match _serde::__private::de::missing_field("a") {
_serde::export::Err(__err) => { _serde::__private::Ok(__val) => __val,
return _serde::export::Err(__err); _serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} }
}, }
}; };
let __field1 = match __field1 { let __field1 = match __field1 {
_serde::export::Some(__field1) => __field1, _serde::__private::Some(__field1) => __field1,
_serde::export::None => match _serde::private::de::missing_field("b") { _serde::__private::None => {
_serde::export::Ok(__val) => __val, match _serde::__private::de::missing_field("b") {
_serde::export::Err(__err) => { _serde::__private::Ok(__val) => __val,
return _serde::export::Err(__err); _serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} }
}, }
}; };
let __field2 = match __field2 { let __field2 = match __field2 {
_serde::export::Some(__field2) => __field2, _serde::__private::Some(__field2) => __field2,
_serde::export::None => match _serde::private::de::missing_field("c") { _serde::__private::None => {
_serde::export::Ok(__val) => __val, match _serde::__private::de::missing_field("c") {
_serde::export::Err(__err) => { _serde::__private::Ok(__val) => __val,
return _serde::export::Err(__err); _serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
} }
}, }
}; };
_serde::export::Ok(DeNamedMap { _serde::__private::Ok(DeNamedMap {
a: __field0, a: __field0,
b: __field1, b: __field1,
c: __field2, c: __field2,
@@ -337,15 +351,15 @@ const _: () = {
"DeNamedMap", "DeNamedMap",
FIELDS, FIELDS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<DeNamedMap<A, B, C>>, marker: _serde::__private::PhantomData::<DeNamedMap<A, B, C>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -361,53 +375,58 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "field identifier") _serde::__private::Formatter::write_str(__formatter, "field identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
0u64 => _serde::export::Ok(__Field::__field0), 0u64 => _serde::__private::Ok(__Field::__field0),
1u64 => _serde::export::Ok(__Field::__field1), 1u64 => _serde::__private::Ok(__Field::__field1),
2u64 => _serde::export::Ok(__Field::__field2), 2u64 => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"field index 0 <= i < 3", &"field index 0 <= i < 3",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
"a" => _serde::export::Ok(__Field::__field0), "a" => _serde::__private::Ok(__Field::__field0),
"b" => _serde::export::Ok(__Field::__field1), "b" => _serde::__private::Ok(__Field::__field1),
"c" => _serde::export::Ok(__Field::__field2), "c" => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
b"a" => _serde::export::Ok(__Field::__field0), b"a" => _serde::__private::Ok(__Field::__field0),
b"b" => _serde::export::Ok(__Field::__field1), b"b" => _serde::__private::Ok(__Field::__field1),
b"c" => _serde::export::Ok(__Field::__field2), b"c" => _serde::__private::Ok(__Field::__field2),
_ => _serde::export::Ok(__Field::__ignore), _ => _serde::__private::Ok(__Field::__ignore),
} }
} }
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -421,7 +440,7 @@ const _: () = {
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
place: &'place mut DeNamedMap<A, B, C>, place: &'place mut DeNamedMap<A, B, C>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de> impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
for __Visitor<'de, 'place, A, B, C> for __Visitor<'de, 'place, A, B, C>
@@ -433,129 +452,129 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "struct DeNamedMap") _serde::__private::Formatter::write_str(__formatter, "struct DeNamedMap")
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.a), _serde::__private::de::InPlaceSeed(&mut self.place.a),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
} }
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.b), _serde::__private::de::InPlaceSeed(&mut self.place.b),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
} }
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.c), _serde::__private::de::InPlaceSeed(&mut self.place.c),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize, 2usize,
&"struct DeNamedMap with 3 elements", &"struct DeNamedMap with 3 elements",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
#[inline] #[inline]
fn visit_map<__A>( fn visit_map<__A>(
self, self,
mut __map: __A, mut __map: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::MapAccess<'de>, __A: _serde::de::MapAccess<'de>,
{ {
let mut __field0: bool = false; let mut __field0: bool = false;
let mut __field1: bool = false; let mut __field1: bool = false;
let mut __field2: bool = false; let mut __field2: bool = false;
while let _serde::export::Some(__key) = while let _serde::__private::Some(__key) =
match _serde::de::MapAccess::next_key::<__Field>(&mut __map) { match _serde::de::MapAccess::next_key::<__Field>(&mut __map) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} }
{ {
match __key { match __key {
__Field::__field0 => { __Field::__field0 => {
if __field0 { if __field0 {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("a"), <__A::Error as _serde::de::Error>::duplicate_field("a"),
); );
} }
match _serde::de::MapAccess::next_value_seed( match _serde::de::MapAccess::next_value_seed(
&mut __map, &mut __map,
_serde::private::de::InPlaceSeed(&mut self.place.a), _serde::__private::de::InPlaceSeed(&mut self.place.a),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
__field0 = true; __field0 = true;
} }
__Field::__field1 => { __Field::__field1 => {
if __field1 { if __field1 {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("b"), <__A::Error as _serde::de::Error>::duplicate_field("b"),
); );
} }
match _serde::de::MapAccess::next_value_seed( match _serde::de::MapAccess::next_value_seed(
&mut __map, &mut __map,
_serde::private::de::InPlaceSeed(&mut self.place.b), _serde::__private::de::InPlaceSeed(&mut self.place.b),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
__field1 = true; __field1 = true;
} }
__Field::__field2 => { __Field::__field2 => {
if __field2 { if __field2 {
return _serde::export::Err( return _serde::__private::Err(
<__A::Error as _serde::de::Error>::duplicate_field("c"), <__A::Error as _serde::de::Error>::duplicate_field("c"),
); );
} }
match _serde::de::MapAccess::next_value_seed( match _serde::de::MapAccess::next_value_seed(
&mut __map, &mut __map,
_serde::private::de::InPlaceSeed(&mut self.place.c), _serde::__private::de::InPlaceSeed(&mut self.place.c),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
__field2 = true; __field2 = true;
@@ -565,39 +584,39 @@ const _: () = {
_serde::de::IgnoredAny, _serde::de::IgnoredAny,
>(&mut __map) >(&mut __map)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
} }
} }
} }
if !__field0 { if !__field0 {
self.place.a = match _serde::private::de::missing_field("a") { self.place.a = match _serde::__private::de::missing_field("a") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
}; };
if !__field1 { if !__field1 {
self.place.b = match _serde::private::de::missing_field("b") { self.place.b = match _serde::__private::de::missing_field("b") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
}; };
if !__field2 { if !__field2 {
self.place.c = match _serde::private::de::missing_field("c") { self.place.c = match _serde::__private::de::missing_field("c") {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
}; };
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
const FIELDS: &'static [&'static str] = &["a", "b", "c"]; const FIELDS: &'static [&'static str] = &["a", "b", "c"];
@@ -607,7 +626,7 @@ const _: () = {
FIELDS, FIELDS,
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/named_tuple.expanded.rs
+76 -67
View File
@@ -12,7 +12,10 @@ const _: () = {
B: _serde::Serialize, B: _serde::Serialize,
C: _serde::Serialize, C: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -21,27 +24,27 @@ const _: () = {
"SerNamedTuple", "SerNamedTuple",
0 + 1 + 1 + 1, 0 + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) { match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.0) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) { match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.1) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) { match _serde::ser::SerializeTupleStruct::serialize_field(&mut __serde_state, &self.2) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeTupleStruct::end(__serde_state) _serde::ser::SerializeTupleStruct::end(__serde_state)
@@ -61,7 +64,7 @@ const _: () = {
B: _serde::Deserialize<'de>, B: _serde::Deserialize<'de>,
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -71,8 +74,8 @@ const _: () = {
B: _serde::Deserialize<'de>, B: _serde::Deserialize<'de>,
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
marker: _serde::export::PhantomData<DeNamedTuple<A, B, C>>, marker: _serde::__private::PhantomData<DeNamedTuple<A, B, C>>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C> impl<'de, A, B, C> _serde::de::Visitor<'de> for __Visitor<'de, A, B, C>
where where
@@ -83,28 +86,31 @@ const _: () = {
type Value = DeNamedTuple<A, B, C>; type Value = DeNamedTuple<A, B, C>;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple") _serde::__private::Formatter::write_str(
__formatter,
"tuple struct DeNamedTuple",
)
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq) let __field0 = match match _serde::de::SeqAccess::next_element::<A>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
@@ -112,14 +118,14 @@ const _: () = {
}; };
let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq) let __field1 = match match _serde::de::SeqAccess::next_element::<B>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
@@ -127,20 +133,20 @@ const _: () = {
}; };
let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq) let __field2 = match match _serde::de::SeqAccess::next_element::<C>(&mut __seq)
{ {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
_serde::export::Some(__value) => __value, _serde::__private::Some(__value) => __value,
_serde::export::None => { _serde::__private::None => {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize, 2usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
} }
}; };
_serde::export::Ok(DeNamedTuple(__field0, __field1, __field2)) _serde::__private::Ok(DeNamedTuple(__field0, __field1, __field2))
} }
} }
_serde::Deserializer::deserialize_tuple_struct( _serde::Deserializer::deserialize_tuple_struct(
@@ -148,15 +154,15 @@ const _: () = {
"DeNamedTuple", "DeNamedTuple",
3usize, 3usize,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<DeNamedTuple<A, B, C>>, marker: _serde::__private::PhantomData::<DeNamedTuple<A, B, C>>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
fn deserialize_in_place<__D>( fn deserialize_in_place<__D>(
__deserializer: __D, __deserializer: __D,
__place: &mut Self, __place: &mut Self,
) -> _serde::export::Result<(), __D::Error> ) -> _serde::__private::Result<(), __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -167,7 +173,7 @@ const _: () = {
C: _serde::Deserialize<'de>, C: _serde::Deserialize<'de>,
{ {
place: &'place mut DeNamedTuple<A, B, C>, place: &'place mut DeNamedTuple<A, B, C>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de> impl<'de, 'place, A: 'place, B: 'place, C: 'place> _serde::de::Visitor<'de>
for __Visitor<'de, 'place, A, B, C> for __Visitor<'de, 'place, A, B, C>
@@ -179,61 +185,64 @@ const _: () = {
type Value = (); type Value = ();
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "tuple struct DeNamedTuple") _serde::__private::Formatter::write_str(
__formatter,
"tuple struct DeNamedTuple",
)
} }
#[inline] #[inline]
fn visit_seq<__A>( fn visit_seq<__A>(
self, self,
mut __seq: __A, mut __seq: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::SeqAccess<'de>, __A: _serde::de::SeqAccess<'de>,
{ {
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.0), _serde::__private::de::InPlaceSeed(&mut self.place.0),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
0usize, 0usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
} }
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.1), _serde::__private::de::InPlaceSeed(&mut self.place.1),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
1usize, 1usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
} }
if let _serde::export::None = match _serde::de::SeqAccess::next_element_seed( if let _serde::__private::None = match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
_serde::private::de::InPlaceSeed(&mut self.place.2), _serde::__private::de::InPlaceSeed(&mut self.place.2),
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
} { } {
return _serde::export::Err(_serde::de::Error::invalid_length( return _serde::__private::Err(_serde::de::Error::invalid_length(
2usize, 2usize,
&"tuple struct DeNamedTuple with 3 elements", &"tuple struct DeNamedTuple with 3 elements",
)); ));
} }
_serde::export::Ok(()) _serde::__private::Ok(())
} }
} }
_serde::Deserializer::deserialize_tuple_struct( _serde::Deserializer::deserialize_tuple_struct(
@@ -242,7 +251,7 @@ const _: () = {
3usize, 3usize,
__Visitor { __Visitor {
place: __place, place: __place,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }
test_suite/tests/expand/named_unit.expanded.rs
+10 -7
View File
@@ -7,7 +7,10 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl _serde::Serialize for NamedUnit { impl _serde::Serialize for NamedUnit {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -22,7 +25,7 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<'de> _serde::Deserialize<'de> for NamedUnit { impl<'de> _serde::Deserialize<'de> for NamedUnit {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -31,16 +34,16 @@ const _: () = {
type Value = NamedUnit; type Value = NamedUnit;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "unit struct NamedUnit") _serde::__private::Formatter::write_str(__formatter, "unit struct NamedUnit")
} }
#[inline] #[inline]
fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E> fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
_serde::export::Ok(NamedUnit) _serde::__private::Ok(NamedUnit)
} }
} }
_serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor) _serde::Deserializer::deserialize_unit_struct(__deserializer, "NamedUnit", __Visitor)
test_suite/tests/expand/ser_enum.expanded.rs
+64 -61
View File
@@ -23,7 +23,10 @@ const _: () = {
C: _serde::Serialize, C: _serde::Serialize,
D: _serde::Serialize, D: _serde::Serialize,
{ {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -42,45 +45,45 @@ const _: () = {
"Seq", "Seq",
0 + 1 + 1 + 1 + 1, 0 + 1 + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field0, __field0,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field1, __field1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field2, __field2,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field3, __field3,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeTupleVariant::end(__serde_state) _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -98,9 +101,9 @@ const _: () = {
"Map", "Map",
0 + 1 + 1 + 1 + 1, 0 + 1 + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -108,9 +111,9 @@ const _: () = {
"a", "a",
a, a,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -118,9 +121,9 @@ const _: () = {
"b", "b",
b, b,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -128,9 +131,9 @@ const _: () = {
"c", "c",
c, c,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -138,9 +141,9 @@ const _: () = {
"d", "d",
d, d,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
@@ -159,45 +162,45 @@ const _: () = {
"_Seq2", "_Seq2",
0 + 1 + 1 + 1 + 1, 0 + 1 + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field0, __field0,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field1, __field1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field2, __field2,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeTupleVariant::serialize_field( match _serde::ser::SerializeTupleVariant::serialize_field(
&mut __serde_state, &mut __serde_state,
__field3, __field3,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeTupleVariant::end(__serde_state) _serde::ser::SerializeTupleVariant::end(__serde_state)
@@ -215,9 +218,9 @@ const _: () = {
"_Map2", "_Map2",
0 + 1 + 1 + 1 + 1, 0 + 1 + 1 + 1 + 1,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -225,9 +228,9 @@ const _: () = {
"a", "a",
a, a,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -235,9 +238,9 @@ const _: () = {
"b", "b",
b, b,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -245,9 +248,9 @@ const _: () = {
"c", "c",
c, c,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
match _serde::ser::SerializeStructVariant::serialize_field( match _serde::ser::SerializeStructVariant::serialize_field(
@@ -255,9 +258,9 @@ const _: () = {
"d", "d",
d, d,
) { ) {
_serde::export::Ok(__val) => __val, _serde::__private::Ok(__val) => __val,
_serde::export::Err(__err) => { _serde::__private::Err(__err) => {
return _serde::export::Err(__err); return _serde::__private::Err(__err);
} }
}; };
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
test_suite/tests/expand/void.expanded.rs
+30 -22
View File
@@ -7,7 +7,10 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl _serde::Serialize for Void { impl _serde::Serialize for Void {
fn serialize<__S>(&self, __serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error> fn serialize<__S>(
&self,
__serializer: __S,
) -> _serde::__private::Result<__S::Ok, __S::Error>
where where
__S: _serde::Serializer, __S: _serde::Serializer,
{ {
@@ -22,7 +25,7 @@ const _: () = {
extern crate serde as _serde; extern crate serde as _serde;
#[automatically_derived] #[automatically_derived]
impl<'de> _serde::Deserialize<'de> for Void { impl<'de> _serde::Deserialize<'de> for Void {
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -33,27 +36,30 @@ const _: () = {
type Value = __Field; type Value = __Field;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "variant identifier") _serde::__private::Formatter::write_str(__formatter, "variant identifier")
} }
fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E> fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
_ => _serde::export::Err(_serde::de::Error::invalid_value( _ => _serde::__private::Err(_serde::de::Error::invalid_value(
_serde::de::Unexpected::Unsigned(__value), _serde::de::Unexpected::Unsigned(__value),
&"variant index 0 <= i < 0", &"variant index 0 <= i < 0",
)), )),
} }
} }
fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E> fn visit_str<__E>(
self,
__value: &str,
) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
_ => _serde::export::Err(_serde::de::Error::unknown_variant( _ => _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)), )),
} }
@@ -61,14 +67,14 @@ const _: () = {
fn visit_bytes<__E>( fn visit_bytes<__E>(
self, self,
__value: &[u8], __value: &[u8],
) -> _serde::export::Result<Self::Value, __E> ) -> _serde::__private::Result<Self::Value, __E>
where where
__E: _serde::de::Error, __E: _serde::de::Error,
{ {
match __value { match __value {
_ => { _ => {
let __value = &_serde::export::from_utf8_lossy(__value); let __value = &_serde::__private::from_utf8_lossy(__value);
_serde::export::Err(_serde::de::Error::unknown_variant( _serde::__private::Err(_serde::de::Error::unknown_variant(
__value, VARIANTS, __value, VARIANTS,
)) ))
} }
@@ -77,7 +83,9 @@ const _: () = {
} }
impl<'de> _serde::Deserialize<'de> for __Field { impl<'de> _serde::Deserialize<'de> for __Field {
#[inline] #[inline]
fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error> fn deserialize<__D>(
__deserializer: __D,
) -> _serde::__private::Result<Self, __D::Error>
where where
__D: _serde::Deserializer<'de>, __D: _serde::Deserializer<'de>,
{ {
@@ -85,25 +93,25 @@ const _: () = {
} }
} }
struct __Visitor<'de> { struct __Visitor<'de> {
marker: _serde::export::PhantomData<Void>, marker: _serde::__private::PhantomData<Void>,
lifetime: _serde::export::PhantomData<&'de ()>, lifetime: _serde::__private::PhantomData<&'de ()>,
} }
impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> { impl<'de> _serde::de::Visitor<'de> for __Visitor<'de> {
type Value = Void; type Value = Void;
fn expecting( fn expecting(
&self, &self,
__formatter: &mut _serde::export::Formatter, __formatter: &mut _serde::__private::Formatter,
) -> _serde::export::fmt::Result { ) -> _serde::__private::fmt::Result {
_serde::export::Formatter::write_str(__formatter, "enum Void") _serde::__private::Formatter::write_str(__formatter, "enum Void")
} }
fn visit_enum<__A>( fn visit_enum<__A>(
self, self,
__data: __A, __data: __A,
) -> _serde::export::Result<Self::Value, __A::Error> ) -> _serde::__private::Result<Self::Value, __A::Error>
where where
__A: _serde::de::EnumAccess<'de>, __A: _serde::de::EnumAccess<'de>,
{ {
_serde::export::Result::map( _serde::__private::Result::map(
_serde::de::EnumAccess::variant::<__Field>(__data), _serde::de::EnumAccess::variant::<__Field>(__data),
|(__impossible, _)| match __impossible {}, |(__impossible, _)| match __impossible {},
) )
@@ -115,8 +123,8 @@ const _: () = {
"Void", "Void",
VARIANTS, VARIANTS,
__Visitor { __Visitor {
marker: _serde::export::PhantomData::<Void>, marker: _serde::__private::PhantomData::<Void>,
lifetime: _serde::export::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
) )
} }