postgres: fix clippy lints (casts, needless borrows, docs, len checks, parsing)

Author: cursoragent

sqlx-core/src/postgres/connection/sasl.rs

@@ -126,7 +126,7 @@ pub(crate) async fn authenticate(
 
     // ClientSignature := HMAC(StoredKey, AuthMessage)
     let mut mac = Hmac::<Sha256>::new_from_slice(&stored_key).map_err(Error::protocol)?;
-    mac.update(&auth_message.as_bytes());
+    mac.update(auth_message.as_bytes());
 
     let client_signature = mac.finalize().into_bytes();
 
@@ -145,7 +145,7 @@ pub(crate) async fn authenticate(
 
     // ServerSignature := HMAC(ServerKey, AuthMessage)
     let mut mac = Hmac::<Sha256>::new_from_slice(&server_key).map_err(Error::protocol)?;
-    mac.update(&auth_message.as_bytes());
+    mac.update(auth_message.as_bytes());
 
     // client-final-message = client-final-message-without-proof "," proof
     let client_final_message = format!(
@@ -183,10 +183,10 @@ fn gen_nonce() -> String {
     // ;; a valid "value".
     let nonce: String = std::iter::repeat(())
         .map(|()| {
-            let mut c = rng.gen_range(0x21..0x7F) as u8;
+            let mut c: u8 = rng.gen_range(0x21u8..0x7Fu8);
 
             while c == 0x2C {
-                c = rng.gen_range(0x21..0x7F) as u8;
+                c = rng.gen_range(0x21u8..0x7Fu8);
             }
 
             c

sqlx-core/src/postgres/connection/stream.rs

@@ -84,7 +84,7 @@ impl PgStream {
         let mut header: Bytes = self.inner.read(5).await?;
 
         let format = MessageFormat::try_from_u8(header.get_u8())?;
-        let size = (header.get_u32() - 4) as usize;
+        let size = usize::try_from(header.get_u32() - 4).expect("message size should fit in usize");
 
         let contents = self.inner.read(size).await?;
 

sqlx-core/src/postgres/copy.rs

@@ -42,7 +42,7 @@ impl PgConnection {
     ///
     /// 1. by closing the connection, or:
     /// 2. by using another connection to kill the server process that is sending the data as shown
-    /// [in this StackOverflow answer](https://stackoverflow.com/a/35319598).
+    ///   [in this StackOverflow answer](https://stackoverflow.com/a/35319598).
     ///
     /// If you don't read the stream to completion, the next time the connection is used it will
     /// need to read and discard all the remaining queued data, which could take some time.
@@ -149,7 +149,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
     /// Returns the number of columns expected in the input.
     pub fn num_columns(&self) -> usize {
         assert_eq!(
-            self.response.num_columns as usize,
+            usize::try_from(self.response.num_columns).expect("num_columns should be non-negative"),
             self.response.format_codes.len(),
             "num_columns does not match format_codes.len()"
         );

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

@@ -25,7 +25,7 @@ impl PgBufMutExt for Vec<u8> {
         f(self);
 
         // now calculate the size of what we wrote and set the length value
-        let size = (self.len() - offset) as i32;
+        let size = i32::try_from(self.len() - offset).expect("message size should fit in i32");
         self[offset..(offset + 4)].copy_from_slice(&size.to_be_bytes());
     }
 

sqlx-core/src/postgres/message/authentication.rs

@@ -162,8 +162,8 @@ impl Decode<'_> for AuthenticationSaslContinue {
         Ok(Self {
             iterations,
             salt,
-            nonce: from_utf8(&*nonce).map_err(Error::protocol)?.to_owned(),
-            message: from_utf8(&*buf).map_err(Error::protocol)?.to_owned(),
+            nonce: from_utf8(&nonce).map_err(Error::protocol)?.to_owned(),
+            message: from_utf8(&buf).map_err(Error::protocol)?.to_owned(),
         })
     }
 }

sqlx-core/src/postgres/message/bind.rs

@@ -42,7 +42,11 @@ impl Encode<'_> for Bind<'_> {
 
             buf.put_statement_name(self.statement);
 
-            buf.extend(&(self.formats.len() as i16).to_be_bytes());
+            buf.extend(
+                &i16::try_from(self.formats.len())
+                    .expect("formats length should fit in i16")
+                    .to_be_bytes(),
+            );
 
             for &format in self.formats {
                 buf.extend(&(format as i16).to_be_bytes());

sqlx-core/src/postgres/message/parse.rs

@@ -1,4 +1,4 @@
-use std::i16;
+// remove legacy numeric constants import
 
 use crate::io::{BufMutExt, Encode};
 use crate::postgres::io::PgBufMutExt;

sqlx-core/src/postgres/options/parse.rs

@@ -16,7 +16,7 @@ impl FromStr for PgConnectOptions {
         if let Some(host) = url.host_str() {
             let host_decoded = percent_decode_str(host);
             options = match host_decoded.clone().next() {
-                Some(b'/') => options.socket(&*host_decoded.decode_utf8().map_err(Error::config)?),
+                Some(b'/') => options.socket(&host_decoded.decode_utf8().map_err(Error::config)?),
                 _ => options.host(host),
             }
         }
@@ -28,15 +28,15 @@ impl FromStr for PgConnectOptions {
         let username = url.username();
         if !username.is_empty() {
             options = options.username(
-                &*percent_decode_str(username)
+                &percent_decode_str(username)
                     .decode_utf8()
                     .map_err(Error::config)?,
             );
         }
 
         if let Some(password) = url.password() {
             options = options.password(
-                &*percent_decode_str(password)
+                &percent_decode_str(password)
                     .decode_utf8()
                     .map_err(Error::config)?,
             );
@@ -54,12 +54,12 @@ impl FromStr for PgConnectOptions {
                 }
 
                 "sslrootcert" | "ssl-root-cert" | "ssl-ca" => {
-                    options = options.ssl_root_cert(&*value);
+                    options = options.ssl_root_cert(&value);
                 }
 
-                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&*value),
+                "sslcert" | "ssl-cert" => options = options.ssl_client_cert(&value),
 
-                "sslkey" | "ssl-key" => options = options.ssl_client_key(&*value),
+                "sslkey" | "ssl-key" => options = options.ssl_client_key(&value),
 
                 "statement-cache-capacity" => {
                     options =
@@ -68,39 +68,39 @@ impl FromStr for PgConnectOptions {
 
                 "host" => {
                     if value.starts_with("/") {
-                        options = options.socket(&*value);
+                        options = options.socket(&value);
                     } else {
-                        options = options.host(&*value);
+                        options = options.host(&value);
                     }
                 }
 
                 "hostaddr" => {
                     value.parse::<IpAddr>().map_err(Error::config)?;
-                    options = options.host(&*value)
+                    options = options.host(&value)
                 }
 
                 "port" => options = options.port(value.parse().map_err(Error::config)?),
 
-                "dbname" => options = options.database(&*value),
+                "dbname" => options = options.database(&value),
 
-                "user" => options = options.username(&*value),
+                "user" => options = options.username(&value),
 
-                "password" => options = options.password(&*value),
+                "password" => options = options.password(&value),
 
-                "application_name" => options = options.application_name(&*value),
+                "application_name" => options = options.application_name(&value),
 
                 "options" => {
                     if let Some(options) = options.options.as_mut() {
                         options.push(' ');
-                        options.push_str(&*value);
+                        options.push_str(&value);
                     } else {
                         options.options = Some(value.to_string());
                     }
                 }
 
                 k if k.starts_with("options[") => {
                     if let Some(key) = k.strip_prefix("options[").unwrap().strip_suffix(']') {
-                        options = options.options([(key, &*value)]);
+                        options = options.options([(key, &value)]);
                     }
                 }
 

sqlx-core/src/postgres/types/array.rs

@@ -94,7 +94,7 @@ where
     T: Encode<'q, Postgres> + Type<Postgres>,
 {
     fn encode_by_ref(&self, buf: &mut PgArgumentBuffer) -> IsNull {
-        let type_info = if self.len() < 1 {
+        let type_info = if self.is_empty() {
             T::type_info()
         } else {
             self[0].produces().unwrap_or_else(T::type_info)

sqlx-core/src/postgres/types/float.rs

@@ -66,7 +66,7 @@ impl Decode<'_, Postgres> for f64 {
         Ok(match value.format() {
             PgValueFormat::Binary => {
                 if value.type_info == PgTypeInfo::NUMERIC {
-                    return Ok(PgNumeric::decode(value.as_bytes()?)?.try_into()?);
+                    return PgNumeric::decode(value.as_bytes()?)?.try_into();
                 }
                 let buf = value.as_bytes()?;
                 match buf.len() {