Remove unnecessary boxfutures (#3525)

* Remove `BoxFuture`'s from `Connection` and `ConnectOptions`

* Remove `BoxFuture`'s for `MigrateDatabase`

* Remove `BoxFuture`'s for `TransactionManager`

* Remove `BoxFuture`'s for `TestSupport`

* Remove `BoxFuture`'s from `PgPoolCopyExt`

* Clippy fixes

* Box timeout future in debug mode

Author: joeydewaal

sqlx-core/src/any/connection/mod.rs

@@ -1,5 +1,6 @@
 use futures_core::future::BoxFuture;
 use std::borrow::Cow;
+use std::future::Future;
 
 use crate::any::{Any, AnyConnectOptions};
 use crate::connection::{ConnectOptions, Connection};
@@ -72,19 +73,21 @@ impl Connection for AnyConnection {
 
     type Options = AnyConnectOptions;
 
-    fn close(self) -> BoxFuture<'static, Result<(), Error>> {
+    fn close(self) -> impl Future<Output = Result<(), Error>> + Send + 'static {
         self.backend.close()
     }
 
-    fn close_hard(self) -> BoxFuture<'static, Result<(), Error>> {
+    fn close_hard(self) -> impl Future<Output = Result<(), Error>> + Send + 'static {
         self.backend.close()
     }
 
-    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>> {
+    fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_ {
         self.backend.ping()
     }
 
-    fn begin(&mut self) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    fn begin(
+        &mut self,
+    ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
@@ -94,7 +97,7 @@ impl Connection for AnyConnection {
     fn begin_with(
         &mut self,
         statement: impl Into<Cow<'static, str>>,
-    ) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
@@ -105,7 +108,7 @@ impl Connection for AnyConnection {
         self.backend.cached_statements_size()
     }
 
-    fn clear_cached_statements(&mut self) -> BoxFuture<'_, crate::Result<()>> {
+    fn clear_cached_statements(&mut self) -> impl Future<Output = crate::Result<()>> + Send + '_ {
         self.backend.clear_cached_statements()
     }
 
@@ -114,7 +117,7 @@ impl Connection for AnyConnection {
     }
 
     #[doc(hidden)]
-    fn flush(&mut self) -> BoxFuture<'_, Result<(), Error>> {
+    fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_ {
         self.backend.flush()
     }
 

sqlx-core/src/any/driver.rs

@@ -5,6 +5,7 @@ use crate::connection::Connection;
 use crate::database::Database;
 use crate::Error;
 use futures_core::future::BoxFuture;
+use futures_util::FutureExt;
 use std::fmt::{Debug, Formatter};
 use std::sync::OnceLock;
 use url::Url;
@@ -67,10 +68,10 @@ impl AnyDriver {
     {
         Self {
             migrate_database: Some(AnyMigrateDatabase {
-                create_database: DebugFn(DB::create_database),
-                database_exists: DebugFn(DB::database_exists),
-                drop_database: DebugFn(DB::drop_database),
-                force_drop_database: DebugFn(DB::force_drop_database),
+                create_database: DebugFn(|url| DB::create_database(url).boxed()),
+                database_exists: DebugFn(|url| DB::database_exists(url).boxed()),
+                drop_database: DebugFn(|url| DB::drop_database(url).boxed()),
+                force_drop_database: DebugFn(|url| DB::force_drop_database(url).boxed()),
             }),
             ..Self::without_migrate::<DB>()
         }

sqlx-core/src/any/migrate.rs

@@ -6,40 +6,32 @@ use futures_core::future::BoxFuture;
 use std::time::Duration;
 
 impl MigrateDatabase for Any {
-    fn create_database(url: &str) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async {
-            driver::from_url_str(url)?
-                .get_migrate_database()?
-                .create_database(url)
-                .await
-        })
+    async fn create_database(url: &str) -> Result<(), Error> {
+        driver::from_url_str(url)?
+            .get_migrate_database()?
+            .create_database(url)
+            .await
     }
 
-    fn database_exists(url: &str) -> BoxFuture<'_, Result<bool, Error>> {
-        Box::pin(async {
-            driver::from_url_str(url)?
-                .get_migrate_database()?
-                .database_exists(url)
-                .await
-        })
+    async fn database_exists(url: &str) -> Result<bool, Error> {
+        driver::from_url_str(url)?
+            .get_migrate_database()?
+            .database_exists(url)
+            .await
     }
 
-    fn drop_database(url: &str) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async {
-            driver::from_url_str(url)?
-                .get_migrate_database()?
-                .drop_database(url)
-                .await
-        })
+    async fn drop_database(url: &str) -> Result<(), Error> {
+        driver::from_url_str(url)?
+            .get_migrate_database()?
+            .drop_database(url)
+            .await
     }
 
-    fn force_drop_database(url: &str) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async {
-            driver::from_url_str(url)?
-                .get_migrate_database()?
-                .force_drop_database(url)
-                .await
-        })
+    async fn force_drop_database(url: &str) -> Result<(), Error> {
+        driver::from_url_str(url)?
+            .get_migrate_database()?
+            .force_drop_database(url)
+            .await
     }
 }
 

sqlx-core/src/any/options.rs

@@ -1,8 +1,8 @@
 use crate::any::AnyConnection;
 use crate::connection::{ConnectOptions, LogSettings};
 use crate::error::Error;
-use futures_core::future::BoxFuture;
 use log::LevelFilter;
+use std::future::Future;
 use std::str::FromStr;
 use std::time::Duration;
 use url::Url;
@@ -48,7 +48,7 @@ impl ConnectOptions for AnyConnectOptions {
     }
 
     #[inline]
-    fn connect(&self) -> BoxFuture<'_, Result<AnyConnection, Error>> {
+    fn connect(&self) -> impl Future<Output = Result<AnyConnection, Error>> + Send + '_ {
         AnyConnection::connect(self)
     }
 

