add serialize_map_struct and deserialize_map_struct

serde/src/de/mod.rs

@@ -1113,6 +1113,22 @@ pub trait Deserializer<'de>: Sized {
     where
         V: Visitor<'de>;
 
+    /// Hint that the `Deserialize` type is expecting a map of key-value pairs.
+    /// Additional name and fields information is provided
+    fn deserialize_map_struct<V>(
+        self,
+        name: &'static str,
+        fields: &'static [&'static str],
+        visitor: V,
+    ) -> Result<V::Value, Self::Error>
+    where
+        V: Visitor<'de>,
+    {
+        let _ = name;
+        let _ = fields;
+        self.deserialize_map(visitor)
+    }
+
     /// Hint that the `Deserialize` type is expecting a struct with a particular
     /// name and fields.
     fn deserialize_struct<V>(

serde/src/ser/mod.rs

@@ -1171,6 +1171,64 @@ pub trait Serializer: Sized {
     /// ```
     fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Self::Error>;
 
+    /// Begin to serialize a map. This call must be followed by zero or more
+    /// calls to `serialize_key` and `serialize_value`, then a call to `end`.
+    ///
+    /// The argument is the number of elements in the map, which may or may not
+    /// be computable before the map is iterated. Some serializers only support
+    /// maps whose length is known up front.
+    ///
+    /// ```edition2018
+    /// # use std::marker::PhantomData;
+    /// #
+    /// # struct HashMap<K, V>(PhantomData<K>, PhantomData<V>);
+    /// #
+    /// # impl<K, V> HashMap<K, V> {
+    /// #     fn len(&self) -> usize {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// # impl<'a, K, V> IntoIterator for &'a HashMap<K, V> {
+    /// #     type Item = (&'a K, &'a V);
+    /// #     type IntoIter = Box<Iterator<Item = (&'a K, &'a V)>>;
+    /// #
+    /// #     fn into_iter(self) -> Self::IntoIter {
+    /// #         unimplemented!()
+    /// #     }
+    /// # }
+    /// #
+    /// use serde::ser::{Serialize, Serializer, SerializeMap};
+    ///
+    /// struct Config {
+    ///     name: String,
+    ///     others: HashMap<String, String>,
+    /// }
+    ///
+    /// impl Serialize for Config {
+    ///     fn serialize<S>(&self, serializer: S) -> Result<S::Ok, S::Error>
+    ///     where
+    ///         S: Serializer,
+    ///     {
+    ///         let mut map = serializer.serialize_map_struct("Config", Some(1 + self.others.len()))?;
+    ///         map.serialize_field("name", &self.name)?;
+    ///         for (k, v) in &self.others {
+    ///             map.serialize_entry(k, v)?;
+    ///         }
+    ///         map.end()
+    ///     }
+    /// }
+    /// ```
+    fn serialize_map_struct(
+        self,
+        name: &'static str,
+        len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Self::Error> {
+        let _ = name;
+        let _ = len;
+        self.serialize_map(len)
+    }
+
     /// Begin to serialize a struct like `struct Rgb { r: u8, g: u8, b: u8 }`.
     /// This call must be followed by zero or more calls to `serialize_field`,
     /// then a call to `end`.
@@ -1847,6 +1905,26 @@ pub trait SerializeMap {
         self.serialize_value(value)
     }
 
+    /// Serialize a struct field consisting of a key and a value.
+    ///
+    /// Some [`Serializer`] types would like to handle struct field key
+    /// differently, since the key would be `&'static str` here.
+    ///
+    /// The default implementation delegates to [`serialize_entry`].
+    ///
+    /// [`Serialize`]: ../trait.Serialize.html
+    /// [`serialize_field`]: #tymethod.serialize_field
+    fn serialize_field<V: ?Sized>(
+        &mut self,
+        key: &'static str,
+        value: &V,
+    ) -> Result<(), Self::Error>
+    where
+        V: Serialize,
+    {
+        self.serialize_entry(key, value)
+    }
+
     /// Finish serializing a map.
     fn end(self) -> Result<Self::Ok, Self::Error>;
 }

serde_derive/src/de.rs

@@ -948,7 +948,7 @@ fn deserialize_struct(
         deserialize_struct_as_struct_visitor(&type_path, params, fields, cattrs)
     };
     let field_visitor = Stmts(field_visitor);
-    let fields_stmt = fields_stmt.map(Stmts);
+    let fields_stmt = Stmts(fields_stmt);
     let visit_map = Stmts(visit_map);
 
     let visitor_expr = quote! {
@@ -971,8 +971,9 @@ fn deserialize_struct(
             _serde::de::VariantAccess::struct_variant(__variant, FIELDS, #visitor_expr)
         }
     } else if cattrs.has_flatten() {
+        let type_name = cattrs.name().deserialize_name();
         quote! {
-            _serde::Deserializer::deserialize_map(__deserializer, #visitor_expr)
+            _serde::Deserializer::deserialize_map_struct(__deserializer, #type_name, FIELDS, #visitor_expr)
         }
     } else {
         let type_name = cattrs.name().deserialize_name();
@@ -2399,7 +2400,7 @@ fn deserialize_struct_as_struct_visitor(
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
-) -> (Fragment, Option<Fragment>, Fragment) {
+) -> (Fragment, Fragment, Fragment) {
     assert!(!cattrs.has_flatten());
 
     let field_names_idents: Vec<_> = fields
@@ -2430,15 +2431,15 @@ fn deserialize_struct_as_struct_visitor(
 
     let visit_map = deserialize_map(struct_path, params, fields, cattrs);
 
-    (field_visitor, Some(fields_stmt), visit_map)
+    (field_visitor, fields_stmt, visit_map)
 }
 
 fn deserialize_struct_as_map_visitor(
     struct_path: &TokenStream,
     params: &Parameters,
     fields: &[Field],
     cattrs: &attr::Container,
-) -> (Fragment, Option<Fragment>, Fragment) {
+) -> (Fragment, Fragment, Fragment) {
     let field_names_idents: Vec<_> = fields
         .iter()
         .enumerate()
@@ -2452,11 +2453,22 @@ fn deserialize_struct_as_map_visitor(
         })
         .collect();
 
+    let fields_stmt = {
+        let field_names = field_names_idents
+            .iter()
+            .flat_map(|(_, _, aliases)| aliases);
+
+        quote_block! {
+            #[doc(hidden)]
+            const FIELDS: &'static [&'static str] = &[ #(#field_names),* ];
+        }
+    };
+
     let field_visitor = deserialize_generated_identifier(&field_names_idents, cattrs, false, None);
 
     let visit_map = deserialize_map(struct_path, params, fields, cattrs);
 
-    (field_visitor, None, visit_map)
+    (field_visitor, fields_stmt, visit_map)
 }
 
 fn deserialize_map(

serde_derive/src/ser.rs

@@ -367,6 +367,8 @@ fn serialize_struct_as_map(
     let serialize_fields =
         serialize_struct_visitor(fields, params, false, &StructTrait::SerializeMap);
 
+    let type_name = cattrs.name().serialize_name();
+
     let tag_field = serialize_struct_tag_field(cattrs, &StructTrait::SerializeMap);
     let tag_field_exists = !tag_field.is_empty();
 
@@ -396,7 +398,7 @@ fn serialize_struct_as_map(
     };
 
     quote_block! {
-        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map(__serializer, #len));
+        let #let_mut __serde_state = try!(_serde::Serializer::serialize_map_struct(__serializer, #type_name, #len));
         #tag_field
         #(#serialize_fields)*
         _serde::ser::SerializeMap::end(__serde_state)
@@ -1296,7 +1298,7 @@ impl StructTrait {
     fn serialize_field(&self, span: Span) -> TokenStream {
         match *self {
             StructTrait::SerializeMap => {
-                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_entry)
+                quote_spanned!(span=> _serde::ser::SerializeMap::serialize_field)
             }
             StructTrait::SerializeStruct => {
                 quote_spanned!(span=> _serde::ser::SerializeStruct::serialize_field)

serde_test/src/de.rs

@@ -159,6 +159,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
                 self.visit_seq(Some(len), Token::TupleStructEnd, visitor)
             }
             Token::Map { len } => self.visit_map(len, Token::MapEnd, visitor),
+            Token::MapStruct { len, .. } => self.visit_map(len, Token::MapStructEnd, visitor),
             Token::Struct { len, .. } => self.visit_map(Some(len), Token::StructEnd, visitor),
             Token::Enum { .. } => {
                 let variant = self.next_token();
@@ -230,6 +231,7 @@ impl<'de, 'a> de::Deserializer<'de> for &'a mut Deserializer<'de> {
             | Token::TupleEnd
             | Token::TupleStructEnd
             | Token::MapEnd
+            | Token::MapStructEnd
             | Token::StructEnd
             | Token::TupleVariantEnd
             | Token::StructVariantEnd => {

serde_test/src/ser.rs

@@ -13,7 +13,7 @@ pub struct Serializer<'a> {
 impl<'a> Serializer<'a> {
     /// Creates the serializer.
     pub fn new(tokens: &'a [Token]) -> Self {
-        Serializer { tokens: tokens }
+        Serializer { tokens }
     }
 
     /// Pulls the next token off of the serializer, ignoring it.
@@ -83,7 +83,7 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
     type SerializeTuple = Self;
     type SerializeTupleStruct = Self;
     type SerializeTupleVariant = Variant<'s, 'a>;
-    type SerializeMap = Self;
+    type SerializeMap = Variant<'s, 'a>;
     type SerializeStruct = Self;
     type SerializeStructVariant = Variant<'s, 'a>;
 
@@ -271,9 +271,24 @@ impl<'s, 'a> ser::Serializer for &'s mut Serializer<'a> {
         }
     }
 
-    fn serialize_map(self, len: Option<usize>) -> Result<Self, Error> {
+    fn serialize_map_struct(
+        self,
+        name: &'static str,
+        len: Option<usize>,
+    ) -> Result<Self::SerializeMap, Self::Error> {
+        assert_next_token!(self, MapStruct { name, len });
+        Ok(Variant {
+            ser: self,
+            end: Token::MapStructEnd,
+        })
+    }
+
+    fn serialize_map(self, len: Option<usize>) -> Result<Self::SerializeMap, Error> {
         assert_next_token!(self, Map { len });
-        Ok(self)
+        Ok(Variant {
+            ser: self,
+            end: Token::MapEnd,
+        })
     }
 
     fn serialize_struct(self, name: &'static str, len: usize) -> Result<Self, Error> {
@@ -391,26 +406,30 @@ impl<'s, 'a> ser::SerializeTupleVariant for Variant<'s, 'a> {
     }
 }
 
-impl<'s, 'a> ser::SerializeMap for &'s mut Serializer<'a> {
+impl<'s, 'a> ser::SerializeMap for Variant<'s, 'a> {
     type Ok = ();
     type Error = Error;
 
     fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
     where
         T: Serialize,
     {
-        key.serialize(&mut **self)
+        key.serialize(&mut *self.ser)
     }
 
     fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
     where
         T: Serialize,
     {
-        value.serialize(&mut **self)
+        value.serialize(&mut *self.ser)
     }
 
     fn end(self) -> Result<(), Self::Error> {
-        assert_next_token!(self, MapEnd);
+        match self.end {
+            Token::MapStructEnd => assert_next_token!(self.ser, MapStructEnd),
+            Token::MapEnd => assert_next_token!(self.ser, MapEnd),
+            _ => unreachable!(),
+        }
         Ok(())
     }
 }

serde_test/src/token.rs

@@ -395,6 +395,45 @@ pub enum Token {
     /// An indicator of the end of a map.
     MapEnd,
 
+    /// The header to a map.
+    ///
+    /// After this header are the entries of the map, followed by `MapEnd`.
+    ///
+    /// ```edition2018
+    /// # use serde::{Serialize, Deserialize};
+    /// # use serde_test::{assert_tokens, Token};
+    /// #
+    /// use std::collections::BTreeMap;
+    /// #[derive(Serialize, Deserialize, PartialEq, Debug)]
+    /// struct S {
+    ///     a: u8,
+    ///     #[serde(flatten)]
+    ///     other: BTreeMap<char, i32>,
+    /// }
+    /// let mut map = BTreeMap::new();
+    /// map.insert('A', 65);
+    /// map.insert('Z', 90);
+    /// let s = S { a: 0, other: map };
+    ///
+    /// assert_tokens(&s, &[
+    ///     Token::MapStruct { name: "S", len: None },
+    ///     Token::Str("a"),
+    ///     Token::U8(0),
+    ///     Token::Char('A'),
+    ///     Token::I32(65),
+    ///     Token::Char('Z'),
+    ///     Token::I32(90),
+    ///     Token::MapStructEnd,
+    /// ]);
+    /// ```
+    MapStruct {
+        name: &'static str,
+        len: Option<usize>,
+    },
+
+    /// An indicator of the end of a map.
+    MapStructEnd,
+
     /// The header of a struct.
     ///
     /// After this header are the fields of the struct, followed by `StructEnd`.