From 5547e77bcd782dbf22461fd7938c5b24f300525e Mon Sep 17 00:00:00 2001
From: Graham Esau <gesau@hotmail.co.uk>
Date: Sat, 24 Aug 2024 11:35:28 +0100
Subject: [PATCH] Resolve clippy lint `multiple_bound_locations`

---
 schemars/src/ser.rs | 56 +++++++++++++++++++--------------------------
 1 file changed, 24 insertions(+), 32 deletions(-)

diff --git a/schemars/src/ser.rs b/schemars/src/ser.rs
index 4b4117f..079c566 100644
--- a/schemars/src/ser.rs
+++ b/schemars/src/ser.rs
@@ -74,9 +74,9 @@ impl<'a> serde::Serializer for Serializer<'a> {
     forward_to_subschema_for!(serialize_str, &str);
     forward_to_subschema_for!(serialize_bytes, &[u8]);
 
-    fn collect_str<T: ?Sized>(self, _value: &T) -> Result<Self::Ok, Self::Error>
+    fn collect_str<T>(self, _value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: Display,
+        T: Display + ?Sized,
     {
         Ok(self.generator.subschema_for::<&str>())
     }
@@ -120,9 +120,9 @@ impl<'a> serde::Serializer for Serializer<'a> {
         self.serialize_none()
     }
 
-    fn serialize_some<T: ?Sized>(self, value: &T) -> Result<Self::Ok, Self::Error>
+    fn serialize_some<T>(self, value: &T) -> Result<Self::Ok, Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         let mut schema = value.serialize(Serializer {
             generator: self.generator,
@@ -185,13 +185,13 @@ impl<'a> serde::Serializer for Serializer<'a> {
         Ok(true.into())
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         name: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         let include_title = self.include_title;
         let mut schema = value.serialize(self)?;
@@ -203,7 +203,7 @@ impl<'a> serde::Serializer for Serializer<'a> {
         Ok(schema)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _name: &'static str,
         _variant_index: u32,
@@ -211,7 +211,7 @@ impl<'a> serde::Serializer for Serializer<'a> {
         _value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         Ok(true.into())
     }
@@ -292,9 +292,9 @@ impl serde::ser::SerializeTupleVariant for Serializer<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, _value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, _value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         Ok(())
     }
@@ -308,13 +308,9 @@ impl serde::ser::SerializeStructVariant for Serializer<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        _key: &'static str,
-        _value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, _key: &'static str, _value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         Ok(())
     }
@@ -328,9 +324,9 @@ impl serde::ser::SerializeSeq for SerializeSeq<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         if self.items != Some(true.into()) {
             let schema = value.serialize(Serializer {
@@ -364,9 +360,9 @@ impl serde::ser::SerializeTuple for SerializeTuple<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         let schema = value.serialize(Serializer {
             generator: self.generator,
@@ -399,9 +395,9 @@ impl serde::ser::SerializeTupleStruct for SerializeTuple<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         serde::ser::SerializeTuple::serialize_element(self, value)
     }
@@ -415,9 +411,9 @@ impl serde::ser::SerializeMap for SerializeMap<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_key<T: ?Sized>(&mut self, key: &T) -> Result<(), Self::Error>
+    fn serialize_key<T>(&mut self, key: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         // FIXME this is too lenient - we should return an error if serde_json
         // doesn't allow T to be a key of a map.
@@ -431,9 +427,9 @@ impl serde::ser::SerializeMap for SerializeMap<'_> {
         Ok(())
     }
 
-    fn serialize_value<T: ?Sized>(&mut self, value: &T) -> Result<(), Self::Error>
+    fn serialize_value<T>(&mut self, value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         let key = self.current_key.take().unwrap_or_default();
         let schema = value.serialize(Serializer {
@@ -465,13 +461,9 @@ impl serde::ser::SerializeStruct for SerializeMap<'_> {
     type Ok = Schema;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        key: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, key: &'static str, value: &T) -> Result<(), Self::Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         let prop_schema = value.serialize(Serializer {
             generator: self.generator,