Release 0.9.9

Fixes #775.

serde/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde"
-version = "0.9.8"
+version = "0.9.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "A generic serialization/deserialization framework"

serde/src/de/content.rs

@@ -29,7 +29,6 @@ use de::{self, Deserialize, DeserializeSeed, Deserializer, Visitor, SeqVisitor,
 /// Not public API. Use serde-value instead.
 #[derive(Debug)]
 pub enum Content {
-    // Don't mind the PhantomData, just need to use E somewhere.
     Bool(bool),
 
     U8(u8),
@@ -58,6 +57,32 @@ pub enum Content {
     Map(Vec<(Content, Content)>),
 }
 
+impl Content {
+    fn unexpected(&self) -> Unexpected {
+        match *self {
+            Content::Bool(b) => Unexpected::Bool(b),
+            Content::U8(n) => Unexpected::Unsigned(n as u64),
+            Content::U16(n) => Unexpected::Unsigned(n as u64),
+            Content::U32(n) => Unexpected::Unsigned(n as u64),
+            Content::U64(n) => Unexpected::Unsigned(n),
+            Content::I8(n) => Unexpected::Signed(n as i64),
+            Content::I16(n) => Unexpected::Signed(n as i64),
+            Content::I32(n) => Unexpected::Signed(n as i64),
+            Content::I64(n) => Unexpected::Signed(n),
+            Content::F32(f) => Unexpected::Float(f as f64),
+            Content::F64(f) => Unexpected::Float(f),
+            Content::Char(c) => Unexpected::Char(c),
+            Content::String(ref s) => Unexpected::Str(s),
+            Content::Bytes(ref b) => Unexpected::Bytes(b),
+            Content::None | Content::Some(_) => Unexpected::Option,
+            Content::Unit => Unexpected::Unit,
+            Content::Newtype(_) => Unexpected::NewtypeStruct,
+            Content::Seq(_) => Unexpected::Seq,
+            Content::Map(_) => Unexpected::Map,
+        }
+    }
+}
+
 impl Deserialize for Content {
     fn deserialize<D: Deserializer>(deserializer: D) -> Result<Self, D::Error> {
         // Untagged and internally tagged enums are only supported in
@@ -607,10 +632,41 @@ impl<E> Deserializer for ContentDeserializer<E>
         visitor.visit_newtype_struct(self)
     }
 
+    fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        let (variant, value) = match self.content {
+            Content::Map(value) => {
+                let mut iter = value.into_iter();
+                let (variant, value) = match iter.next() {
+                    Some(v) => v,
+                    None => {
+                        return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key"));
+                    }
+                };
+                // enums are encoded in json as maps with a single key:value pair
+                if iter.next().is_some() {
+                    return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key"));
+                }
+                (variant, Some(value))
+            }
+            Content::String(variant) => (Content::String(variant), None),
+            other => {
+                return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
+            }
+        };
+
+        visitor.visit_enum(EnumDeserializer {
+            variant: variant,
+            value: value,
+            err: PhantomData,
+        })
+    }
+
     forward_to_deserialize! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
         seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
-        struct_field tuple enum ignored_any
+        struct_field tuple ignored_any
     }
 }
 
@@ -624,6 +680,203 @@ impl<E> ContentDeserializer<E> {
     }
 }
 
