adjust tests for new interface

serde/src/ser/impls.rs

@@ -169,7 +169,7 @@ macro_rules! array_impls {
             fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
                 where S: Serializer,
             {
-                let mut state = try!(serializer.serialize_seq(Some($len)));
+                let mut state = try!(serializer.serialize_seq_fixed_size($len));
                 for e in self.iter() {
                     try!(serializer.serialize_seq_elt(&mut state, e));
                 }

serde_codegen/src/ser.rs

@@ -230,9 +230,9 @@ fn serialize_tuple_struct(
     let len = serialize_stmts.len();
 
     quote_expr!(cx, {
-        let state = try!(_serializer.serialize_tuple_struct($type_name, $len));
+        let mut state = try!(_serializer.serialize_tuple_struct($type_name, $len));
         $serialize_stmts
-        _serializer.serialize_tuple_struct_end($type_name, $len, state)
+        _serializer.serialize_tuple_struct_end(state)
     })
 }
 
@@ -269,10 +269,9 @@ fn serialize_struct(
         .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
 
     quote_expr!(cx, {
-        let len = $len;
+        let mut state = try!(_serializer.serialize_struct($type_name, $len));
-        let state = try!(_serializer.serialize_struct($type_name, len));
         $serialize_fields
-        _serializer.serialize_struct_end($type_name, len, state)
+        _serializer.serialize_struct_end(state)
     })
 }
 
@@ -464,9 +463,9 @@ fn serialize_tuple_variant(
     let len = serialize_stmts.len();
 
     quote_expr!(cx, {
-        let state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
+        let mut state = try!(_serializer.serialize_tuple_variant($type_name, $variant_index, $variant_name, $len));
         $serialize_stmts
-        _serializer.serialize_tuple_variant_end($type_name, $variant_index, $variant_name, $len, state)
+        _serializer.serialize_tuple_variant_end(state)
     })
 }
 
@@ -506,21 +505,14 @@ fn serialize_struct_variant(
         .fold(quote_expr!(cx, 0), |sum, expr| quote_expr!(cx, $sum + $expr));
 
     quote_expr!(cx, {
-        let len = $len;
+        let mut state = try!(_serializer.serialize_struct_variant(
-        let state = try!(_serializer.serialize_struct_variant(
             $item_name,
             $variant_index,
             $variant_name,
-            len,
+            $len,
         ));
         $serialize_fields
-        _serializer.serialize_struct_variant_end(
+        _serializer.serialize_struct_variant_end(state)
-            $item_name,
-            $variant_index,
-            $variant_name,
-            len,
-            state,
-        )
     })
 }
 
@@ -553,7 +545,7 @@ fn serialize_tuple_struct_visitor(
 
             quote_stmt!(cx,
                 if !$skip {
-                    try!(_serializer.$func($field_expr));
+                    try!(_serializer.$func(&mut state, $field_expr));
                 }
             ).unwrap()
         })
@@ -592,7 +584,7 @@ fn serialize_struct_visitor(
 
             quote_stmt!(cx,
                 if !$skip {
-                    try!(_serializer.$func($key_expr, $field_expr));
+                    try!(_serializer.$func(&mut state, $key_expr, $field_expr));
                 }
             ).unwrap()
         })

serde_test/src/ser.rs

@@ -36,6 +36,11 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
     type Error = Error;
     type MapState = ();
     type SeqState = ();
+    type TupleState = ();
+    type TupleStructState = ();
+    type TupleVariantState = ();
+    type StructState = ();
+    type StructVariantState = ();
 
     fn serialize_unit(&mut self) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::Unit));
@@ -160,38 +165,38 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_seq_elt<T>(&mut self, _: &mut (), value: T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::SeqSep));
         value.serialize(self)
     }
 
-    fn serialize_seq_end(&mut self, _len: Option<usize>, _: ()) -> Result<(), Error> {
+    fn serialize_seq_end(&mut self, _: ()) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
         Ok(())
     }
 
