(avro) 01/01: NO-JIRA: Fix clippy errors from Rust 1.78

[mgrigorov]

This is an automated email from the ASF dual-hosted git repository.

mgrigorov pushed a commit to branch fix-build-rust-1.78.0
in repository https://gitbox.apache.org/repos/asf/avro.git

commit 47d9ed1fb1035745e673964d6618fceee3ca0b25
Author: Martin Tzvetanov Grigorov <mgrigo...@apache.org>
AuthorDate: Tue May 7 16:34:32 2024 +0300

    NO-JIRA: Fix clippy errors from Rust 1.78
    
    Signed-off-by: Martin Tzvetanov Grigorov <mgrigo...@apache.org>
---
 lang/rust/avro/src/schema.rs |  2 +-
 lang/rust/avro/src/ser.rs    | 56 +++++++++++++++++++-------------------------
 2 files changed, 25 insertions(+), 33 deletions(-)

diff --git a/lang/rust/avro/src/schema.rs b/lang/rust/avro/src/schema.rs
index 7cff0f417..e7f6d5e4b 100644
--- a/lang/rust/avro/src/schema.rs
+++ b/lang/rust/avro/src/schema.rs
@@ -1271,7 +1271,7 @@ impl Parser {
         let name = Name::new(name)?;
         let fully_qualified_name = 
name.fully_qualified_name(enclosing_namespace);
 
-        if self.parsed_schemas.get(&fully_qualified_name).is_some() {
+        if self.parsed_schemas.contains_key(&fully_qualified_name) {
             return Ok(Schema::Ref {
                 name: fully_qualified_name,
             });
diff --git a/lang/rust/avro/src/ser.rs b/lang/rust/avro/src/ser.rs
index ce779b946..9f05836ab 100644
--- a/lang/rust/avro/src/ser.rs
+++ b/lang/rust/avro/src/ser.rs
@@ -181,9 +181,9 @@ impl<'b> ser::Serializer for &'b mut Serializer {
         Ok(Value::from(None::<Self::Ok>))
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         let v = value.serialize(&mut Serializer::default())?;
         Ok(Value::from(Some(v)))
@@ -206,18 +206,18 @@ impl<'b> ser::Serializer for &'b mut Serializer {
         Ok(Value::String(variant.to_string()))
     }
 
-    fn serialize_newtype_struct<T: ?Sized>(
+    fn serialize_newtype_struct<T>(
         self,
         _: &'static str,
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         value.serialize(self)
     }
 
-    fn serialize_newtype_variant<T: ?Sized>(
+    fn serialize_newtype_variant<T>(
         self,
         _: &'static str,
         index: u32,
@@ -225,7 +225,7 @@ impl<'b> ser::Serializer for &'b mut Serializer {
         value: &T,
     ) -> Result<Self::Ok, Self::Error>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         Ok(Value::Record(vec![
             ("type".to_owned(), Value::Enum(index, variant.to_owned())),
@@ -293,9 +293,9 @@ impl ser::SerializeSeq for SeqSerializer {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         self.items
             .push(value.serialize(&mut Serializer::default())?);
@@ -311,9 +311,9 @@ impl ser::SerializeTuple for SeqSerializer {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -327,9 +327,9 @@ impl ser::SerializeTupleStruct for SeqSerializer {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -343,9 +343,9 @@ impl<'a> ser::SerializeSeq for SeqVariantSerializer<'a> {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         self.items.push(Value::Union(
             self.index,
@@ -369,9 +369,9 @@ impl<'a> ser::SerializeTupleVariant for 
SeqVariantSerializer<'a> {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         ser::SerializeSeq::serialize_element(self, value)
     }
@@ -385,9 +385,9 @@ impl ser::SerializeMap for MapSerializer {
     type Ok = Value;
     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: Serialize,
+        T: Serialize + ?Sized,
     {
         let key = key.serialize(&mut Serializer::default())?;
 
@@ -399,9 +399,9 @@ impl ser::SerializeMap for MapSerializer {
         }
     }
 
-    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: Serialize,
+        T: Serialize + ?Sized,
     {
         self.values
             .push(value.serialize(&mut Serializer::default())?);
@@ -424,13 +424,9 @@ impl ser::SerializeStruct for StructSerializer {
     type Ok = Value;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        name: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> 
Result<(), Self::Error>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         self.fields.push((
             name.to_owned(),
@@ -448,13 +444,9 @@ impl<'a> ser::SerializeStructVariant for 
StructVariantSerializer<'a> {
     type Ok = Value;
     type Error = Error;
 
-    fn serialize_field<T: ?Sized>(
-        &mut self,
-        name: &'static str,
-        value: &T,
-    ) -> Result<(), Self::Error>
+    fn serialize_field<T>(&mut self, name: &'static str, value: &T) -> 
Result<(), Self::Error>
     where
-        T: Serialize,
+        T: Serialize + ?Sized,
     {
         self.fields.push((
             name.to_owned(),