Merge pull request #771 from elliottslaughter:internally_content_tagged

serde_derive/src/de.rs

@@ -494,7 +494,7 @@ fn deserialize_item_enum(type_ident: &syn::Ident,
         attr::EnumTag::External => {
             deserialize_externally_tagged_enum(type_ident, impl_generics, ty, variants, item_attrs)
         }
-        attr::EnumTag::Internal(ref tag) => {
+        attr::EnumTag::Internal { ref tag } => {
             deserialize_internally_tagged_enum(type_ident,
                                                impl_generics,
                                                ty,
@@ -502,6 +502,7 @@ fn deserialize_item_enum(type_ident: &syn::Ident,
                                                item_attrs,
                                                tag)
         }
+        attr::EnumTag::Adjacent { .. } => unimplemented!(),
         attr::EnumTag::None => {
             deserialize_untagged_enum(type_ident, impl_generics, ty, variants, item_attrs)
         }

serde_derive/src/ser.rs

@@ -266,7 +266,7 @@ fn serialize_variant(type_ident: &syn::Ident,
                                                     variant_index,
                                                     item_attrs)
             }
-            attr::EnumTag::Internal(ref tag) => {
+            attr::EnumTag::Internal { ref tag } => {
                 serialize_internally_tagged_variant(type_ident.as_ref(),
                                                     variant_ident.as_ref(),
                                                     generics,
@@ -275,6 +275,9 @@ fn serialize_variant(type_ident: &syn::Ident,
                                                     item_attrs,
                                                     tag)
             }
+            attr::EnumTag::Adjacent { ref tag, ref content } => {
+                serialize_adjacently_tagged_variant(generics, ty, variant, item_attrs, tag, content)
+            }
             attr::EnumTag::None => serialize_untagged_variant(generics, ty, variant, item_attrs),
         };
 
@@ -343,7 +346,7 @@ fn serialize_externally_tagged_variant(generics: &syn::Generics,
                                                  generics,
                                                  ty,
                                                  &variant.fields,
-                                                 item_attrs);
+                                                 &type_name);
 
             quote! {
                 { #block }
@@ -399,7 +402,7 @@ fn serialize_internally_tagged_variant(type_ident: &str,
                                                  generics,
                                                  ty,
                                                  &variant.fields,
-                                                 item_attrs);
+                                                 &type_name);
 
             quote! {
                 { #block }
@@ -409,6 +412,110 @@ fn serialize_internally_tagged_variant(type_ident: &str,
     }
 }
 
+fn serialize_adjacently_tagged_variant(generics: &syn::Generics,
+                                       ty: syn::Ty,
+                                       variant: &Variant,
+                                       item_attrs: &attr::Item,
+                                       tag: &str,
+                                       content: &str)
+                                       -> Tokens {
+    let type_name = item_attrs.name().serialize_name();
+    let variant_name = variant.attrs.name().serialize_name();
+
+    let inner = match variant.style {
+        Style::Unit => {
+            return quote!({
+                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)
+            });
+        }
+        Style::Newtype => {
+            let field = &variant.fields[0];
+            let mut field_expr = quote!(__simple_value);
+            if let Some(path) = field.attrs.serialize_with() {
+                field_expr = wrap_serialize_with(&ty, generics, field.ty, path, field_expr);
+            }
+
+            quote! {
+                _serde::Serialize::serialize(#field_expr, _serializer)
+            }
+        }
+        Style::Tuple => {
+            serialize_tuple_variant(TupleVariant::Untagged,
+                                    generics,
+                                    ty.clone(),
+                                    &variant.fields)
+        }
+        Style::Struct => {
+            serialize_struct_variant(StructVariant::Untagged,
+                                     generics,
+                                     ty.clone(),
+                                     &variant.fields,
+                                     &variant_name)
+        }
+    };
+
+    let fields_ty = variant.fields.iter().map(|f| &f.ty);
+    let ref fields_ident: Vec<_> = match variant.style {
+        Style::Unit => unreachable!(),
+        Style::Newtype => vec![Ident::new("__simple_value")],
+        Style::Tuple => {
+            (0..variant.fields.len())
+                .map(|i| Ident::new(format!("__field{}", i)))
+                .collect()
+        }
+        Style::Struct => {
+            variant.fields
+                .iter()
+                .map(|f| f.ident.clone().expect("struct variant has unnamed fields"))
+                .collect()
+        }
+    };
+
+    let where_clause = &generics.where_clause;
+
+    let wrapper_generics = aster::from_generics(generics.clone())
+        .add_lifetime_bound("'__a")
+        .lifetime_name("'__a")
+        .build();
+
+    let wrapper_ty = aster::path()
+        .segment("__AdjacentlyTagged")
+        .with_generics(wrapper_generics.clone())
+        .build()
+        .build();
+
+    quote!({
+        struct __AdjacentlyTagged #wrapper_generics #where_clause {
+            data: (#(&'__a #fields_ty,)*),
+            phantom: _serde::export::PhantomData<#ty>,
+        }
+
+        impl #wrapper_generics _serde::Serialize for #wrapper_ty #where_clause {
+            fn serialize<__S>(&self, _serializer: __S) -> _serde::export::Result<__S::Ok, __S::Error>
+                where __S: _serde::Serializer
+            {
+                let (#(#fields_ident,)*) = self.data;
+                #inner
+            }
+        }
+
+        let mut __struct = try!(_serde::Serializer::serialize_struct(
+            _serializer, #type_name, 2));
+        try!(_serde::ser::SerializeStruct::serialize_field(
+            &mut __struct, #tag, #variant_name));
+        try!(_serde::ser::SerializeStruct::serialize_field(
+            &mut __struct, #content, &__AdjacentlyTagged {
+                data: (#(#fields_ident,)*),
+                phantom: _serde::export::PhantomData::<#ty>,
+            }));
+        _serde::ser::SerializeStruct::end(__struct)
+    })
+}
+
 fn serialize_untagged_variant(generics: &syn::Generics,
                               ty: syn::Ty,
                               variant: &Variant,
@@ -440,11 +547,12 @@ fn serialize_untagged_variant(generics: &syn::Generics,
             }
         }
         Style::Struct => {
+            let type_name = item_attrs.name().serialize_name();
             let block = serialize_struct_variant(StructVariant::Untagged,
                                                  generics,
                                                  ty,
                                                  &variant.fields,
-                                                 item_attrs);
+                                                 &type_name);
 
             quote! {
                 { #block }
@@ -518,7 +626,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
                                 generics: &syn::Generics,
                                 ty: syn::Ty,
                                 fields: &[Field],
-                                item_attrs: &attr::Item)
+                                name: &str)
                                 -> Tokens {
     let method = match context {
         StructVariant::ExternallyTagged { .. } => {
@@ -530,8 +638,6 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
 
     let serialize_fields = serialize_struct_visitor(ty.clone(), fields, generics, true, method);
 
-    let item_name = item_attrs.name().serialize_name();
-
     let mut serialized_fields = fields.iter()
         .filter(|&field| !field.attrs.skip_serializing())
         .peekable();
@@ -553,7 +659,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
             quote! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct_variant(
                     _serializer,
-                    #item_name,
+                    #name,
                     #variant_index,
                     #variant_name,
                     #len,
@@ -566,7 +672,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
             quote! {
                 let mut __serde_state = try!(_serde::Serializer::serialize_struct(
                     _serializer,
-                    #item_name,
+                    #name,
                     #len + 1,
                 ));
                 try!(_serde::ser::SerializeStruct::serialize_field(
@@ -582,7 +688,7 @@ fn serialize_struct_variant<'a>(context: StructVariant<'a>,
             quote! {
                 let #let_mut __serde_state = try!(_serde::Serializer::serialize_struct(
                     _serializer,
-                    #item_name,
+                    #name,
                     #len,
                 ));
                 #(#serialize_fields)*