+struct EnumDeserializer<E> where E: de::Error {
+    variant: Content,
+    value: Option<Content>,
+    err: PhantomData<E>,
+}
+
+impl<E> de::EnumVisitor for EnumDeserializer<E> where E: de::Error {
+    type Error = E;
+    type Variant = VariantDeserializer<Self::Error>;
+
+    fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, VariantDeserializer<E>), Self::Error>
+        where V: de::DeserializeSeed,
+    {
+        let visitor = VariantDeserializer { value: self.value, err: PhantomData, };
+        seed.deserialize(ContentDeserializer::new(self.variant)).map(|v| (v, visitor))
+    }
+}
+
+struct VariantDeserializer<E> where E: de::Error {
+    value: Option<Content>,
+    err: PhantomData<E>,
+}
+
+impl<E> de::VariantVisitor for VariantDeserializer<E> where E: de::Error {
+    type Error = E;
+
+    fn visit_unit(self) -> Result<(), E> {
+        match self.value {
+            Some(value) => de::Deserialize::deserialize(ContentDeserializer::new(value)),
+            None => Ok(()),
+        }
+    }
+
+    fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, E>
+        where T: de::DeserializeSeed
+    {
+        match self.value {
+            Some(value) => seed.deserialize(ContentDeserializer::new(value)),
+            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")),
+        }
+    }
+
+    fn visit_tuple<V>(
+        self,
+        _len: usize,
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
+    {
+        match self.value {
+            Some(Content::Seq(v)) => {
+                de::Deserializer::deserialize(SeqDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
+            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant"))
+        }
+    }
+
+    fn visit_struct<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
+    {
+        match self.value {
+            Some(Content::Map(v)) => {
+                de::Deserializer::deserialize(MapDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
+            _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant"))
+        }
+    }
+}
+
+struct SeqDeserializer<E> where E: de::Error {
+    iter: <Vec<Content> as IntoIterator>::IntoIter,
+    err: PhantomData<E>,
+}
+
+impl<E> SeqDeserializer<E> where E: de::Error {
+    fn new(vec: Vec<Content>) -> Self {
+        SeqDeserializer {
+            iter: vec.into_iter(),
+            err: PhantomData,
+        }
+    }
+}
+
+impl<E> de::Deserializer for SeqDeserializer<E> where E: de::Error {
+    type Error = E;
+
+    #[inline]
+    fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        let len = self.iter.len();
+        if len == 0 {
+            visitor.visit_unit()
+        } else {
+            let ret = try!(visitor.visit_seq(&mut self));
+            let remaining = self.iter.len();
+            if remaining == 0 {
+                Ok(ret)
+            } else {
+                Err(de::Error::invalid_length(len, &"fewer elements in array"))
+            }
+        }
+    }
+
+    forward_to_deserialize! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
+        seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
+    }
+}
+
+impl<E> de::SeqVisitor for SeqDeserializer<E> where E: de::Error {
+    type Error = E;
+
+    fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.iter.next() {
+            Some(value) => seed.deserialize(ContentDeserializer::new(value)).map(Some),
+            None => Ok(None),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+struct MapDeserializer<E> where E: de::Error {
+    iter: <Vec<(Content, Content)> as IntoIterator>::IntoIter,
+    value: Option<Content>,
+    err: PhantomData<E>,
+}
+
+impl<E> MapDeserializer<E> where E: de::Error {
+    fn new(map: Vec<(Content, Content)>) -> Self {
+        MapDeserializer {
+            iter: map.into_iter(),
+            value: None,
+            err: PhantomData,
+        }
+    }
+}
+
+impl<E> de::MapVisitor for MapDeserializer<E> where E: de::Error {
+    type Error = E;
+
+    fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.iter.next() {
+            Some((key, value)) => {
+                self.value = Some(value);
+                seed.deserialize(ContentDeserializer::new(key)).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.value.take() {
+            Some(value) => seed.deserialize(ContentDeserializer::new(value)),
+            None => Err(de::Error::custom("value is missing")),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<E> de::Deserializer for MapDeserializer<E> where E: de::Error {
+    type Error = E;
+
+    #[inline]
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_map(self)
+    }
+
+    forward_to_deserialize! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
+        seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
+    }
+}
+
+
 /// Not public API.
 pub struct ContentRefDeserializer<'a, E> {
     content: &'a Content,
@@ -637,7 +890,7 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
 {
     type Error = E;
 
-    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, E>
         where V: Visitor
     {
         match *self.content {
@@ -678,7 +931,7 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
         }
     }
 
-    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_option<V>(self, visitor: V) -> Result<V::Value, E>
         where V: Visitor
     {
         match *self.content {
@@ -689,16 +942,47 @@ impl<'a, E> Deserializer for ContentRefDeserializer<'a, E>
         }
     }
 
-    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, Self::Error>
+    fn deserialize_newtype_struct<V>(self, _name: &str, visitor: V) -> Result<V::Value, E>
         where V: Visitor
     {
         visitor.visit_newtype_struct(self)
     }
 
+    fn deserialize_enum<V>(self, _name: &str, _variants: &'static [&'static str], visitor: V) -> Result<V::Value, Self::Error>
+        where V: Visitor,
+    {
+        let (variant, value) = match *self.content {
+            Content::Map(ref value) => {
+                let mut iter = value.into_iter();
+                let &(ref variant, ref value) = match iter.next() {
+                    Some(v) => v,
+                    None => {
+                        return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key"));
+                    }
+                };
+                // enums are encoded in json as maps with a single key:value pair
+                if iter.next().is_some() {
+                    return Err(de::Error::invalid_value(de::Unexpected::Map, &"map with a single key"));
+                }
+                (variant, Some(value))
+            }
+            ref s @ Content::String(_) => (s, None),
+            ref other => {
+                return Err(de::Error::invalid_type(other.unexpected(), &"string or map"));
+            }
+        };
+
+        visitor.visit_enum(EnumRefDeserializer {
+            variant: variant,
+            value: value,
+            err: PhantomData,
+        })
+    }
+
     forward_to_deserialize! {
         bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit seq
         seq_fixed_size bytes byte_buf map unit_struct tuple_struct struct
-        struct_field tuple enum ignored_any
+        struct_field tuple ignored_any
     }
 }
 
@@ -712,6 +996,202 @@ impl<'a, E> ContentRefDeserializer<'a, E> {
     }
 }
 
+struct EnumRefDeserializer<'a, E> where E: de::Error {
+    variant: &'a Content,
+    value: Option<&'a Content>,
+    err: PhantomData<E>,
+}
+
+impl<'a, E> de::EnumVisitor for EnumRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+    type Variant = VariantRefDeserializer<'a, Self::Error>;
+
+    fn visit_variant_seed<V>(self, seed: V) -> Result<(V::Value, Self::Variant), Self::Error>
+        where V: de::DeserializeSeed,
+    {
+        let visitor = VariantRefDeserializer { value: self.value, err: PhantomData, };
+        seed.deserialize(ContentRefDeserializer::new(self.variant)).map(|v| (v, visitor))
+    }
+}
+
+struct VariantRefDeserializer<'a, E> where E: de::Error {
+    value: Option<&'a Content>,
+    err: PhantomData<E>,
+}
+
+impl<'a, E> de::VariantVisitor for VariantRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+
+    fn visit_unit(self) -> Result<(), E> {
+        match self.value {
+            Some(value) => de::Deserialize::deserialize(ContentRefDeserializer::new(value)),
+            None => Ok(()),
+        }
+    }
+
+    fn visit_newtype_seed<T>(self, seed: T) -> Result<T::Value, E>
+        where T: de::DeserializeSeed
+    {
+        match self.value {
+            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
+            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"newtype variant")),
+        }
+    }
+
+    fn visit_tuple<V>(
+        self,
+        _len: usize,
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
+    {
+        match self.value {
+            Some(&Content::Seq(ref v)) => {
+                de::Deserializer::deserialize(SeqRefDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"tuple variant")),
+            None => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"tuple variant"))
+        }
+    }
+
+    fn visit_struct<V>(
+        self,
+        _fields: &'static [&'static str],
+        visitor: V
+    ) -> Result<V::Value, Self::Error>
+        where V: de::Visitor
+    {
+        match self.value {
+            Some(&Content::Map(ref v)) => {
+                de::Deserializer::deserialize(MapRefDeserializer::new(v), visitor)
+            }
+            Some(other) => Err(de::Error::invalid_type(other.unexpected(), &"struct variant")),
+            _ => Err(de::Error::invalid_type(de::Unexpected::UnitVariant, &"struct variant"))
+        }
+    }
+}
+
+struct SeqRefDeserializer<'a, E> where E: de::Error {
+    iter: <&'a [Content] as IntoIterator>::IntoIter,
+    err: PhantomData<E>,
+}
+
+impl<'a, E> SeqRefDeserializer<'a, E> where E: de::Error {
+    fn new(vec: &'a [Content]) -> Self {
+        SeqRefDeserializer {
+            iter: vec.into_iter(),
+            err: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> de::Deserializer for SeqRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+
+    #[inline]
+    fn deserialize<V>(mut self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        let len = self.iter.len();
+        if len == 0 {
+            visitor.visit_unit()
+        } else {
+            let ret = try!(visitor.visit_seq(&mut self));
+            let remaining = self.iter.len();
+            if remaining == 0 {
+                Ok(ret)
+            } else {
+                Err(de::Error::invalid_length(len, &"fewer elements in array"))
+            }
+        }
+    }
+
+    forward_to_deserialize! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
+        seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
+    }
+}
+
+impl<'a, E> de::SeqVisitor for SeqRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+
+    fn visit_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.iter.next() {
+            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)).map(Some),
+            None => Ok(None),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+struct MapRefDeserializer<'a, E> where E: de::Error {
+    iter: <&'a [(Content, Content)] as IntoIterator>::IntoIter,
+    value: Option<&'a Content>,
+    err: PhantomData<E>,
+}
+
+impl<'a, E> MapRefDeserializer<'a, E> where E: de::Error {
+    fn new(map: &'a [(Content, Content)]) -> Self {
+        MapRefDeserializer {
+            iter: map.into_iter(),
+            value: None,
+            err: PhantomData,
+        }
+    }
+}
+
+impl<'a, E> de::MapVisitor for MapRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+
+    fn visit_key_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.iter.next() {
+            Some(&(ref key, ref value)) => {
+                self.value = Some(value);
+                seed.deserialize(ContentRefDeserializer::new(key)).map(Some)
+            }
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value_seed<T>(&mut self, seed: T) -> Result<T::Value, Self::Error>
+        where T: de::DeserializeSeed,
+    {
+        match self.value.take() {
+            Some(value) => seed.deserialize(ContentRefDeserializer::new(value)),
+            None => Err(de::Error::custom("value is missing")),
+        }
+    }
+
+    fn size_hint(&self) -> (usize, Option<usize>) {
+        self.iter.size_hint()
+    }
+}
+
+impl<'a, E> de::Deserializer for MapRefDeserializer<'a, E> where E: de::Error {
+    type Error = E;
+
+    #[inline]
+    fn deserialize<V>(self, visitor: V) -> Result<V::Value, Self::Error>
+        where V: de::Visitor,
+    {
+        visitor.visit_map(self)
+    }
+
+    forward_to_deserialize! {
+        bool u8 u16 u32 u64 i8 i16 i32 i64 f32 f64 char str string unit option
+        seq seq_fixed_size bytes byte_buf map unit_struct newtype_struct
+        tuple_struct struct struct_field tuple enum ignored_any
+    }
+}
+
 impl<E> de::value::ValueDeserializer<E> for ContentDeserializer<E>
     where E: de::Error
 {

serde/src/ser/content.rs

@@ -0,0 +1,635 @@
+use core::marker::PhantomData;
+
+#[cfg(all(not(feature = "std"), feature = "collections"))]
+use collections::{String, Vec};
+
+#[cfg(all(feature = "alloc", not(feature = "std")))]
+use alloc::boxed::Box;
+
+#[cfg(feature = "collections")]
+use collections::borrow::ToOwned;
+
+use ser::{self, Serialize, Serializer};
+
+pub struct SerializeTupleVariantAsMapValue<M> {
+    map: M,
+    name: &'static str,
+    fields: Vec<Content>,
+}
+
+impl<M> SerializeTupleVariantAsMapValue<M> {
+    pub fn new(map: M, name: &'static str, len: usize) -> Self {
+        SerializeTupleVariantAsMapValue {
+            map: map,
+            name: name,
+            fields: Vec::with_capacity(len),
+        }
+    }
+}
+
+impl<M> ser::SerializeTupleVariant for SerializeTupleVariantAsMapValue<M>
+    where M: ser::SerializeMap
+{
+    type Ok = M::Ok;
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              value: &T)
+                                              -> Result<(), M::Error>
+    {
+        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
+        self.fields.push(value);
+        Ok(())
+    }
+
+    fn end(mut self) -> Result<M::Ok, M::Error> {
+        try!(self.map.serialize_value(&Content::TupleStruct(self.name, self.fields)));
+        self.map.end()
+    }
+}
+
+pub struct SerializeStructVariantAsMapValue<M> {
+    map: M,
+    name: &'static str,
+    fields: Vec<(&'static str, Content)>,
+}
+
+impl<M> SerializeStructVariantAsMapValue<M> {
+    pub fn new(map: M, name: &'static str, len: usize) -> Self {
+        SerializeStructVariantAsMapValue {
+            map: map,
+            name: name,
+            fields: Vec::with_capacity(len),
+        }
+    }
+}
+
+impl<M> ser::SerializeStructVariant for SerializeStructVariantAsMapValue<M>
+    where M: ser::SerializeMap
+{
+    type Ok = M::Ok;
+    type Error = M::Error;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              key: &'static str,
+                                              value: &T)
+                                              -> Result<(), M::Error>
+    {
+        let value = try!(value.serialize(ContentSerializer::<M::Error>::new()));
+        self.fields.push((key, value));
+        Ok(())
+    }
+
+    fn end(mut self) -> Result<M::Ok, M::Error> {
+        try!(self.map.serialize_value(&Content::Struct(self.name, self.fields)));
+        self.map.end()
+    }
+}
+
+#[derive(Debug)]
+enum Content {
+    Bool(bool),
+
+    U8(u8),
+    U16(u16),
+    U32(u32),
+    U64(u64),
+
+    I8(i8),
+    I16(i16),
+    I32(i32),
+    I64(i64),
+
+    F32(f32),
+    F64(f64),
+
+    Char(char),
+    String(String),
+    Bytes(Vec<u8>),
+
+    None,
+    Some(Box<Content>),
+
+    Unit,
+    UnitStruct(&'static str),
+    UnitVariant(&'static str, usize, &'static str),
+    NewtypeStruct(&'static str, Box<Content>),
+    NewtypeVariant(&'static str, usize, &'static str, Box<Content>),
+
+    Seq(Vec<Content>),
+    SeqFixedSize(Vec<Content>),
+    Tuple(Vec<Content>),
+    TupleStruct(&'static str, Vec<Content>),
+    TupleVariant(&'static str, usize, &'static str, Vec<Content>),
+    Map(Vec<(Content, Content)>),
+    Struct(&'static str, Vec<(&'static str, Content)>),
+    StructVariant(&'static str, usize, &'static str, Vec<(&'static str, Content)>),
+}
+
+impl Serialize for Content {
+    fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+        where S: Serializer
+    {
+        match *self {
+            Content::Bool(b) => serializer.serialize_bool(b),
+            Content::U8(u) => serializer.serialize_u8(u),
+            Content::U16(u) => serializer.serialize_u16(u),
+            Content::U32(u) => serializer.serialize_u32(u),
+            Content::U64(u) => serializer.serialize_u64(u),
+            Content::I8(i) => serializer.serialize_i8(i),
+            Content::I16(i) => serializer.serialize_i16(i),
+            Content::I32(i) => serializer.serialize_i32(i),
+            Content::I64(i) => serializer.serialize_i64(i),
+            Content::F32(f) => serializer.serialize_f32(f),
+            Content::F64(f) => serializer.serialize_f64(f),
+            Content::Char(c) => serializer.serialize_char(c),
+            Content::String(ref s) => serializer.serialize_str(s),
+            Content::Bytes(ref b) => serializer.serialize_bytes(b),
+            Content::None => serializer.serialize_none(),
+            Content::Some(ref c) => serializer.serialize_some(&**c),
+            Content::Unit => serializer.serialize_unit(),
+            Content::UnitStruct(n) => serializer.serialize_unit_struct(n),
+            Content::UnitVariant(n, i, v) => serializer.serialize_unit_variant(n, i, v),
+            Content::NewtypeStruct(n, ref c) => serializer.serialize_newtype_struct(n, &**c),
+            Content::NewtypeVariant(n, i, v, ref c) => serializer.serialize_newtype_variant(n, i, v, &**c),
+            Content::Seq(ref elements) => elements.serialize(serializer),
+            Content::SeqFixedSize(ref elements) => {
+                use ser::SerializeSeq;
+                let mut seq = try!(serializer.serialize_seq_fixed_size(elements.len()));
+                for e in elements {
+                    try!(seq.serialize_element(e));
+                }
+                seq.end()
+            }
+            Content::Tuple(ref elements) => {
+                use ser::SerializeTuple;
+                let mut tuple = try!(serializer.serialize_tuple(elements.len()));
+                for e in elements {
+                    try!(tuple.serialize_element(e));
+                }
+                tuple.end()
+            }
+            Content::TupleStruct(n, ref fields) => {
+                use ser::SerializeTupleStruct;
+                let mut ts = try!(serializer.serialize_tuple_struct(n, fields.len()));
+                for f in fields {
+                    try!(ts.serialize_field(f));
+                }
+                ts.end()
+            }
+            Content::TupleVariant(n, i, v, ref fields) => {
+                use ser::SerializeTupleVariant;
+                let mut tv = try!(serializer.serialize_tuple_variant(n, i, v, fields.len()));
+                for f in fields {
+                    try!(tv.serialize_field(f));
+                }
+                tv.end()
+            }
+            Content::Map(ref entries) => {
+                use ser::SerializeMap;
+                let mut map = try!(serializer.serialize_map(Some(entries.len())));
+                for &(ref k, ref v) in entries {
+                    try!(map.serialize_entry(k, v));
+                }
+                map.end()
+            }
+            Content::Struct(n, ref fields) => {
+                use ser::SerializeStruct;
+                let mut s = try!(serializer.serialize_struct(n, fields.len()));
+                for &(k, ref v) in fields {
+                    try!(s.serialize_field(k, v));
+                }
+                s.end()
+            }
+            Content::StructVariant(n, i, v, ref fields) => {
+                use ser::SerializeStructVariant;
+                let mut sv = try!(serializer.serialize_struct_variant(n, i, v, fields.len()));
+                for &(k, ref v) in fields {
+                    try!(sv.serialize_field(k, v));
+                }
+                sv.end()
+            }
+        }
+    }
+}
+
+struct ContentSerializer<E> {
+    error: PhantomData<E>,
+}
+
+impl<E> ContentSerializer<E> {
+    fn new() -> Self {
+        ContentSerializer {
+            error: PhantomData,
+        }
+    }
+}
+
+impl<E> Serializer for ContentSerializer<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    type SerializeSeq = SerializeSeq<E>;
+    type SerializeTuple = SerializeTuple<E>;
+    type SerializeTupleStruct = SerializeTupleStruct<E>;
+    type SerializeTupleVariant = SerializeTupleVariant<E>;
+    type SerializeMap = SerializeMap<E>;
+    type SerializeStruct = SerializeStruct<E>;
+    type SerializeStructVariant = SerializeStructVariant<E>;
+
+    fn serialize_bool(self, v: bool) -> Result<Content, E> {
+        Ok(Content::Bool(v))
+    }
+
+    fn serialize_i8(self, v: i8) -> Result<Content, E> {
+        Ok(Content::I8(v))
+    }
+
+    fn serialize_i16(self, v: i16) -> Result<Content, E> {
+        Ok(Content::I16(v))
+    }
+
+    fn serialize_i32(self, v: i32) -> Result<Content, E> {
+        Ok(Content::I32(v))
+    }
+
+    fn serialize_i64(self, v: i64) -> Result<Content, E> {
+        Ok(Content::I64(v))
+    }
+
+    fn serialize_u8(self, v: u8) -> Result<Content, E> {
+        Ok(Content::U8(v))
+    }
+
+    fn serialize_u16(self, v: u16) -> Result<Content, E> {
+        Ok(Content::U16(v))
+    }
+
+    fn serialize_u32(self, v: u32) -> Result<Content, E> {
+        Ok(Content::U32(v))
+    }
+
+    fn serialize_u64(self, v: u64) -> Result<Content, E> {
+        Ok(Content::U64(v))
+    }
+
+    fn serialize_f32(self, v: f32) -> Result<Content, E> {
+        Ok(Content::F32(v))
+    }
+
+    fn serialize_f64(self, v: f64) -> Result<Content, E> {
+        Ok(Content::F64(v))
+    }
+
+    fn serialize_char(self, v: char) -> Result<Content, E> {
+        Ok(Content::Char(v))
+    }
+
+    fn serialize_str(self, value: &str) -> Result<Content, E> {
+        Ok(Content::String(value.to_owned()))
+    }
+
+    fn serialize_bytes(self, value: &[u8]) -> Result<Content, E> {
+        Ok(Content::Bytes(value.to_owned()))
+    }
+
+    fn serialize_none(self) -> Result<Content, E> {
+        Ok(Content::None)
+    }
+
+    fn serialize_some<T: ?Sized + Serialize>(self,
+                                             value: &T)
+                                             -> Result<Content, E> {
+        Ok(Content::Some(Box::new(try!(value.serialize(self)))))
+    }
+
+    fn serialize_unit(self) -> Result<Content, E> {
+        Ok(Content::Unit)
+    }
+
+    fn serialize_unit_struct(self,
+                             name: &'static str)
+                             -> Result<Content, E> {
+        Ok(Content::UnitStruct(name))
+    }
+
+    fn serialize_unit_variant(self,
+                              name: &'static str,
+                              variant_index: usize,
+                              variant: &'static str)
+                              -> Result<Content, E> {
+        Ok(Content::UnitVariant(name, variant_index, variant))
+    }
+
+    fn serialize_newtype_struct<T: ?Sized + Serialize>(self,
+                                                       name: &'static str,
+                                                       value: &T)
+                                                       -> Result<Content, E> {
+        Ok(Content::NewtypeStruct(name, Box::new(try!(value.serialize(self)))))
+    }
+
+    fn serialize_newtype_variant<T: ?Sized + Serialize>(self,
+                                                        name: &'static str,
+                                                        variant_index: usize,
+                                                        variant: &'static str,
+                                                        value: &T)
+                                                        -> Result<Content, E> {
+        Ok(Content::NewtypeVariant(name, variant_index, variant, Box::new(try!(value.serialize(self)))))
+    }
+
+    fn serialize_seq(self,
+                     len: Option<usize>)
+                     -> Result<Self::SerializeSeq, E> {
+        Ok(SerializeSeq {
+            fixed_size: false,
+            elements: Vec::with_capacity(len.unwrap_or(0)),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_seq_fixed_size(self,
+                                size: usize)
+                                -> Result<Self::SerializeSeq, E> {
+        Ok(SerializeSeq {
+            fixed_size: true,
+            elements: Vec::with_capacity(size),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_tuple(self,
+                       len: usize)
+                       -> Result<Self::SerializeTuple, E> {
+        Ok(SerializeTuple {
+            elements: Vec::with_capacity(len),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_tuple_struct(self,
+                              name: &'static str,
+                              len: usize)
+                              -> Result<Self::SerializeTupleStruct, E> {
+        Ok(SerializeTupleStruct {
+            name: name,
+            fields: Vec::with_capacity(len),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_tuple_variant(self,
+                               name: &'static str,
+                               variant_index: usize,
+                               variant: &'static str,
+                               len: usize)
+                               -> Result<Self::SerializeTupleVariant, E> {
+        Ok(SerializeTupleVariant {
+            name: name,
+            variant_index: variant_index,
+            variant: variant,
+            fields: Vec::with_capacity(len),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_map(self,
+                     len: Option<usize>)
+                     -> Result<Self::SerializeMap, E> {
+        Ok(SerializeMap {
+            entries: Vec::with_capacity(len.unwrap_or(0)),
+            key: None,
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_struct(self,
+                        name: &'static str,
+                        len: usize)
+                        -> Result<Self::SerializeStruct, E> {
+        Ok(SerializeStruct {
+            name: name,
+            fields: Vec::with_capacity(len),
+            error: PhantomData,
+        })
+    }
+
+    fn serialize_struct_variant(self,
+                                name: &'static str,
+                                variant_index: usize,
+                                variant: &'static str,
+                                len: usize)
+                                -> Result<Self::SerializeStructVariant, E> {
+        Ok(SerializeStructVariant {
+            name: name,
+            variant_index: variant_index,
+            variant: variant,
+            fields: Vec::with_capacity(len),
+            error: PhantomData,
+        })
+    }
+}
+
+struct SerializeSeq<E> {
+    fixed_size: bool,
+    elements: Vec<Content>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeSeq for SerializeSeq<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_element<T: ?Sized + Serialize>(&mut self,
+                                                value: &T)
+                                                -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.elements.push(value);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(if self.fixed_size {
+            Content::SeqFixedSize(self.elements)
+        } else {
+            Content::Seq(self.elements)
+        })
+    }
+}
+
+struct SerializeTuple<E> {
+    elements: Vec<Content>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTuple for SerializeTuple<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_element<T: ?Sized + Serialize>(&mut self,
+                                                value: &T)
+                                                -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.elements.push(value);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::Tuple(self.elements))
+    }
+}
+
+struct SerializeTupleStruct<E> {
+    name: &'static str,
+    fields: Vec<Content>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTupleStruct for SerializeTupleStruct<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              value: &T)
+                                              -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.fields.push(value);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::TupleStruct(self.name, self.fields))
+    }
+}
+
+struct SerializeTupleVariant<E> {
+    name: &'static str,
+    variant_index: usize,
+    variant: &'static str,
+    fields: Vec<Content>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeTupleVariant for SerializeTupleVariant<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              value: &T)
+                                              -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.fields.push(value);
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::TupleVariant(self.name, self.variant_index, self.variant, self.fields))
+    }
+}
+
+struct SerializeMap<E> {
+    entries: Vec<(Content, Content)>,
+    key: Option<Content>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeMap for SerializeMap<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_key<T: ?Sized + Serialize>(&mut self,
+                                            key: &T)
+                                            -> Result<(), E> {
+        let key = try!(key.serialize(ContentSerializer::<E>::new()));
+        self.key = Some(key);
+        Ok(())
+    }
+
+    fn serialize_value<T: ?Sized + Serialize>(&mut self,
+                                              value: &T)
+                                              -> Result<(), E> {
+        let key = self.key.take().expect("serialize_value called before serialize_key");
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.entries.push((key, value));
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::Map(self.entries))
+    }
+
+    fn serialize_entry<K: ?Sized + Serialize, V: ?Sized + Serialize>(&mut self,
+                                                                     key: &K,
+                                                                     value: &V)
+                                                                     -> Result<(), E> {
+        let key = try!(key.serialize(ContentSerializer::<E>::new()));
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.entries.push((key, value));
+        Ok(())
+    }
+}
+
+struct SerializeStruct<E> {
+    name: &'static str,
+    fields: Vec<(&'static str, Content)>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeStruct for SerializeStruct<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              key: &'static str,
+                                              value: &T)
+                                              -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.fields.push((key, value));
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::Struct(self.name, self.fields))
+    }
+}
+
+struct SerializeStructVariant<E> {
+    name: &'static str,
+    variant_index: usize,
+    variant: &'static str,
+    fields: Vec<(&'static str, Content)>,
+    error: PhantomData<E>,
+}
+
+impl<E> ser::SerializeStructVariant for SerializeStructVariant<E>
+    where E: ser::Error
+{
+    type Ok = Content;
+    type Error = E;
+
+    fn serialize_field<T: ?Sized + Serialize>(&mut self,
+                                              key: &'static str,
+                                              value: &T)
+                                              -> Result<(), E> {
+        let value = try!(value.serialize(ContentSerializer::<E>::new()));
+        self.fields.push((key, value));
+        Ok(())
+    }
+
+    fn end(self) -> Result<Content, E> {
+        Ok(Content::StructVariant(self.name, self.variant_index, self.variant, self.fields))
+    }
+}

serde/src/ser/mod.rs

@@ -107,6 +107,8 @@ mod impossible;
 // Helpers used by generated code. Not public API.
 #[doc(hidden)]
 pub mod private;
+#[cfg(any(feature = "std", feature = "collections"))]
+mod content;
 
 pub use self::impossible::Impossible;
 

serde/src/ser/private.rs

@@ -1,6 +1,9 @@
 use core::fmt::{self, Display};
 
-use ser::{self, Serialize, Serializer, SerializeMap, SerializeStruct};
+use ser::{self, Serialize, Serializer, SerializeMap, SerializeStruct, Impossible};
+
+#[cfg(any(feature = "std", feature = "collections"))]
+use ser::content::{SerializeTupleVariantAsMapValue, SerializeStructVariantAsMapValue};
 
 /// Not public API.
 pub fn serialize_tagged_newtype<S, T>(serializer: S,
@@ -43,6 +46,7 @@ enum Unsupported {
     Sequence,
     Tuple,
     TupleStruct,
+    #[cfg(not(any(feature = "std", feature = "collections")))]
     Enum,
 }
 
@@ -61,6 +65,7 @@ impl Display for Unsupported {
             Unsupported::Sequence => formatter.write_str("a sequence"),
             Unsupported::Tuple => formatter.write_str("a tuple"),
             Unsupported::TupleStruct => formatter.write_str("a tuple struct"),
+            #[cfg(not(any(feature = "std", feature = "collections")))]
             Unsupported::Enum => formatter.write_str("an enum"),
         }
     }
@@ -98,13 +103,21 @@ impl<S> Serializer for TaggedSerializer<S>
     type Ok = S::Ok;
     type Error = S::Error;
 
-    type SerializeSeq = S::SerializeSeq;
+    type SerializeSeq = Impossible<S::Ok, S::Error>;
-    type SerializeTuple = S::SerializeTuple;
+    type SerializeTuple = Impossible<S::Ok, S::Error>;
-    type SerializeTupleStruct = S::SerializeTupleStruct;
+    type SerializeTupleStruct = Impossible<S::Ok, S::Error>;
-    type SerializeTupleVariant = S::SerializeTupleVariant;
     type SerializeMap = S::SerializeMap;
     type SerializeStruct = S::SerializeStruct;
-    type SerializeStructVariant = S::SerializeStructVariant;
+
+    #[cfg(not(any(feature = "std", feature = "collections")))]
+    type SerializeTupleVariant = Impossible<S::Ok, S::Error>;
+    #[cfg(any(feature = "std", feature = "collections"))]
+    type SerializeTupleVariant = SerializeTupleVariantAsMapValue<S::SerializeMap>;
+
+    #[cfg(not(any(feature = "std", feature = "collections")))]
+    type SerializeStructVariant = Impossible<S::Ok, S::Error>;
+    #[cfg(any(feature = "std", feature = "collections"))]
+    type SerializeStructVariant = SerializeStructVariantAsMapValue<S::SerializeMap>;
 
     fn serialize_bool(self, _: bool) -> Result<Self::Ok, Self::Error> {
         Err(self.bad_type(Unsupported::Boolean))
@@ -183,9 +196,12 @@ impl<S> Serializer for TaggedSerializer<S>
     fn serialize_unit_variant(self,
                               _: &'static str,
                               _: usize,
-                              _: &'static str)
+                              inner_variant: &'static str)
                               -> Result<Self::Ok, Self::Error> {
-        Err(self.bad_type(Unsupported::Enum))
+        let mut map = try!(self.delegate.serialize_map(Some(2)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        try!(map.serialize_entry(inner_variant, &()));
+        map.end()
     }
 
     fn serialize_newtype_struct<T: ?Sized>(self,
@@ -200,12 +216,15 @@ impl<S> Serializer for TaggedSerializer<S>
     fn serialize_newtype_variant<T: ?Sized>(self,
                                             _: &'static str,
                                             _: usize,
-                                            _: &'static str,
+                                            inner_variant: &'static str,
-                                            _: &T)
+                                            inner_value: &T)
                                             -> Result<Self::Ok, Self::Error>
         where T: Serialize
     {
-        Err(self.bad_type(Unsupported::Enum))
+        let mut map = try!(self.delegate.serialize_map(Some(2)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        try!(map.serialize_entry(inner_variant, inner_value));
+        map.end()
     }
 
     fn serialize_seq(self, _: Option<usize>) -> Result<Self::SerializeSeq, Self::Error> {
@@ -227,15 +246,31 @@ impl<S> Serializer for TaggedSerializer<S>
         Err(self.bad_type(Unsupported::TupleStruct))
     }
 
+    #[cfg(not(any(feature = "std", feature = "collections")))]
     fn serialize_tuple_variant(self,
                                _: &'static str,
                                _: usize,
                                _: &'static str,
                                _: usize)
                                -> Result<Self::SerializeTupleVariant, Self::Error> {
+        // Lack of push-based serialization means we need to buffer the content
+        // of the tuple variant, so it requires std.
         Err(self.bad_type(Unsupported::Enum))
     }
 
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn serialize_tuple_variant(self,
+                               _: &'static str,
+                               _: usize,
+                               inner_variant: &'static str,
+                               len: usize)
+                               -> Result<Self::SerializeTupleVariant, Self::Error> {
+        let mut map = try!(self.delegate.serialize_map(Some(2)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        try!(map.serialize_key(inner_variant));
+        Ok(SerializeTupleVariantAsMapValue::new(map, inner_variant, len))
+    }
+
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error> {
         let mut map = try!(self.delegate.serialize_map(len.map(|len| len + 1)));
         try!(map.serialize_entry(self.tag, self.variant_name));
@@ -251,12 +286,28 @@ impl<S> Serializer for TaggedSerializer<S>
         Ok(state)
     }
 
+    #[cfg(not(any(feature = "std", feature = "collections")))]
     fn serialize_struct_variant(self,
                                 _: &'static str,
                                 _: usize,
                                 _: &'static str,
                                 _: usize)
                                 -> Result<Self::SerializeStructVariant, Self::Error> {
+        // Lack of push-based serialization means we need to buffer the content
+        // of the struct variant, so it requires std.
         Err(self.bad_type(Unsupported::Enum))
     }
+
+    #[cfg(any(feature = "std", feature = "collections"))]
+    fn serialize_struct_variant(self,
+                                _: &'static str,
+                                _: usize,
+                                inner_variant: &'static str,
+                                len: usize)
+                                -> Result<Self::SerializeStructVariant, Self::Error> {
+        let mut map = try!(self.delegate.serialize_map(Some(2)));
+        try!(map.serialize_entry(self.tag, self.variant_name));
+        try!(map.serialize_key(inner_variant));
+        Ok(SerializeStructVariantAsMapValue::new(map, inner_variant, len))
+    }
 }

serde_derive/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_derive"
-version = "0.9.8"
+version = "0.9.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Macros 1.1 implementation of #[derive(Serialize, Deserialize)]"

serde_test/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "serde_test"
-version = "0.9.8"
+version = "0.9.9"
 authors = ["Erick Tryzelaar <erick.tryzelaar@gmail.com>"]
 license = "MIT/Apache-2.0"
 description = "Token De/Serializer for testing De/Serialize implementations"

serde_test/src/de.rs

@@ -2,7 +2,7 @@ use std::iter;
 
 use serde::de::{self, Deserialize, DeserializeSeed, EnumVisitor, MapVisitor, SeqVisitor,
                 VariantVisitor, Visitor};
-use serde::de::value::ValueDeserializer;
+use serde::de::value::{ValueDeserializer, MapVisitorDeserializer, SeqVisitorDeserializer};
 
 use error::Error;
 use token::Token;
@@ -129,6 +129,13 @@ impl<'a, I> de::Deserializer for &'a mut Deserializer<I>
             Some(Token::StructStart(_, len)) => {
                 self.visit_map(Some(len), Token::StructSep, Token::StructEnd, visitor)
             }
+            Some(Token::EnumUnit(_, variant)) => visitor.visit_str(variant),
+            Some(Token::EnumStart(variant)) |
+            Some(Token::EnumNewType(_, variant)) |
+            Some(Token::EnumSeqStart(_, variant, _)) |
+            Some(Token::EnumMapStart(_, variant, _)) => {
+                visitor.visit_map(EnumMapVisitor::new(self, variant))
+            }
             Some(token) => Err(Error::UnexpectedToken(token)),
             None => Err(Error::EndOfTokens),
         }
@@ -541,3 +548,72 @@ impl<'a, I> VariantVisitor for DeserializerEnumVisitor<'a, I>
         }
     }
 }
+
+//////////////////////////////////////////////////////////////////////////
+
+struct EnumMapVisitor<'a, I: 'a>
+    where I: Iterator<Item = Token<'static>>
+{
+    de: &'a mut Deserializer<I>,
+    variant: Option<&'a str>,
+}
+
+impl<'a, I: 'a> EnumMapVisitor<'a, I>
+    where I: Iterator<Item = Token<'static>>
+{
+    fn new(de: &'a mut Deserializer<I>, variant: &'a str) -> Self {
+        EnumMapVisitor {
+            de: de,
+            variant: Some(variant),
+        }
+    }
+}
+
+impl<'a, I: 'a> MapVisitor for EnumMapVisitor<'a, I>
+    where I: Iterator<Item = Token<'static>>
+{
+    type Error = Error;
+
+    fn visit_key_seed<K>(&mut self, seed: K) -> Result<Option<K::Value>, Error>
+        where K: DeserializeSeed
+    {
+        match self.variant.take() {
+            Some(variant) => seed.deserialize(variant.into_deserializer()).map(Some),
+            None => Ok(None),
+        }
+    }
+
+    fn visit_value_seed<V>(&mut self, seed: V) -> Result<V::Value, Error>
+        where V: DeserializeSeed
+    {
+        match self.de.tokens.peek() {
+            Some(&Token::EnumSeqSep) => {
+                let value = {
+                    let visitor = DeserializerSeqVisitor {
+                        de: self.de,
+                        len: None,
+                        sep: Token::EnumSeqSep,
+                        end: Token::EnumSeqEnd,
+                    };
+                    try!(seed.deserialize(SeqVisitorDeserializer::new(visitor)))
+                };
+                try!(self.de.expect_token(Token::EnumSeqEnd));
+                Ok(value)
+            }
+            Some(&Token::EnumMapSep) => {
+                let value = {
+                    let visitor = DeserializerMapVisitor {
+                        de: self.de,
+                        len: None,
+                        sep: Token::EnumMapSep,
+                        end: Token::EnumMapEnd,
+                    };
+                    try!(seed.deserialize(MapVisitorDeserializer::new(visitor)))
+                };
+                try!(self.de.expect_token(Token::EnumMapEnd));
+                Ok(value)
+            }
+            _ => seed.deserialize(&mut *self.de),
+        }
+    }
+}

test_suite/tests/test_macros.rs

@@ -1069,3 +1069,156 @@ fn test_adjacently_tagged_enum() {
         ]
     );
 }
+
+#[test]
+fn test_enum_in_internally_tagged_enum() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(tag = "type")]
+    enum Outer {
+        Inner(Inner),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    enum Inner {
+        Unit,
+        Newtype(u8),
+        Tuple(u8, u8),
+        Struct { f: u8 },
+    }
+
+    assert_tokens(
+        &Outer::Inner(Inner::Unit),
+        &[
+            Token::MapStart(Some(2)),
+
+            Token::MapSep,
+            Token::Str("type"),
+            Token::Str("Inner"),
+
+            Token::MapSep,
+            Token::Str("Unit"),
+            Token::Unit,
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Newtype(1)),
+        &[
+            Token::MapStart(Some(2)),
+
+            Token::MapSep,
+            Token::Str("type"),
+            Token::Str("Inner"),
+
+            Token::MapSep,
+            Token::Str("Newtype"),
+            Token::U8(1),
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Tuple(1, 1)),
+        &[
+            Token::MapStart(Some(2)),
+
+            Token::MapSep,
+            Token::Str("type"),
+            Token::Str("Inner"),
+
+            Token::MapSep,
+            Token::Str("Tuple"),
+            Token::TupleStructStart("Tuple", 2),
+            Token::TupleStructSep,
+            Token::U8(1),
+            Token::TupleStructSep,
+            Token::U8(1),
+            Token::TupleStructEnd,
+
+            Token::MapEnd,
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Struct { f: 1 }),
+        &[
+            Token::MapStart(Some(2)),
+
+            Token::MapSep,
+            Token::Str("type"),
+            Token::Str("Inner"),
+
+            Token::MapSep,
+            Token::Str("Struct"),
+            Token::StructStart("Struct", 1),
+            Token::StructSep,
+            Token::Str("f"),
+            Token::U8(1),
+            Token::StructEnd,
+
+            Token::MapEnd,
+        ]
+    );
+}
+
+#[test]
+fn test_enum_in_untagged_enum() {
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    #[serde(untagged)]
+    enum Outer {
+        Inner(Inner),
+    }
+
+    #[derive(Debug, PartialEq, Serialize, Deserialize)]
+    enum Inner {
+        Unit,
+        Newtype(u8),
+        Tuple(u8, u8),
+        Struct { f: u8 },
+    }
+
+    assert_tokens(
+        &Outer::Inner(Inner::Unit),
+        &[
+            Token::EnumUnit("Inner", "Unit"),
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Newtype(1)),
+        &[
+            Token::EnumNewType("Inner", "Newtype"),
+            Token::U8(1),
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Tuple(1, 1)),
+        &[
+            Token::EnumSeqStart("Inner", "Tuple", 2),
+
+            Token::EnumSeqSep,
+            Token::U8(1),
+            Token::EnumSeqSep,
+            Token::U8(1),
+
+            Token::EnumSeqEnd,
+        ]
+    );
+
+    assert_tokens(
+        &Outer::Inner(Inner::Struct { f: 1 }),
+        &[
+            Token::EnumMapStart("Inner", "Struct", 1),
+
+            Token::EnumMapSep,
+            Token::Str("f"),
+            Token::U8(1),
+
+            Token::EnumMapEnd,
+        ]
+    );
+}