Improve serialization of xs:lists with empty elements

Changelog.md

@@ -39,6 +39,7 @@ MSRV bumped to 1.56! Crate now uses Rust 2021 edition.
 - [#619]: Allow to raise application errors in `ElementWriter::write_inner_content`
   (and newly added `ElementWriter::write_inner_content_async` of course).
 - [#662]: Get rid of some allocations during serde deserialization.
+- [#665]: Improve serialization of `xs:list`s when some elements serialized to an empty string.
 
 [#545]: https://github.com/tafia/quick-xml/pull/545
 [#567]: https://github.com/tafia/quick-xml/issues/567
@@ -51,6 +52,7 @@ MSRV bumped to 1.56! Crate now uses Rust 2021 edition.
 [#660]: https://github.com/tafia/quick-xml/pull/660
 [#661]: https://github.com/tafia/quick-xml/pull/661
 [#662]: https://github.com/tafia/quick-xml/pull/662
+[#665]: https://github.com/tafia/quick-xml/pull/665
 
 
 ## 0.30.0 -- 2023-07-23

src/de/key.rs

@@ -315,6 +315,9 @@ mod tests {
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct Newtype(String);
 
+    #[derive(Debug, Deserialize, Serialize, PartialEq)]
+    struct Tuple((), ());
+
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct Struct {
         key: String,
@@ -459,8 +462,8 @@ mod tests {
         => Custom("invalid type: string \"name\", expected a sequence"));
     err!(tuple: ((), ()) = "name"
         => Custom("invalid type: string \"name\", expected a tuple of size 2"));
-    err!(tuple_struct: ((), ()) = "name"
-        => Custom("invalid type: string \"name\", expected a tuple of size 2"));
+    err!(tuple_struct: Tuple = "name"
+        => Custom("invalid type: string \"name\", expected tuple struct Tuple"));
 
     err!(map: HashMap<(), ()> = "name"
         => Custom("invalid type: string \"name\", expected a map"));

src/de/simple_type.rs

@@ -881,6 +881,9 @@ mod tests {
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct Newtype(String);
 
+    #[derive(Debug, Deserialize, Serialize, PartialEq)]
+    struct Tuple((), ());
+
     #[derive(Debug, Deserialize, Serialize, PartialEq)]
     struct BorrowedNewtype<'a>(&'a str);
 
@@ -950,15 +953,17 @@ mod tests {
                     assert_eq!(data, $result);
 
                     // Roundtrip to ensure that serializer corresponds to deserializer
-                    assert_eq!(
-                        data.serialize(AtomicSerializer {
-                            writer: String::new(),
+                    let mut buffer = String::new();
+                    let has_written = data
+                        .serialize(AtomicSerializer {
+                            writer: &mut buffer,
                             target: QuoteTarget::Text,
                             level: QuoteLevel::Full,
+                            indent: Some(Indent::None),
                         })
-                        .unwrap(),
-                        $input
-                    );
+                        .unwrap();
+                    assert_eq!(buffer, $input);
+                    assert_eq!(has_written, !buffer.is_empty());
                 }
             };
         }
@@ -1040,7 +1045,7 @@ mod tests {
                 => Unsupported("sequences are not supported as `xs:list` items"));
         err!(tuple: ((), ()) = "non-escaped string"
                 => Unsupported("tuples are not supported as `xs:list` items"));
-        err!(tuple_struct: ((), ()) = "non-escaped string"
+        err!(tuple_struct: Tuple = "non-escaped string"
                 => Unsupported("tuples are not supported as `xs:list` items"));
 
         err!(map: HashMap<(), ()> = "non-escaped string"

src/se/content.rs

@@ -338,12 +338,12 @@ impl<'w, 'i, W: Write> SerializeTuple for ContentSerializer<'w, 'i, W> {
     where
         T: ?Sized + Serialize,
     {
-        <Self as SerializeSeq>::serialize_element(self, value)
+        SerializeSeq::serialize_element(self, value)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        <Self as SerializeSeq>::end(self)
+        SerializeSeq::end(self)
     }
 }
 
@@ -356,12 +356,12 @@ impl<'w, 'i, W: Write> SerializeTupleStruct for ContentSerializer<'w, 'i, W> {
     where
         T: ?Sized + Serialize,
     {
-        <Self as SerializeSeq>::serialize_element(self, value)
+        SerializeSeq::serialize_element(self, value)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        <Self as SerializeSeq>::end(self)
+        SerializeSeq::end(self)
     }
 }
 

src/se/element.rs

@@ -265,12 +265,12 @@ impl<'w, 'k, W: Write> SerializeTuple for ElementSerializer<'w, 'k, W> {
     where
         T: ?Sized + Serialize,
     {
-        <Self as SerializeSeq>::serialize_element(self, value)
+        SerializeSeq::serialize_element(self, value)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        <Self as SerializeSeq>::end(self)
+        SerializeSeq::end(self)
     }
 }
 
@@ -283,12 +283,12 @@ impl<'w, 'k, W: Write> SerializeTupleStruct for ElementSerializer<'w, 'k, W> {
     where
         T: ?Sized + Serialize,
     {
-        <Self as SerializeSeq>::serialize_element(self, value)
+        SerializeSeq::serialize_element(self, value)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        <Self as SerializeSeq>::end(self)
+        SerializeSeq::end(self)
     }
 }
 
@@ -314,16 +314,16 @@ impl<'w, 'k, W: Write> SerializeTupleVariant for Tuple<'w, 'k, W> {
         T: ?Sized + Serialize,
     {
         match self {
-            Tuple::Element(ser) => SerializeTuple::serialize_element(ser, value),
-            Tuple::Text(ser) => SerializeTuple::serialize_element(ser, value),
+            Self::Element(ser) => SerializeTuple::serialize_element(ser, value),
+            Self::Text(ser) => SerializeTuple::serialize_element(ser, value),
         }
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
         match self {
-            Tuple::Element(ser) => SerializeTuple::end(ser),
-            Tuple::Text(ser) => SerializeTuple::end(ser).map(|_| ()),
+            Self::Element(ser) => SerializeTuple::end(ser),
+            Self::Text(ser) => SerializeTuple::end(ser).map(|_| ()),
         }
     }
 }
@@ -461,12 +461,12 @@ impl<'w, 'k, W: Write> SerializeStructVariant for Struct<'w, 'k, W> {
     where
         T: ?Sized + Serialize,
     {
-        <Self as SerializeStruct>::serialize_field(self, key, value)
+        SerializeStruct::serialize_field(self, key, value)
     }
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        <Self as SerializeStruct>::end(self)
+        SerializeStruct::end(self)
     }
 }
 

src/se/mod.rs

@@ -390,8 +390,12 @@ impl<'n> XmlName<'n> {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 pub(crate) enum Indent<'i> {
+    /// No indent should be written before the element
     None,
+    /// The specified indent should be written. The type owns the buffer with indent
     Owned(Indentation),
+    /// The specified indent should be written. The type borrows buffer with indent
+    /// from its owner
     Borrow(&'i mut Indentation),
 }