adjust codegen to work with the revamped map/seq serializer

serde/src/ser/impls.rs

@@ -64,8 +64,6 @@ use super::{
     Error,
     Serialize,
     Serializer,
-    SeqSerializer,
-    MapSerializer,
 };
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -155,11 +153,11 @@ impl<T> Serialize for [T]
         where S: Serializer,
     {
 
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -172,11 +170,11 @@ macro_rules! array_impls {
             fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
                 where S: Serializer,
             {
-                let mut seq_serializer = try!(serializer.serialize_seq());
+                let mut seq_serializer = try!(serializer.serialize_fixed_size_array($len));
                 for e in self.iter() {
                     try!(seq_serializer.serialize_elt(e));
                 }
-                Ok(())
+                seq_serializer.drop()
             }
         }
     }
@@ -226,11 +224,11 @@ impl<T> Serialize for BinaryHeap<T>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -242,11 +240,11 @@ impl<T> Serialize for BTreeSet<T>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -258,7 +256,7 @@ impl<T> Serialize for EnumSet<T>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
@@ -274,11 +272,11 @@ impl<T, H> Serialize for HashSet<T, H>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -290,11 +288,11 @@ impl<T> Serialize for LinkedList<T>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -307,11 +305,11 @@ impl<A> Serialize for ops::Range<A>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serialize,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -331,11 +329,11 @@ impl<T> Serialize for VecDeque<T> where T: Serialize {
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut seq_serializer = try!(serializer.serialize_seq());
+        let mut seq_serializer = try!(serializer.serialize_seq(Some(self.len())));
         for e in self.iter() {
             try!(seq_serializer.serialize_elt(e));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 }
 
@@ -357,7 +355,6 @@ macro_rules! e {
     ($e:expr) => { $e }
 }
 
-/* TODO: FIX tuple magic
 macro_rules! tuple_impls {
     ($(
         $TupleVisitor:ident ($len:expr, $($T:ident),+) {
@@ -369,15 +366,14 @@ macro_rules! tuple_impls {
                 where $($T: Serialize),+
             {
                 #[inline]
-                fn serialize<S,SS>(&self, serializer: &mut S) -> Result<(), S::Error>
-                    where S: Serializer<SeqSerializer=SS>,
-                          SS : SeqSerializer,
+                fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
+                    where S: Serializer,
                 {
-
-                    for e in self.iter() {
-                        try!(seq_serializer.serialize_elt(e));
-                    }
-                    serializer.serialize_tuple($TupleVisitor::new(self))
+                    let mut ser = try!(serializer.serialize_tuple($len));
+                    $(
+                        try!(ser.serialize_elt(&e!(self.$idx)));
+                    )+
+                    ser.drop()
                 }
             }
         )+
@@ -554,7 +550,6 @@ tuple_impls! {
         15 => 15,
     }
 }
-*/
 
 ///////////////////////////////////////////////////////////////////////////////
 
@@ -567,11 +562,11 @@ impl<K, V> Serialize for BTreeMap<K, V>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut map_serializer = try!(serializer.serialize_map());
+        let mut map_serializer = try!(serializer.serialize_map(Some(self.len())));
         for (k, v) in self.iter() {
             try!(map_serializer.serialize_elt(k, v));
         }
-        Ok(())
+        map_serializer.drop()
     }
 }
 
@@ -585,11 +580,11 @@ impl<K, V, H> Serialize for HashMap<K, V, H>
     fn serialize<S>(&self, serializer: &mut S) -> Result<(), S::Error>
         where S: Serializer,
     {
-        let mut map_serializer = try!(serializer.serialize_map());
+        let mut map_serializer = try!(serializer.serialize_map(Some(self.len())));
         for (k, v) in self.iter() {
             try!(map_serializer.serialize_elt(k, v));
         }
-        Ok(())
+        map_serializer.drop()
     }
 }
 

serde/src/ser/mod.rs

