From c268eb22580dffd63f3f8228cd81264188c396d4 Mon Sep 17 00:00:00 2001 From: Erick Tryzelaar Date: Thu, 18 Feb 2016 19:31:43 -0800 Subject: [PATCH] feat(codegen): Remove #[serde(skip_serializing_if_{none,empty})] `#[serde(skip_serializing_if="...")]` can replace this functionality. --- serde_codegen/src/attr.rs | 22 ------------ serde_codegen/src/ser.rs | 44 +++++++----------------- serde_tests/tests/test_annotations.rs | 48 +++------------------------ 3 files changed, 16 insertions(+), 98 deletions(-) diff --git a/serde_codegen/src/attr.rs b/serde_codegen/src/attr.rs index 975ca303..cb95014f 100644 --- a/serde_codegen/src/attr.rs +++ b/serde_codegen/src/attr.rs @@ -167,8 +167,6 @@ pub struct FieldAttrs { deserialize_name: Option, skip_serializing_field: bool, skip_serializing_field_if: Option>, - skip_serializing_field_if_empty: bool, - skip_serializing_field_if_none: bool, default_expr_if_missing: Option>, serialize_with: Option>, deserialize_with: Option>, @@ -193,8 +191,6 @@ impl FieldAttrs { deserialize_name: None, skip_serializing_field: false, skip_serializing_field_if: None, - skip_serializing_field_if_empty: false, - skip_serializing_field_if_none: false, default_expr_if_missing: None, serialize_with: None, deserialize_with: None, @@ -251,16 +247,6 @@ impl FieldAttrs { field_attrs.skip_serializing_field_if = Some(expr); } - // Parse `#[serde(skip_serializing_if_none)]` - ast::MetaItemKind::Word(ref name) if name == &"skip_serializing_if_none" => { - field_attrs.skip_serializing_field_if_none = true; - } - - // Parse `#[serde(skip_serializing_if_empty)]` - ast::MetaItemKind::Word(ref name) if name == &"skip_serializing_if_empty" => { - field_attrs.skip_serializing_field_if_empty = true; - } - // Parse `#[serde(serialize_with="...")]` ast::MetaItemKind::NameValue(ref name, ref lit) if name == &"serialize_with" => { let expr = wrap_serialize_with( @@ -345,14 +331,6 @@ impl FieldAttrs { self.skip_serializing_field_if.as_ref() } - pub fn skip_serializing_field_if_empty(&self) -> bool { - self.skip_serializing_field_if_empty - } - - pub fn skip_serializing_field_if_none(&self) -> bool { - self.skip_serializing_field_if_none - } - pub fn serialize_with(&self) -> Option<&P> { self.serialize_with.as_ref() } diff --git a/serde_codegen/src/ser.rs b/serde_codegen/src/ser.rs index fdf42883..de1693e9 100644 --- a/serde_codegen/src/ser.rs +++ b/serde_codegen/src/ser.rs @@ -657,19 +657,10 @@ fn serialize_struct_visitor( let key_expr = field_attr.serialize_name_expr(); - let stmt = match field_attr.skip_serializing_field_if() { - Some(expr) => { + let stmt = if let Some(expr) = field_attr.skip_serializing_field_if() { Some(quote_stmt!(cx, if $expr { continue; })) - } - None => { - if field_attr.skip_serializing_field_if_empty() { - Some(quote_stmt!(cx, if self.value.$name.is_empty() { continue; })) - } else if field_attr.skip_serializing_field_if_none() { - Some(quote_stmt!(cx, if self.value.$name.is_none() { continue; })) - } else { - None - } - } + } else { + None }; let field_expr = match field_attr.serialize_with() { @@ -702,26 +693,15 @@ fn serialize_struct_visitor( .strip_bounds() .build(); - let len = fields.iter().zip(field_attrs.iter()) - .map(|(field, field_attr)| { - if field_attr.skip_serializing_field() { - quote_expr!(cx, 0) - } else { - match field_attr.skip_serializing_field_if() { - Some(expr) => { - quote_expr!(cx, if $expr { 0 } else { 1 }) - } - None => { - let name = field.node.ident().expect("struct has unnamed field"); - - if field_attr.skip_serializing_field_if_empty() { - quote_expr!(cx, if self.value.$name.is_empty() { 0 } else { 1 }) - } else if field_attr.skip_serializing_field_if_none() { - quote_expr!(cx, if self.value.$name.is_none() { 0 } else { 1 }) - } else { - quote_expr!(cx, 1) - } - } + let len = field_attrs.iter() + .filter(|field_attr| !field_attr.skip_serializing_field()) + .map(|field_attr| { + match field_attr.skip_serializing_field_if() { + Some(expr) => { + quote_expr!(cx, if $expr { 0 } else { 1 }) + } + None => { + quote_expr!(cx, 1) } } }) diff --git a/serde_tests/tests/test_annotations.rs b/serde_tests/tests/test_annotations.rs index 5521c1d0..031b6bb5 100644 --- a/serde_tests/tests/test_annotations.rs +++ b/serde_tests/tests/test_annotations.rs @@ -389,16 +389,12 @@ fn test_rename_enum() { } #[derive(Debug, PartialEq, Serialize)] -struct SkipSerializingStruct<'a, B, C, D, E> where C: Trait { +struct SkipSerializingStruct<'a, B, C> where C: Trait { a: &'a i8, #[serde(skip_serializing)] b: B, #[serde(skip_serializing_if="self.c.should_skip()")] c: C, - #[serde(skip_serializing_if_none)] - d: Option, - #[serde(skip_serializing_if_empty)] - e: Vec, } #[test] @@ -409,11 +405,9 @@ fn test_skip_serializing_struct() { a: &a, b: 2, c: 3, - d: Some(4), - e: vec![5], }, &[ - Token::StructStart("SkipSerializingStruct", Some(4)), + Token::StructStart("SkipSerializingStruct", Some(2)), Token::StructSep, Token::Str("a"), @@ -423,18 +417,6 @@ fn test_skip_serializing_struct() { Token::Str("c"), Token::I32(3), - Token::StructSep, - Token::Str("d"), - Token::Option(true), - Token::I32(4), - - Token::StructSep, - Token::Str("e"), - Token::SeqStart(Some(1)), - Token::SeqSep, - Token::I32(5), - Token::SeqEnd, - Token::StructEnd, ] ); @@ -444,8 +426,6 @@ fn test_skip_serializing_struct() { a: &a, b: 2, c: 123, - d: None::, - e: Vec::::new(), }, &[ Token::StructStart("SkipSerializingStruct", Some(1)), @@ -460,17 +440,13 @@ fn test_skip_serializing_struct() { } #[derive(Debug, PartialEq, Serialize)] -enum SkipSerializingEnum<'a, B, C, D, E> where C: Trait { +enum SkipSerializingEnum<'a, B, C> where C: Trait { Struct { a: &'a i8, #[serde(skip_serializing)] _b: B, #[serde(skip_serializing_if="self.c.should_skip()")] c: C, - #[serde(skip_serializing_if_none)] - d: Option, - #[serde(skip_serializing_if_empty)] - e: Vec, } } @@ -482,11 +458,9 @@ fn test_skip_serializing_enum() { a: &a, _b: 2, c: 3, - d: Some(4), - e: vec![5], }, &[ - Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(4)), + Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(2)), Token::EnumMapSep, Token::Str("a"), @@ -496,18 +470,6 @@ fn test_skip_serializing_enum() { Token::Str("c"), Token::I32(3), - Token::EnumMapSep, - Token::Str("d"), - Token::Option(true), - Token::I32(4), - - Token::EnumMapSep, - Token::Str("e"), - Token::SeqStart(Some(1)), - Token::SeqSep, - Token::I32(5), - Token::SeqEnd, - Token::EnumMapEnd, ] ); @@ -517,8 +479,6 @@ fn test_skip_serializing_enum() { a: &a, _b: 2, c: 123, - d: None::, - e: Vec::::new(), }, &[ Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),