clippy: bump clippy to 1.81

iqlusioninc · Jan 23, 2025 · 8d07216 · 8d07216
1 parent 9bf1737
commit 8d07216
Show file tree

Hide file tree

Showing 13 changed files with 43 additions and 43 deletions.
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
@@ -63,7 +63,7 @@ jobs:
       - uses: actions/checkout@v1
       - uses: dtolnay/rust-toolchain@master
         with:
-          toolchain: 1.71.0 # pinned to prevent CI breakages
+          toolchain: 1.81.0 # pinned to prevent CI breakages
           components: clippy
       - uses: actions-rs/cargo@v1
         with:

diff --git a/src/audit.rs b/src/audit.rs
@@ -73,7 +73,7 @@ impl<'de> Deserialize<'de> for AuditOption {
     fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<AuditOption, D::Error> {
         struct AuditOptionVisitor;
 
-        impl<'de> de::Visitor<'de> for AuditOptionVisitor {
+        impl de::Visitor<'_> for AuditOptionVisitor {
             type Value = AuditOption;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
@@ -130,7 +130,7 @@ impl<'de> Deserialize<'de> for AuditTag {
     fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<AuditTag, D::Error> {
         struct AuditTagVisitor;
 
-        impl<'de> de::Visitor<'de> for AuditTagVisitor {
+        impl de::Visitor<'_> for AuditTagVisitor {
             type Value = AuditTag;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

diff --git a/src/capability.rs b/src/capability.rs
@@ -347,7 +347,7 @@ impl<'de> Deserialize<'de> for Capability {
     {
         struct CapabilityVisitor;
 
-        impl<'de> Visitor<'de> for CapabilityVisitor {
+        impl Visitor<'_> for CapabilityVisitor {
             type Value = Capability;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

diff --git a/src/command.rs b/src/command.rs
@@ -30,7 +30,7 @@ pub(crate) trait Command: Serialize + DeserializeOwned + Sized {
     const COMMAND_CODE: Code = Self::ResponseType::COMMAND_CODE;
 }
 
-impl<'c, C: Command> From<&'c C> for Message {
+impl<C: Command> From<&C> for Message {
     fn from(command: &C) -> Message {
         Self::create(C::COMMAND_CODE, serialize(command).unwrap()).unwrap()
     }

diff --git a/src/connector/http/client/path.rs b/src/connector/http/client/path.rs
@@ -32,7 +32,7 @@ impl Display for PathBuf {
     }
 }
 
-impl<'a> From<&'a str> for PathBuf {
+impl From<&str> for PathBuf {
     fn from(path: &str) -> Self {
         Self::from_str(path).unwrap()
     }

diff --git a/src/domain.rs b/src/domain.rs
@@ -88,7 +88,7 @@ impl<'de> Deserialize<'de> for Domain {
     {
         struct DomainVisitor;
 
-        impl<'de> de::Visitor<'de> for DomainVisitor {
+        impl de::Visitor<'_> for DomainVisitor {
             type Value = Domain;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

diff --git a/src/object/origins.rs b/src/object/origins.rs
@@ -54,7 +54,7 @@ impl<'de> Deserialize<'de> for Origin {
     {
         struct OriginVisitor;
 
-        impl<'de> de::Visitor<'de> for OriginVisitor {
+        impl de::Visitor<'_> for OriginVisitor {
             type Value = Origin;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

diff --git a/src/object/types.rs b/src/object/types.rs
@@ -91,7 +91,7 @@ impl<'de> Deserialize<'de> for Type {
     fn deserialize<D: de::Deserializer<'de>>(deserializer: D) -> Result<Type, D::Error> {
         struct TypeVisitor;
 
-        impl<'de> de::Visitor<'de> for TypeVisitor {
+        impl de::Visitor<'_> for TypeVisitor {
             type Value = Type;
 
             fn expecting(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {

diff --git a/src/serialization/de.rs b/src/serialization/de.rs
@@ -15,7 +15,7 @@ impl<R: Read> Deserializer<R> {
     }
 }
 
-impl<'de, 'a, R: Read> serde::Deserializer<'de> for &'a mut Deserializer<R> {
+impl<'de, R: Read> serde::Deserializer<'de> for &mut Deserializer<R> {
     type Error = Error;
 
     #[inline]
@@ -184,7 +184,7 @@ impl<'de, 'a, R: Read> serde::Deserializer<'de> for &'a mut Deserializer<R> {
             len: usize,
         }
 
-        impl<'de, 'a, 'b: 'a, R: Read> SeqAccess<'de> for Access<'a, R> {
+        impl<'de, R: Read> SeqAccess<'de> for Access<'_, R> {
             type Error = Error;
 
             fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
@@ -227,7 +227,7 @@ impl<'de, 'a, R: Read> serde::Deserializer<'de> for &'a mut Deserializer<R> {
             deserializer: &'a mut Deserializer<R>,
         }
 
-        impl<'de, 'a, 'b: 'a, R: Read> SeqAccess<'de> for Access<'a, R> {
+        impl<'de, R: Read> SeqAccess<'de> for Access<'_, R> {
             type Error = Error;
 
             fn next_element_seed<T>(&mut self, seed: T) -> Result<Option<T::Value>, Error>
@@ -309,7 +309,7 @@ impl<'de, 'a, R: Read> serde::Deserializer<'de> for &'a mut Deserializer<R> {
     }
 }
 
-impl<'de, 'a, R: Read> serde::de::VariantAccess<'de> for &'a mut Deserializer<R> {
+impl<'de, R: Read> serde::de::VariantAccess<'de> for &mut Deserializer<R> {
     type Error = Error;
 
     fn unit_variant(self) -> Result<(), Error> {

diff --git a/src/serialization/ser.rs b/src/serialization/ser.rs
@@ -5,7 +5,7 @@ use serde::ser::{
     SerializeMap, SerializeSeq, SerializeStruct, SerializeStructVariant, SerializeTuple,
     SerializeTupleStruct, SerializeTupleVariant,
 };
-use std::{io::Write, u32};
+use std::io::Write;
 
 /// Serializer for `YubiHSM` messages
 pub(crate) struct Serializer<W> {
@@ -97,9 +97,9 @@ impl<'a, W: Write> serde::Serializer for &'a mut Serializer<W> {
         unimplemented!();
     }
 
-    fn serialize_some<T: ?Sized>(self, _v: &T) -> Result<(), Error>
+    fn serialize_some<T>(self, _v: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         unimplemented!();
     }
@@ -190,14 +190,14 @@ pub(crate) struct SerializeHelper<'a, W> {
     ser: &'a mut Serializer<W>,
 }
 
-impl<'a, W: Write> SerializeSeq for SerializeHelper<'a, W> {
+impl<W: Write> SerializeSeq for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -208,14 +208,14 @@ impl<'a, W: Write> SerializeSeq for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeTuple for SerializeHelper<'a, W> {
+impl<W: Write> SerializeTuple for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_element<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_element<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -226,14 +226,14 @@ impl<'a, W: Write> SerializeTuple for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeTupleStruct for SerializeHelper<'a, W> {
+impl<W: Write> SerializeTupleStruct for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -244,14 +244,14 @@ impl<'a, W: Write> SerializeTupleStruct for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeTupleVariant for SerializeHelper<'a, W> {
+impl<W: Write> SerializeTupleVariant for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -262,22 +262,22 @@ impl<'a, W: Write> SerializeTupleVariant for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeMap for SerializeHelper<'a, W> {
+impl<W: Write> SerializeMap for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_key<K: ?Sized>(&mut self, value: &K) -> Result<(), Error>
+    fn serialize_key<K>(&mut self, value: &K) -> Result<(), Error>
     where
-        K: serde::Serialize,
+        K: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
 
     #[inline]
-    fn serialize_value<V: ?Sized>(&mut self, value: &V) -> Result<(), Error>
+    fn serialize_value<V>(&mut self, value: &V) -> Result<(), Error>
     where
-        V: serde::Serialize,
+        V: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -288,14 +288,14 @@ impl<'a, W: Write> SerializeMap for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeStruct for SerializeHelper<'a, W> {
+impl<W: Write> SerializeStruct for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }
@@ -306,14 +306,14 @@ impl<'a, W: Write> SerializeStruct for SerializeHelper<'a, W> {
     }
 }
 
-impl<'a, W: Write> SerializeStructVariant for SerializeHelper<'a, W> {
+impl<W: Write> SerializeStructVariant for SerializeHelper<'_, W> {
     type Ok = ();
     type Error = Error;
 
     #[inline]
-    fn serialize_field<T: ?Sized>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>
+    fn serialize_field<T>(&mut self, _key: &'static str, value: &T) -> Result<(), Error>
     where
-        T: serde::Serialize,
+        T: serde::Serialize + ?Sized,
     {
         value.serialize(&mut *self.ser)
     }

diff --git a/src/session/guard.rs b/src/session/guard.rs
@@ -18,15 +18,15 @@ impl<'mutex> Guard<'mutex> {
     }
 }
 
-impl<'mutex> Deref for Guard<'mutex> {
+impl Deref for Guard<'_> {
     type Target = Session;
 
     fn deref(&self) -> &Session {
         self.0.deref().as_ref().unwrap()
     }
 }
 
-impl<'mutex> DerefMut for Guard<'mutex> {
+impl DerefMut for Guard<'_> {
     fn deref_mut(&mut self) -> &mut Session {
         self.0.deref_mut().as_mut().unwrap()
     }

diff --git a/src/session/securechannel/challenge.rs b/src/session/securechannel/challenge.rs
@@ -34,7 +34,7 @@ impl Challenge {
     }
 
     /// Borrow the challenge value as a slice
-    #[cfg_attr(clippy, allow(clippy::trivially_copy_pass_by_ref))]
+    #[allow(clippy::trivially_copy_pass_by_ref)]
     pub fn as_slice(&self) -> &[u8] {
         &self.0
     }

diff --git a/src/wrap/nonce.rs b/src/wrap/nonce.rs
@@ -35,7 +35,7 @@ impl From<[u8; SIZE]> for Nonce {
     }
 }
 
-impl<'a> From<&'a [u8]> for Nonce {
+impl From<&[u8]> for Nonce {
     fn from(bytes: &[u8]) -> Nonce {
         assert_eq!(
             bytes.len(),