@@ -44,9 +44,14 @@ pub trait MapSerializer : Sized {
     type Error: Error;
 
     /// Serializes an element of a map (key-value pair).
-    fn serialize_elt<K, V>(&mut self, key: K, value: V) -> Result<(), Self::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;
+              V: Serialize,
+              S: Serializer<Error = Self::Error>;
+
+    /// Finish serializing the map
+    fn drop<S: ?Sized>(self, serializer: &mut S) -> Result<(), Self::Error>
+        where S: Serializer<Error = Self::Error>;
 }
 
 /// A trait that described a type that can serialize elements of a Sequence
@@ -55,8 +60,58 @@ pub trait SeqSerializer : Sized {
     type Error: Error;
 
     /// Serializes an element of a sequence.
-    fn serialize_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
-        where T: Serialize;
+    fn serialize_elt<S: ?Sized, T>(&mut self, serializer: &mut S, value: T) -> Result<(), Self::Error>
+        where T: Serialize,
+              S: Serializer<Error = Self::Error>;
+
+    /// Finish serializing the map
+    fn drop<S: ?Sized>(self, serializer: &mut S) -> Result<(), Self::Error>
+        where S: Serializer<Error = Self::Error>;
+}
+
+/// A helper type for serializing maps. This is a workaround for HKL associated types
+pub struct MapHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::MapSerializer);
+
+impl<'a, S: Serializer + 'a + ?Sized> MapHelper<'a, S> {
+    /// Create a new MapHelper
+    pub fn new(s: &'a mut S, ms: S::MapSerializer) -> Self {
+        MapHelper(s, ms)
+    }
+}
+
+impl<'a, S: Serializer + ?Sized> MapHelper<'a, S> {
+    /// Serializes an element of a map (key-value pair).
+    pub fn serialize_elt<K, V>(&mut self, key: K, value: V) -> Result<(), S::Error>
+        where K: Serialize,
+              V: Serialize {
+        self.1.serialize_elt(self.0, key, value)
+    }
+    /// Closes the sequence
+    pub fn drop(self) -> Result<(), S::Error> {
+        self.1.drop(self.0)
+    }
+}
+
+/// A helper type for serializing sequences. This is a workaround for HKL associated types
+pub struct SeqHelper<'a, S: Serializer + 'a + ?Sized>(&'a mut S, S::SeqSerializer);
+
+impl<'a, S: Serializer + 'a + ?Sized> SeqHelper<'a, S> {
+    /// Create a new SeqHelper
+    pub fn new(s: &'a mut S, ms: S::SeqSerializer) -> Self {
+        SeqHelper(s, ms)
+    }
+}
+
+impl<'a, S: Serializer + ?Sized> SeqHelper<'a, S> {
+    /// Serializes an element of a sequence.
+    pub fn serialize_elt<V>(&mut self, value: V) -> Result<(), S::Error>
+        where V: Serialize {
+        self.1.serialize_elt(self.0, value)
+    }
+    /// Closes the sequence
+    pub fn drop(self) -> Result<(), S::Error> {
+        self.1.drop(self.0)
+    }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -162,11 +217,11 @@ pub trait Serializer {
     /// byte slices separately from generic arrays. By default it serializes as a regular array.
     #[inline]
     fn serialize_bytes(&mut self, value: &[u8]) -> Result<(), Self::Error> {
-        let mut seq_serializer = try!(self.serialize_seq());
+        let mut seq_serializer = try!(self.serialize_seq(Some(value.len())));
         for b in value.iter() {
             try!(seq_serializer.serialize_elt(b));
         }
-        Ok(())
+        seq_serializer.drop()
     }
 
     /// Serializes a `()` value.
@@ -200,7 +255,9 @@ pub trait Serializer {
                                    value: T) -> Result<(), Self::Error>
         where T: Serialize,
     {
-        self.serialize_tuple_struct(name).and_then(|mut s| s.serialize_elt(Some(value)))
+        let mut ser = try!(self.serialize_tuple_struct(name, 1));
+        try!(ser.serialize_elt((value,)));
+        ser.drop()
     }
 
     /// Allows a variant with a single item to be more efficiently
@@ -214,10 +271,9 @@ pub trait Serializer {
                                     value: T) -> Result<(), Self::Error>
         where T: Serialize,
     {
-        self.serialize_tuple_variant(
-            name,
-            variant_index,
-            variant).and_then(|mut s| s.serialize_elt(Some(value)))
+        let mut ser = try!(self.serialize_tuple_variant(name, variant_index, variant, 1));
+        try!(ser.serialize_elt((value,)));
+        ser.drop()
     }
 
     /// Serializes a `None` value..serialize
@@ -231,15 +287,22 @@ pub trait Serializer {
     ///
     /// Callees of this method need to construct a `SeqVisitor`, which iterates through each item
     /// in the sequence.
-    fn serialize_seq(&mut self) -> Result<Self::SeqSerializer, Self::Error>;
+    fn serialize_seq<'a>(&'a mut self, len: Option<usize>) -> Result<SeqHelper<'a, Self>, Self::Error>;
+
+    /// Serializes a sequence element.
+    fn serialize_seq_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
+        where T: Serialize;
+
+    /// Finish serializing a sequence.
+    fn serialize_seq_end(&mut self) -> Result<(), Self::Error>;
 
     /// Serializes a tuple.
     ///
     /// By default this serializes a tuple as a sequence.
     #[inline]
-    fn serialize_tuple(&mut self) -> Result<Self::SeqSerializer, Self::Error>
+    fn serialize_tuple<'a>(&'a mut self, len: usize) -> Result<SeqHelper<'a, Self>, Self::Error>
     {
-        self.serialize_seq()
+        self.serialize_seq(Some(len))
     }
 
     /// Serializes a tuple element.
@@ -247,32 +310,37 @@ pub trait Serializer {
     /// By default, tuples are serialized as a sequence.
     #[inline]
     fn serialize_tuple_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
-        where T: Serialize
-    {
-        self.serialize_seq().and_then(|mut s| s.serialize_elt(value))
+        where T: Serialize {
+        self.serialize_seq_elt(value)
+    }
+
+    /// Finishes serialization of a tuple.
+    ///
+    /// By default, tuples are serialized as a sequence.
+    #[inline]
+    fn serialize_tuple_end(&mut self) -> Result<(), Self::Error> {
+        self.serialize_seq_end()
     }
 
-    /*
-      TODO: Fixed-sized visitor would kind of make sense here
     /// Serializes a fixed-size array.
     ///
     /// By default this serializes an array as a sequence.
     #[inline]
-    fn serialize_fixed_size_array(&mut self, visitor: V) -> Result<(), Self::Error>
+    fn serialize_fixed_size_array<'a>(&'a mut self, size: usize) -> Result<SeqHelper<'a, Self>, Self::Error>
     {
-        self.serialize_seq(visitor)
+        self.serialize_seq(Some(size))
     }
-    */
 
     /// Serializes a tuple struct.
     ///
     /// By default, tuple structs are serialized as a tuple.
     #[inline]
-    fn serialize_tuple_struct(&mut self,
+    fn serialize_tuple_struct<'a>(&'a mut self,
                                  _name: &'static str,
-                                 ) -> Result<Self::SeqSerializer, Self::Error>
+                                 len: usize,
+                                 ) -> Result<SeqHelper<'a, Self>, Self::Error>
     {
-        self.serialize_tuple()
+        self.serialize_tuple(len)
     }
 
     /// Serializes a tuple struct element.
@@ -285,53 +353,106 @@ pub trait Serializer {
         self.serialize_tuple_elt(value)
     }
 
+    /// Finishes serialization of a tuple struct.
+    ///
+    /// By default, tuple structs are serialized as a sequence.
+    #[inline]
+    fn serialize_tuple_struct_end(&mut self) -> Result<(), Self::Error> {
+        self.serialize_tuple_end()
+    }
+
     /// Serializes a tuple variant.
     ///
     /// By default, tuple variants are serialized as a tuple struct.
     #[inline]
-    fn serialize_tuple_variant(&mut self,
+    fn serialize_tuple_variant<'a>(&'a mut self,
                                   _name: &'static str,
                                   _variant_index: usize,
                                   variant: &'static str,
-                                  ) -> Result<Self::SeqSerializer, Self::Error>
+                                  len: usize,
+                                  ) -> Result<SeqHelper<'a, Self>, Self::Error>
     {
-        self.serialize_tuple_struct(variant)
+        self.serialize_tuple_struct(variant, len)
     }
 
-    /// Serializes a tuple element.
+    /// Serializes a tuple variant element.
     ///
-    /// By default, tuples are serialized as a sequence.
+    /// By default, tuple variants are serialized as tuples.
     #[inline]
     fn serialize_tuple_variant_elt<T>(&mut self, value: T) -> Result<(), Self::Error>
         where T: Serialize
     {
-        self.serialize_tuple_struct_elt(value)
+        self.serialize_tuple_elt(value)
+    }
+
+    /// Finishes serialization of a tuple variant.
+    ///
+    /// By default, tuple variants are serialized as tuples.
+    #[inline]
+    fn serialize_tuple_variant_end(&mut self) -> Result<(), Self::Error> {
+        self.serialize_tuple_end()
     }
 
     /// Serialize a map.
-    fn serialize_map(&mut self) -> Result<Self::MapSerializer, Self::Error>;
+    fn serialize_map<'a>(&'a mut self, len: Option<usize>) -> Result<MapHelper<'a, Self>, Self::Error>;
+
+    /// Serialize a map element
+    fn serialize_map_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize;
+
+    /// Finishes serializing a map
+    fn serialize_map_end<'a>(&'a mut self) -> Result<(), Self::Error>;
 
     /// Serializes a struct.
     ///
     /// By default, structs are serialized as a map with the field name as the key.
     #[inline]
