adjust codegen to work with the revamped map/seq serializer

serde_test/src/de.rs

@@ -135,15 +135,18 @@ impl<I> de::Deserializer for Deserializer<I>
             Some(Token::Option(true)) => visitor.visit_some(self),
             Some(Token::Unit) => visitor.visit_unit(),
             Some(Token::UnitStruct(name)) => visitor.visit_unit_struct(name),
-            Some(Token::SeqStart(len)) | Some(Token::TupleStructStart(_, len)) => {
+            Some(Token::SeqStart(len)) => {
                 self.visit_seq(len, visitor)
             }
-            Some(Token::SeqArrayStart(len)) => {
+            Some(Token::SeqArrayStart(len))| Some(Token::TupleStructStart(_, len)) => {
                 self.visit_seq(Some(len), visitor)
             }
-            Some(Token::MapStart(len)) | Some(Token::StructStart(_, len)) => {
+            Some(Token::MapStart(len)) => {
                 self.visit_map(len, visitor)
             }
+            Some(Token::StructStart(_, len)) => {
+                self.visit_map(Some(len), visitor)
+            }
             Some(token) => Err(Error::UnexpectedToken(token)),
             None => Err(Error::EndOfStream),
         }
@@ -745,7 +748,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
         where V: Visitor,
     {
         match self.de.tokens.peek() {
-            Some(&Token::EnumSeqStart(_, _, Some(enum_len))) => {
+            Some(&Token::EnumSeqStart(_, _, enum_len)) => {
                 let token = self.de.tokens.next().unwrap();
 
                 if len == enum_len {
@@ -776,7 +779,7 @@ impl<'a, I> VariantVisitor for DeserializerVariantVisitor<'a, I>
         where V: Visitor,
     {
         match self.de.tokens.peek() {
-            Some(&Token::EnumMapStart(_, _, Some(enum_len))) => {
+            Some(&Token::EnumMapStart(_, _, enum_len)) => {
                 let token = self.de.tokens.next().unwrap();
 
                 if fields.len() == enum_len {

serde_test/src/ser.rs

@@ -2,14 +2,73 @@ use std::marker::PhantomData;
 
 use serde::ser::{
     self,
-    MapVisitor,
-    SeqVisitor,
     Serialize,
+    MapHelper,
+    SeqHelper,
 };
 
 use error::Error;
 use token::Token;
 
+pub enum MapSerializer {
+    Map,
+    Struct,
+    Enum,
+}
+
+impl ser::MapSerializer for MapSerializer {
+    type Error = Error;
+
+    fn serialize_elt<S: ?Sized, K, V>(&mut self, serializer: &mut S, key: K, value: V) -> Result<(), Self::Error>
+        where K: Serialize,
+              V: Serialize,
+              S: ser::Serializer<Error = Error> {
+        match *self {
+            MapSerializer::Map => serializer.serialize_map_elt(key, value),
+            MapSerializer::Struct => serializer.serialize_struct_elt(key, value),
+            MapSerializer::Enum => serializer.serialize_struct_variant_elt(key, value),
+        }
+    }
+
+    fn drop<S: ?Sized>(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer<Error = Error> {
+        match self {
+            MapSerializer::Map => serializer.serialize_map_end(),
+            MapSerializer::Struct => serializer.serialize_struct_end(),
+            MapSerializer::Enum => serializer.serialize_struct_variant_end(),
+        }
+    }
+}
+
+pub enum SeqSerializer {
+    Seq,
+    Tuple,
+    TupleStruct,
+    Enum,
+}
+
+impl ser::SeqSerializer for SeqSerializer {
+    type Error = Error;
+
+    fn serialize_elt<S: ?Sized, T>(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error>
+        where T: Serialize, S: ser::Serializer<Error = Error> {
+        match *self {
+            SeqSerializer::Seq => serializer.serialize_seq_elt(value),
+            SeqSerializer::Tuple => serializer.serialize_tuple_elt(value),
+            SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_elt(value),
+            SeqSerializer::Enum => serializer.serialize_tuple_variant_elt(value),
+        }
+    }
+
+    fn drop<S: ?Sized>(self, serializer: &mut S) -> Result<(), Self::Error> where S: ser::Serializer<Error = Error> {
+        match self {
+            SeqSerializer::Seq => serializer.serialize_seq_end(),
+            SeqSerializer::Tuple => serializer.serialize_tuple_end(),
+            SeqSerializer::TupleStruct => serializer.serialize_tuple_struct_end(),
+            SeqSerializer::Enum => serializer.serialize_tuple_variant_end(),
+        }
+    }
+}
+
 pub struct Serializer<'a, I>
     where I: Iterator<Item=&'a Token<'a>>,
 {
@@ -30,32 +89,14 @@ impl<'a, I> Serializer<'a, I>
     pub fn next_token(&mut self) -> Option<&'a Token<'a>> {
         self.tokens.next()
     }
-
-    fn visit_seq<V>(&mut self, mut visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::SeqEnd));
-
-        Ok(())
-    }
-
-    fn visit_map<V>(&mut self, mut visitor: V) -> Result<(), Error>
-        where V: MapVisitor
-    {
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
-
-        Ok(())
-    }
 }
 
 impl<'a, I> ser::Serializer for Serializer<'a, I>
     where I: Iterator<Item=&'a Token<'a>>,
 {
     type Error = Error;
+    type SeqSerializer = SeqSerializer;
+    type MapSerializer = MapSerializer;
 
     fn serialize_unit(&mut self) -> Result<(), Error> {
         assert_eq!(self.tokens.next(), Some(&Token::Unit));
@@ -174,25 +215,10 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         value.serialize(self)
     }
 
-
-    fn serialize_seq<V>(&mut self, visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
+    fn serialize_seq<'b>(&'b mut self, len: Option<usize>) -> Result<SeqHelper<'b, Self>, Error>
     {
-        let len = visitor.len();
-
         assert_eq!(self.tokens.next(), Some(&Token::SeqStart(len)));
-
-        self.visit_seq(visitor)
-    }
-
-    fn serialize_fixed_size_array<V>(&mut self, visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
-    {
-        let len = visitor.len().expect("arrays must have a length");
-
-        assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len)));
-
-        self.visit_seq(visitor)
+        Ok(SeqHelper::new(self, SeqSerializer::Seq))
     }
 
     fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Error>
@@ -202,18 +228,22 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         value.serialize(self)
     }
 
-    fn serialize_tuple<V>(&mut self, mut visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
-    {
-        let len = visitor.len().expect("arrays must have a length");
+    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<SeqHelper<'b, Self>, Error>
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::SeqArrayStart(len)));
+        Ok(SeqHelper::new(self, SeqSerializer::Seq))
+    }
+
+    fn serialize_tuple<'b>(&'b mut self, len: usize) -> Result<SeqHelper<'b, Self>, Error>
+    {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStart(len)));
 
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::TupleEnd));
-
-        Ok(())
+        Ok(SeqHelper::new(self, SeqSerializer::Tuple))
     }
 
     fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Error>
@@ -223,128 +253,117 @@ impl<'a, I> ser::Serializer for Serializer<'a, I>
         value.serialize(self)
     }
 
+    fn serialize_tuple_end(&mut self) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::TupleEnd));
+        Ok(())
+    }
+
     fn serialize_newtype_struct<T>(&mut self,
-                               name: &'static str,
-                               value: T) -> Result<(), Error>
+                                   name: &'static str,
+                                   value: T) -> Result<(), Error>
         where T: Serialize,
     {
         assert_eq!(self.tokens.next(), Some(&Token::StructNewType(name)));
         value.serialize(self)
     }
 