sqlx-core/src/any/transaction.rs

@@ -1,5 +1,5 @@
-use futures_core::future::BoxFuture;
 use std::borrow::Cow;
+use std::future::Future;
 
 use crate::any::{Any, AnyConnection};
 use crate::database::Database;
@@ -14,15 +14,15 @@ impl TransactionManager for AnyTransactionManager {
     fn begin<'conn>(
         conn: &'conn mut AnyConnection,
         statement: Option<Cow<'static, str>>,
-    ) -> BoxFuture<'conn, Result<(), Error>> {
+    ) -> impl Future<Output = Result<(), Error>> + Send + 'conn {
         conn.backend.begin(statement)
     }
 
-    fn commit(conn: &mut AnyConnection) -> BoxFuture<'_, Result<(), Error>> {
+    fn commit(conn: &mut AnyConnection) -> impl Future<Output = Result<(), Error>> + Send + '_ {
         conn.backend.commit()
     }
 
-    fn rollback(conn: &mut AnyConnection) -> BoxFuture<'_, Result<(), Error>> {
+    fn rollback(conn: &mut AnyConnection) -> impl Future<Output = Result<(), Error>> + Send + '_ {
         conn.backend.rollback()
     }
 

sqlx-core/src/connection.rs

@@ -6,6 +6,7 @@ use futures_core::future::BoxFuture;
 use log::LevelFilter;
 use std::borrow::Cow;
 use std::fmt::Debug;
+use std::future::Future;
 use std::str::FromStr;
 use std::time::Duration;
 use url::Url;
