sqlite/mysql: fix clippy warnings (needless borrows, ptr_arg, casts, loops, conversions)

Author: cursoragent

sqlx-core/src/mysql/connection/auth.rs

@@ -76,7 +76,7 @@ fn scramble_sha1(password: &str, nonce: &Chain<Bytes, Bytes>) -> Vec<u8> {
 
     let mut pw_hash = ctx.finalize_reset();
 
-    ctx.update(&pw_hash);
+    ctx.update(pw_hash);
 
     let pw_hash_hash = ctx.finalize_reset();
 
@@ -100,7 +100,7 @@ fn scramble_sha256(password: &str, nonce: &Chain<Bytes, Bytes>) -> Vec<u8> {
 
     let mut pw_hash = ctx.finalize_reset();
 
-    ctx.update(&pw_hash);
+    ctx.update(pw_hash);
 
     let pw_hash_hash = ctx.finalize_reset();
 

sqlx-core/src/mysql/connection/executor.rs

@@ -25,7 +25,7 @@ use futures_util::{pin_mut, TryStreamExt};
 use std::{borrow::Cow, sync::Arc};
 
 impl MySqlConnection {
-    async fn get_or_prepare<'c>(
+    async fn get_or_prepare(
         &mut self,
         sql: &str,
         persistent: bool,
@@ -155,7 +155,7 @@ impl MySqlConnection {
                 // otherwise, this first packet is the start of the result-set metadata,
                 *self.stream.waiting.front_mut().unwrap() = Waiting::Row;
 
-                let num_columns = packet.get_uint_lenenc() as usize; // column count
+                let num_columns = usize::try_from(packet.get_uint_lenenc()).expect("column count should fit in usize"); // column count
 
                 if needs_metadata {
                     column_names = Arc::new(recv_result_metadata(&mut self.stream, num_columns, Arc::make_mut(&mut columns)).await?);
@@ -289,7 +289,7 @@ impl<'c> Executor<'c> for &'c mut MySqlConnection {
 
             let (_, metadata) = self.get_or_prepare(sql, false).await?;
 
-            let columns = (&*metadata.columns).clone();
+            let columns = (*metadata.columns).clone();
 
             let nullable = columns
                 .iter()
@@ -335,7 +335,7 @@ fn recv_next_result_column(def: &ColumnDefinition, ordinal: usize) -> Result<MyS
         (name, _) => UStr::new(name),
     };
 
-    let type_info = MySqlTypeInfo::from_column(&def);
+    let type_info = MySqlTypeInfo::from_column(def);
 
     Ok(MySqlColumn {
         name,

sqlx-core/src/mysql/io/buf.rs

@@ -31,11 +31,11 @@ impl MySqlBufExt for Bytes {
 
     fn get_str_lenenc(&mut self) -> Result<String, Error> {
         let size = self.get_uint_lenenc();
-        self.get_str(size as usize)
+        self.get_str(usize::try_from(size).expect("string length should fit in usize"))
     }
 
     fn get_bytes_lenenc(&mut self) -> Bytes {
         let size = self.get_uint_lenenc();
-        self.split_to(size as usize)
+        self.split_to(usize::try_from(size).expect("split size should fit in usize"))
     }
 }

sqlx-core/src/mysql/io/buf_mut.rs

@@ -14,13 +14,17 @@ impl MySqlBufMutExt for Vec<u8> {
         // https://mariadb.com/kb/en/library/protocol-data-types/#length-encoded-integers
 
         if v < 251 {
-            self.push(v as u8);
+            self.push(u8::try_from(v).expect("value < 251 should fit in u8"));
         } else if v < 0x1_00_00 {
             self.push(0xfc);
-            self.extend(&(v as u16).to_le_bytes());
+            self.extend(&u16::try_from(v).expect("value < 0x1_00_00").to_le_bytes());
         } else if v < 0x1_00_00_00 {
             self.push(0xfd);
-            self.extend(&(v as u32).to_le_bytes()[..3]);
+            self.extend(
+                &u32::try_from(v)
+                    .expect("value < 0x1_00_00_00")
+                    .to_le_bytes()[..3],
+            );
         } else {
             self.push(0xfe);
             self.extend(&v.to_le_bytes());

sqlx-core/src/mysql/migrate.rs

@@ -192,11 +192,11 @@ CREATE TABLE IF NOT EXISTS _sqlx_migrations (
                     .map_err(MigrateError::AccessMigrationMetadata)?;
 
             if let Some(checksum) = checksum {
-                return if checksum == &*migration.checksum {
+                if checksum == &*migration.checksum {
                     Ok(())
                 } else {
                     Err(MigrateError::VersionMismatch(migration.version))
-                };
+                }
             } else {
                 Err(MigrateError::VersionMissing(migration.version))
             }
@@ -264,7 +264,7 @@ CREATE TABLE IF NOT EXISTS _sqlx_migrations (
     WHERE version = ?
                 "#,
             )
-            .bind(elapsed.as_nanos() as i64)
+            .bind(i64::try_from(elapsed.as_nanos()).expect("elapsed nanos should fit in i64"))
             .bind(migration.version)
             .execute(self)
             .await?;

sqlx-core/src/mysql/protocol/connect/handshake.rs

@@ -61,7 +61,8 @@ impl Decode<'_> for Handshake {
         }
 
         let auth_plugin_data_2 = if capabilities.contains(Capabilities::SECURE_CONNECTION) {
-            let len = core::cmp::max((auth_plugin_data_len as isize) - 9, 12) as usize;
+            let len = usize::try_from(core::cmp::max((auth_plugin_data_len as isize) - 9, 12))
+                .expect("auth plugin data length should be non-negative");
             let v = buf.get_bytes(len);
             buf.advance(1); // NUL-terminator
 

sqlx-core/src/mysql/protocol/connect/handshake_response.rs

@@ -48,7 +48,7 @@ impl Encode<'_, Capabilities> for HandshakeResponse<'_> {
         } else if capabilities.contains(Capabilities::SECURE_CONNECTION) {
             let response = self.auth_response.unwrap_or_default();
 
-            buf.push(response.len() as u8);
+            buf.push(u8::try_from(response.len()).expect("auth response length should fit in u8"));
             buf.extend(response);
         } else {
             buf.push(0);

sqlx-core/src/mysql/protocol/connect/ssl_request.rs

@@ -12,7 +12,11 @@ pub struct SslRequest {
 
 impl Encode<'_, Capabilities> for SslRequest {
     fn encode_with(&self, buf: &mut Vec<u8>, capabilities: Capabilities) {
-        buf.extend(&(capabilities.bits() as u32).to_le_bytes());
+        buf.extend(
+            &u32::try_from(capabilities.bits())
+                .expect("capabilities bits should fit in u32")
+                .to_le_bytes(),
+        );
         buf.extend(&self.max_packet_size.to_le_bytes());
         buf.push(self.collation);
 
@@ -24,7 +28,11 @@ impl Encode<'_, Capabilities> for SslRequest {
             buf.extend(&[0_u8; 4]);
         } else {
             // extended client capabilities (MariaDB-specified): int<4>
-            buf.extend(&((capabilities.bits() >> 32) as u32).to_le_bytes());
+            buf.extend(
+                &u32::try_from(capabilities.bits() >> 32)
+                    .expect("capabilities hi bits should fit in u32")
+                    .to_le_bytes(),
+            );
         }
     }
 }

sqlx-core/src/mysql/protocol/packet.rs

@@ -34,7 +34,11 @@ where
         // FIXME: Support larger packets
         assert!(len < 0xFF_FF_FF);
 
-        header[..4].copy_from_slice(&(len as u32).to_le_bytes());
+        header[..4].copy_from_slice(
+            &u32::try_from(len)
+                .expect("packet length should fit in u32")
+                .to_le_bytes(),
+        );
         header[3] = *sequence_id;
 
         *sequence_id = sequence_id.wrapping_add(1);

sqlx-core/src/mysql/protocol/row.rs

@@ -12,6 +12,6 @@ impl Row {
     pub(crate) fn get(&self, index: usize) -> Option<&[u8]> {
         self.values[index]
             .as_ref()
-            .map(|col| &self.storage[(col.start as usize)..(col.end as usize)])
+            .map(|col| &self.storage[(col.start)..(col.end)])
     }
 }