Merge branch origin/master into origin/syn

Conflicts:
    serde_codegen/src/ser.rs

serde_codegen/src/ser.rs

@@ -164,11 +164,25 @@ fn serialize_tuple_struct(
     let len = serialize_stmts.len();
     let let_mut = mut_if(len > 0);
 
+<<<<<<< HEAD
     quote! {
         let #let_mut state = try!(_serializer.serialize_tuple_struct(#type_name, #len));
         #(serialize_stmts)*
         _serializer.serialize_tuple_struct_end(state)
     }
+||||||| merged common ancestors
+    quote_block!(cx, {
+        let $let_mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
+        $serialize_stmts
+        _serializer.serialize_tuple_struct_end(state)
+    }).unwrap()
+=======
+    quote_block!(cx, {
+        let $let_mut __serde_state = try!(_serializer.serialize_tuple_struct($type_name, $len));
+        $serialize_stmts
+        _serializer.serialize_tuple_struct_end(__serde_state)
+    }).unwrap()
+>>>>>>> origin/master
 }
 
 fn serialize_struct(
@@ -205,11 +219,25 @@ fn serialize_struct(
          })
         .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
+<<<<<<< HEAD
     quote! {
         let #let_mut state = try!(_serializer.serialize_struct(#type_name, #len));
         #(serialize_fields)*
         _serializer.serialize_struct_end(state)
     }
+||||||| merged common ancestors
+    quote_block!(cx, {
+        let $let_mut state = try!(_serializer.serialize_struct($type_name, $len));
+        $serialize_fields
+        _serializer.serialize_struct_end(state)
+    }).unwrap()
+=======
+    quote_block!(cx, {
+        let $let_mut __serde_state = try!(_serializer.serialize_struct($type_name, $len));
+        $serialize_fields
+        _serializer.serialize_struct_end(__serde_state)
+    }).unwrap()
+>>>>>>> origin/master
 }
 
 fn serialize_item_enum(
@@ -373,11 +401,29 @@ fn serialize_tuple_variant(
     let len = serialize_stmts.len();
     let let_mut = mut_if(len > 0);
 
+<<<<<<< HEAD
     quote! {
         let #let_mut state = try!(_serializer.serialize_tuple_variant(#type_name, #variant_index, #variant_name, #len));
         #(serialize_stmts)*
         _serializer.serialize_tuple_variant_end(state)
     }
+||||||| merged common ancestors
+    quote_block!(cx, {
+        let $let_mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
+        $serialize_stmts
+        _serializer.serialize_tuple_variant_end(state)
+    }).unwrap()
+=======
+    quote_block!(cx, {
+        let $let_mut __serde_state = try!(_serializer.serialize_tuple_variant(
+            $type_name,
+            $variant_index,
+            $variant_name,
+            $len));
+        $serialize_stmts
+        _serializer.serialize_tuple_variant_end(__serde_state)
+    }).unwrap()
+>>>>>>> origin/master
 }
 
 fn serialize_struct_variant(
@@ -413,6 +459,7 @@ fn serialize_struct_variant(
                 None => quote!(1),
             }
          })
+<<<<<<< HEAD
         .fold(quote!(0), |sum, expr| quote!(#sum + #expr));
 
     quote! {
@@ -421,10 +468,39 @@ fn serialize_struct_variant(
             #variant_index,
             #variant_name,
             #len,
+||||||| merged common ancestors
+        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
+
+    quote_block!(cx, {
+        let $let_mut state = try!(_serializer.serialize_struct_variant(
+            $item_name,
+            $variant_index,
+            $variant_name,
+            $len,
+=======
+        .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
+
+    quote_block!(cx, {
+        let $let_mut __serde_state = try!(_serializer.serialize_struct_variant(
+            $item_name,
+            $variant_index,
+            $variant_name,
+            $len,
+>>>>>>> origin/master
         ));
+<<<<<<< HEAD
         #(serialize_fields)*
         _serializer.serialize_struct_variant_end(state)
     }
+||||||| merged common ancestors
+        $serialize_fields
+        _serializer.serialize_struct_variant_end(state)
+    }).unwrap()
+=======
+        $serialize_fields
+        _serializer.serialize_struct_variant_end(__serde_state)
+    }).unwrap()
+>>>>>>> origin/master
 }
 
 fn serialize_tuple_struct_visitor(
@@ -452,9 +528,19 @@ fn serialize_tuple_struct_visitor(
                     &structure_ty, generics, &field.ty, path, field_expr);
             }
 
+<<<<<<< HEAD
             let ser = quote! {
                 try!(_serializer.#func(&mut state, #field_expr));
             };
+||||||| merged common ancestors
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut state, $field_expr));
+            );
+=======
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut __serde_state, $field_expr));
+            );
+>>>>>>> origin/master
 
             match skip {
                 None => ser,
@@ -491,9 +577,19 @@ fn serialize_struct_visitor(
                     &structure_ty, generics, &field.ty, path, field_expr)
             }
 
+<<<<<<< HEAD
             let ser = quote! {
                 try!(_serializer.#func(&mut state, #key_expr, #field_expr));
             };
+||||||| merged common ancestors
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut state, $key_expr, $field_expr));
+            );
+=======
+            let ser = quote_expr!(cx,
+                try!(_serializer.$func(&mut __serde_state, $key_expr, $field_expr));
+            );
+>>>>>>> origin/master
 
             match skip {
                 None => ser,
@@ -548,8 +644,8 @@ fn wrap_serialize_with(
 
 // Serialization of an empty struct results in code like:
 //
-//     let mut state = try!(serializer.serialize_struct("S", 0));
+//     let mut __serde_state = try!(serializer.serialize_struct("S", 0));
-//     serializer.serialize_struct_end(state)
+//     serializer.serialize_struct_end(__serde_state)
 //
 // where we want to omit the `mut` to avoid a warning.
 fn mut_if(is_mut: bool) -> Option<Tokens> {

testing/tests/test_macros.rs

@@ -600,3 +600,28 @@ fn test_default_ty_param() {
         ]
     );
 }
+
+#[test]
+fn test_enum_state_field() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    enum SomeEnum {
+        Key { key: char, state: bool },
+    }
+
+    assert_tokens(
+        &SomeEnum::Key { key: 'a', state: true },
+        &[
+            Token::EnumMapStart("SomeEnum", "Key", 2),
+
+            Token::EnumMapSep,
+            Token::Str("key"),
+            Token::Char('a'),
+
+            Token::EnumMapSep,
+            Token::Str("state"),
+            Token::Bool(true),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}