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()
+                    ),
+                    _ => 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 => {

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);
@@ -825,6 +835,12 @@ fn serialize_tuple_variant(
             variant_index,
             variant_name,
         } => {
+            if len.to_string() == "0" {
+                return quote_expr! {
+                    _serde::Serializer::serialize_unit_variant(__serializer, #type_name, #variant_index, #variant_name)
+                }               
+            }
+
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple_variant(
                     __serializer,
@@ -837,6 +853,11 @@ fn serialize_tuple_variant(
             }
         }
         TupleVariant::Untagged => {
+            if len.to_string() == "0" {
+                return quote_expr! {
+                    _serde::Serializer::serialize_unit(__serializer)
+                }               
+            }
             quote_block! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_tuple(
                     __serializer,