Apply workaround for rust-lang/rust#107837

Mingun · dralley · commit 03deb70238d6 · 2023-02-20T00:27:13.000-05:00
diff --git a/Changelog.md b/Changelog.md
@@ -23,13 +23,16 @@
   mappings (`xmlns:xxx`) that was broken since [#490]
 - [#510]: Fix an error of deserialization of `Option<T>` fields where `T` is some
   sequence type (for example, `Vec` or tuple)
+- [#540]: Fix a compilation error (probably a rustc bug) in some circumstances.
+  `Serializer::new` and `Serializer::with_root` now accepts only references to `Write`r.
 
 ### Misc Changes
 
 [externally tagged]: https://serde.rs/enum-representations.html#externally-tagged
 [#490]: https://github.com/tafia/quick-xml/pull/490
 [#510]: https://github.com/tafia/quick-xml/issues/510
 [#537]: https://github.com/tafia/quick-xml/issues/537
+[#540]: https://github.com/tafia/quick-xml/issues/540
 [#541]: https://github.com/tafia/quick-xml/pull/541
 [#556]: https://github.com/tafia/quick-xml/pull/556
 
diff --git a/src/se/content.rs b/src/se/content.rs
@@ -44,8 +44,8 @@ macro_rules! write_primitive {
 /// with indent, sequence of strings become one big string with additional content
 /// and it would be impossible to distinguish between content of the original
 /// strings and inserted indent characters.
-pub struct ContentSerializer<'i, W: Write> {
-    pub writer: W,
+pub struct ContentSerializer<'w, 'i, W: Write> {
+    pub writer: &'w mut W,
     /// Defines which XML characters need to be escaped in text content
     pub level: QuoteLevel,
     /// Current indentation level. Note, that `Indent::None` means that there is
@@ -59,10 +59,10 @@ pub struct ContentSerializer<'i, W: Write> {
     //TODO: add settings to disallow consequent serialization of primitives
 }
 
-impl<'i, W: Write> ContentSerializer<'i, W> {
+impl<'w, 'i, W: Write> ContentSerializer<'w, 'i, W> {
     /// Turns this serializer into serializer of a text content
     #[inline]
-    pub fn into_simple_type_serializer(self) -> SimpleTypeSerializer<'i, W> {
+    pub fn into_simple_type_serializer(self) -> SimpleTypeSerializer<'i, &'w mut W> {
         //TODO: Customization point: choose between CDATA and Text representation
         SimpleTypeSerializer {
             writer: self.writer,
@@ -79,9 +79,9 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
     /// Creates new serializer that shares state with this serializer and
     /// writes to the same underlying writer
     #[inline]
-    pub fn new_seq_element_serializer(&mut self) -> ContentSerializer<&mut W> {
+    pub fn new_seq_element_serializer(&mut self) -> ContentSerializer<W> {
         ContentSerializer {
-            writer: &mut self.writer,
+            writer: self.writer,
             level: self.level,
             indent: self.indent.borrow(),
             write_indent: self.write_indent,
@@ -101,14 +101,14 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
     /// Writes simple type content between `name` tags
     pub(super) fn write_wrapped<S>(mut self, name: XmlName, serialize: S) -> Result<(), DeError>
     where
-        S: FnOnce(SimpleTypeSerializer<'i, W>) -> Result<W, DeError>,
+        S: for<'a> FnOnce(SimpleTypeSerializer<'i, &'a mut W>) -> Result<&'a mut W, DeError>,
     {
         self.write_indent()?;
         self.writer.write_char('<')?;
         self.writer.write_str(name.0)?;
         self.writer.write_char('>')?;
 
-        let mut writer = serialize(self.into_simple_type_serializer())?;
+        let writer = serialize(self.into_simple_type_serializer())?;
 
         writer.write_str("</")?;
         writer.write_str(name.0)?;
@@ -125,17 +125,17 @@ impl<'i, W: Write> ContentSerializer<'i, W> {
     }
 }
 
-impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
+impl<'w, 'i, W: Write> Serializer for ContentSerializer<'w, 'i, W> {
     type Ok = ();
     type Error = DeError;
 
     type SerializeSeq = Self;
     type SerializeTuple = Self;
     type SerializeTupleStruct = Self;
-    type SerializeTupleVariant = ElementSerializer<'i, W>;
+    type SerializeTupleVariant = ElementSerializer<'w, 'i, W>;
     type SerializeMap = Impossible<Self::Ok, Self::Error>;
     type SerializeStruct = Impossible<Self::Ok, Self::Error>;
-    type SerializeStructVariant = Struct<'i, W>;
+    type SerializeStructVariant = Struct<'w, 'i, W>;
 
     write_primitive!(serialize_bool(bool));
 
@@ -297,7 +297,7 @@ impl<'i, W: Write> Serializer for ContentSerializer<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeSeq for ContentSerializer<'i, W> {
+impl<'w, 'i, W: Write> SerializeSeq for ContentSerializer<'w, 'i, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -317,7 +317,7 @@ impl<'i, W: Write> SerializeSeq for ContentSerializer<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeTuple for ContentSerializer<'i, W> {
+impl<'w, 'i, W: Write> SerializeTuple for ContentSerializer<'w, 'i, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -335,7 +335,7 @@ impl<'i, W: Write> SerializeTuple for ContentSerializer<'i, W> {
     }
 }
 
-impl<'i, W: Write> SerializeTupleStruct for ContentSerializer<'i, W> {
+impl<'w, 'i, W: Write> SerializeTupleStruct for ContentSerializer<'w, 'i, W> {
     type Ok = ();
     type Error = DeError;
 
diff --git a/src/se/element.rs b/src/se/element.rs
@@ -24,23 +24,23 @@ macro_rules! write_primitive {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// A serializer used to serialize element with specified name.
-pub struct ElementSerializer<'k, W: Write> {
-    pub ser: ContentSerializer<'k, W>,
+pub struct ElementSerializer<'w, 'k, W: Write> {
+    pub ser: ContentSerializer<'w, 'k, W>,
     /// Tag name used to wrap serialized types except enum variants which uses the variant name
     pub(super) key: XmlName<'k>,
 }
 
-impl<'k, W: Write> Serializer for ElementSerializer<'k, W> {
+impl<'w, 'k, W: Write> Serializer for ElementSerializer<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
     type SerializeSeq = Self;
     type SerializeTuple = Self;
     type SerializeTupleStruct = Self;
     type SerializeTupleVariant = Self;
-    type SerializeMap = Map<'k, W>;
-    type SerializeStruct = Struct<'k, W>;
-    type SerializeStructVariant = Struct<'k, W>;
+    type SerializeMap = Map<'w, 'k, W>;
+    type SerializeStruct = Struct<'w, 'k, W>;
+    type SerializeStructVariant = Struct<'w, 'k, W>;
 
     write_primitive!(serialize_bool(bool));
 
@@ -200,7 +200,7 @@ impl<'k, W: Write> Serializer for ElementSerializer<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeSeq for ElementSerializer<'k, W> {
+impl<'w, 'k, W: Write> SerializeSeq for ElementSerializer<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -223,7 +223,7 @@ impl<'k, W: Write> SerializeSeq for ElementSerializer<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeTuple for ElementSerializer<'k, W> {
+impl<'w, 'k, W: Write> SerializeTuple for ElementSerializer<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -241,7 +241,7 @@ impl<'k, W: Write> SerializeTuple for ElementSerializer<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeTupleStruct for ElementSerializer<'k, W> {
+impl<'w, 'k, W: Write> SerializeTupleStruct for ElementSerializer<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -259,7 +259,7 @@ impl<'k, W: Write> SerializeTupleStruct for ElementSerializer<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeTupleVariant for ElementSerializer<'k, W> {
+impl<'w, 'k, W: Write> SerializeTupleVariant for ElementSerializer<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -286,16 +286,16 @@ impl<'k, W: Write> SerializeTupleVariant for ElementSerializer<'k, W> {
 /// - attributes written directly to the higher serializer
 /// - elements buffered into internal buffer and at the end written into higher
 ///   serializer
-pub struct Struct<'k, W: Write> {
-    ser: ElementSerializer<'k, W>,
+pub struct Struct<'w, 'k, W: Write> {
+    ser: ElementSerializer<'w, 'k, W>,
     /// Buffer to store serialized elements
     // TODO: Customization point: allow direct writing of elements, but all
     // attributes should be listed first. Fail, if attribute encountered after
     // element. Use feature to configure
     children: String,
 }
 
-impl<'k, W: Write> Struct<'k, W> {
+impl<'w, 'k, W: Write> Struct<'w, 'k, W> {
     #[inline]
     fn write_field<T>(&mut self, key: &str, value: &T) -> Result<(), DeError>
     where
@@ -370,7 +370,7 @@ impl<'k, W: Write> Struct<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeStruct for Struct<'k, W> {
+impl<'w, 'k, W: Write> SerializeStruct for Struct<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -400,7 +400,7 @@ impl<'k, W: Write> SerializeStruct for Struct<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeStructVariant for Struct<'k, W> {
+impl<'w, 'k, W: Write> SerializeStructVariant for Struct<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
@@ -420,14 +420,14 @@ impl<'k, W: Write> SerializeStructVariant for Struct<'k, W> {
 
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
-pub struct Map<'k, W: Write> {
-    ser: Struct<'k, W>,
+pub struct Map<'w, 'k, W: Write> {
+    ser: Struct<'w, 'k, W>,
     /// Key, serialized by `QNameSerializer` if consumer uses `serialize_key` +
     /// `serialize_value` calls instead of `serialize_entry`
     key: Option<String>,
 }
 
-impl<'k, W: Write> Map<'k, W> {
+impl<'w, 'k, W: Write> Map<'w, 'k, W> {
     fn make_key<T>(&mut self, key: &T) -> Result<String, DeError>
     where
         T: ?Sized + Serialize,
@@ -438,7 +438,7 @@ impl<'k, W: Write> Map<'k, W> {
     }
 }
 
-impl<'k, W: Write> SerializeMap for Map<'k, W> {
+impl<'w, 'k, W: Write> SerializeMap for Map<'w, 'k, W> {
     type Ok = ();
     type Error = DeError;
 
diff --git a/src/se/mod.rs b/src/se/mod.rs
@@ -122,12 +122,12 @@ use std::str::from_utf8;
 ///     </Root>"
 /// );
 /// ```
-pub fn to_writer<W, T>(writer: W, value: &T) -> Result<(), DeError>
+pub fn to_writer<W, T>(mut writer: W, value: &T) -> Result<(), DeError>
 where
     W: Write,
     T: ?Sized + Serialize,
 {
-    value.serialize(Serializer::new(writer))
+    value.serialize(Serializer::new(&mut writer))
 }
 
 /// Serialize struct into a `String`.
@@ -208,12 +208,12 @@ 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<(), DeError>
+pub fn to_writer_with_root<W, T>(mut writer: W, root_tag: &str, value: &T) -> Result<(), DeError>
 where
     W: Write,
     T: ?Sized + Serialize,
 {
-    value.serialize(Serializer::with_root(writer, Some(root_tag))?)
+    value.serialize(Serializer::with_root(&mut writer, Some(root_tag))?)
 }
 
 /// Serialize struct into a `String` using specified root tag name.
@@ -439,19 +439,19 @@ impl<'i> Indent<'i> {
 ////////////////////////////////////////////////////////////////////////////////////////////////////
 
 /// A Serializer
-pub struct Serializer<'r, W: Write> {
-    ser: ContentSerializer<'r, W>,
+pub struct Serializer<'w, 'r, W: Write> {
+    ser: ContentSerializer<'w, 'r, W>,
     /// Name of the root tag. If not specified, deduced from the structure name
     root_tag: Option<XmlName<'r>>,
 }
 
-impl<'r, W: Write> Serializer<'r, W> {
+impl<'w, 'r, W: Write> Serializer<'w, 'r, W> {
     /// Creates a new `Serializer` that uses struct name as a root tag name.
     ///
     /// Note, that attempt to serialize a non-struct (including unit structs
     /// and newtype structs) will end up to an error. Use `with_root` to create
     /// serializer with explicitly defined root element name
-    pub fn new(writer: W) -> Self {
+    pub fn new(writer: &'w mut W) -> Self {
         Self {
             ser: ContentSerializer {
                 writer,
@@ -515,7 +515,7 @@ impl<'r, W: Write> Serializer<'r, W> {
     /// ```
     ///
     /// [XML name]: https://www.w3.org/TR/REC-xml/#NT-Name
-    pub fn with_root(writer: W, root_tag: Option<&'r str>) -> Result<Self, DeError> {
+    pub fn with_root(writer: &'w mut W, root_tag: Option<&'r str>) -> Result<Self, DeError> {
         Ok(Self {
             ser: ContentSerializer {
                 writer,
@@ -535,7 +535,7 @@ impl<'r, W: Write> Serializer<'r, W> {
 
     /// Creates actual serializer or returns an error if root tag is not defined.
     /// In that case `err` contains the name of type that cannot be serialized.
-    fn ser(self, err: &str) -> Result<ElementSerializer<'r, W>, DeError> {
+    fn ser(self, err: &str) -> Result<ElementSerializer<'w, 'r, W>, DeError> {
         if let Some(key) = self.root_tag {
             Ok(ElementSerializer { ser: self.ser, key })
         } else {
@@ -548,7 +548,7 @@ impl<'r, W: Write> Serializer<'r, W> {
     /// Creates actual serializer using root tag or a specified `key` if root tag
     /// is not defined. Returns an error if root tag is not defined and a `key`
     /// does not conform [XML rules](XmlName::try_from) for names.
-    fn ser_name(self, key: &'static str) -> Result<ElementSerializer<'r, W>, DeError> {
+    fn ser_name(self, key: &'static str) -> Result<ElementSerializer<'w, 'r, W>, DeError> {
         Ok(ElementSerializer {
             ser: self.ser,
             key: match self.root_tag {
@@ -559,19 +559,20 @@ impl<'r, W: Write> Serializer<'r, W> {
     }
 }
 
-impl<'r, W: Write> ser::Serializer for Serializer<'r, W> {
+impl<'w, 'r, W: Write> ser::Serializer for Serializer<'w, 'r, W> {
     type Ok = ();
     type Error = DeError;
 
-    type SerializeSeq = <ElementSerializer<'r, W> as ser::Serializer>::SerializeSeq;
-    type SerializeTuple = <ElementSerializer<'r, W> as ser::Serializer>::SerializeTuple;
-    type SerializeTupleStruct = <ElementSerializer<'r, W> as ser::Serializer>::SerializeTupleStruct;
+    type SerializeSeq = <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeSeq;
+    type SerializeTuple = <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeTuple;
+    type SerializeTupleStruct =
+        <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeTupleStruct;
     type SerializeTupleVariant =
-        <ElementSerializer<'r, W> as ser::Serializer>::SerializeTupleVariant;
-    type SerializeMap = <ElementSerializer<'r, W> as ser::Serializer>::SerializeMap;
-    type SerializeStruct = <ElementSerializer<'r, W> as ser::Serializer>::SerializeStruct;
+        <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeTupleVariant;
+    type SerializeMap = <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeMap;
+    type SerializeStruct = <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeStruct;
     type SerializeStructVariant =
-        <ElementSerializer<'r, W> as ser::Serializer>::SerializeStructVariant;
+        <ElementSerializer<'w, 'r, W> as ser::Serializer>::SerializeStructVariant;
 
     forward!(serialize_bool(bool));
 
