From 4dd54a17c4a1b70d2cbf9891c2122994fcec71af Mon Sep 17 00:00:00 2001
From: Cyril Plisko <cyril.plisko@mountall.com>
Date: Tue, 4 Mar 2025 20:04:08 +0200
Subject: clippy::multiple_bound_locations (#103)

* clippy::multiple_bound_locations

* A few more clippy fixes.

---------

Co-authored-by: Sam Scott <sam@osohq.com>
---
 src/ser.rs | 52 ++++++++++++++++++++++++++--------------------------
 1 file changed, 26 insertions(+), 26 deletions(-)

(limited to 'src/ser.rs')

diff --git a/src/ser.rs b/src/ser.rs
index 5198d71..5c21d92 100644
--- a/src/ser.rs
+++ b/src/ser.rs
@@ -458,12 +458,12 @@ pub struct QsSeq<'a, W: 'a + Write>(QsSerializer<'a, W>, usize);
 #[doc(hidden)]
 pub struct QsMap<'a, W: 'a + Write>(QsSerializer<'a, W>, Option<Cow<'a, str>>);
 
-impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTuple for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let key = self.1.to_string();
         self.1 += 1;
@@ -477,12 +477,12 @@ impl<'a, W: Write> ser::SerializeTuple for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeSeq for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -494,12 +494,12 @@ impl<'a, W: Write> ser::SerializeSeq for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeStruct for QsSerializer<'a, W> {
+impl<W: Write> ser::SerializeStruct for QsSerializer<'_, W> {
     type Ok = ();
     type Error = Error;
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -510,13 +510,13 @@ impl<'a, W: Write> ser::SerializeStruct for QsSerializer<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeStructVariant for QsSerializer<'a, W> {
+impl<W: Write> ser::SerializeStructVariant for QsSerializer<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, key: &'static str, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(self);
         serializer.extend_key(key);
@@ -528,13 +528,13 @@ impl<'a, W: Write> ser::SerializeStructVariant for QsSerializer<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTupleVariant for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -547,13 +547,13 @@ impl<'a, W: Write> ser::SerializeTupleVariant for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> {
+impl<W: Write> ser::SerializeTupleStruct for QsSeq<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&self.1.to_string());
@@ -566,21 +566,21 @@ impl<'a, W: Write> ser::SerializeTupleStruct for QsSeq<'a, W> {
     }
 }
 
-impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
+impl<W: Write> ser::SerializeMap for QsMap<'_, W> {
     type Ok = ();
     type Error = Error;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<()>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         self.1 = Some(Cow::from(key.serialize(StringSerializer)?));
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<()>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<()>
     where
-        T: ser::Serialize,
+        T: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         if let Some(ref key) = self.1 {
@@ -596,10 +596,10 @@ impl<'a, W: Write> ser::SerializeMap for QsMap<'a, W> {
         Ok(())
     }
 
-    fn serialize_entry<K: ?Sized, V: ?Sized>(&mut self, key: &K, value: &V) -> Result<()>
+    fn serialize_entry<K, V>(&mut self, key: &K, value: &V) -> Result<()>
     where
-        K: ser::Serialize,
-        V: ser::Serialize,
+        K: ser::Serialize + ?Sized,
+        V: ser::Serialize + ?Sized,
     {
         let mut serializer = QsSerializer::new_from_ref(&mut self.0);
         serializer.extend_key(&key.serialize(StringSerializer)?);
-- 
cgit v1.2.3