-    fn serialize_fixed_size_array<'b>(&'b mut self, len: usize) -> Result<(), Error>
+    fn serialize_seq_fixed_size(&mut self, len: usize) -> Result<(), Error>
     {
         assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len)));
         Ok(())
     }
 
-    fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result<(), Error>
+    fn serialize_tuple(&mut self, len: usize) -> Result<(), Error>
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len)));
         Ok(())
     }
 
-    fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_tuple_elt<T>(&mut self, _: &mut (), value: T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleSep));
         value.serialize(self)
     }
 
-    fn serialize_tuple_end(&mut self, _len: usize, _: ()) -> Result<(), Error> {
+    fn serialize_tuple_end(&mut self, _: ()) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::TupleEnd));
         Ok(())
     }
@@ -205,21 +210,21 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         value.serialize(self)
     }
 
-    fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<(), Error>
+    fn serialize_tuple_struct(&mut self, name: &'static str, len: usize) -> Result<(), Error>
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len)));
 
         Ok(())
     }
 
-    fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_tuple_struct_elt<T>(&mut self, _: &mut (), value: T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep));
         value.serialize(self)
     }
 
-    fn serialize_tuple_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Error> {
+    fn serialize_tuple_struct_end(&mut self, _: ()) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd));
         Ok(())
     }
@@ -235,18 +240,14 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Error>
+    fn serialize_tuple_variant_elt<T>(&mut self, _: &mut (), value: T) -> Result<(), Error>
         where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep));
         value.serialize(self)
     }
 
-    fn serialize_tuple_variant_end(&mut self,
+    fn serialize_tuple_variant_end(&mut self, _: ()) -> Result<(), Error> {
-                               _name: &str,
-                               _variant_index: usize,
-                               _variant: &str,
-                               _len: usize, _: ()) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd));
         Ok(())
     }
@@ -258,13 +259,13 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
+    fn serialize_map_elt<K, V>(&mut self, _: &mut (), key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::MapSep));
         try!(key.serialize(self));
         value.serialize(self)
     }
 
-    fn serialize_map_end(&mut self, _len: Option<usize>, _: ()) -> Result<(), Self::Error> {
+    fn serialize_map_end(&mut self, _: ()) -> Result<(), Self::Error> {
         assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
         Ok(())
     }
@@ -276,18 +277,18 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_struct_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
+    fn serialize_struct_elt<V>(&mut self, _: &mut (), key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::StructSep));
         try!(key.serialize(self));
         value.serialize(self)
     }
 
-    fn serialize_struct_end(&mut self, _name: &str, _len: usize, _: ()) -> Result<(), Self::Error> {
+    fn serialize_struct_end(&mut self, _: ()) -> Result<(), Self::Error> {
         assert_eq!(self.tokens.next(), Some(&Token::StructEnd));
         Ok(())
     }
 
-    fn serialize_struct_variant<'b>(&'b mut self,
+    fn serialize_struct_variant(&mut self,
                                 name: &str,
                                 _variant_index: usize,
                                 variant: &str,
@@ -298,18 +299,22 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         Ok(())
     }
 
-    fn serialize_struct_variant_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
+    fn serialize_struct_variant_elt<V>(&mut self, _: &mut (), key: &'static str, value: V) -> Result<(), Self::Error> where V: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep));
         try!(key.serialize(self));
         value.serialize(self)
     }
 
-    fn serialize_struct_variant_end(&mut self,
+    fn serialize_struct_variant_end(&mut self, _: ()) -> Result<(), Self::Error> {
-                                _name: &str,
-                                _variant_index: usize,
-                                _variant: &str,
-                                _len: usize, _: ()) -> Result<(), Self::Error> {
         assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd));
         Ok(())
     }
+
+    fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
+        let mut state = try!(self.serialize_seq(Some(value.len())));
+        for c in value {
+            try!(self.serialize_seq_elt(&mut state, c));
+        }
+        self.serialize_seq_end(state)
+    }
 }

testing/tests/test_bytes.rs

