use dummy;
use fragment::{Fragment, Match, Stmts};
use internals::ast::{Container, Data, Field, Style, Variant};
-use internals::{attr, Ctxt, Derive};
+use internals::{attr, replace_receiver, Ctxt, Derive};
use pretend;
-pub fn expand_derive_serialize(input: &syn::DeriveInput) -> Result<TokenStream, Vec<syn::Error>> {
+pub fn expand_derive_serialize(
+ input: &mut syn::DeriveInput,
+) -> Result<TokenStream, Vec<syn::Error>> {
+ replace_receiver(input);
+
let ctxt = Ctxt::new();
let cont = match Container::from_ast(&ctxt, input, Derive::Serialize) {
Some(cont) => cont,
let used = pretend::pretend_used(&cont);
quote! {
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
__S: #serde::Serializer,
{
quote! {
#[automatically_derived]
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
__S: #serde::Serializer,
{
let self_var = ¶ms.self_var;
quote_block! {
_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)
}
}
let let_mut = mut_if(serialized_fields.peek().is_some() || tag_field_exists);
let len = if cattrs.has_flatten() {
- quote!(_serde::export::None)
+ quote!(_serde::__private::None)
} else {
let len = serialized_fields
.map(|field| match field.attrs.skip_serializing_if() {
quote!(#tag_field_exists as usize),
|sum, expr| quote!(#sum + #expr),
);
- quote!(_serde::export::Some(#len))
+ quote!(_serde::__private::Some(#len))
};
quote_block! {
variant_ident
);
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 {
Style::Unit => quote!(),
if let Some(path) = variant.attrs.serialize_with() {
let ser = wrap_serialize_variant_with(params, path, variant);
return quote_expr! {
- _serde::private::ser::serialize_tagged_newtype(
+ _serde::__private::ser::serialize_tagged_newtype(
__serializer,
#enum_ident_str,
#variant_ident_str,
}
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! {
#func(
__serializer,
quote_block! {
struct __AdjacentlyTagged #wrapper_generics #where_clause {
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 {
- 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
__S: _serde::Serializer,
{
try!(_serde::ser::SerializeStruct::serialize_field(
&mut __struct, #content, &__AdjacentlyTagged {
data: (#(#fields_ident,)*),
- phantom: _serde::export::PhantomData::<#this #ty_generics>,
+ phantom: _serde::__private::PhantomData::<#this #ty_generics>,
}));
_serde::ser::SerializeStruct::end(__struct)
}
quote_block! {
struct __EnumFlatten #wrapper_generics #where_clause {
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 {
- 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
__S: _serde::Serializer,
{
let (#(#members,)*) = self.data;
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer,
- _serde::export::None));
+ _serde::__private::None));
#(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state)
}
#variant_name,
&__EnumFlatten {
data: (#(#members,)*),
- phantom: _serde::export::PhantomData::<#this #ty_generics>,
+ phantom: _serde::__private::PhantomData::<#this #ty_generics>,
})
}
}
quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer,
- _serde::export::None));
+ _serde::__private::None));
try!(_serde::ser::SerializeMap::serialize_entry(
&mut __serde_state,
#tag,
quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(
__serializer,
- _serde::export::None));
+ _serde::__private::None));
#(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state)
}
let ser = if field.attrs.flatten() {
let func = quote_spanned!(span=> _serde::Serialize::serialize);
quote! {
- try!(#func(&#field_expr, _serde::private::ser::FlatMapSerializer(&mut __serde_state)));
+ try!(#func(&#field_expr, _serde::__private::ser::FlatMapSerializer(&mut __serde_state)));
}
} else {
let func = struct_trait.serialize_field(span);
quote!({
struct __SerializeWith #wrapper_impl_generics #where_clause {
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 {
- 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
__S: _serde::Serializer,
{
&__SerializeWith {
values: (#(#field_exprs, )*),
- phantom: _serde::export::PhantomData::<#this #ty_generics>,
+ phantom: _serde::__private::PhantomData::<#this #ty_generics>,
}
})
}
quote!(&#self_var.#member)
};
let ty = field.ty;
- quote!(_serde::private::ser::constrain::<#ty>(#inner))
+ quote!(_serde::__private::ser::constrain::<#ty>(#inner))
}
(true, Some(getter)) => {
let ty = field.ty;
- quote!(_serde::private::ser::constrain::<#ty>(&#getter(#self_var)))
+ quote!(_serde::__private::ser::constrain::<#ty>(&#getter(#self_var)))
}
(false, Some(_)) => {
unreachable!("getter is only allowed for remote impls");