feat(codegen): Remove #[serde(skip_serializing_if_{none,empty})]

`#[serde(skip_serializing_if="...")]` can replace this functionality.

serde_codegen/src/attr.rs

@@ -167,8 +167,6 @@ pub struct FieldAttrs {
     deserialize_name: Option<ast::Lit>,
     skip_serializing_field: bool,
     skip_serializing_field_if: Option<P<ast::Expr>>,
-    skip_serializing_field_if_empty: bool,
-    skip_serializing_field_if_none: bool,
     default_expr_if_missing: Option<P<ast::Expr>>,
     serialize_with: Option<P<ast::Expr>>,
     deserialize_with: Option<P<ast::Expr>>,
@@ -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<ast::Expr>> {
         self.serialize_with.as_ref()
     }

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() {
+            let stmt = if let Some(expr) = field_attr.skip_serializing_field_if() {
-                Some(expr) => {
                     Some(quote_stmt!(cx, if $expr { continue; }))
-                }
+            } else {
-                None => {
+                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
-                    }
-                }
             };
 
             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())
+    let len = field_attrs.iter()
-        .map(|(field, field_attr)| {
+        .filter(|field_attr| !field_attr.skip_serializing_field())
-            if field_attr.skip_serializing_field() {
+        .map(|field_attr| {
-                quote_expr!(cx, 0)
+            match field_attr.skip_serializing_field_if() {
-            } else {
+                Some(expr) => {
-                match field_attr.skip_serializing_field_if() {
+                    quote_expr!(cx, if $expr { 0 } else { 1 })
-                    Some(expr) => {
+                }
-                        quote_expr!(cx, if $expr { 0 } else { 1 })
+                None => {
-                    }
+                    quote_expr!(cx, 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)
-                        }
-                    }
                 }
             }
         })

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<D>,
-    #[serde(skip_serializing_if_empty)]
-    e: Vec<E>,
 }
 
 #[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::<u8>,
-            e: Vec::<u8>::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<D>,
-        #[serde(skip_serializing_if_empty)]
-        e: Vec<E>,
     }
 }
 
@@ -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::<u8>,
-            e: Vec::<u8>::new(),
         },
         &[
             Token::EnumMapStart("SkipSerializingEnum", "Struct", Some(1)),