itsscb/serde
1
0
Fork 0
mirror of https://github.com/serde-rs/serde.git synced 2025-10-02 07:21:12 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge pull request #2539 from dtolnay/questionmark

Browse Source 
Replace `try!` with `?` in serde_derive
This commit is contained in:
David Tolnay 2023-07-27 19:20:15 -07:00 committed by GitHub
commit 7b09cccd77
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
6 changed files with 90 additions and 118 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
precompiled/serde_derive/src/lib_from_source.rs
View File

@ -14,7 +14,6 @@ mod internals;
mod pretend; mod pretend;
mod ser; mod ser;
mod this; mod this;
mod try;
use proc_macro::TokenStream; use proc_macro::TokenStream;
use syn::{parse_macro_input, DeriveInput}; use syn::{parse_macro_input, DeriveInput};

82
serde_derive/src/de.rs
View File

@ -710,14 +710,14 @@ fn deserialize_seq(
let span = field.original.span(); let span = field.original.span();
let func = let func =
quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>); quote_spanned!(span=> _serde::de::SeqAccess::next_element::<#field_ty>);
quote!(try!(#func(&mut __seq))) quote!(#func(&mut __seq)?)
} }
Some(path) => { Some(path) => {
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path); let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({ quote!({
#wrapper #wrapper
_serde::__private::Option::map( _serde::__private::Option::map(
try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)), _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)?,
|__wrap| __wrap.value) |__wrap| __wrap.value)
}) })
} }
@ -824,8 +824,8 @@ fn deserialize_seq_in_place(
let write = match field.attrs.deserialize_with() { let write = match field.attrs.deserialize_with() {
None => { None => {
quote! { quote! {
if let _serde::__private::None = try!(_serde::de::SeqAccess::next_element_seed(&mut __seq, if let _serde::__private::None = _serde::de::SeqAccess::next_element_seed(&mut __seq,
_serde::__private::de::InPlaceSeed(&mut self.place.#member))) _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
{ {
#value_if_none #value_if_none
} }
@ -835,7 +835,7 @@ fn deserialize_seq_in_place(
let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path); let (wrapper, wrapper_ty) = wrap_deserialize_field_with(params, field.ty, path);
quote!({ quote!({
#wrapper #wrapper
match try!(_serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)) { match _serde::de::SeqAccess::next_element::<#wrapper_ty>(&mut __seq)? {
_serde::__private::Some(__wrap) => { _serde::__private::Some(__wrap) => {
self.place.#member = __wrap.value; self.place.#member = __wrap.value;
} }
@ -887,12 +887,12 @@ fn deserialize_newtype_struct(
let span = field.original.span(); let span = field.original.span();
let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize); let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
quote! { quote! {
try!(#func(__e)) #func(__e)?
} }
} }
Some(path) => { Some(path) => {
quote! { quote! {
try!(#path(__e)) #path(__e)?
} }
} }
}; };
@ -1364,7 +1364,7 @@ fn deserialize_externally_tagged_enum(
} }
} else { } else {
quote! { quote! {
match try!(_serde::de::EnumAccess::variant(__data)) { match _serde::de::EnumAccess::variant(__data)? {
#(#variant_arms)* #(#variant_arms)*
} }
} }
@ -1444,9 +1444,9 @@ fn deserialize_internally_tagged_enum(
#variants_stmt #variants_stmt
let (__tag, __content) = try!(_serde::Deserializer::deserialize_any( let (__tag, __content) = _serde::Deserializer::deserialize_any(
__deserializer, __deserializer,
_serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))); _serde::__private::de::TaggedContentVisitor::<__Field>::new(#tag, #expecting))?;
let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content); let __deserializer = _serde::__private::de::ContentDeserializer::<__D::Error>::new(__content);
match __tag { match __tag {
@ -1554,7 +1554,7 @@ fn deserialize_adjacently_tagged_enum(
// Advance the map by one key, returning early in case of error. // Advance the map by one key, returning early in case of error.
let next_key = quote! { let next_key = quote! {
try!(_serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content)) _serde::de::MapAccess::next_key_seed(&mut __map, #tag_or_content)?
}; };
// When allowing unknown fields, we want to transparently step through keys // When allowing unknown fields, we want to transparently step through keys
@ -1567,7 +1567,7 @@ fn deserialize_adjacently_tagged_enum(
while let _serde::__private::Some(__k) = #next_key { while let _serde::__private::Some(__k) = #next_key {
match __k { match __k {
_serde::__private::de::TagContentOtherField::Other => { _serde::__private::de::TagContentOtherField::Other => {
let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?;
continue; continue;
}, },
_serde::__private::de::TagContentOtherField::Tag => { _serde::__private::de::TagContentOtherField::Tag => {
@ -1602,14 +1602,14 @@ fn deserialize_adjacently_tagged_enum(
let finish_content_then_tag = if variant_arms.is_empty() { let finish_content_then_tag = if variant_arms.is_empty() {
quote! { quote! {
match try!(_serde::de::MapAccess::next_value::<__Field>(&mut __map)) {} match _serde::de::MapAccess::next_value::<__Field>(&mut __map)? {}
} }
} else { } else {
quote! { quote! {
let __ret = try!(match try!(_serde::de::MapAccess::next_value(&mut __map)) { let __ret = match _serde::de::MapAccess::next_value(&mut __map)? {
// Deserialize the buffered content now that we know the variant. // Deserialize the buffered content now that we know the variant.
#(#variant_arms)* #(#variant_arms)*
}); }?;
// Visit remaining keys, looking for duplicates. // Visit remaining keys, looking for duplicates.
#visit_remaining_keys #visit_remaining_keys
} }
@ -1662,7 +1662,7 @@ fn deserialize_adjacently_tagged_enum(
// First key is the tag. // First key is the tag.
_serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => { _serde::__private::Some(_serde::__private::de::TagOrContentField::Tag) => {
// Parse the tag. // Parse the tag.
let __field = try!(_serde::de::MapAccess::next_value(&mut __map)); let __field = _serde::de::MapAccess::next_value(&mut __map)?;
// Visit the second key. // Visit the second key.
match #next_relevant_key { match #next_relevant_key {
// Second key is a duplicate of the tag. // Second key is a duplicate of the tag.
@ -1671,12 +1671,12 @@ fn deserialize_adjacently_tagged_enum(
} }
// Second key is the content. // Second key is the content.
_serde::__private::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, let __ret = _serde::de::MapAccess::next_value_seed(&mut __map,
__Seed { __Seed {
field: __field, field: __field,
marker: _serde::__private::PhantomData, marker: _serde::__private::PhantomData,
lifetime: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData,
})); })?;
// Visit remaining keys, looking for duplicates. // Visit remaining keys, looking for duplicates.
#visit_remaining_keys #visit_remaining_keys
} }
@ -1687,7 +1687,7 @@ fn deserialize_adjacently_tagged_enum(
// First key is the content. // First key is the content.
_serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => { _serde::__private::Some(_serde::__private::de::TagOrContentField::Content) => {
// Buffer up the content. // Buffer up the content.
let __content = try!(_serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map)); let __content = _serde::de::MapAccess::next_value::<_serde::__private::de::Content>(&mut __map)?;
// Visit the second key. // Visit the second key.
match #next_relevant_key { match #next_relevant_key {
// Second key is the tag. // Second key is the tag.
@ -1717,17 +1717,17 @@ fn deserialize_adjacently_tagged_enum(
__A: _serde::de::SeqAccess<#delife>, __A: _serde::de::SeqAccess<#delife>,
{ {
// Visit the first element - the tag. // Visit the first element - the tag.
match try!(_serde::de::SeqAccess::next_element(&mut __seq)) { match _serde::de::SeqAccess::next_element(&mut __seq)? {
_serde::__private::Some(__field) => { _serde::__private::Some(__field) => {
// Visit the second element - the content. // Visit the second element - the content.
match try!(_serde::de::SeqAccess::next_element_seed( match _serde::de::SeqAccess::next_element_seed(
&mut __seq, &mut __seq,
__Seed { __Seed {
field: __field, field: __field,
marker: _serde::__private::PhantomData, marker: _serde::__private::PhantomData,
lifetime: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData,
}, },
)) { )? {
_serde::__private::Some(__ret) => _serde::__private::Ok(__ret), _serde::__private::Some(__ret) => _serde::__private::Ok(__ret),
// There is no second element. // There is no second element.
_serde::__private::None => { _serde::__private::None => {
@ -1797,7 +1797,7 @@ fn deserialize_untagged_enum_after(
let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg); let fallthrough_msg = cattrs.expecting().unwrap_or(&fallthrough_msg);
quote_block! { quote_block! {
let __content = try!(<_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)); let __content = <_serde::__private::de::Content as _serde::Deserialize>::deserialize(__deserializer)?;
let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content); let __deserializer = _serde::__private::de::ContentRefDeserializer::<__D::Error>::new(&__content);
#( #(
@ -1830,7 +1830,7 @@ fn deserialize_externally_tagged_variant(
Style::Unit => { Style::Unit => {
let this_value = &params.this_value; let this_value = &params.this_value;
quote_block! { quote_block! {
try!(_serde::de::VariantAccess::unit_variant(__variant)); _serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private::Ok(#this_value::#variant_ident) _serde::__private::Ok(#this_value::#variant_ident)
} }
} }
@ -1879,7 +1879,7 @@ fn deserialize_internally_tagged_variant(
quote!((#default)) quote!((#default))
}); });
quote_block! { quote_block! {
try!(_serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))); _serde::Deserializer::deserialize_any(#deserializer, _serde::__private::de::InternallyTaggedUnitVisitor::new(#type_name, #variant_name))?;
_serde::__private::Ok(#this_value::#variant_ident #default) _serde::__private::Ok(#this_value::#variant_ident #default)
} }
} }
@ -1965,7 +1965,7 @@ fn deserialize_externally_tagged_newtype_variant(
if field.attrs.skip_deserializing() { if field.attrs.skip_deserializing() {
let default = Expr(expr_is_missing(field, cattrs)); let default = Expr(expr_is_missing(field, cattrs));
return quote_block! { return quote_block! {
try!(_serde::de::VariantAccess::unit_variant(__variant)); _serde::de::VariantAccess::unit_variant(__variant)?;
_serde::__private::Ok(#this_value::#variant_ident(#default)) _serde::__private::Ok(#this_value::#variant_ident(#default))
}; };
} }
@ -2540,7 +2540,7 @@ fn deserialize_map(
let func = let func =
quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>); quote_spanned!(span=> _serde::de::MapAccess::next_value::<#field_ty>);
quote! { quote! {
try!(#func(&mut __map)) #func(&mut __map)?
} }
} }
Some(path) => { Some(path) => {
@ -2572,14 +2572,14 @@ fn deserialize_map(
__Field::__other(__name) => { __Field::__other(__name) => {
__collect.push(_serde::__private::Some(( __collect.push(_serde::__private::Some((
__name, __name,
try!(_serde::de::MapAccess::next_value(&mut __map))))); _serde::de::MapAccess::next_value(&mut __map)?)));
} }
}) })
} else if cattrs.deny_unknown_fields() { } else if cattrs.deny_unknown_fields() {
None None
} else { } else {
Some(quote! { Some(quote! {
_ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); } _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
}) })
}; };
@ -2587,14 +2587,14 @@ fn deserialize_map(
let match_keys = if cattrs.deny_unknown_fields() && all_skipped { let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! { quote! {
// FIXME: Once feature(exhaustive_patterns) is stable: // FIXME: Once feature(exhaustive_patterns) is stable:
// let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map)); // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
_serde::__private::Option::map( _serde::__private::Option::map(
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)), _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
|__impossible| match __impossible {}); |__impossible| match __impossible {});
} }
} else { } else {
quote! { quote! {
while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) { while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key { match __key {
#(#value_arms)* #(#value_arms)*
#ignored_arm #ignored_arm
@ -2630,10 +2630,10 @@ fn deserialize_map(
Some(path) => quote!(#path), Some(path) => quote!(#path),
}; };
quote! { quote! {
let #name: #field_ty = try!(#func( let #name: #field_ty = #func(
_serde::__private::de::FlatMapDeserializer( _serde::__private::de::FlatMapDeserializer(
&mut __collect, &mut __collect,
_serde::__private::PhantomData))); _serde::__private::PhantomData))?;
} }
}); });
@ -2780,7 +2780,7 @@ fn deserialize_map_in_place(
let visit = match field.attrs.deserialize_with() { let visit = match field.attrs.deserialize_with() {
None => { None => {
quote! { quote! {
try!(_serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))) _serde::de::MapAccess::next_value_seed(&mut __map, _serde::__private::de::InPlaceSeed(&mut self.place.#member))?
} }
} }
Some(path) => { Some(path) => {
@ -2812,7 +2812,7 @@ fn deserialize_map_in_place(
None None
} else { } else {
Some(quote! { Some(quote! {
_ => { let _ = try!(_serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)); } _ => { let _ = _serde::de::MapAccess::next_value::<_serde::de::IgnoredAny>(&mut __map)?; }
}) })
}; };
@ -2821,14 +2821,14 @@ fn deserialize_map_in_place(
let match_keys = if cattrs.deny_unknown_fields() && all_skipped { let match_keys = if cattrs.deny_unknown_fields() && all_skipped {
quote! { quote! {
// FIXME: Once feature(exhaustive_patterns) is stable: // FIXME: Once feature(exhaustive_patterns) is stable:
// let _serde::__private::None::<__Field> = try!(_serde::de::MapAccess::next_key(&mut __map)); // let _serde::__private::None::<__Field> = _serde::de::MapAccess::next_key(&mut __map)?;
_serde::__private::Option::map( _serde::__private::Option::map(
try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)), _serde::de::MapAccess::next_key::<__Field>(&mut __map)?,
|__impossible| match __impossible {}); |__impossible| match __impossible {});
} }
} else { } else {
quote! { quote! {
while let _serde::__private::Some(__key) = try!(_serde::de::MapAccess::next_key::<__Field>(&mut __map)) { while let _serde::__private::Some(__key) = _serde::de::MapAccess::next_key::<__Field>(&mut __map)? {
match __key { match __key {
#(#value_arms_from)* #(#value_arms_from)*
#ignored_arm #ignored_arm
@ -2925,7 +2925,7 @@ fn wrap_deserialize_with(
__D: _serde::Deserializer<#delife>, __D: _serde::Deserializer<#delife>,
{ {
_serde::__private::Ok(__DeserializeWith { _serde::__private::Ok(__DeserializeWith {
value: try!(#deserialize_with(__deserializer)), value: #deserialize_with(__deserializer)?,
phantom: _serde::__private::PhantomData, phantom: _serde::__private::PhantomData,
lifetime: _serde::__private::PhantomData, lifetime: _serde::__private::PhantomData,
}) })
@ -3035,7 +3035,7 @@ fn expr_is_missing(field: &Field, cattrs: &attr::Container) -> Fragment {
let span = field.original.span(); 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! { quote_expr! {
try!(#func(#name)) #func(#name)?
} }
} }
Some(_) => { Some(_) => {

4
serde_derive/src/dummy.rs
View File

@ -1,10 +1,7 @@
use crate::try;
use proc_macro2::TokenStream; use proc_macro2::TokenStream;
use quote::quote; use quote::quote;
pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream { pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> TokenStream {
let try_replacement = try::replacement();
let use_serde = match serde_path { let use_serde = match serde_path {
Some(path) => quote! { Some(path) => quote! {
use #path as _serde; use #path as _serde;
@ -20,7 +17,6 @@ pub fn wrap_in_const(serde_path: Option<&syn::Path>, code: TokenStream) -> Token
#[allow(non_upper_case_globals, unused_attributes, unused_qualifications)] #[allow(non_upper_case_globals, unused_attributes, unused_qualifications)]
const _: () = { const _: () = {
#use_serde #use_serde
#try_replacement
#code #code
}; };
} }

1
serde_derive/src/lib.rs
View File

@ -90,7 +90,6 @@ mod dummy;
mod pretend; mod pretend;
mod ser; mod ser;
mod this; mod this;
mod try;
#[cfg(precompiled)] #[cfg(precompiled)]
macro_rules! parse_macro_input { macro_rules! parse_macro_input {

98
serde_derive/src/ser.rs
View File

@ -282,7 +282,7 @@ fn serialize_tuple_struct(
.fold(quote!(0), |sum, expr| quote!(#sum + #expr)); .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len)); let #let_mut __serde_state = _serde::Serializer::serialize_tuple_struct(__serializer, #type_name, #len)?;
#(#serialize_stmts)* #(#serialize_stmts)*
_serde::ser::SerializeTupleStruct::end(__serde_state) _serde::ser::SerializeTupleStruct::end(__serde_state)
} }
@ -304,7 +304,7 @@ fn serialize_struct_tag_field(cattrs: &attr::Container, struct_trait: &StructTra
let type_name = cattrs.name().serialize_name(); let type_name = cattrs.name().serialize_name();
let func = struct_trait.serialize_field(Span::call_site()); let func = struct_trait.serialize_field(Span::call_site());
quote! { quote! {
try!(#func(&mut __serde_state, #tag, #type_name)); #func(&mut __serde_state, #tag, #type_name)?;
} }
} }
_ => quote! {}, _ => quote! {},
@ -345,7 +345,7 @@ fn serialize_struct_as_struct(
); );
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(__serializer, #type_name, #len)); let #let_mut __serde_state = _serde::Serializer::serialize_struct(__serializer, #type_name, #len)?;
#tag_field #tag_field
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
@ -389,7 +389,7 @@ fn serialize_struct_as_map(
}; };
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len)); let #let_mut __serde_state = _serde::Serializer::serialize_map(__serializer, #len)?;
#tag_field #tag_field
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
@ -593,10 +593,10 @@ fn serialize_internally_tagged_variant(
match effective_style(variant) { match effective_style(variant) {
Style::Unit => { Style::Unit => {
quote_block! { quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = _serde::Serializer::serialize_struct(
__serializer, #type_name, 1)); __serializer, #type_name, 1)?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name)?;
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
} }
} }
@ -650,10 +650,10 @@ fn serialize_adjacently_tagged_variant(
match effective_style(variant) { match effective_style(variant) {
Style::Unit => { Style::Unit => {
return quote_block! { return quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = _serde::Serializer::serialize_struct(
__serializer, #type_name, 1)); __serializer, #type_name, 1)?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name)?;
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
}; };
} }
@ -667,12 +667,12 @@ fn serialize_adjacently_tagged_variant(
let span = field.original.span(); let span = field.original.span();
let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field); let func = quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field);
return quote_block! { return quote_block! {
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = _serde::Serializer::serialize_struct(
__serializer, #type_name, 2)); __serializer, #type_name, 2)?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name)?;
try!(#func( #func(
&mut __struct, #content, #field_expr)); &mut __struct, #content, #field_expr)?;
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
}; };
} }
@ -732,15 +732,15 @@ fn serialize_adjacently_tagged_variant(
} }
} }
let mut __struct = try!(_serde::Serializer::serialize_struct( let mut __struct = _serde::Serializer::serialize_struct(
__serializer, #type_name, 2)); __serializer, #type_name, 2)?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __struct, #tag, #variant_name)); &mut __struct, #tag, #variant_name)?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __struct, #content, &__AdjacentlyTagged { &mut __struct, #content, &__AdjacentlyTagged {
data: (#(#fields_ident,)*), data: (#(#fields_ident,)*),
phantom: _serde::__private::PhantomData::<#this_type #ty_generics>, phantom: _serde::__private::PhantomData::<#this_type #ty_generics>,
})); })?;
_serde::ser::SerializeStruct::end(__struct) _serde::ser::SerializeStruct::end(__struct)
} }
} }
@ -830,21 +830,21 @@ fn serialize_tuple_variant(
variant_name, variant_name,
} => { } => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant( let #let_mut __serde_state = _serde::Serializer::serialize_tuple_variant(
__serializer, __serializer,
#type_name, #type_name,
#variant_index, #variant_index,
#variant_name, #variant_name,
#len)); #len)?;
#(#serialize_stmts)* #(#serialize_stmts)*
_serde::ser::SerializeTupleVariant::end(__serde_state) _serde::ser::SerializeTupleVariant::end(__serde_state)
} }
} }
TupleVariant::Untagged => { TupleVariant::Untagged => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple( let #let_mut __serde_state = _serde::Serializer::serialize_tuple(
__serializer, __serializer,
#len)); #len)?;
#(#serialize_stmts)* #(#serialize_stmts)*
_serde::ser::SerializeTuple::end(__serde_state) _serde::ser::SerializeTuple::end(__serde_state)
} }
@ -907,40 +907,40 @@ fn serialize_struct_variant(
variant_name, variant_name,
} => { } => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant( let #let_mut __serde_state = _serde::Serializer::serialize_struct_variant(
__serializer, __serializer,
#name, #name,
#variant_index, #variant_index,
#variant_name, #variant_name,
#len, #len,
)); )?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStructVariant::end(__serde_state) _serde::ser::SerializeStructVariant::end(__serde_state)
} }
} }
StructVariant::InternallyTagged { tag, variant_name } => { StructVariant::InternallyTagged { tag, variant_name } => {
quote_block! { quote_block! {
let mut __serde_state = try!(_serde::Serializer::serialize_struct( let mut __serde_state = _serde::Serializer::serialize_struct(
__serializer, __serializer,
#name, #name,
#len + 1, #len + 1,
)); )?;
try!(_serde::ser::SerializeStruct::serialize_field( _serde::ser::SerializeStruct::serialize_field(
&mut __serde_state, &mut __serde_state,
#tag, #tag,
#variant_name, #variant_name,
)); )?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
} }
} }
StructVariant::Untagged => { StructVariant::Untagged => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct( let #let_mut __serde_state = _serde::Serializer::serialize_struct(
__serializer, __serializer,
#name, #name,
#len, #len,
)); )?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeStruct::end(__serde_state) _serde::ser::SerializeStruct::end(__serde_state)
} }
@ -990,9 +990,9 @@ fn serialize_struct_variant_with_flatten(
__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 = _serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::__private::None)); _serde::__private::None)?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
} }
@ -1011,23 +1011,23 @@ fn serialize_struct_variant_with_flatten(
} }
StructVariant::InternallyTagged { tag, variant_name } => { StructVariant::InternallyTagged { tag, variant_name } => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( let #let_mut __serde_state = _serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::__private::None)); _serde::__private::None)?;
try!(_serde::ser::SerializeMap::serialize_entry( _serde::ser::SerializeMap::serialize_entry(
&mut __serde_state, &mut __serde_state,
#tag, #tag,
#variant_name, #variant_name,
)); )?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
} }
} }
StructVariant::Untagged => { StructVariant::Untagged => {
quote_block! { quote_block! {
let #let_mut __serde_state = try!(_serde::Serializer::serialize_map( let #let_mut __serde_state = _serde::Serializer::serialize_map(
__serializer, __serializer,
_serde::__private::None)); _serde::__private::None)?;
#(#serialize_fields)* #(#serialize_fields)*
_serde::ser::SerializeMap::end(__serde_state) _serde::ser::SerializeMap::end(__serde_state)
} }
@ -1072,7 +1072,7 @@ fn serialize_tuple_struct_visitor(
let span = field.original.span(); let span = field.original.span();
let func = tuple_trait.serialize_element(span); let func = tuple_trait.serialize_element(span);
let ser = quote! { let ser = quote! {
try!(#func(&mut __serde_state, #field_expr)); #func(&mut __serde_state, #field_expr)?;
}; };
match skip { match skip {
@ -1116,12 +1116,12 @@ 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))); #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);
quote! { quote! {
try!(#func(&mut __serde_state, #key_expr, #field_expr)); #func(&mut __serde_state, #key_expr, #field_expr)?;
} }
}; };
@ -1133,7 +1133,7 @@ fn serialize_struct_visitor(
if !#skip { if !#skip {
#ser #ser
} else { } else {
try!(#skip_func(&mut __serde_state, #key_expr)); #skip_func(&mut __serde_state, #key_expr)?;
} }
} }
} else { } else {
@ -1233,7 +1233,7 @@ fn wrap_serialize_with(
// Serialization of an empty struct results in code like: // Serialization of an empty struct results in code like:
// //
// let mut __serde_state = try!(serializer.serialize_struct("S", 0)); // let mut __serde_state = serializer.serialize_struct("S", 0)?;
// _serde::ser::SerializeStruct::end(__serde_state) // _serde::ser::SerializeStruct::end(__serde_state)
// //
// where we want to omit the `mut` to avoid a warning. // where we want to omit the `mut` to avoid a warning.

22
serde_derive/src/try.rs
View File

@ -1,22 +0,0 @@
use proc_macro2::TokenStream;
use quote::quote;
// None of our generated code requires the `From::from` error conversion
// performed by the standard library's `try!` macro. With this simplified macro
// we see a significant improvement in type checking and borrow checking time of
// the generated code and a slight improvement in binary size.
pub fn replacement() -> TokenStream {
quote! {
#[allow(unused_macros)]
macro_rules! try {
($__expr:expr) => {
match $__expr {
_serde::__private::Ok(__val) => __val,
_serde::__private::Err(__err) => {
return _serde::__private::Err(__err);
}
}
}
}
}
}