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

Remove unnecessary nesting from generated Serialize implementations

Browse Source
This commit is contained in:
David Tolnay
2016-08-03 20:40:57 -07:00
parent b289edd4a4
commit 69de46f9e0
1 changed files with 35 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files
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(