Run into_parts eagerly in more places

axum-core/src/extract/mod.rs

@@ -101,9 +101,12 @@ where
 {
     type Rejection = <Self as FromRequestParts<S>>::Rejection;
 
-    async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+    fn from_request(
+        req: Request,
+        state: &S,
+    ) -> impl Future<Output = Result<Self, Self::Rejection>> {
         let (mut parts, _) = req.into_parts();
-        Self::from_request_parts(&mut parts, state).await
+        async move { Self::from_request_parts(&mut parts, state).await }
     }
 }
 

axum-core/src/extract/tuple.rs

@@ -1,7 +1,7 @@
 use super::{FromRequest, FromRequestParts, Request};
 use crate::response::{IntoResponse, Response};
 use http::request::Parts;
-use std::convert::Infallible;
+use std::{convert::Infallible, future::Future};
 
 impl<S> FromRequestParts<S> for ()
 where
@@ -52,18 +52,20 @@ macro_rules! impl_from_request {
         {
             type Rejection = Response;
 
-            async fn from_request(req: Request, state: &S) -> Result<Self, Self::Rejection> {
+            fn from_request(req: Request, state: &S) -> impl Future<Output = Result<Self, Self::Rejection>> {
                 let (mut parts, body) = req.into_parts();
 
-                $(
+                async move {
-                    let $ty = $ty::from_request_parts(&mut parts, state).await.map_err(|err| err.into_response())?;
+                    $(
-                )*
+                        let $ty = $ty::from_request_parts(&mut parts, state).await.map_err(|err| err.into_response())?;
+                    )*
 
-                let req = Request::from_parts(parts, body);
+                    let req = Request::from_parts(parts, body);
 
-                let $last = $last::from_request(req, state).await.map_err(|err| err.into_response())?;
+                    let $last = $last::from_request(req, state).await.map_err(|err| err.into_response())?;
 
-                Ok(($($ty,)* $last,))
+                    Ok(($($ty,)* $last,))
+                }
             }
         }
     };

axum-extra/src/handler/or.rs

@@ -66,9 +66,9 @@ where
     type Future = BoxFuture<'static, Response>;
 
     fn call(self, req: Request, state: S) -> Self::Future {
-        Box::pin(async move {
+        let (mut parts, body) = req.into_parts();
-            let (mut parts, body) = req.into_parts();
 
+        Box::pin(async move {
             if let Ok(lt) = Lt::from_request_parts(&mut parts, &state).await {
                 return self.lhs.call(lt, state).await;
             }

axum/src/error_handling/mod.rs

@@ -180,9 +180,9 @@ macro_rules! impl_service {
                 let clone = self.inner.clone();
                 let inner = std::mem::replace(&mut self.inner, clone);
 
-                let future = Box::pin(async move {
+                let (mut parts, body) = req.into_parts();
-                    let (mut parts, body) = req.into_parts();
 
+                let future = Box::pin(async move {
                     $(
                         let $ty = match $ty::from_request_parts(&mut parts, &()).await {
                             Ok(value) => value,

axum/src/middleware/from_extractor.rs

@@ -214,8 +214,9 @@ where
 
     fn call(&mut self, req: Request<B>) -> Self::Future {
         let state = self.state.clone();
+        let (mut parts, body) = req.into_parts();
+
         let extract_future = Box::pin(async move {
-            let (mut parts, body) = req.into_parts();
             let extracted = E::from_request_parts(&mut parts, &state).await;
             let req = Request::from_parts(parts, body);
             (req, extracted)

axum/src/middleware/from_fn.rs

@@ -283,10 +283,9 @@ macro_rules! impl_service {
 
                 let mut f = self.f.clone();
                 let state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
 
                 let future = Box::pin(async move {
-                    let (mut parts, body) = req.into_parts();
-
                     $(
                         let $ty = match $ty::from_request_parts(&mut parts, &state).await {
                             Ok(value) => value,

axum/src/middleware/map_request.rs

@@ -282,10 +282,9 @@ macro_rules! impl_service {
 
                 let mut f = self.f.clone();
                 let state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
 
                 let future = Box::pin(async move {
-                    let (mut parts, body) = req.into_parts();
-
                     $(
                         let $ty = match $ty::from_request_parts(&mut parts, &state).await {
                             Ok(value) => value,

axum/src/middleware/map_response.rs

@@ -261,10 +261,9 @@ macro_rules! impl_service {
 
                 let mut f = self.f.clone();
                 let _state = self.state.clone();
+                let (mut parts, body) = req.into_parts();
 
                 let future = Box::pin(async move {
-                    let (mut parts, body) = req.into_parts();
-
                     $(
                         let $ty = match $ty::from_request_parts(&mut parts, &_state).await {
                             Ok(value) => value,