-    fn serialize_tuple_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
+    fn serialize_tuple_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<SeqHelper<'b, Self>, Error>
     {
-        let len = visitor.len();
-
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructStart(name, len)));
 
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd));
-
-        Ok(())
+        Ok(SeqHelper::new(self, SeqSerializer::TupleStruct))
     }
 
     fn serialize_tuple_struct_elt<T>(&mut self, value: T) -> Result<(), Error>
-        where T: Serialize,
+        where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::TupleStructSep));
         value.serialize(self)
     }
 
-    fn serialize_tuple_variant<V>(&mut self,
-                                  name: &str,
-                                  _variant_index: usize,
-                                  variant: &str,
-                                  mut visitor: V) -> Result<(), Error>
-        where V: SeqVisitor
-    {
-        let len = visitor.len();
-
-        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len)));
-
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd));
-
+    fn serialize_tuple_struct_end(&mut self) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::TupleStructEnd));
         Ok(())
     }
 
+    fn serialize_tuple_variant<'b>(&'b mut self,
+                               name: &str,
+                               _variant_index: usize,
+                               variant: &str,
+                               len: usize) -> Result<SeqHelper<'b, Self>, Error>
+    {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqStart(name, variant, len)));
+
+        Ok(SeqHelper::new(self, SeqSerializer::Enum))
+    }
+
     fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Error>