@@ -32,23 +33,23 @@ pub trait Connection: Send {
     ///
     /// Therefore it is recommended to call `.close()` on a connection when you are done using it
     /// and to `.await` the result to ensure the termination message is sent.
-    fn close(self) -> BoxFuture<'static, Result<(), Error>>;
+    fn close(self) -> impl Future<Output = Result<(), Error>> + Send + 'static;
 
     /// Immediately close the connection without sending a graceful shutdown.
     ///
     /// This should still at least send a TCP `FIN` frame to let the server know we're dying.
     #[doc(hidden)]
-    fn close_hard(self) -> BoxFuture<'static, Result<(), Error>>;
+    fn close_hard(self) -> impl Future<Output = Result<(), Error>> + Send + 'static;
 
     /// Checks if a connection to the database is still valid.
-    fn ping(&mut self) -> BoxFuture<'_, Result<(), Error>>;
+    fn ping(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     /// Begin a new transaction or establish a savepoint within the active transaction.
     ///
     /// Returns a [`Transaction`] for controlling and tracking the new transaction.
-    fn begin(&mut self) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
-    where
-        Self: Sized;
+    fn begin(
+        &mut self,
+    ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_;
 
     /// Begin a new transaction with a custom statement.
     ///
@@ -59,7 +60,7 @@ pub trait Connection: Send {
     fn begin_with(
         &mut self,
         statement: impl Into<Cow<'static, str>>,
-    ) -> BoxFuture<'_, Result<Transaction<'_, Self::Database>, Error>>
+    ) -> impl Future<Output = Result<Transaction<'_, Self::Database>, Error>> + Send + '_
     where
         Self: Sized,
     {
@@ -94,7 +95,10 @@ pub trait Connection: Send {
     /// })).await
     /// # }
     /// ```
-    fn transaction<'a, F, R, E>(&'a mut self, callback: F) -> BoxFuture<'a, Result<R, E>>
+    fn transaction<'a, F, R, E>(
+        &'a mut self,
+        callback: F,
+    ) -> impl Future<Output = Result<R, E>> + Send + 'a
     where
         for<'c> F: FnOnce(&'c mut Transaction<'_, Self::Database>) -> BoxFuture<'c, Result<R, E>>
             + 'a
@@ -104,7 +108,7 @@ pub trait Connection: Send {
         R: Send,
         E: From<Error> + Send,
     {
-        Box::pin(async move {
+        async move {
             let mut transaction = self.begin().await?;
             let ret = callback(&mut transaction).await;
 
@@ -120,7 +124,7 @@ pub trait Connection: Send {
                     Err(err)
                 }
             }
-        })
+        }
     }
 
     /// The number of statements currently cached in the connection.
@@ -133,11 +137,11 @@ pub trait Connection: Send {
 
     /// Removes all statements from the cache, closing them on the server if
     /// needed.
-    fn clear_cached_statements(&mut self) -> BoxFuture<'_, Result<(), Error>>
+    fn clear_cached_statements(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_
     where
         Self::Database: HasStatementCache,
     {
-        Box::pin(async move { Ok(()) })
+        async move { Ok(()) }
     }
 
     /// Restore any buffers in the connection to their default capacity, if possible.
@@ -155,7 +159,7 @@ pub trait Connection: Send {
     fn shrink_buffers(&mut self);
 
     #[doc(hidden)]
-    fn flush(&mut self) -> BoxFuture<'_, Result<(), Error>>;
+    fn flush(&mut self) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     #[doc(hidden)]
     fn should_flush(&self) -> bool;
@@ -165,17 +169,19 @@ pub trait Connection: Send {
     /// A value of [`Options`][Self::Options] is parsed from the provided connection string. This parsing
     /// is database-specific.
     #[inline]
-    fn connect(url: &str) -> BoxFuture<'static, Result<Self, Error>>
+    fn connect(url: &str) -> impl Future<Output = Result<Self, Error>> + Send + 'static
     where
         Self: Sized,
     {
         let options = url.parse();
 
-        Box::pin(async move { Self::connect_with(&options?).await })
+        async move { Self::connect_with(&options?).await }
     }
 
     /// Establish a new database connection with the provided options.
-    fn connect_with(options: &Self::Options) -> BoxFuture<'_, Result<Self, Error>>
+    fn connect_with(
+        options: &Self::Options,
+    ) -> impl Future<Output = Result<Self, Error>> + Send + '_
     where
         Self: Sized,
     {
@@ -247,7 +253,7 @@ pub trait ConnectOptions: 'static + Send + Sync + FromStr<Err = Error> + Debug +
     }
 
     /// Establish a new database connection with the options specified by `self`.
-    fn connect(&self) -> BoxFuture<'_, Result<Self::Connection, Error>>
+    fn connect(&self) -> impl Future<Output = Result<Self::Connection, Error>> + Send + '_
     where
         Self::Connection: Sized;
 

sqlx-core/src/migrate/migrate.rs

@@ -1,25 +1,26 @@
 use crate::error::Error;
 use crate::migrate::{AppliedMigration, MigrateError, Migration};
 use futures_core::future::BoxFuture;
+use std::future::Future;
 use std::time::Duration;
 
 pub trait MigrateDatabase {
     // create database in url
     // uses a maintenance database depending on driver
-    fn create_database(url: &str) -> BoxFuture<'_, Result<(), Error>>;
+    fn create_database(url: &str) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     // check if the database in url exists
     // uses a maintenance database depending on driver
-    fn database_exists(url: &str) -> BoxFuture<'_, Result<bool, Error>>;
+    fn database_exists(url: &str) -> impl Future<Output = Result<bool, Error>> + Send + '_;
 
     // drop database in url
     // uses a maintenance database depending on driver
-    fn drop_database(url: &str) -> BoxFuture<'_, Result<(), Error>>;
+    fn drop_database(url: &str) -> impl Future<Output = Result<(), Error>> + Send + '_;
 
     // force drop database in url
     // uses a maintenance database depending on driver
-    fn force_drop_database(_url: &str) -> BoxFuture<'_, Result<(), Error>> {
-        Box::pin(async { Err(MigrateError::ForceNotSupported)? })
+    fn force_drop_database(_url: &str) -> impl Future<Output = Result<(), Error>> + Send + '_ {
+        async { Err(MigrateError::ForceNotSupported)? }
     }
 }
 

sqlx-core/src/rt/mod.rs

@@ -24,6 +24,9 @@ pub enum JoinHandle<T> {
 }
 
 pub async fn timeout<F: Future>(duration: Duration, f: F) -> Result<F::Output, TimeoutError> {
+    #[cfg(debug_assertions)]
+    let f = Box::pin(f);
+
     #[cfg(feature = "_rt-tokio")]
     if rt_tokio::available() {
         return tokio::time::timeout(duration, f)