remove all warnings in cargo check --manifest-path sqlx-core/Cargo.toml --no-default-features --features offline,all-databases,all-types,migrate,runtime-tokio-native-tls

Author: lovasoa

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

@@ -141,26 +141,31 @@ where
     }
 
     pub fn downgrade(&mut self) -> Result<(), Error> {
-        let stream = match replace(self, MaybeTlsStream::Upgrading) {
+        match replace(self, MaybeTlsStream::Upgrading) {
             MaybeTlsStream::Tls(stream) => {
                 #[cfg(feature = "_tls-rustls")]
-                let raw = stream.into_inner().0;
+                {
+                    let raw = stream.into_inner().0;
+                    *self = MaybeTlsStream::Raw(raw);
+                    return Ok(());
+                }
+                
                 #[cfg(feature = "_tls-native-tls")]
-                let raw = unimplemented!("No way to downgrade a native-tls stream, use rustls instead, or never disable tls");
-                raw
+                {
+                    let _ = stream; // Use the variable to avoid warning
+                    return Err(Error::tls("No way to downgrade a native-tls stream, use rustls instead, or never disable tls"));
+                }
             }
 
-            MaybeTlsStream::Raw(_) => {
+            MaybeTlsStream::Raw(stream) => {
+                *self = MaybeTlsStream::Raw(stream);
                 return Ok(());
             }
 
             MaybeTlsStream::Upgrading => {
                 return Err(Error::Io(io::ErrorKind::ConnectionAborted.into()));
             }
-        };
-
-        *self = MaybeTlsStream::Raw(stream);
-        Ok(())
+        }
     }
 }
 

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

@@ -63,7 +63,7 @@ async fn prepare(
     conn.stream.flush().await?;
 
     // indicates that the SQL query string is now successfully parsed and has semantic validity
-    let _ = conn
+    let _: () = conn
         .stream
         .recv_expect(MessageFormat::ParseComplete)
         .await?;

sqlx-core/src/postgres/copy.rs

@@ -128,7 +128,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
                     .send(CopyFail::new("failed to start COPY"))
                     .await?;
                 conn.stream
-                    .recv_expect(MessageFormat::ReadyForQuery)
+                    .recv_expect::<()>(MessageFormat::ReadyForQuery)
                     .await?;
                 Err(e)
             }
@@ -213,7 +213,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
             loop {
                 let read = match () {
                     // Tokio lets us read into the buffer without zeroing first
-                    #[cfg(feature = "runtime-tokio")]
+                    #[cfg(feature = "_rt-tokio")]
                     _ if buf.len() != buf.capacity() => {
                         // in case we have some data in the buffer, which can occur
                         // if the previous write did not fill the buffer
@@ -267,7 +267,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
                     Some(Cow::Borrowed("57014")) => {
                         // postgres abort received error code
                         conn.stream
-                            .recv_expect(MessageFormat::ReadyForQuery)
+                            .recv_expect::<()>(MessageFormat::ReadyForQuery)
                             .await?;
                         Ok(())
                     }
@@ -294,7 +294,7 @@ impl<C: DerefMut<Target = PgConnection>> PgCopyIn<C> {
             .await?;
 
         conn.stream
-            .recv_expect(MessageFormat::ReadyForQuery)
+            .recv_expect::<()>(MessageFormat::ReadyForQuery)
             .await?;
 
         Ok(cc.rows_affected())
@@ -330,8 +330,8 @@ async fn pg_begin_copy_out<'c, C: DerefMut<Target = PgConnection> + Send + 'c>(
                 MessageFormat::CopyData => r#yield!(msg.decode::<CopyData<Bytes>>()?.0),
                 MessageFormat::CopyDone => {
                     let _ = msg.decode::<CopyDone>()?;
-                    conn.stream.recv_expect(MessageFormat::CommandComplete).await?;
-                    conn.stream.recv_expect(MessageFormat::ReadyForQuery).await?;
+                    conn.stream.recv_expect::<CommandComplete>(MessageFormat::CommandComplete).await?;
+                    conn.stream.recv_expect::<()>(MessageFormat::ReadyForQuery).await?;
                     return Ok(())
                 },
                 _ => return Err(err_protocol!("unexpected message format during copy out: {:?}", msg.format))