use dummy;
use fragment::{Expr, Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, ungroup, Ctxt, Derive};
+use internals::{attr, replace_receiver, ungroup, Ctxt, Derive};
use pretend;
use std::collections::BTreeSet;
+use std::ptr;
+
+pub fn expand_derive_deserialize(
+ input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+ replace_receiver(input);
-pub fn expand_derive_deserialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
let ctxt = Ctxt::new();
let cont = match Container::from_ast(&ctxt, input, Derive::Deserialize) {
Some(cont) => cont,
let used = pretend::pretend_used(&cont);
quote! {
impl #de_impl_generics #ident #ty_generics #where_clause {
- #vis fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<#remote #ty_generics, __D::Error>
+ #vis fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<#remote #ty_generics, __D::Error>
where
__D: #serde::Deserializer<#delife>,
{
quote! {
#[automatically_derived]
impl #de_impl_generics #serde::Deserialize<#delife> for #ident #ty_generics #where_clause {
- fn deserialize<__D>(__deserializer: __D) -> #serde::export::Result<Self, __D::Error>
+ fn deserialize<__D>(__deserializer: __D) -> #serde::__private::Result<Self, __D::Error>
where
__D: #serde::Deserializer<#delife>,
{
Some(predicates) => bound::with_where_predicates(&generics, predicates),
None => {
let generics = match *cont.attrs.default() {
- attr::Default::Default => {
- bound::with_self_bound(cont, &generics, &parse_quote!(_serde::export::Default))
- }
+ attr::Default::Default => bound::with_self_bound(
+ cont,
+ &generics,
+ &parse_quote!(_serde::__private::Default),
+ ),
attr::Default::None | attr::Default::Path(_) => generics,
};
cont,
&generics,
requires_default,
- &parse_quote!(_serde::export::Default),
+ &parse_quote!(_serde::__private::Default),
)
}
}
let stmts = Stmts(code);
let fn_deserialize_in_place = quote_block! {
- fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::export::Result<(), __D::Error>
+ fn deserialize_in_place<__D>(__deserializer: __D, __place: &mut Self) -> _serde::__private::Result<(), __D::Error>
where
__D: _serde::Deserializer<#delife>,
{
let assign = fields.iter().map(|field| {
let member = &field.member;
- if field as *const Field == transparent_field as *const Field {
+ if ptr::eq(field, transparent_field) {
quote!(#member: __transparent)
} else {
let value = match field.attrs.default() {
- attr::Default::Default => quote!(_serde::export::Default::default()),
+ attr::Default::Default => quote!(_serde::__private::Default::default()),
attr::Default::Path(path) => quote!(#path()),
- attr::Default::None => quote!(_serde::export::PhantomData),
+ attr::Default::None => quote!(_serde::__private::PhantomData),
};
quote!(#member: #value)
}
});
quote_block! {
- _serde::export::Result::map(
+ _serde::__private::Result::map(
#path(__deserializer),
|__transparent| #this { #(#assign),* })
}
fn deserialize_from(type_from: &syn::Type) -> Fragment {
quote_block! {
- _serde::export::Result::map(
+ _serde::__private::Result::map(
<#type_from as _serde::Deserialize>::deserialize(__deserializer),
- _serde::export::From::from)
+ _serde::__private::From::from)
}
}
fn deserialize_try_from(type_try_from: &syn::Type) -> Fragment {
quote_block! {
- _serde::export::Result::and_then(
+ _serde::__private::Result::and_then(
<#type_try_from as _serde::Deserialize>::deserialize(__deserializer),
- |v| _serde::export::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
+ |v| _serde::__private::TryFrom::try_from(v).map_err(_serde::de::Error::custom))
}
}
let type_name = cattrs.name().deserialize_name();
let expecting = format!("unit struct {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
quote_block! {
struct __Visitor;
impl<'de> _serde::de::Visitor<'de> for __Visitor {
type Value = #this;
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#[inline]
- fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
+ fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(#this)
+ _serde::__private::Ok(#this)
}
}
Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
None => format!("tuple struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let nfields = fields.len();
let visitor_expr = quote! {
__Visitor {
- marker: _serde::export::PhantomData::<#this #ty_generics>,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData::<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData,
}
};
let dispatch = if let Some(deserializer) = deserializer {
quote_block! {
struct __Visitor #de_impl_generics #where_clause {
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#visit_newtype_struct
#[inline]
- fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<#delife>,
{
Some(variant_ident) => format!("tuple variant {}::{}", params.type_name(), variant_ident),
None => format!("tuple struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let nfields = fields.len();
let visitor_expr = quote! {
__Visitor {
place: __place,
- lifetime: _serde::export::PhantomData,
+ lifetime: _serde::__private::PhantomData,
}
};
quote_block! {
struct __Visitor #in_place_impl_generics #where_clause {
place: &#place_life mut #this #ty_generics,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
type Value = ();
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#visit_newtype_struct
#[inline]
- fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<#delife>,
{
} else {
format!("{} with {} elements", expecting, deserialized_count)
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let mut index_in_seq = 0_usize;
let let_values = vars.clone().zip(fields).map(|(var, field)| {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({
#wrapper
- _serde::export::Option::map(
+ _serde::__private::Option::map(
try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)),
|__wrap| __wrap.value)
})
}
};
let value_if_none = match field.attrs.default() {
- attr::Default::Default => quote!(_serde::export::Default::default()),
+ attr::Default::Default => quote!(_serde::__private::Default::default()),
attr::Default::Path(path) => quote!(#path()),
attr::Default::None => quote!(
- return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+ return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
),
};
let assign = quote! {
let #var = match #visit {
- _serde::export::Some(__value) => __value,
- _serde::export::None => {
+ _serde::__private::Some(__value) => __value,
+ _serde::__private::None => {
#value_if_none
}
};
if params.has_getter {
let this = ¶ms.this;
result = quote! {
- _serde::export::Into::<#this>::into(#result)
+ _serde::__private::Into::<#this>::into(#result)
};
}
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
- let __default: Self::Value = _serde::export::Default::default();
+ let __default: Self::Value = _serde::__private::Default::default();
)),
attr::Default::Path(path) => Some(quote!(
let __default: Self::Value = #path();
quote_block! {
#let_default
#(#let_values)*
- _serde::export::Ok(#result)
+ _serde::__private::Ok(#result)
}
}
} else {
format!("{} with {} elements", expecting, deserialized_count)
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let mut index_in_seq = 0usize;
let write_values = fields.iter().map(|field| {
} else {
let value_if_none = match field.attrs.default() {
attr::Default::Default => quote!(
- self.place.#member = _serde::export::Default::default();
+ self.place.#member = _serde::__private::Default::default();
),
attr::Default::Path(path) => quote!(
self.place.#member = #path();
),
attr::Default::None => quote!(
- return _serde::export::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
+ return _serde::__private::Err(_serde::de::Error::invalid_length(#index_in_seq, &#expecting));
),
};
let write = match field.attrs.deserialize_with() {
None => {
quote! {
- if let _serde::export::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
- _serde::private::de::InPlaceSeed(&mut self.place.#member)))
+ if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq,
+ _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
{
#value_if_none
}
quote!({
#wrapper
match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) {
- _serde::export::Some(__wrap) => {
+ _serde::__private::Some(__wrap) => {
self.place.#member = __wrap.value;
}
- _serde::export::None => {
+ _serde::__private::None => {
#value_if_none
}
}
let (_, ty_generics, _) = params.generics.split_for_impl();
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
- let __default: #this #ty_generics = _serde::export::Default::default();
+ let __default: #this #ty_generics = _serde::__private::Default::default();
)),
attr::Default::Path(path) => Some(quote!(
let __default: #this #ty_generics = #path();
quote_block! {
#let_default
#(#write_values)*
- _serde::export::Ok(())
+ _serde::__private::Ok(())
}
}
if params.has_getter {
let this = ¶ms.this;
result = quote! {
- _serde::export::Into::<#this>::into(#result)
+ _serde::__private::Into::<#this>::into(#result)
};
}
quote! {
#[inline]
- fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
+ fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<#delife>,
{
let __field0: #field_ty = #value;
- _serde::export::Ok(#result)
+ _serde::__private::Ok(#result)
}
}
}
quote! {
#[inline]
- fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::export::Result<Self::Value, __E::Error>
+ fn visit_newtype_struct<__E>(self, __e: __E) -> _serde::__private::Result<Self::Value, __E::Error>
where
__E: _serde::Deserializer<#delife>,
{
Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
None => format!("struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let visit_seq = Stmts(deserialize_seq(
&type_path, params, fields, true, cattrs, &expecting,
let visitor_expr = quote! {
__Visitor {
- marker: _serde::export::PhantomData::<#this #ty_generics>,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData::<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData,
}
};
let dispatch = if let Some(deserializer) = deserializer {
let visit_seq = match *untagged {
Untagged::No if !cattrs.has_flatten() => Some(quote! {
#[inline]
- fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<#delife>,
{
impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Visitor #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
+ fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
#field_visitor
struct __Visitor #de_impl_generics #where_clause {
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#visit_seq
#[inline]
- fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<#delife>,
{
Some(variant_ident) => format!("struct variant {}::{}", params.type_name(), variant_ident),
None => format!("struct {}", params.type_name()),
};
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let visit_seq = Stmts(deserialize_seq_in_place(params, fields, cattrs, &expecting));
let visitor_expr = quote! {
__Visitor {
place: __place,
- lifetime: _serde::export::PhantomData,
+ lifetime: _serde::__private::PhantomData,
}
};
let dispatch = if let Some(deserializer) = deserializer {
let visit_seq = quote! {
#[inline]
- fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_seq<__A>(self, #visitor_var: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<#delife>,
{
struct __Visitor #in_place_impl_generics #where_clause {
place: &#place_life mut #this #ty_generics,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #in_place_impl_generics _serde::de::Visitor<#delife> for __Visitor #in_place_ty_generics #where_clause {
type Value = ();
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#visit_seq
#[inline]
- fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<#delife>,
{
let type_name = cattrs.name().deserialize_name();
let expecting = format!("enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let (variants_stmt, variant_visitor) = prepare_enum_variant_enum(variants, cattrs);
// all variants have `#[serde(skip_deserializing)]`.
quote! {
// FIXME: Once we drop support for Rust 1.15:
- // let _serde::export::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
- // _serde::export::Err(__err)
- _serde::export::Result::map(
+ // let _serde::__private::Err(__err) = _serde::de::EnumAccess::variant::<__Field>(__data);
+ // _serde::__private::Err(__err)
+ _serde::__private::Result::map(
_serde::de::EnumAccess::variant::<__Field>(__data),
|(__impossible, _)| match __impossible {})
}
#variant_visitor
struct __Visitor #de_impl_generics #where_clause {
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
- fn visit_enum<__A>(self, __data: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_enum<__A>(self, __data: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::EnumAccess<#delife>,
{
#type_name,
VARIANTS,
__Visitor {
- marker: _serde::export::PhantomData::<#this #ty_generics>,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData::<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData,
},
)
}
variant,
cattrs,
quote! {
- _serde::private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
+ _serde::__private::de::ContentDeserializer::<__D::Error>::new(__tagged.content)
},
));
}
});
+ let expecting = format!("internally tagged enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
+
quote_block! {
#variant_visitor
let __tagged = try!(_serde::Deserializer::deserialize_any(
__deserializer,
- _serde::private::de::TaggedContentVisitor::<__Field>::new(#tag)));
+ _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting)));
match __tagged.tag {
#(#variant_arms)*
.collect();
let expecting = format!("adjacently tagged enum {}", params.type_name());
+ let expecting = cattrs.expecting().unwrap_or(&expecting);
let type_name = cattrs.name().deserialize_name();
let deny_unknown_fields = cattrs.deny_unknown_fields();
// If unknown fields are allowed, we pick the visitor that can step over
// those. Otherwise we pick the visitor that fails on unknown keys.
let field_visitor_ty = if deny_unknown_fields {
- quote! { _serde::private::de::TagOrContentFieldVisitor }
+ quote! { _serde::__private::de::TagOrContentFieldVisitor }
} else {
- quote! { _serde::private::de::TagContentOtherFieldVisitor }
+ quote! { _serde::__private::de::TagContentOtherFieldVisitor }
};
let tag_or_content = quote! {
};
let mut missing_content = quote! {
- _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#content))
};
let mut missing_content_fallthrough = quote!();
let missing_content_arms = variants
let arm = match variant.style {
Style::Unit => quote! {
- _serde::export::Ok(#this::#variant_ident)
+ _serde::__private::Ok(#this::#variant_ident)
},
Style::Newtype if variant.attrs.deserialize_with().is_none() => {
let span = variant.original.span();
- let func = quote_spanned!(span=> _serde::private::de::missing_field);
+ let func = quote_spanned!(span=> _serde::__private::de::missing_field);
quote! {
#func(#content).map(#this::#variant_ident)
}
next_key
} else {
quote!({
- let mut __rk : _serde::export::Option<_serde::private::de::TagOrContentField> = _serde::export::None;
- while let _serde::export::Some(__k) = #next_key {
+ let mut __rk : _serde::__private::Option<_serde::__private::de::TagOrContentField> = _serde::__private::None;
+ while let _serde::__private::Some(__k) = #next_key {
match __k {
- _serde::private::de::TagContentOtherField::Other => {
+ _serde::__private::de::TagContentOtherField::Other => {
try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map));
continue;
},
- _serde::private::de::TagContentOtherField::Tag => {
- __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Tag);
+ _serde::__private::de::TagContentOtherField::Tag => {
+ __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag);
break;
}
- _serde::private::de::TagContentOtherField::Content => {
- __rk = _serde::export::Some(_serde::private::de::TagOrContentField::Content);
+ _serde::__private::de::TagContentOtherField::Content => {
+ __rk = _serde::__private::Some(_serde::__private::de::TagOrContentField::Content);
break;
}
}
// at this point immediately produce an error.
let visit_remaining_keys = quote! {
match #next_relevant_key {
- _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
}
- _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
}
- _serde::export::None => _serde::export::Ok(__ret),
+ _serde::__private::None => _serde::__private::Ok(__ret),
}
};
struct __Seed #de_impl_generics #where_clause {
field: __Field,
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::DeserializeSeed<#delife> for __Seed #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn deserialize<__D>(self, __deserializer: __D) -> _serde::export::Result<Self::Value, __D::Error>
+ fn deserialize<__D>(self, __deserializer: __D) -> _serde::__private::Result<Self::Value, __D::Error>
where
__D: _serde::Deserializer<#delife>,
{
}
struct __Visitor #de_impl_generics #where_clause {
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::Visitor<#delife> for __Visitor #de_ty_generics #where_clause {
type Value = #this #ty_generics;
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
- fn visit_map<__A>(self, mut __map: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_map<__A>(self, mut __map: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::MapAccess<#delife>,
{
// Visit the first relevant key.
match #next_relevant_key {
// First key is the tag.
- _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
// Parse the tag.
let __field = try!(_serde::de::MapAccess::next_value(&mut __map));
// Visit the second key.
match #next_relevant_key {
// Second key is a duplicate of the tag.
- _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#tag))
}
// Second key is the content.
- _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
let __ret = try!(_serde::de::MapAccess::next_value_seed(&mut __map,
__Seed {
field: __field,
- marker: _serde::export::PhantomData,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData,
+ lifetime: _serde::__private::PhantomData,
}));
// Visit remaining keys, looking for duplicates.
#visit_remaining_keys
}
// There is no second key; might be okay if the we have a unit variant.
- _serde::export::None => #missing_content
+ _serde::__private::None => #missing_content
}
}
// First key is the content.
- _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
// Buffer up the content.
- let __content = try!(_serde::de::MapAccess::next_value::<_serde::private::de::Content>(&mut __map));
+ let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map));
// Visit the second key.
match #next_relevant_key {
// Second key is the tag.
- _serde::export::Some(_serde::private::de::TagOrContentField::Tag) => {
- let __deserializer = _serde::private::de::ContentDeserializer::<__A::Error>::new(__content);
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
+ let __deserializer = _serde::__private::de::ContentDeserializer::<__A::Error>::new(__content);
#finish_content_then_tag
}
// Second key is a duplicate of the content.
- _serde::export::Some(_serde::private::de::TagOrContentField::Content) => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
+ _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#content))
}
// There is no second key.
- _serde::export::None => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
+ _serde::__private::None => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
}
}
}
// There is no first key.
- _serde::export::None => {
- _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
+ _serde::__private::None => {
+ _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#tag))
}
}
}
- fn visit_seq<__A>(self, mut __seq: __A) -> _serde::export::Result<Self::Value, __A::Error>
+ fn visit_seq<__A>(self, mut __seq: __A) -> _serde::__private::Result<Self::Value, __A::Error>
where
__A: _serde::de::SeqAccess<#delife>,
{
// Visit the first element - the tag.
match try!(_serde::de::SeqAccess::next_element(&mut __seq)) {
- _serde::export::Some(__field) => {
+ _serde::__private::Some(__field) => {
// Visit the second element - the content.
match try!(_serde::de::SeqAccess::next_element_seed(
&mut __seq,
__Seed {
field: __field,
- marker: _serde::export::PhantomData,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData,
+ lifetime: _serde::__private::PhantomData,
},
)) {
- _serde::export::Some(__ret) => _serde::export::Ok(__ret),
+ _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
// There is no second element.
- _serde::export::None => {
- _serde::export::Err(_serde::de::Error::invalid_length(1, &self))
+ _serde::__private::None => {
+ _serde::__private::Err(_serde::de::Error::invalid_length(1, &self))
}
}
}
// There is no first element.
- _serde::export::None => {
- _serde::export::Err(_serde::de::Error::invalid_length(0, &self))
+ _serde::__private::None => {
+ _serde::__private::Err(_serde::de::Error::invalid_length(0, &self))
}
}
}
#type_name,
FIELDS,
__Visitor {
- marker: _serde::export::PhantomData::<#this #ty_generics>,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData::<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData,
},
)
}
params,
variant,
cattrs,
- quote!(_serde::private::de::ContentRefDeserializer::<__D::Error>::new(&__content)),
+ quote!(
+ _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content)
+ ),
))
});
"data did not match any variant of untagged enum {}",
params.type_name()
);
+ let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
quote_block! {
- let __content = try!(<_serde::private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
+ let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer));
#(
- if let _serde::export::Ok(__ok) = #attempts {
- return _serde::export::Ok(__ok);
+ if let _serde::__private::Ok(__ok) = #attempts {
+ return _serde::__private::Ok(__ok);
}
)*
- _serde::export::Err(_serde::de::Error::custom(#fallthrough_msg))
+ _serde::__private::Err(_serde::de::Error::custom(#fallthrough_msg))
}
}
let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
return quote_block! {
#wrapper
- _serde::export::Result::map(
+ _serde::__private::Result::map(
_serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant), #unwrap_fn)
};
}
let this = ¶ms.this;
quote_block! {
try!(_serde::de::VariantAccess::unit_variant(__variant));
- _serde::export::Ok(#this::#variant_ident)
+ _serde::__private::Ok(#this::#variant_ident)
}
}
Style::Newtype => deserialize_externally_tagged_newtype_variant(
quote!((#default))
});
quote_block! {
- try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
- _serde::export::Ok(#this::#variant_ident #default)
+ try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name)));
+ _serde::__private::Ok(#this::#variant_ident #default)
}
}
Style::Newtype => deserialize_untagged_newtype_variant(
let (wrapper, wrapper_ty, unwrap_fn) = wrap_deserialize_variant_with(params, variant, path);
return quote_block! {
#wrapper
- _serde::export::Result::map(
+ _serde::__private::Result::map(
<#wrapper_ty as _serde::Deserialize>::deserialize(#deserializer), #unwrap_fn)
};
}
quote_expr! {
match _serde::Deserializer::deserialize_any(
#deserializer,
- _serde::private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
+ _serde::__private::de::UntaggedUnitVisitor::new(#type_name, #variant_name)
) {
- _serde::export::Ok(()) => _serde::export::Ok(#this::#variant_ident #default),
- _serde::export::Err(__err) => _serde::export::Err(__err),
+ _serde::__private::Ok(()) => _serde::__private::Ok(#this::#variant_ident #default),
+ _serde::__private::Err(__err) => _serde::__private::Err(__err),
}
}
}
let default = Expr(expr_is_missing(field, cattrs));
return quote_block! {
try!(_serde::de::VariantAccess::unit_variant(__variant));
- _serde::export::Ok(#this::#variant_ident(#default))
+ _serde::__private::Ok(#this::#variant_ident(#default))
};
}
let func =
quote_spanned!(span=> _serde::de::VariantAccess::newtype_variant::<#field_ty>);
quote_expr! {
- _serde::export::Result::map(#func(__variant), #this::#variant_ident)
+ _serde::__private::Result::map(#func(__variant), #this::#variant_ident)
}
}
Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote_block! {
#wrapper
- _serde::export::Result::map(
+ _serde::__private::Result::map(
_serde::de::VariantAccess::newtype_variant::<#wrapper_ty>(__variant),
|__wrapper| #this::#variant_ident(__wrapper.value))
}
let span = field.original.span();
let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
quote_expr! {
- _serde::export::Result::map(#func(#deserializer), #this::#variant_ident)
+ _serde::__private::Result::map(#func(#deserializer), #this::#variant_ident)
}
}
Some(path) => {
quote_block! {
- let __value: _serde::export::Result<#field_ty, _> = #path(#deserializer);
- _serde::export::Result::map(__value, #this::#variant_ident)
+ let __value: _serde::__private::Result<#field_ty, _> = #path(#deserializer);
+ _serde::__private::Result::map(__value, #this::#variant_ident)
}
}
}
let field_idents: &Vec<_> = &fields.iter().map(|(_, ident, _)| ident).collect();
let (ignore_variant, fallthrough) = if !is_variant && cattrs.has_flatten() {
- let ignore_variant = quote!(__other(_serde::private::de::Content<'de>),);
- let fallthrough = quote!(_serde::export::Ok(__Field::__other(__value)));
+ let ignore_variant = quote!(__other(_serde::__private::de::Content<'de>),);
+ let fallthrough = quote!(_serde::__private::Ok(__Field::__other(__value)));
(Some(ignore_variant), Some(fallthrough))
} else if let Some(other_idx) = other_idx {
let ignore_variant = fields[other_idx].1.clone();
- let fallthrough = quote!(_serde::export::Ok(__Field::#ignore_variant));
+ let fallthrough = quote!(_serde::__private::Ok(__Field::#ignore_variant));
(None, Some(fallthrough))
} else if is_variant || cattrs.deny_unknown_fields() {
(None, None)
} else {
let ignore_variant = quote!(__ignore,);
- let fallthrough = quote!(_serde::export::Ok(__Field::__ignore));
+ let fallthrough = quote!(_serde::__private::Ok(__Field::__ignore));
(Some(ignore_variant), Some(fallthrough))
};
fields,
is_variant,
fallthrough,
+ None,
!is_variant && cattrs.has_flatten(),
+ None,
));
let lifetime = if !is_variant && cattrs.has_flatten() {
impl<'de> _serde::Deserialize<'de> for __Field #lifetime {
#[inline]
- fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+ fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<'de>,
{
}
}
+// Generates `Deserialize::deserialize` body for an enum with
+// `serde(field_identifier)` or `serde(variant_identifier)` attribute.
fn deserialize_custom_identifier(
params: &Parameters,
variants: &[Variant],
let this = ¶ms.this;
let this = quote!(#this);
- let (ordinary, fallthrough) = if let Some(last) = variants.last() {
+ let (ordinary, fallthrough, fallthrough_borrowed) = if let Some(last) = variants.last() {
let last_ident = &last.ident;
if last.attrs.other() {
+ // Process `serde(other)` attribute. It would always be found on the
+ // last variant (checked in `check_identifier`), so all preceding
+ // are ordinary variants.
let ordinary = &variants[..variants.len() - 1];
- let fallthrough = quote!(_serde::export::Ok(#this::#last_ident));
- (ordinary, Some(fallthrough))
+ let fallthrough = quote!(_serde::__private::Ok(#this::#last_ident));
+ (ordinary, Some(fallthrough), None)
} else if let Style::Newtype = last.style {
let ordinary = &variants[..variants.len() - 1];
- let deserializer = quote!(_serde::private::de::IdentifierDeserializer::from(__value));
- let fallthrough = quote! {
- _serde::export::Result::map(
- _serde::Deserialize::deserialize(#deserializer),
- #this::#last_ident)
+ let fallthrough = |value| {
+ quote! {
+ _serde::__private::Result::map(
+ _serde::Deserialize::deserialize(
+ _serde::__private::de::IdentifierDeserializer::from(#value)
+ ),
+ #this::#last_ident)
+ }
};
- (ordinary, Some(fallthrough))
+ (
+ ordinary,
+ Some(fallthrough(quote!(__value))),
+ Some(fallthrough(quote!(_serde::__private::de::Borrowed(
+ __value
+ )))),
+ )
} else {
- (variants, None)
+ (variants, None, None)
}
} else {
- (variants, None)
+ (variants, None, None)
};
let names_idents: Vec<_> = ordinary
&names_idents,
is_variant,
fallthrough,
+ fallthrough_borrowed,
false,
+ cattrs.expecting(),
));
quote_block! {
#names_const
struct __FieldVisitor #de_impl_generics #where_clause {
- marker: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ marker: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::de::Visitor<#delife> for __FieldVisitor #de_ty_generics #where_clause {
}
let __visitor = __FieldVisitor {
- marker: _serde::export::PhantomData::<#this #ty_generics>,
- lifetime: _serde::export::PhantomData,
+ marker: _serde::__private::PhantomData::<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData,
};
_serde::Deserializer::deserialize_identifier(__deserializer, __visitor)
}
fields: &[(String, Ident, Vec<String>)],
is_variant: bool,
fallthrough: Option<TokenStream>,
+ fallthrough_borrowed: Option<TokenStream>,
collect_other_fields: bool,
+ expecting: Option<&str>,
) -> Fragment {
let mut flat_fields = Vec::new();
for (_, ident, aliases) in fields {
flat_fields.extend(aliases.iter().map(|alias| (alias, ident)))
}
- let field_strs = flat_fields.iter().map(|(name, _)| name);
- let field_borrowed_strs = flat_fields.iter().map(|(name, _)| name);
- let field_bytes = flat_fields
- .iter()
- .map(|(name, _)| Literal::byte_string(name.as_bytes()));
- let field_borrowed_bytes = flat_fields
+ let field_strs: &Vec<_> = &flat_fields.iter().map(|(name, _)| name).collect();
+ let field_bytes: &Vec<_> = &flat_fields
.iter()
- .map(|(name, _)| Literal::byte_string(name.as_bytes()));
+ .map(|(name, _)| Literal::byte_string(name.as_bytes()))
+ .collect();
let constructors: &Vec<_> = &flat_fields
.iter()
.map(|(_, ident, _)| quote!(#this::#ident))
.collect();
- let expecting = if is_variant {
+ let expecting = expecting.unwrap_or(if is_variant {
"variant identifier"
} else {
"field identifier"
- };
+ });
let index_expecting = if is_variant { "variant" } else { "field" };
None
} else {
Some(quote! {
- let __value = &_serde::export::from_utf8_lossy(__value);
+ let __value = &_serde::__private::from_utf8_lossy(__value);
})
};
) = if collect_other_fields {
(
Some(quote! {
- let __value = _serde::private::de::Content::String(_serde::export::ToString::to_string(__value));
+ let __value = _serde::__private::de::Content::String(_serde::__private::ToString::to_string(__value));
}),
Some(quote! {
- let __value = _serde::private::de::Content::Str(__value);
+ let __value = _serde::__private::de::Content::Str(__value);
}),
Some(quote! {
- let __value = _serde::private::de::Content::ByteBuf(__value.to_vec());
+ let __value = _serde::__private::de::Content::ByteBuf(__value.to_vec());
}),
Some(quote! {
- let __value = _serde::private::de::Content::Bytes(__value);
+ let __value = _serde::__private::de::Content::Bytes(__value);
}),
)
} else {
(None, None, None, None)
};
- let fallthrough_arm = if let Some(fallthrough) = fallthrough {
+ let fallthrough_arm_tokens;
+ let fallthrough_arm = if let Some(fallthrough) = &fallthrough {
fallthrough
} else if is_variant {
- quote! {
- _serde::export::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
- }
+ fallthrough_arm_tokens = quote! {
+ _serde::__private::Err(_serde::de::Error::unknown_variant(__value, VARIANTS))
+ };
+ &fallthrough_arm_tokens
} else {
- quote! {
- _serde::export::Err(_serde::de::Error::unknown_field(__value, FIELDS))
- }
+ fallthrough_arm_tokens = quote! {
+ _serde::__private::Err(_serde::de::Error::unknown_field(__value, FIELDS))
+ };
+ &fallthrough_arm_tokens
+ };
+
+ let u64_fallthrough_arm_tokens;
+ let u64_fallthrough_arm = if let Some(fallthrough) = &fallthrough {
+ fallthrough
+ } else {
+ let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
+ u64_fallthrough_arm_tokens = quote! {
+ _serde::__private::Err(_serde::de::Error::invalid_value(
+ _serde::de::Unexpected::Unsigned(__value),
+ &#fallthrough_msg,
+ ))
+ };
+ &u64_fallthrough_arm_tokens
};
let variant_indices = 0_u64..;
- let fallthrough_msg = format!("{} index 0 <= i < {}", index_expecting, fields.len());
let visit_other = if collect_other_fields {
quote! {
- fn visit_bool<__E>(self, __value: bool) -> _serde::export::Result<Self::Value, __E>
+ fn visit_bool<__E>(self, __value: bool) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::Bool(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Bool(__value)))
}
- fn visit_i8<__E>(self, __value: i8) -> _serde::export::Result<Self::Value, __E>
+ fn visit_i8<__E>(self, __value: i8) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::I8(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I8(__value)))
}
- fn visit_i16<__E>(self, __value: i16) -> _serde::export::Result<Self::Value, __E>
+ fn visit_i16<__E>(self, __value: i16) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::I16(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I16(__value)))
}
- fn visit_i32<__E>(self, __value: i32) -> _serde::export::Result<Self::Value, __E>
+ fn visit_i32<__E>(self, __value: i32) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::I32(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I32(__value)))
}
- fn visit_i64<__E>(self, __value: i64) -> _serde::export::Result<Self::Value, __E>
+ fn visit_i64<__E>(self, __value: i64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::I64(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::I64(__value)))
}
- fn visit_u8<__E>(self, __value: u8) -> _serde::export::Result<Self::Value, __E>
+ fn visit_u8<__E>(self, __value: u8) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::U8(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U8(__value)))
}
- fn visit_u16<__E>(self, __value: u16) -> _serde::export::Result<Self::Value, __E>
+ fn visit_u16<__E>(self, __value: u16) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::U16(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U16(__value)))
}
- fn visit_u32<__E>(self, __value: u32) -> _serde::export::Result<Self::Value, __E>
+ fn visit_u32<__E>(self, __value: u32) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::U32(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U32(__value)))
}
- fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+ fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::U64(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::U64(__value)))
}
- fn visit_f32<__E>(self, __value: f32) -> _serde::export::Result<Self::Value, __E>
+ fn visit_f32<__E>(self, __value: f32) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::F32(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F32(__value)))
}
- fn visit_f64<__E>(self, __value: f64) -> _serde::export::Result<Self::Value, __E>
+ fn visit_f64<__E>(self, __value: f64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::F64(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::F64(__value)))
}
- fn visit_char<__E>(self, __value: char) -> _serde::export::Result<Self::Value, __E>
+ fn visit_char<__E>(self, __value: char) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::Char(__value)))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Char(__value)))
}
- fn visit_unit<__E>(self) -> _serde::export::Result<Self::Value, __E>
+ fn visit_unit<__E>(self) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
- _serde::export::Ok(__Field::__other(_serde::private::de::Content::Unit))
+ _serde::__private::Ok(__Field::__other(_serde::__private::de::Content::Unit))
}
-
- fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::export::Result<Self::Value, __E>
+ }
+ } else {
+ quote! {
+ fn visit_u64<__E>(self, __value: u64) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
#(
- #field_borrowed_strs => _serde::export::Ok(#constructors),
+ #variant_indices => _serde::__private::Ok(#main_constructors),
)*
- _ => {
- #value_as_borrowed_str_content
- #fallthrough_arm
- }
+ _ => #u64_fallthrough_arm,
}
}
+ }
+ };
- fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::export::Result<Self::Value, __E>
+ let visit_borrowed = if fallthrough_borrowed.is_some() || collect_other_fields {
+ let fallthrough_borrowed_arm = fallthrough_borrowed.as_ref().unwrap_or(&fallthrough_arm);
+ Some(quote! {
+ fn visit_borrowed_str<__E>(self, __value: &'de str) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
#(
- #field_borrowed_bytes => _serde::export::Ok(#constructors),
+ #field_strs => _serde::__private::Ok(#constructors),
)*
_ => {
- #bytes_to_str
- #value_as_borrowed_bytes_content
- #fallthrough_arm
+ #value_as_borrowed_str_content
+ #fallthrough_borrowed_arm
}
}
}
- }
- } else {
- quote! {
- fn visit_u64<__E>(self, __value: u64) -> _serde::export::Result<Self::Value, __E>
+
+ fn visit_borrowed_bytes<__E>(self, __value: &'de [u8]) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
#(
- #variant_indices => _serde::export::Ok(#main_constructors),
+ #field_bytes => _serde::__private::Ok(#constructors),
)*
- _ => _serde::export::Err(_serde::de::Error::invalid_value(
- _serde::de::Unexpected::Unsigned(__value),
- &#fallthrough_msg,
- ))
+ _ => {
+ #bytes_to_str
+ #value_as_borrowed_bytes_content
+ #fallthrough_borrowed_arm
+ }
}
}
- }
+ })
+ } else {
+ None
};
quote_block! {
- fn expecting(&self, __formatter: &mut _serde::export::Formatter) -> _serde::export::fmt::Result {
- _serde::export::Formatter::write_str(__formatter, #expecting)
+ fn expecting(&self, __formatter: &mut _serde::__private::Formatter) -> _serde::__private::fmt::Result {
+ _serde::__private::Formatter::write_str(__formatter, #expecting)
}
#visit_other
- fn visit_str<__E>(self, __value: &str) -> _serde::export::Result<Self::Value, __E>
+ fn visit_str<__E>(self, __value: &str) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
#(
- #field_strs => _serde::export::Ok(#constructors),
+ #field_strs => _serde::__private::Ok(#constructors),
)*
_ => {
#value_as_str_content
}
}
- fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::export::Result<Self::Value, __E>
+ fn visit_bytes<__E>(self, __value: &[u8]) -> _serde::__private::Result<Self::Value, __E>
where
__E: _serde::de::Error,
{
match __value {
#(
- #field_bytes => _serde::export::Ok(#constructors),
+ #field_bytes => _serde::__private::Ok(#constructors),
)*
_ => {
#bytes_to_str
}
}
}
+
+ #visit_borrowed
}
}
.map(|(field, name)| {
let field_ty = field.ty;
quote! {
- let mut #name: _serde::export::Option<#field_ty> = _serde::export::None;
+ let mut #name: _serde::__private::Option<#field_ty> = _serde::__private::None;
}
});
// Collect contents for flatten fields into a buffer
let let_collect = if cattrs.has_flatten() {
Some(quote! {
- let mut __collect = _serde::export::Vec::<_serde::export::Option<(
- _serde::private::de::Content,
- _serde::private::de::Content
+ let mut __collect = _serde::__private::Vec::<_serde::__private::Option<(
+ _serde::__private::de::Content,
+ _serde::__private::de::Content
)>>::new();
})
} else {
quote!({
#wrapper
match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
- _serde::export::Ok(__wrapper) => __wrapper.value,
- _serde::export::Err(__err) => {
- return _serde::export::Err(__err);
+ _serde::__private::Ok(__wrapper) => __wrapper.value,
+ _serde::__private::Err(__err) => {
+ return _serde::__private::Err(__err);
}
}
})
};
quote! {
__Field::#name => {
- if _serde::export::Option::is_some(&#name) {
- return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
+ if _serde::__private::Option::is_some(&#name) {
+ return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
}
- #name = _serde::export::Some(#visit);
+ #name = _serde::__private::Some(#visit);
}
}
});
let ignored_arm = if cattrs.has_flatten() {
Some(quote! {
__Field::__other(__name) => {
- __collect.push(_serde::export::Some((
+ __collect.push(_serde::__private::Some((
__name,
try!(_serde::de::MapAccess::next_value(&mut __map)))));
}
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! {
// FIXME: Once we drop support for Rust 1.15:
- // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
- _serde::export::Option::map(
+ // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+ _serde::__private::Option::map(
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
|__impossible| match __impossible {});
}
} else {
quote! {
- while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+ while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
match __key {
#(#value_arms)*
#ignored_arm
quote! {
let #name = match #name {
- _serde::export::Some(#name) => #name,
- _serde::export::None => #missing_expr
+ _serde::__private::Some(#name) => #name,
+ _serde::__private::None => #missing_expr
};
}
});
};
quote! {
let #name: #field_ty = try!(#func(
- _serde::private::de::FlatMapDeserializer(
+ _serde::__private::de::FlatMapDeserializer(
&mut __collect,
- _serde::export::PhantomData)));
+ _serde::__private::PhantomData)));
}
});
let collected_deny_unknown_fields = if cattrs.has_flatten() && cattrs.deny_unknown_fields() {
Some(quote! {
- if let _serde::export::Some(_serde::export::Some((__key, _))) =
- __collect.into_iter().filter(_serde::export::Option::is_some).next()
+ if let _serde::__private::Some(_serde::__private::Some((__key, _))) =
+ __collect.into_iter().filter(_serde::__private::Option::is_some).next()
{
- if let _serde::export::Some(__key) = __key.as_str() {
- return _serde::export::Err(
+ if let _serde::__private::Some(__key) = __key.as_str() {
+ return _serde::__private::Err(
_serde::de::Error::custom(format_args!("unknown field `{}`", &__key)));
} else {
- return _serde::export::Err(
+ return _serde::__private::Err(
_serde::de::Error::custom(format_args!("unexpected map key")));
}
}
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
- let __default: Self::Value = _serde::export::Default::default();
+ let __default: Self::Value = _serde::__private::Default::default();
)),
attr::Default::Path(path) => Some(quote!(
let __default: Self::Value = #path();
if params.has_getter {
let this = ¶ms.this;
result = quote! {
- _serde::export::Into::<#this>::into(#result)
+ _serde::__private::Into::<#this>::into(#result)
};
}
#collected_deny_unknown_fields
- _serde::export::Ok(#result)
+ _serde::__private::Ok(#result)
}
}
let visit = match field.attrs.deserialize_with() {
None => {
quote! {
- try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::private::de::InPlaceSeed(&mut self.place.#member)))
+ try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member)))
}
}
Some(path) => {
quote!({
#wrapper
self.place.#member = match _serde::de::MapAccess::next_value::<#wrapper_ty>(&mut __map) {
- _serde::export::Ok(__wrapper) => __wrapper.value,
- _serde::export::Err(__err) => {
- return _serde::export::Err(__err);
+ _serde::__private::Ok(__wrapper) => __wrapper.value,
+ _serde::__private::Err(__err) => {
+ return _serde::__private::Err(__err);
}
};
})
quote! {
__Field::#name => {
if #name {
- return _serde::export::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
+ return _serde::__private::Err(<__A::Error as _serde::de::Error>::duplicate_field(#deser_name));
}
#visit;
#name = true;
let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! {
// FIXME: Once we drop support for Rust 1.15:
- // let _serde::export::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
- _serde::export::Option::map(
+ // let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map));
+ _serde::__private::Option::map(
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)),
|__impossible| match __impossible {});
}
} else {
quote! {
- while let _serde::export::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
+ while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) {
match __key {
#(#value_arms_from)*
#ignored_arm
let let_default = match cattrs.default() {
attr::Default::Default => Some(quote!(
- let __default: #this #ty_generics = _serde::export::Default::default();
+ let __default: #this #ty_generics = _serde::__private::Default::default();
)),
attr::Default::Path(path) => Some(quote!(
let __default: #this #ty_generics = #path();
#(#check_flags)*
- _serde::export::Ok(())
+ _serde::__private::Ok(())
}
}
let wrapper = quote! {
struct __DeserializeWith #de_impl_generics #where_clause {
value: #value_ty,
- phantom: _serde::export::PhantomData<#this #ty_generics>,
- lifetime: _serde::export::PhantomData<&#delife ()>,
+ phantom: _serde::__private::PhantomData<#this #ty_generics>,
+ lifetime: _serde::__private::PhantomData<&#delife ()>,
}
impl #de_impl_generics _serde::Deserialize<#delife> for __DeserializeWith #de_ty_generics #where_clause {
- fn deserialize<__D>(__deserializer: __D) -> _serde::export::Result<Self, __D::Error>
+ fn deserialize<__D>(__deserializer: __D) -> _serde::__private::Result<Self, __D::Error>
where
__D: _serde::Deserializer<#delife>,
{
- _serde::export::Ok(__DeserializeWith {
+ _serde::__private::Ok(__DeserializeWith {
value: try!(#deserialize_with(__deserializer)),
- phantom: _serde::export::PhantomData,
- lifetime: _serde::export::PhantomData,
+ phantom: _serde::__private::PhantomData,
+ lifetime: _serde::__private::PhantomData,
})
}
}
match field.attrs.default() {
attr::Default::Default => {
let span = field.original.span();
- let func = quote_spanned!(span=> _serde::export::Default::default);
+ let func = quote_spanned!(span=> _serde::__private::Default::default);
return quote_expr!(#func());
}
attr::Default::Path(path) => {
match field.attrs.deserialize_with() {
None => {
let span = field.original.span();
- let func = quote_spanned!(span=> _serde::private::de::missing_field);
+ let func = quote_spanned!(span=> _serde::__private::de::missing_field);
quote_expr! {
try!(#func(#name))
}
}
Some(_) => {
quote_expr! {
- return _serde::export::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
+ return _serde::__private::Err(<__A::Error as _serde::de::Error>::missing_field(#name))
}
}
}
projects / cargo.git / blobdiff