fix: lots, *lots* more Clippy warnings

Author: abonander

examples/postgres/listen/src/main.rs

@@ -98,9 +98,9 @@ from (
      ) notifies(chan, payload)
     "#,
     )
-    .bind(&COUNTER.fetch_add(1, Ordering::SeqCst))
-    .bind(&COUNTER.fetch_add(1, Ordering::SeqCst))
-    .bind(&COUNTER.fetch_add(1, Ordering::SeqCst))
+    .bind(COUNTER.fetch_add(1, Ordering::SeqCst))
+    .bind(COUNTER.fetch_add(1, Ordering::SeqCst))
+    .bind(COUNTER.fetch_add(1, Ordering::SeqCst))
     .execute(pool)
     .await;
 

sqlx-core/src/net/tls/tls_rustls.rs

@@ -138,7 +138,7 @@ where
         }
     } else {
         #[cfg(any(feature = "_tls-rustls-aws-lc-rs", feature = "_tls-rustls-ring-webpki"))]
-        let cert_store = certs_from_webpki();
+        let mut cert_store = certs_from_webpki();
         #[cfg(feature = "_tls-rustls-ring-native-roots")]
         let mut cert_store = certs_from_native_store();
 

sqlx-core/src/pool/inner.rs

@@ -451,13 +451,15 @@ pub(super) fn is_beyond_max_lifetime<DB: Database>(
     options: &PoolOptions<DB>,
 ) -> bool {
     options
-        .max_lifetime.is_some_and(|max| live.created_at.elapsed() > max)
+        .max_lifetime
+        .is_some_and(|max| live.created_at.elapsed() > max)
 }
 
 /// Returns `true` if the connection has exceeded `options.idle_timeout` if set, `false` otherwise.
 fn is_beyond_idle_timeout<DB: Database>(idle: &Idle<DB>, options: &PoolOptions<DB>) -> bool {
     options
-        .idle_timeout.is_some_and(|timeout| idle.idle_since.elapsed() > timeout)
+        .idle_timeout
+        .is_some_and(|timeout| idle.idle_since.elapsed() > timeout)
 }
 
 async fn check_idle_conn<DB: Database>(

sqlx-mysql/src/io/buf_mut.rs

@@ -45,71 +45,71 @@ impl MySqlBufMutExt for Vec<u8> {
 #[test]
 fn test_encodes_int_lenenc_u8() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFA as u64);
+    buf.put_uint_lenenc(0xFA_u64);
 
     assert_eq!(&buf[..], b"\xFA");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u16() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(std::u16::MAX as u64);
+    buf.put_uint_lenenc(u16::MAX as u64);
 
     assert_eq!(&buf[..], b"\xFC\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u24() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFF_FF_FF as u64);
+    buf.put_uint_lenenc(0xFF_FF_FF_u64);
 
     assert_eq!(&buf[..], b"\xFD\xFF\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_u64() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(std::u64::MAX);
+    buf.put_uint_lenenc(u64::MAX);
 
     assert_eq!(&buf[..], b"\xFE\xFF\xFF\xFF\xFF\xFF\xFF\xFF\xFF");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fb() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFB as u64);
+    buf.put_uint_lenenc(0xFB_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFB\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fc() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFC as u64);
+    buf.put_uint_lenenc(0xFC_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFC\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fd() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFD as u64);
+    buf.put_uint_lenenc(0xFD_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFD\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_fe() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFE as u64);
+    buf.put_uint_lenenc(0xFE_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFE\x00");
 }
 
 #[test]
 fn test_encodes_int_lenenc_ff() {
     let mut buf = Vec::with_capacity(1024);
-    buf.put_uint_lenenc(0xFF as u64);
+    buf.put_uint_lenenc(0xFF_u64);
 
     assert_eq!(&buf[..], b"\xFC\xFF\x00");
 }

sqlx-postgres/src/advisory_lock.rs

@@ -362,7 +362,7 @@ impl<'lock, C: AsMut<PgConnection>> PgAdvisoryLockGuard<'lock, C> {
     }
 }
 
-impl<'lock, C: AsMut<PgConnection> + AsRef<PgConnection>> Deref for PgAdvisoryLockGuard<'lock, C> {
+impl<C: AsMut<PgConnection> + AsRef<PgConnection>> Deref for PgAdvisoryLockGuard<'_, C> {
     type Target = PgConnection;
 
     fn deref(&self) -> &Self::Target {
@@ -376,16 +376,14 @@ impl<'lock, C: AsMut<PgConnection> + AsRef<PgConnection>> Deref for PgAdvisoryLo
 /// However, replacing the connection with a different one using, e.g. [`std::mem::replace()`]
 /// is a logic error and will cause a warning to be logged by the PostgreSQL server when this
 /// guard attempts to release the lock.
-impl<'lock, C: AsMut<PgConnection> + AsRef<PgConnection>> DerefMut
-    for PgAdvisoryLockGuard<'lock, C>
-{
+impl<C: AsMut<PgConnection> + AsRef<PgConnection>> DerefMut for PgAdvisoryLockGuard<'_, C> {
     fn deref_mut(&mut self) -> &mut Self::Target {
         self.conn.as_mut().expect(NONE_ERR).as_mut()
     }
 }
 
-impl<'lock, C: AsMut<PgConnection> + AsRef<PgConnection>> AsRef<PgConnection>
-    for PgAdvisoryLockGuard<'lock, C>
+impl<C: AsMut<PgConnection> + AsRef<PgConnection>> AsRef<PgConnection>
+    for PgAdvisoryLockGuard<'_, C>
 {
     fn as_ref(&self) -> &PgConnection {
         self.conn.as_ref().expect(NONE_ERR).as_ref()
@@ -398,7 +396,7 @@ impl<'lock, C: AsMut<PgConnection> + AsRef<PgConnection>> AsRef<PgConnection>
 /// However, replacing the connection with a different one using, e.g. [`std::mem::replace()`]
 /// is a logic error and will cause a warning to be logged by the PostgreSQL server when this
 /// guard attempts to release the lock.
-impl<'lock, C: AsMut<PgConnection>> AsMut<PgConnection> for PgAdvisoryLockGuard<'lock, C> {
+impl<C: AsMut<PgConnection>> AsMut<PgConnection> for PgAdvisoryLockGuard<'_, C> {
     fn as_mut(&mut self) -> &mut PgConnection {
         self.conn.as_mut().expect(NONE_ERR).as_mut()
     }
@@ -407,7 +405,7 @@ impl<'lock, C: AsMut<PgConnection>> AsMut<PgConnection> for PgAdvisoryLockGuard<
 /// Queues a `pg_advisory_unlock()` call on the wrapped connection which will be flushed
 /// to the server the next time it is used, or when it is returned to [`PgPool`][crate::PgPool]
 /// in the case of [`PoolConnection<Postgres>`][crate::pool::PoolConnection].
-impl<'lock, C: AsMut<PgConnection>> Drop for PgAdvisoryLockGuard<'lock, C> {
+impl<C: AsMut<PgConnection>> Drop for PgAdvisoryLockGuard<'_, C> {
     fn drop(&mut self) {
         if let Some(mut conn) = self.conn.take() {
             // Queue a simple query message to execute next time the connection is used.

sqlx-postgres/src/connection/executor.rs

@@ -159,7 +159,7 @@ impl PgConnection {
         self.inner.pending_ready_for_query_count += 1;
     }
 
-    async fn get_or_prepare<'a>(
+    async fn get_or_prepare(
         &mut self,
         sql: &str,
         parameters: &[PgTypeInfo],

sqlx-postgres/src/connection/tls.rs

@@ -7,7 +7,7 @@ use crate::{PgConnectOptions, PgSslMode};
 
 pub struct MaybeUpgradeTls<'a>(pub &'a PgConnectOptions);
 
-impl<'a> WithSocket for MaybeUpgradeTls<'a> {
+impl WithSocket for MaybeUpgradeTls<'_> {
     type Output = crate::Result<Box<dyn Socket>>;
 
     async fn with_socket<S: Socket>(self, socket: S) -> Self::Output {

sqlx-postgres/src/listener.rs

@@ -506,12 +506,12 @@ fn build_listen_all_query(channels: impl IntoIterator<Item = impl AsRef<str>>) -
 
 #[test]
 fn test_build_listen_all_query_with_single_channel() {
-    let output = build_listen_all_query(&["test"]);
+    let output = build_listen_all_query(["test"]);
     assert_eq!(output.as_str(), r#"LISTEN "test";"#);
 }
 
 #[test]
 fn test_build_listen_all_query_with_multiple_channels() {
-    let output = build_listen_all_query(&["channel.0", "channel.1"]);
+    let output = build_listen_all_query(["channel.0", "channel.1"]);
     assert_eq!(output.as_str(), r#"LISTEN "channel.0";LISTEN "channel.1";"#);
 }

sqlx-postgres/src/message/response.rs

@@ -195,7 +195,7 @@ struct Fields<'a> {
     offset: usize,
 }
 
-impl<'a> Iterator for Fields<'a> {
+impl Iterator for Fields<'_> {
     type Item = (u8, Range<usize>);
 
     fn next(&mut self) -> Option<Self::Item> {

sqlx-postgres/src/options/parse.rs

@@ -336,7 +336,7 @@ fn built_url_can_be_parsed() {
     let url = "postgres://username:p@ssw0rd@hostname:5432/database";
     let opts = PgConnectOptions::from_str(url).unwrap();
 
-    let parsed = PgConnectOptions::from_str(&opts.build_url().to_string());
+    let parsed = PgConnectOptions::from_str(opts.build_url().as_ref());
 
     assert!(parsed.is_ok());
 }

sqlx-postgres/src/types/bigdecimal.rs

@@ -213,7 +213,8 @@ fn sign_to_pg(sign: Sign) -> PgNumericSign {
 }
 
 #[cfg(test)]
-mod bigdecimal_to_pgnumeric {
+#[allow(clippy::zero_prefixed_literal)] // Used for clarity
+mod tests {
     use super::{BigDecimal, PgNumeric, PgNumericSign};
     use std::convert::TryFrom;
 

sqlx-postgres/src/types/interval.rs

@@ -231,7 +231,7 @@ fn test_encode_interval() {
         microseconds: 0,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(&**buf, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0]);
@@ -243,7 +243,7 @@ fn test_encode_interval() {
         microseconds: 1_000,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(&**buf, [0, 0, 0, 0, 0, 0, 3, 232, 0, 0, 0, 0, 0, 0, 0, 0]);
@@ -255,7 +255,7 @@ fn test_encode_interval() {
         microseconds: 1_000_000,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(&**buf, [0, 0, 0, 0, 0, 15, 66, 64, 0, 0, 0, 0, 0, 0, 0, 0]);
@@ -267,7 +267,7 @@ fn test_encode_interval() {
         microseconds: 3_600_000_000,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(
@@ -282,7 +282,7 @@ fn test_encode_interval() {
         microseconds: 0,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(&**buf, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0]);
@@ -294,7 +294,7 @@ fn test_encode_interval() {
         microseconds: 0,
     };
     assert!(matches!(
-        Encode::<Postgres>::encode(&interval, &mut buf),
+        Encode::<Postgres>::encode(interval, &mut buf),
         Ok(IsNull::No)
     ));
     assert_eq!(&**buf, [0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1]);

sqlx-postgres/src/types/json.rs

@@ -54,7 +54,7 @@ impl PgHasArrayType for JsonRawValue {
     }
 }
 
-impl<'q, T> Encode<'q, Postgres> for Json<T>
+impl<T> Encode<'_, Postgres> for Json<T>
 where
     T: Serialize,
 {