Do not return writer from serializer methods

Mingun · dralley · commit 7c3ea8af4f34 · 2023-02-20T00:27:13.000-05:00
diff --git a/src/se/content.rs b/src/se/content.rs
@@ -14,7 +14,8 @@ macro_rules! write_primitive {
     ($method:ident ( $ty:ty )) => {
         #[inline]
         fn $method(self, value: $ty) -> Result<Self::Ok, Self::Error> {
-            self.into_simple_type_serializer().$method(value)
+            self.into_simple_type_serializer().$method(value)?;
+            Ok(())
         }
     };
 }
@@ -89,16 +90,16 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
 
     /// Writes `name` as self-closed tag
     #[inline]
-    pub(super) fn write_empty(mut self, name: XmlName) -> Result<W, DeError> {
+    pub(super) fn write_empty(mut self, name: XmlName) -> Result<(), DeError> {
         self.write_indent()?;
         self.writer.write_char('<')?;
         self.writer.write_str(name.0)?;
         self.writer.write_str("/>")?;
-        Ok(self.writer)
+        Ok(())
     }
 
     /// Writes simple type content between `name` tags
-    pub(super) fn write_wrapped<S>(mut self, name: XmlName, serialize: S) -> Result<W, DeError>
+    pub(super) fn write_wrapped<S>(mut self, name: XmlName, serialize: S) -> Result<(), DeError>
     where
         S: FnOnce(SimpleTypeSerializer<'i, W>) -> Result<W, DeError>,
     {
@@ -112,7 +113,7 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
         writer.write_str("</")?;
         writer.write_str(name.0)?;
         writer.write_char('>')?;
-        Ok(writer)
+        Ok(())
     }
 
     pub(super) fn write_indent(&mut self) -> Result<(), DeError> {
@@ -125,7 +126,7 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
 }
 
 impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     type SerializeSeq = Self;
@@ -161,17 +162,16 @@ impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
 
     #[inline]
     fn serialize_str(self, value: &str) -> Result<Self::Ok, Self::Error> {
-        if value.is_empty() {
-            Ok(self.writer)
-        } else {
-            self.into_simple_type_serializer().serialize_str(value)
+        if !value.is_empty() {
+            self.into_simple_type_serializer().serialize_str(value)?;
         }
+        Ok(())
     }
 
     /// Does not write anything
     #[inline]
     fn serialize_none(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.writer)
+        Ok(())
     }
 
     fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, Self::Error> {
@@ -181,13 +181,13 @@ impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
     /// Does not write anything
     #[inline]
     fn serialize_unit(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.writer)
+        Ok(())
     }
 
     /// Does not write anything
     #[inline]
     fn serialize_unit_struct(self, _name: &'static str) -> Result<Self::Ok, Self::Error> {
-        Ok(self.writer)
+        Ok(())
     }
 
     /// Checks `variant` for XML name validity and writes `<${variant}/>`
@@ -298,7 +298,7 @@ impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
 }
 
 impl<'i, W: Write> SerializeSeq for ContentSerializer<'i, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
@@ -313,12 +313,12 @@ impl<'i, W: Write> SerializeSeq for ContentSerializer<'i, W> {
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.writer)
+        Ok(())
     }
 }
 
 impl<'i, W: Write> SerializeTuple for ContentSerializer<'i, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
@@ -336,7 +336,7 @@ impl<'i, W: Write> SerializeTuple for ContentSerializer<'i, W> {
 }
 
 impl<'i, W: Write> SerializeTupleStruct for ContentSerializer<'i, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
diff --git a/src/se/element.rs b/src/se/element.rs
@@ -31,7 +31,7 @@ pub struct ElementSerializer<'k, W: Write> {
 }
 
 impl<'k, W: Write> Serializer for ElementSerializer<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     type SerializeSeq = Self;
@@ -201,7 +201,7 @@ impl<'k, W: Write> Serializer for ElementSerializer<'k, W> {
 }
 
 impl<'k, W: Write> SerializeSeq for ElementSerializer<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
@@ -219,12 +219,12 @@ impl<'k, W: Write> SerializeSeq for ElementSerializer<'k, W> {
 
     #[inline]
     fn end(self) -> Result<Self::Ok, Self::Error> {
-        Ok(self.ser.writer)
+        Ok(())
     }
 }
 
 impl<'k, W: Write> SerializeTuple for ElementSerializer<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
@@ -242,7 +242,7 @@ impl<'k, W: Write> SerializeTuple for ElementSerializer<'k, W> {
 }
 
 impl<'k, W: Write> SerializeTupleStruct for ElementSerializer<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
@@ -260,7 +260,7 @@ impl<'k, W: Write> SerializeTupleStruct for ElementSerializer<'k, W> {
 }
 
 impl<'k, W: Write> SerializeTupleVariant for ElementSerializer<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
@@ -371,7 +371,7 @@ impl<'k, W: Write> Struct<'k, W> {
 }
 
 impl<'k, W: Write> SerializeStruct for Struct<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
@@ -396,12 +396,12 @@ impl<'k, W: Write> SerializeStruct for Struct<'k, W> {
             self.ser.ser.writer.write_str(self.ser.key.0)?;
             self.ser.ser.writer.write_char('>')?;
         }
-        Ok(self.ser.ser.writer)
+        Ok(())
     }
 }
 
 impl<'k, W: Write> SerializeStructVariant for Struct<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     #[inline]
@@ -439,7 +439,7 @@ impl<'k, W: Write> Map<'k, W> {
 }
 
 impl<'k, W: Write> SerializeMap for Map<'k, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
diff --git a/src/se/mod.rs b/src/se/mod.rs
@@ -122,7 +122,7 @@ use std::str::from_utf8;
 ///     </Root>"
 /// );
 /// ```
-pub fn to_writer<W, T>(writer: W, value: &T) -> Result<W, DeError>
+pub fn to_writer<W, T>(writer: W, value: &T) -> Result<(), DeError>
 where
     W: Write,
     T: ?Sized + Serialize,
@@ -208,7 +208,7 @@ where
 /// ```
 ///
 /// [XML name]: https://www.w3.org/TR/REC-xml/#NT-Name
-pub fn to_writer_with_root<W, T>(writer: W, root_tag: &str, value: &T) -> Result<W, DeError>
+pub fn to_writer_with_root<W, T>(writer: W, root_tag: &str, value: &T) -> Result<(), DeError>
 where
     W: Write,
     T: ?Sized + Serialize,
@@ -560,7 +560,7 @@ impl<'r, W: Write> Serializer<'r, W> {
 }
 
 impl<'r, W: Write> ser::Serializer for Serializer<'r, W> {
-    type Ok = W;
+    type Ok = ();
     type Error = DeError;
 
     type SerializeSeq = <ElementSerializer<'r, W> as ser::Serializer>::SerializeSeq;
@@ -598,7 +598,7 @@ impl<'r, W: Write> ser::Serializer for Serializer<'r, W> {
     forward!(serialize_bytes(&[u8]));
 
     fn serialize_none(self) -> Result<Self::Ok, DeError> {
-        Ok(self.ser.writer)
+        Ok(())
     }
 
     fn serialize_some<T: ?Sized + Serialize>(self, value: &T) -> Result<Self::Ok, DeError> {