-        where T: Serialize,
+        where T: Serialize
     {
         assert_eq!(self.tokens.next(), Some(&Token::EnumSeqSep));
         value.serialize(self)
     }
 
-    fn serialize_map<V>(&mut self, visitor: V) -> Result<(), Error>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
+    fn serialize_tuple_variant_end(&mut self) -> Result<(), Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumSeqEnd));
+        Ok(())
+    }
 
+    fn serialize_map<'b>(&'b mut self, len: Option<usize>) -> Result<MapHelper<'b, Self>, Error>
+    {
         assert_eq!(self.tokens.next(), Some(&Token::MapStart(len)));
 
-        self.visit_map(visitor)
+        Ok(MapHelper::new(self, MapSerializer::Map))
     }
 
-    fn serialize_map_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Error>
-        where K: Serialize,
-              V: Serialize,
-    {
+    fn serialize_map_elt<K, V>(&mut self, 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_struct<V>(&mut self, name: &str, mut visitor: V) -> Result<(), Error>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
+    fn serialize_map_end(&mut self) -> Result<(), Self::Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::MapEnd));
+        Ok(())
+    }
 
+    fn serialize_struct<'b>(&'b mut self, name: &str, len: usize) -> Result<MapHelper<'b, Self>, Error>
+    {
         assert_eq!(self.tokens.next(), Some(&Token::StructStart(name, len)));
 
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::StructEnd));
-
-        Ok(())
+        Ok(MapHelper::new(self, MapSerializer::Struct))
     }
 
-    fn serialize_struct_elt<T>(&mut self, key: &'static str, value: T) -> Result<(), Error>
-        where T: Serialize,
-    {
+    fn serialize_struct_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::StructSep));
-
         try!(key.serialize(self));
         value.serialize(self)
     }
 
-    fn serialize_struct_variant<V>(&mut self,
-                                   name: &str,
-                                   _variant_index: usize,
-                                   variant: &str,
-                                   mut visitor: V) -> Result<(), Error>
-        where V: MapVisitor
-    {
-        let len = visitor.len();
+    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,
+                                name: &str,
+                                _variant_index: usize,
+                                variant: &str,
+                                len: usize) -> Result<MapHelper<'b, Self>, Error>
+    {
         assert_eq!(self.tokens.next(), Some(&Token::EnumMapStart(name, variant, len)));
 
-        while let Some(()) = try!(visitor.visit(self)) { }
-
-        assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd));
-
-        Ok(())
+        Ok(MapHelper::new(self, MapSerializer::Enum))
     }
 
-    fn serialize_struct_variant_elt<T>(&mut self, key: &'static str, value: T) -> Result<(), Error>
-        where T: Serialize,
-    {
+    fn serialize_struct_variant_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
         assert_eq!(self.tokens.next(), Some(&Token::EnumMapSep));
-
         try!(key.serialize(self));
         value.serialize(self)
     }
+
+    fn serialize_struct_variant_end(&mut self) -> Result<(), Self::Error> {
+        assert_eq!(self.tokens.next(), Some(&Token::EnumMapEnd));
+        Ok(())
+    }
 }

serde_test/src/token.rs

@@ -38,7 +38,7 @@ pub enum Token<'a> {
     TupleSep,
     TupleEnd,
 
-    TupleStructStart(&'a str, Option<usize>),
+    TupleStructStart(&'a str, usize),
     TupleStructSep,
     TupleStructEnd,
 
@@ -46,15 +46,15 @@ pub enum Token<'a> {
     MapSep,
     MapEnd,
 
-    StructStart(&'a str, Option<usize>),
+    StructStart(&'a str, usize),
     StructSep,
     StructEnd,
 
-    EnumSeqStart(&'a str, &'a str, Option<usize>),
+    EnumSeqStart(&'a str, &'a str, usize),
     EnumSeqSep,
     EnumSeqEnd,
 
-    EnumMapStart(&'a str, &'a str, Option<usize>),
+    EnumMapStart(&'a str, &'a str, usize),
     EnumMapSep,
     EnumMapEnd,
 }