Merge pull request #1622 from Xaeroxe/fix-new-types

Fix (de)serialization of new types where the internal type is skipped

serde_derive/src/de.rs

@@ -1689,6 +1689,24 @@ fn deserialize_externally_tagged_variant(
             }
         }
         Style::Newtype => {
+            if variant.fields[0].attrs.skip_deserializing() {
+                let this = &params.this;
+                let let_default = match variant.fields[0].attrs.default() {
+                    attr::Default::Default => quote!(
+                        _serde::export::Default::default()
+                    ),
+                    attr::Default::Path(ref path) => quote!(
+                        #path()
+                    ),
+                    attr::Default::None => unimplemented!(),
+                };
+
+
+                return quote_block! {
+                    try!(_serde::de::VariantAccess::unit_variant(__variant));
+                    _serde::export::Ok(#this::#variant_ident(#let_default))
+                };   
+            }
             deserialize_externally_tagged_newtype_variant(variant_ident, params, &variant.fields[0])
         }
         Style::Tuple => {
@@ -1839,6 +1857,21 @@ fn deserialize_untagged_newtype_variant(
     let field_ty = field.ty;
     match field.attrs.deserialize_with() {
         None => {
+            if field.attrs.skip_deserializing() {
+                let let_default = match field.attrs.default() {
+                    attr::Default::Default => quote!(
+                        _serde::export::Default::default()
+                    ),
+                    attr::Default::Path(ref path) => quote!(
+                        #path()
+                    ),
+                    attr::Default::None => unimplemented!(),
+                };
+
+                return quote_expr! {
+                    _serde::export::Ok(#this::#variant_ident(#let_default))
+                };
+            }
             let span = field.original.span();
             let func = quote_spanned!(span=> <#field_ty as _serde::Deserialize>::deserialize);
             quote_expr! {

serde_derive/src/ser.rs

@@ -522,6 +522,16 @@ fn serialize_externally_tagged_variant(
         }
         Style::Newtype => {
             let field = &variant.fields[0];
+            if field.attrs.skip_serializing() {
+                return quote_expr! {
+                    _serde::Serializer::serialize_unit_variant(
+                        __serializer,
+                        #type_name,
+                        #variant_index,
+                        #variant_name,
+                    )
+                }
+            }
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
@@ -598,6 +608,15 @@ fn serialize_internally_tagged_variant(
         }
         Style::Newtype => {
             let field = &variant.fields[0];
+            if field.attrs.skip_serializing() {
+                return quote_block! {
+                    let mut __struct = try!(_serde::Serializer::serialize_struct(
+                        __serializer, #type_name, 1));
+                    try!(_serde::ser::SerializeStruct::serialize_field(
+                        &mut __struct, #tag, #variant_name));
+                    _serde::ser::SerializeStruct::end(__struct)
+                };
+            }
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
@@ -658,6 +677,15 @@ fn serialize_adjacently_tagged_variant(
             }
             Style::Newtype => {
                 let field = &variant.fields[0];
+                if field.attrs.skip_serializing() {
+                     return quote_block! {
+                        let mut __struct = try!(_serde::Serializer::serialize_struct(
+                            __serializer, #type_name, 1));
+                        try!(_serde::ser::SerializeStruct::serialize_field(
+                            &mut __struct, #tag, #variant_name));
+                        _serde::ser::SerializeStruct::end(__struct)
+                    };   
+                }
                 let mut field_expr = quote!(__field0);
                 if let Some(path) = field.attrs.serialize_with() {
                     field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);
@@ -761,6 +789,11 @@ fn serialize_untagged_variant(
         }
         Style::Newtype => {
             let field = &variant.fields[0];
+            if field.attrs.skip_serializing() {
+                return quote_expr! {
+                    _serde::Serializer::serialize_unit(__serializer)
+                };
+            }
             let mut field_expr = quote!(__field0);
             if let Some(path) = field.attrs.serialize_with() {
                 field_expr = wrap_serialize_field_with(params, field.ty, path, &field_expr);

test_suite/tests/test_de.rs

@@ -104,6 +104,9 @@ struct StructSkipAllDenyUnknown {
     a: i32,
 }
 
+#[derive(Default, PartialEq, Debug)]
+struct NotDeserializable;
+
 #[derive(PartialEq, Debug, Deserialize)]
 enum Enum {
     #[allow(dead_code)]
@@ -117,6 +120,7 @@ enum Enum {
         b: i32,
         c: i32,
     },
+    SimpleWithSkipped(#[serde(skip_deserializing)] NotDeserializable),
 }
 
 #[derive(PartialEq, Debug, Deserialize)]
@@ -728,6 +732,11 @@ declare_tests! {
             Token::I32(1),
         ],
     }
+    test_enum_simple_with_skipped {
+        Enum::SimpleWithSkipped(NotDeserializable) => &[
+            Token::UnitVariant { name: "Enum", variant: "SimpleWithSkipped" },
+        ],
+    }
     test_enum_seq {
         Enum::Seq(1, 2, 3) => &[
             Token::TupleVariant { name: "Enum", variant: "Seq", len: 3 },
@@ -1217,13 +1226,13 @@ declare_error_tests! {
         &[
             Token::UnitVariant { name: "Enum", variant: "Foo" },
         ],
-        "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
+        "unknown variant `Foo`, expected one of `Unit`, `Simple`, `Seq`, `Map`, `SimpleWithSkipped`",
     }
     test_enum_skipped_variant<Enum> {
         &[
             Token::UnitVariant { name: "Enum", variant: "Skipped" },
         ],
-        "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`",
+        "unknown variant `Skipped`, expected one of `Unit`, `Simple`, `Seq`, `Map`, `SimpleWithSkipped`",
     }
     test_enum_skip_all<EnumSkipAll> {
         &[
@@ -1254,10 +1263,10 @@ declare_error_tests! {
     test_enum_out_of_range<Enum> {
         &[
             Token::Enum { name: "Enum" },
-            Token::U32(4),
+            Token::U32(5),
             Token::Unit,
         ],
-        "invalid value: integer `4`, expected variant index 0 <= i < 4",
+        "invalid value: integer `5`, expected variant index 0 <= i < 5",
     }
     test_short_tuple<(u8, u8, u8)> {
         &[

test_suite/tests/test_ser.rs

@@ -44,6 +44,9 @@ struct Struct {
     c: i32,
 }
 
+#[derive(PartialEq, Debug)]
+struct NotSerializable;
+
 #[derive(Serialize, PartialEq, Debug)]
 enum Enum {
     Unit,
@@ -64,6 +67,7 @@ enum Enum {
         _a: i32,
         _b: i32,
     },
+    OneWithSkipped(#[serde(skip_serializing)] NotSerializable),
 }
 
 //////////////////////////////////////////////////////////////////////////
@@ -326,6 +330,7 @@ declare_tests! {
                 Token::I32(2),
             Token::StructVariantEnd,
         ],
+        Enum::OneWithSkipped(NotSerializable) => &[Token::UnitVariant {name: "Enum", variant: "OneWithSkipped" }],
     }
     test_box {
         Box::new(0i32) => &[Token::I32(0)],