@@ -54,15 +54,60 @@ impl serde::Serializer for BytesSerializer {
     type Error = Error;
     type SeqState = ();
     type MapState = ();
+    type TupleState = ();
+    type TupleStructState = ();
+    type TupleVariantState = ();
+    type StructState = ();
+    type StructVariantState = ();
 
     fn serialize_unit(&mut self) -> Result<(), Error> {
         Err(Error)
     }
 
+    fn serialize_unit_struct(&mut self, _name: &'static str) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_unit_variant(&mut self, _: &'static str, _: usize, _: &'static str) -> Result<(), Error> {
+        Err(Error)
+    }
+
     fn serialize_bool(&mut self, _v: bool) -> Result<(), Error> {
         Err(Error)
     }
 
+    fn serialize_isize(&mut self, _v: isize) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_usize(&mut self, _v: usize) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_i8(&mut self, _v: i8) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_u8(&mut self, _v: u8) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_i16(&mut self, _v: i16) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_u16(&mut self, _v: u16) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_i32(&mut self, _v: i32) -> Result<(), Error> {
+        Err(Error)
+    }
+
+    fn serialize_u32(&mut self, _v: u32) -> Result<(), Error> {
+        Err(Error)
+    }
+
     fn serialize_i64(&mut self, _v: i64) -> Result<(), Error> {
         Err(Error)
     }
@@ -97,18 +142,83 @@ impl serde::Serializer for BytesSerializer {
         Err(Error)
     }
 
+    fn serialize_newtype_struct<V>(&mut self, _: &'static str, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn serialize_newtype_variant<V>(&mut self, _: &'static str, _: usize, _: &'static str, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
     fn serialize_seq(&mut self, _len: Option<usize>) -> Result<(), Error>
     {
         Err(Error)
     }
 
-    fn serialize_seq_elt<T>(&mut self, _value: T) -> Result<(), Error>
+    fn serialize_seq_fixed_size(&mut self, _len: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_seq_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
         where T: serde::Serialize
     {
         Err(Error)
     }
 
-    fn serialize_seq_end(&mut self, _: Option<usize>, _: ()) -> Result<(), Error>
+    fn serialize_seq_end(&mut self, _: ()) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple(&mut self, _len: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
+        where T: serde::Serialize
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_end(&mut self, _: ()) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_struct(&mut self, _: &'static str, _len: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_struct_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
+        where T: serde::Serialize
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_struct_end(&mut self, _: ()) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_variant(&mut self, _: &'static str, _: usize, _: &'static str, _len: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_variant_elt<T>(&mut self, _: &mut (), _value: T) -> Result<(), Error>
+        where T: serde::Serialize
+    {
+        Err(Error)
+    }
+
+    fn serialize_tuple_variant_end(&mut self, _: ()) -> Result<(), Error>
     {
         Err(Error)
     }
@@ -118,14 +228,46 @@ impl serde::Serializer for BytesSerializer {
         Err(Error)
     }
 
-    fn serialize_map_elt<K, V>(&mut self, _key: K, _value: V) -> Result<(), Error>
+    fn serialize_map_elt<K, V>(&mut self, _: &mut (), _key: K, _value: V) -> Result<(), Error>
         where K: serde::Serialize,
               V: serde::Serialize,
     {
         Err(Error)
     }
 
-    fn serialize_map_end(&mut self, _: Option<usize>, _: ()) -> Result<(), Error>
+    fn serialize_map_end(&mut self, _: ()) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct(&mut self, _: &'static str, _: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct_elt<V>(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct_end(&mut self, _: ()) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct_variant(&mut self, _: &'static str, _: usize, _: &'static str, _: usize) -> Result<(), Error>
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct_variant_elt<V>(&mut self, _: &mut (), _key: &'static str, _value: V) -> Result<(), Error>
+        where V: serde::Serialize,
+    {
+        Err(Error)
+    }
+
+    fn serialize_struct_variant_end(&mut self, _: ()) -> Result<(), Error>
     {
         Err(Error)
     }