-    fn serialize_struct(&mut self,
+    fn serialize_struct<'a>(&'a mut self,
                            _name: &'static str,
-                           ) -> Result<Self::MapSerializer, Self::Error>
+                           len: usize,
+                           ) -> Result<MapHelper<'a, Self>, Self::Error>
     {
-        self.serialize_map()
+        self.serialize_map(Some(len))
+    }
+
+    /// Serialize a struct field
+    ///
+    /// By default, structs are serialized as a map with the field name as the key.
+    fn serialize_struct_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
+        self.serialize_map_elt(key, value)
+    }
+
+    /// Finishes serializing a struct
+    ///
+    /// By default, structs are serialized as a map with the field name as the key.
+    fn serialize_struct_end<'a>(&'a mut self) -> Result<(), Self::Error> {
+        self.serialize_map_end()
     }
 
     /// Serializes a struct variant.
     ///
     /// By default, struct variants are serialized as a struct.
     #[inline]
-    fn serialize_struct_variant(&mut self,
+    fn serialize_struct_variant<'a>(&'a mut self,
                                    _name: &'static str,
                                    _variant_index: usize,
-                                   variant: &'static str
-                                   ) -> Result<Self::MapSerializer, Self::Error>
+                                   variant: &'static str,
+                                   len: usize,
+                                   ) -> Result<MapHelper<'a, Self>, Self::Error>
     {
-        self.serialize_struct(variant)
+        self.serialize_struct(variant, len)
+    }
+
+    /// Serialize a struct variant element
+    ///
+    /// By default, structs are serialized as a map with the field name as the key.
+    fn serialize_struct_variant_elt<'a, K, V>(&'a mut self, key: K, value: V) -> Result<(), Self::Error> where K: Serialize, V: Serialize {
+        self.serialize_struct_elt(key, value)
+    }
+
+    /// Finishes serializing a struct variant
+    ///
+    /// By default, structs are serialized as a map with the field name as the key.
+    fn serialize_struct_variant_end<'a>(&'a mut self) -> Result<(), Self::Error> {
+        self.serialize_struct_end()
     }
 }