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

Merge pull request #479 from serde-rs/nestser

Browse Source 
Remove unnecessary nesting from generated impls
This commit is contained in:
Oliver Schneider
2016-08-04 09:08:59 +02:00
committed by GitHub
parent df3c3cb555 c539563687
commit 1c55f58093
2 changed files with 90 additions and 107 deletions
Download Patch File Download Diff File Expand all files Collapse all files
serde_codegen/src/de.rs
+55 -69
View File
@@ -76,10 +76,8 @@ fn deserialize_item(
#[automatically_derived] #[automatically_derived]
impl $impl_generics _serde::de::Deserialize for $ty $where_clause { impl $impl_generics _serde::de::Deserialize for $ty $where_clause {
fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<$ty, __D::Error> fn deserialize<__D>(deserializer: &mut __D) -> ::std::result::Result<$ty, __D::Error>
where __D: _serde::de::Deserializer, where __D: _serde::de::Deserializer
{ $body
$body
}
} }
}; };
).unwrap() ).unwrap()
@@ -136,7 +134,7 @@ fn deserialize_body(
item: &Item, item: &Item,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
) -> P<ast::Expr> { ) -> P<ast::Block> {
match item.body { match item.body {
Body::Enum(ref variants) => { Body::Enum(ref variants) => {
deserialize_item_enum( deserialize_item_enum(
@@ -274,10 +272,10 @@ fn deserialize_unit_struct(
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
type_ident: Ident, type_ident: Ident,
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let type_name = name_expr(builder, item_attrs.name()); let type_name = name_expr(builder, item_attrs.name());
quote_expr!(cx, { quote_block!(cx, {
struct __Visitor; struct __Visitor;
impl _serde::de::Visitor for __Visitor { impl _serde::de::Visitor for __Visitor {
@@ -300,7 +298,7 @@ fn deserialize_unit_struct(
} }
deserializer.deserialize_unit_struct($type_name, __Visitor) deserializer.deserialize_unit_struct($type_name, __Visitor)
}) }).unwrap()
} }
fn deserialize_tuple( fn deserialize_tuple(
@@ -312,7 +310,7 @@ fn deserialize_tuple(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor( let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor(
@@ -343,7 +341,7 @@ fn deserialize_tuple(
None None
}; };
let visit_seq_expr = deserialize_seq( let visit_seq = deserialize_seq(
cx, cx,
builder, builder,
type_ident, type_ident,
@@ -366,7 +364,7 @@ fn deserialize_tuple(
deserializer.deserialize_tuple_struct($type_name, $nfields, $visitor_expr)) deserializer.deserialize_tuple_struct($type_name, $nfields, $visitor_expr))
}; };
quote_expr!(cx, { quote_block!(cx, {
$visitor_item $visitor_item
impl $visitor_generics _serde::de::Visitor for $visitor_ty $where_clause { impl $visitor_generics _serde::de::Visitor for $visitor_ty $where_clause {
@@ -376,14 +374,12 @@ fn deserialize_tuple(
#[inline] #[inline]
fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error> fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
where __V: _serde::de::SeqVisitor, where __V: _serde::de::SeqVisitor
{ $visit_seq
$visit_seq_expr
}
} }
$dispatch $dispatch
}) }).unwrap()
} }
fn deserialize_seq( fn deserialize_seq(
@@ -394,7 +390,7 @@ fn deserialize_seq(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
fields: &[Field], fields: &[Field],
is_struct: bool, is_struct: bool,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let mut index_in_seq = 0usize; let mut index_in_seq = 0usize;
let let_values: Vec<_> = fields.iter() let let_values: Vec<_> = fields.iter()
.enumerate() .enumerate()
@@ -461,13 +457,13 @@ fn deserialize_seq(
.build() .build()
}; };
quote_expr!(cx, { quote_block!(cx, {
$let_values $let_values
try!(visitor.end()); try!(visitor.end());
Ok($result) Ok($result)
}) }).unwrap()
} }
fn deserialize_newtype_struct( fn deserialize_newtype_struct(
@@ -513,7 +509,7 @@ fn deserialize_struct(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor( let (visitor_item, visitor_ty, visitor_expr, visitor_generics) = deserialize_visitor(
@@ -528,7 +524,7 @@ fn deserialize_struct(
None => builder.path().id(type_ident).build(), None => builder.path().id(type_ident).build(),
}; };
let visit_seq_expr = deserialize_seq( let visit_seq = deserialize_seq(
cx, cx,
builder, builder,
type_ident, type_ident,
@@ -538,7 +534,7 @@ fn deserialize_struct(
true, true,
); );
let (field_visitor, fields_stmt, visit_map_expr) = deserialize_struct_visitor( let (field_visitor, fields_stmt, visit_map) = deserialize_struct_visitor(
cx, cx,
builder, builder,
type_ident, type_ident,
@@ -558,7 +554,7 @@ fn deserialize_struct(
deserializer.deserialize_struct($type_name, FIELDS, $visitor_expr)) deserializer.deserialize_struct($type_name, FIELDS, $visitor_expr))
}; };
quote_expr!(cx, { quote_block!(cx, {
$field_visitor $field_visitor
$visitor_item $visitor_item
@@ -568,23 +564,19 @@ fn deserialize_struct(
#[inline] #[inline]
fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error> fn visit_seq<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
where __V: _serde::de::SeqVisitor, where __V: _serde::de::SeqVisitor
{ $visit_seq
$visit_seq_expr
}
#[inline] #[inline]
fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error> fn visit_map<__V>(&mut self, mut visitor: __V) -> ::std::result::Result<$ty, __V::Error>
where __V: _serde::de::MapVisitor, where __V: _serde::de::MapVisitor
{ $visit_map
$visit_map_expr
}
} }
$fields_stmt $fields_stmt
$dispatch $dispatch
}) }).unwrap()
} }
fn deserialize_item_enum( fn deserialize_item_enum(
@@ -595,7 +587,7 @@ fn deserialize_item_enum(
ty: P<ast::Ty>, ty: P<ast::Ty>,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item item_attrs: &attr::Item
) -> P<ast::Expr> { ) -> P<ast::Block> {
let where_clause = &impl_generics.where_clause; let where_clause = &impl_generics.where_clause;
let type_name = name_expr(builder, item_attrs.name()); let type_name = name_expr(builder, item_attrs.name());
@@ -633,7 +625,7 @@ fn deserialize_item_enum(
.id("__Field").id(format!("__field{}", i)) .id("__Field").id(format!("__field{}", i))
.build(); .build();
let expr = deserialize_variant( let block = deserialize_variant(
cx, cx,
builder, builder,
type_ident, type_ident,
@@ -643,7 +635,7 @@ fn deserialize_item_enum(
item_attrs, item_attrs,
); );
let arm = quote_arm!(cx, $variant_name => { $expr }); let arm = quote_arm!(cx, $variant_name => $block);
variant_arms.push(arm); variant_arms.push(arm);
} }
variant_arms.extend(ignored_arm.into_iter()); variant_arms.extend(ignored_arm.into_iter());
@@ -655,7 +647,7 @@ fn deserialize_item_enum(
vec![deserializer_ty_arg(builder)], vec![deserializer_ty_arg(builder)],
); );
quote_expr!(cx, { quote_block!(cx, {
$variant_visitor $variant_visitor
$visitor_item $visitor_item
@@ -675,7 +667,7 @@ fn deserialize_item_enum(
$variants_stmt $variants_stmt
deserializer.deserialize_enum($type_name, VARIANTS, $visitor_expr) deserializer.deserialize_enum($type_name, VARIANTS, $visitor_expr)
}) }).unwrap()
} }
fn deserialize_variant( fn deserialize_variant(
@@ -686,15 +678,15 @@ fn deserialize_variant(
ty: P<ast::Ty>, ty: P<ast::Ty>,
variant: &Variant, variant: &Variant,
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let variant_ident = variant.ident; let variant_ident = variant.ident;
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote_expr!(cx, { quote_block!(cx, {
try!(visitor.visit_unit()); try!(visitor.visit_unit());
Ok($type_ident::$variant_ident) Ok($type_ident::$variant_ident)
}) }).unwrap()
} }
Style::Newtype => { Style::Newtype => {
deserialize_newtype_variant( deserialize_newtype_variant(
@@ -740,7 +732,7 @@ fn deserialize_newtype_variant(
variant_ident: Ident, variant_ident: Ident,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
field: &Field, field: &Field,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let visit = match field.attrs.deserialize_with() { let visit = match field.attrs.deserialize_with() {
None => { None => {
let field_ty = &field.ty; let field_ty = &field.ty;
@@ -756,7 +748,9 @@ fn deserialize_newtype_variant(
}) })
} }
}; };
quote_expr!(cx, Ok($type_ident::$variant_ident($visit))) quote_block!(cx, {
Ok($type_ident::$variant_ident($visit))
}).unwrap()
} }
fn deserialize_field_visitor( fn deserialize_field_visitor(
@@ -805,17 +799,15 @@ fn deserialize_field_visitor(
let fallthrough_index_arm_expr = if !is_variant && !item_attrs.deny_unknown_fields() { let fallthrough_index_arm_expr = if !is_variant && !item_attrs.deny_unknown_fields() {
quote_expr!(cx, Ok(__Field::__ignore)) quote_expr!(cx, Ok(__Field::__ignore))
} else { } else {
quote_expr!(cx, { quote_expr!(cx, Err(_serde::de::Error::invalid_value($index_error_msg)))
Err(_serde::de::Error::invalid_value($index_error_msg))
})
}; };
let index_body = quote_expr!(cx, let index_body = quote_block!(cx, {
match value { match value {
$index_field_arms $index_field_arms
_ => $fallthrough_index_arm_expr _ => $fallthrough_index_arm_expr
} }
); }).unwrap();
// Convert the field names into byte strings. // Convert the field names into byte strings.
let str_field_names: Vec<_> = field_names.iter() let str_field_names: Vec<_> = field_names.iter()
@@ -835,12 +827,12 @@ fn deserialize_field_visitor(
quote_expr!(cx, Err(_serde::de::Error::$unknown_ident(value))) quote_expr!(cx, Err(_serde::de::Error::$unknown_ident(value)))
}; };
let str_body = quote_expr!(cx, let str_body = quote_block!(cx, {
match value { match value {
$str_field_arms $str_field_arms
_ => $fallthrough_str_arm_expr _ => $fallthrough_str_arm_expr
} }
); }).unwrap();
// Convert the field names into byte strings. // Convert the field names into byte strings.
let bytes_field_names: Vec<_> = field_names.iter() let bytes_field_names: Vec<_> = field_names.iter()
@@ -866,12 +858,12 @@ fn deserialize_field_visitor(
}) })
}; };
let bytes_body = quote_expr!(cx, let bytes_body = quote_block!(cx, {
match value { match value {
$bytes_field_arms $bytes_field_arms
_ => $fallthrough_bytes_arm_expr _ => $fallthrough_bytes_arm_expr
} }
); }).unwrap();
let impl_item = quote_item!(cx, let impl_item = quote_item!(cx,
impl _serde::de::Deserialize for __Field { impl _serde::de::Deserialize for __Field {
@@ -889,22 +881,16 @@ fn deserialize_field_visitor(
type Value = __Field; type Value = __Field;
fn visit_usize<__E>(&mut self, value: usize) -> ::std::result::Result<__Field, __E> fn visit_usize<__E>(&mut self, value: usize) -> ::std::result::Result<__Field, __E>
where __E: _serde::de::Error, where __E: _serde::de::Error
{ $index_body
$index_body
}
fn visit_str<__E>(&mut self, value: &str) -> ::std::result::Result<__Field, __E> fn visit_str<__E>(&mut self, value: &str) -> ::std::result::Result<__Field, __E>
where __E: _serde::de::Error, where __E: _serde::de::Error
{ $str_body
$str_body
}
fn visit_bytes<__E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, __E> fn visit_bytes<__E>(&mut self, value: &[u8]) -> ::std::result::Result<__Field, __E>
where __E: _serde::de::Error, where __E: _serde::de::Error
{ $bytes_body
$bytes_body
}
} }
deserializer.deserialize_struct_field( deserializer.deserialize_struct_field(
@@ -927,7 +913,7 @@ fn deserialize_struct_visitor(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> (Vec<P<ast::Item>>, ast::Stmt, P<ast::Expr>) { ) -> (Vec<P<ast::Item>>, ast::Stmt, P<ast::Block>) {
let field_exprs = fields.iter() let field_exprs = fields.iter()
.map(|field| field.attrs.name().deserialize_name()) .map(|field| field.attrs.name().deserialize_name())
.collect(); .collect();
@@ -940,7 +926,7 @@ fn deserialize_struct_visitor(
false, false,
); );
let visit_map_expr = deserialize_map( let visit_map = deserialize_map(
cx, cx,
builder, builder,
type_ident, type_ident,
@@ -968,7 +954,7 @@ fn deserialize_struct_visitor(
const FIELDS: &'static [&'static str] = $fields_expr; const FIELDS: &'static [&'static str] = $fields_expr;
).unwrap(); ).unwrap();
(field_visitor, fields_stmt, visit_map_expr) (field_visitor, fields_stmt, visit_map)
} }
fn deserialize_map( fn deserialize_map(
@@ -979,7 +965,7 @@ fn deserialize_map(
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
// Create the field names for the fields. // Create the field names for the fields.
let fields_names = fields.iter() let fields_names = fields.iter()
.enumerate() .enumerate()
@@ -1086,7 +1072,7 @@ fn deserialize_map(
) )
.build(); .build();
quote_expr!(cx, { quote_block!(cx, {
$let_values $let_values
while let Some(key) = try!(visitor.visit_key::<__Field>()) { while let Some(key) = try!(visitor.visit_key::<__Field>()) {
@@ -1102,7 +1088,7 @@ fn deserialize_map(
$extract_values $extract_values
Ok($result) Ok($result)
}) }).unwrap()
} }
/// This function wraps the expression in `#[serde(deserialize_with="...")]` in /// This function wraps the expression in `#[serde(deserialize_with="...")]` in
serde_codegen/src/ser.rs
+35 -38
View File
@@ -70,10 +70,8 @@ fn serialize_item(
#[automatically_derived] #[automatically_derived]
impl $impl_generics _serde::ser::Serialize for $ty $where_clause { impl $impl_generics _serde::ser::Serialize for $ty $where_clause {
fn serialize<__S>(&self, _serializer: &mut __S) -> ::std::result::Result<(), __S::Error> fn serialize<__S>(&self, _serializer: &mut __S) -> ::std::result::Result<(), __S::Error>
where __S: _serde::ser::Serializer, where __S: _serde::ser::Serializer
{ $body
$body
}
} }
}; };
).unwrap() ).unwrap()
@@ -119,7 +117,7 @@ fn serialize_body(
item: &Item, item: &Item,
impl_generics: &ast::Generics, impl_generics: &ast::Generics,
ty: P<ast::Ty>, ty: P<ast::Ty>,
) -> P<ast::Expr> { ) -> P<ast::Block> {
match item.body { match item.body {
Body::Enum(ref variants) => { Body::Enum(ref variants) => {
serialize_item_enum( serialize_item_enum(
@@ -179,12 +177,12 @@ fn serialize_unit_struct(
cx: &ExtCtxt, cx: &ExtCtxt,
builder: &aster::AstBuilder, builder: &aster::AstBuilder,
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let type_name = name_expr(builder, item_attrs.name()); let type_name = name_expr(builder, item_attrs.name());
quote_expr!(cx, quote_block!(cx, {
_serializer.serialize_unit_struct($type_name) _serializer.serialize_unit_struct($type_name)
) }).unwrap()
} }
fn serialize_newtype_struct( fn serialize_newtype_struct(
@@ -194,7 +192,7 @@ fn serialize_newtype_struct(
item_ty: P<ast::Ty>, item_ty: P<ast::Ty>,
field: &Field, field: &Field,
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let type_name = name_expr(builder, item_attrs.name()); let type_name = name_expr(builder, item_attrs.name());
let mut field_expr = quote_expr!(cx, &self.0); let mut field_expr = quote_expr!(cx, &self.0);
@@ -203,9 +201,9 @@ fn serialize_newtype_struct(
&item_ty, impl_generics, &field.ty, path, field_expr); &item_ty, impl_generics, &field.ty, path, field_expr);
} }
quote_expr!(cx, quote_block!(cx, {
_serializer.serialize_newtype_struct($type_name, $field_expr) _serializer.serialize_newtype_struct($type_name, $field_expr)
) }).unwrap()
} }
fn serialize_tuple_struct( fn serialize_tuple_struct(
@@ -215,7 +213,7 @@ fn serialize_tuple_struct(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let serialize_stmts = serialize_tuple_struct_visitor( let serialize_stmts = serialize_tuple_struct_visitor(
cx, cx,
builder, builder,
@@ -229,11 +227,11 @@ fn serialize_tuple_struct(
let type_name = name_expr(builder, item_attrs.name()); let type_name = name_expr(builder, item_attrs.name());
let len = serialize_stmts.len(); let len = serialize_stmts.len();
quote_expr!(cx, { quote_block!(cx, {
let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len)); let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
$serialize_stmts $serialize_stmts
_serializer.serialize_tuple_struct_end(state) _serializer.serialize_tuple_struct_end(state)
}) }).unwrap()
} }
fn serialize_struct( fn serialize_struct(
@@ -243,7 +241,7 @@ fn serialize_struct(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let serialize_fields = serialize_struct_visitor( let serialize_fields = serialize_struct_visitor(
cx, cx,
builder, builder,
@@ -268,11 +266,11 @@ fn serialize_struct(
}) })
.fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
quote_expr!(cx, { quote_block!(cx, {
let mut state = try!(_serializer.serialize_struct($type_name, $len)); let mut state = try!(_serializer.serialize_struct($type_name, $len));
$serialize_fields $serialize_fields
_serializer.serialize_struct_end(state) _serializer.serialize_struct_end(state)
}) }).unwrap()
} }
fn serialize_item_enum( fn serialize_item_enum(
@@ -283,7 +281,7 @@ fn serialize_item_enum(
ty: P<ast::Ty>, ty: P<ast::Ty>,
variants: &[Variant], variants: &[Variant],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let arms: Vec<_> = let arms: Vec<_> =
variants.iter() variants.iter()
.enumerate() .enumerate()
@@ -301,11 +299,11 @@ fn serialize_item_enum(
}) })
.collect(); .collect();
quote_expr!(cx, quote_block!(cx, {
match *self { match *self {
$arms $arms
} }
) }).unwrap()
} }
fn serialize_variant( fn serialize_variant(
@@ -326,18 +324,17 @@ fn serialize_variant(
match variant.style { match variant.style {
Style::Unit => { Style::Unit => {
quote_arm!(cx, quote_arm!(cx,
$type_ident::$variant_ident => { $type_ident::$variant_ident =>
_serde::ser::Serializer::serialize_unit_variant( _serde::ser::Serializer::serialize_unit_variant(
_serializer, _serializer,
$type_name, $type_name,
$variant_index, $variant_index,
$variant_name, $variant_name,
) ),
}
) )
}, },
Style::Newtype => { Style::Newtype => {
let expr = serialize_newtype_variant( let block = serialize_newtype_variant(
cx, cx,
builder, builder,
type_name, type_name,
@@ -349,7 +346,7 @@ fn serialize_variant(
); );
quote_arm!(cx, quote_arm!(cx,
$type_ident::$variant_ident(ref __simple_value) => { $expr } $type_ident::$variant_ident(ref __simple_value) => $block
) )
}, },
Style::Tuple => { Style::Tuple => {
@@ -365,7 +362,7 @@ fn serialize_variant(
) )
.build(); .build();
let expr = serialize_tuple_variant( let block = serialize_tuple_variant(
cx, cx,
builder, builder,
type_name, type_name,
@@ -377,7 +374,7 @@ fn serialize_variant(
); );
quote_arm!(cx, quote_arm!(cx,
$pat => { $expr } $pat => $block
) )
} }
Style::Struct => { Style::Struct => {
@@ -395,7 +392,7 @@ fn serialize_variant(
} }
let pat = pat.build(); let pat = pat.build();
let expr = serialize_struct_variant( let block = serialize_struct_variant(
cx, cx,
builder, builder,
variant_index, variant_index,
@@ -407,7 +404,7 @@ fn serialize_variant(
); );
quote_arm!(cx, quote_arm!(cx,
$pat => { $expr } $pat => $block
) )
} }
} }
@@ -422,14 +419,14 @@ fn serialize_newtype_variant(
item_ty: P<ast::Ty>, item_ty: P<ast::Ty>,
generics: &ast::Generics, generics: &ast::Generics,
field: &Field, field: &Field,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let mut field_expr = quote_expr!(cx, __simple_value); let mut field_expr = quote_expr!(cx, __simple_value);
if let Some(path) = field.attrs.serialize_with() { if let Some(path) = field.attrs.serialize_with() {
field_expr = wrap_serialize_with(cx, builder, field_expr = wrap_serialize_with(cx, builder,
&item_ty, generics, &field.ty, path, field_expr); &item_ty, generics, &field.ty, path, field_expr);
} }
quote_expr!(cx, quote_block!(cx, {
_serde::ser::Serializer::serialize_newtype_variant( _serde::ser::Serializer::serialize_newtype_variant(
_serializer, _serializer,
$type_name, $type_name,
@@ -437,7 +434,7 @@ fn serialize_newtype_variant(
$variant_name, $variant_name,
$field_expr, $field_expr,
) )
) }).unwrap()
} }
fn serialize_tuple_variant( fn serialize_tuple_variant(
@@ -449,7 +446,7 @@ fn serialize_tuple_variant(
generics: &ast::Generics, generics: &ast::Generics,
structure_ty: P<ast::Ty>, structure_ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
) -> P<ast::Expr> { ) -> P<ast::Block> {
let serialize_stmts = serialize_tuple_struct_visitor( let serialize_stmts = serialize_tuple_struct_visitor(
cx, cx,
builder, builder,
@@ -462,11 +459,11 @@ fn serialize_tuple_variant(
let len = serialize_stmts.len(); let len = serialize_stmts.len();
quote_expr!(cx, { quote_block!(cx, {
let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len)); let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
$serialize_stmts $serialize_stmts
_serializer.serialize_tuple_variant_end(state) _serializer.serialize_tuple_variant_end(state)
}) }).unwrap()
} }
fn serialize_struct_variant( fn serialize_struct_variant(
@@ -478,7 +475,7 @@ fn serialize_struct_variant(
ty: P<ast::Ty>, ty: P<ast::Ty>,
fields: &[Field], fields: &[Field],
item_attrs: &attr::Item, item_attrs: &attr::Item,
) -> P<ast::Expr> { ) -> P<ast::Block> {
let serialize_fields = serialize_struct_visitor( let serialize_fields = serialize_struct_visitor(
cx, cx,
@@ -504,7 +501,7 @@ fn serialize_struct_variant(
}) })
.fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr)); .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
quote_expr!(cx, { quote_block!(cx, {
let mut state = try!(_serializer.serialize_struct_variant( let mut state = try!(_serializer.serialize_struct_variant(
$item_name, $item_name,
$variant_index, $variant_index,
@@ -513,7 +510,7 @@ fn serialize_struct_variant(
)); ));
$serialize_fields $serialize_fields
_serializer.serialize_struct_variant_end(state) _serializer.serialize_struct_variant_end(state)
}) }).unwrap()
} }
fn serialize_tuple_struct_visitor( fn serialize_tuple_struct_visitor(