Misc(serde): improve error types and its messages.

 - New error type introduced - UnknownLength. Returned on attempt to
   serialize struct, map or serquence with unknown length (Serde allows
   this).
 - The new type is returned if necessary.
 - Added unit test to check proper empty map serialization.

Author: 3Hren

rmp-serde/src/encode.rs

@@ -25,15 +25,25 @@ pub enum Error {
     /// Failed to write MessagePack'ed single-byte value into the write.
     InvalidFixedValueWrite(WriteError),
     InvalidValueWrite(ValueWriteError),
+
+    /// Failed to serialize struct, sequence or map, because its length is unknown.
+    UnknownLength,
 }
 
 impl ::std::error::Error for Error {
-    fn description(&self) -> &str { "an error occurred while writing encoded value" }
+    fn description(&self) -> &str {
+        match *self {
+            Error::InvalidFixedValueWrite(..) => "invalid fixed value write",
+            Error::InvalidValueWrite(..) => "invalid value write",
+            Error::UnknownLength => "attempt to serialize struct, sequence or map with unknown length",
+        }
+    }
 
     fn cause(&self) -> Option<&::std::error::Error> {
         match *self {
             Error::InvalidFixedValueWrite(ref err) => Some(err),
             Error::InvalidValueWrite(ref err) => Some(err),
+            Error::UnknownLength => None,
         }
     }
 }
@@ -229,7 +239,7 @@ impl<'a, W: VariantWriter> serde::Serializer for Serializer<'a, W> {
 
         let len = match visitor.len() {
             Some(len) => len,
-            None => panic!("do not know how to serialize a sequence with no length"),
+            None => return Err(Error::UnknownLength),
         };
 
         // ... and its arguments length.
@@ -266,7 +276,7 @@ impl<'a, W: VariantWriter> serde::Serializer for Serializer<'a, W> {
     {
         let len = match visitor.len() {
             Some(len) => len,
-            None => panic!("do not know how to serialize a sequence with no length"),
+            None => return Err(Error::UnknownLength),
         };
 
         try!(write_array_len(&mut self.wr, len as u32));
@@ -287,7 +297,7 @@ impl<'a, W: VariantWriter> serde::Serializer for Serializer<'a, W> {
     {
         let len = match visitor.len() {
             Some(len) => len,
-            None => panic!("do not know how to serialize a map with no length"),
+            None => return Err(Error::UnknownLength),
         };
 
         try!(write_map_len(&mut self.wr, len as u32));
@@ -316,7 +326,7 @@ impl<'a, W: VariantWriter> serde::Serializer for Serializer<'a, W> {
     {
         let len = match visitor.len() {
             Some(len) => len,
-            None => panic!("do not know how to serialize a sequence with no length"),
+            None => return Err(Error::UnknownLength),
         };
 
         try!(self.vw.write_struct_len(&mut self.wr, len as u32));

rmp-serde/tests/se.rs

@@ -251,6 +251,21 @@ fn pass_map() {
     assert_eq!(out, buf);
 }
 
+#[test]
+fn pass_empty_map() {
+    use std::collections::BTreeMap;
+
+    let mut buf = vec![];
+
+    let val: BTreeMap<u64, u64> = BTreeMap::new();
+    val.serialize(&mut Serializer::new(&mut buf)).ok().unwrap();
+
+    let out = vec![
+        0x80, // (size: 0)
+    ];
+    assert_eq!(out, buf);
+}
+
 #[test]
 fn pass_encoding_struct_into_vec() {
     let val = (42u8, "the Answer");