Cleanup and compile time improvement

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();
 
-                $(
-                    let $ty = $ty::from_request_parts(&mut parts, state).await.map_err(|err| err.into_response())?;
-                )*
+                async move {
+                    $(
+                        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/CHANGELOG.md

@@ -10,12 +10,13 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - **added:** Implement `From<Bytes>` for `Message` ([#3273])
 - **added:** Implement `OptionalFromRequest` for `Json` ([#3142])
 - **added:** Implement `OptionalFromRequest` for `Extension` ([#3157])
-- **changed:** Improved code size / compile time of `Handler` implementations ([#3285])
+- **changed:** Improved code size / compile time of dependent crates ([#3285], ([#3294]))
 
 [#3273]: https://github.com/tokio-rs/axum/pull/3273
 [#3142]: https://github.com/tokio-rs/axum/pull/3142
 [#3157]: https://github.com/tokio-rs/axum/pull/3157
 [#3285]: https://github.com/tokio-rs/axum/pull/3285
+[#3294]: https://github.com/tokio-rs/axum/pull/3294
 
 # 0.8.2
 

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

@@ -1,4 +1,3 @@
-use crate::response::{IntoResponse, Response};
 use axum_core::extract::{FromRequest, FromRequestParts, Request};
 use futures_util::future::BoxFuture;
 use std::{
@@ -11,10 +10,14 @@ use std::{
     task::{Context, Poll},
 };
 use tower::util::BoxCloneSyncService;
-use tower::ServiceBuilder;
 use tower_layer::Layer;
 use tower_service::Service;
 
+use crate::{
+    response::{IntoResponse, Response},
+    util::MapIntoResponse,
+};
+
 /// Create a middleware from an async function.
 ///
 /// `from_fn` requires the function given to
@@ -283,10 +286,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,
@@ -301,10 +303,7 @@ macro_rules! impl_service {
                         Err(rejection) => return rejection.into_response(),
                     };
 
-                    let inner = ServiceBuilder::new()
-                        .layer_fn(BoxCloneSyncService::new)
-                        .map_response(IntoResponse::into_response)
-                        .service(ready_inner);
+                    let inner = BoxCloneSyncService::new(MapIntoResponse::new(ready_inner));
                     let next = Next { inner };
 
                     f($($ty,)* $last, next).await.into_response()

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,

axum/src/routing/method_routing.rs

@@ -19,7 +19,7 @@ use std::{
     fmt,
     task::{Context, Poll},
 };
-use tower::{service_fn, util::MapResponseLayer};
+use tower::service_fn;
 use tower_layer::Layer;
 use tower_service::Service;
 
@@ -748,7 +748,7 @@ where
     /// requests.
     pub fn new() -> Self {
         let fallback = Route::new(service_fn(|_: Request| async {
-            Ok(StatusCode::METHOD_NOT_ALLOWED.into_response())
+            Ok(StatusCode::METHOD_NOT_ALLOWED)
         }));
 
         Self {
@@ -1016,11 +1016,7 @@ where
             );
         }
 
-        let layer_fn = move |svc| {
-            let svc = layer.layer(svc);
-            let svc = MapResponseLayer::new(IntoResponse::into_response).layer(svc);
-            Route::new(svc)
-        };
+        let layer_fn = move |svc| Route::new(layer.layer(svc));
 
         self.get = self.get.map(layer_fn.clone());
         self.head = self.head.map(layer_fn.clone());

axum/src/routing/route.rs

@@ -1,6 +1,7 @@
 use crate::{
     body::{Body, HttpBody},
     response::Response,
+    util::MapIntoResponse,
 };
 use axum_core::{extract::Request, response::IntoResponse};
 use bytes::Bytes;
@@ -17,7 +18,7 @@ use std::{
     task::{ready, Context, Poll},
 };
 use tower::{
-    util::{BoxCloneSyncService, MapErrLayer, MapResponseLayer, Oneshot},
+    util::{BoxCloneSyncService, MapErrLayer, Oneshot},
     ServiceExt,
 };
 use tower_layer::Layer;
@@ -36,9 +37,7 @@ impl<E> Route<E> {
         T::Response: IntoResponse + 'static,
         T::Future: Send + 'static,
     {
-        Self(BoxCloneSyncService::new(
-            svc.map_response(IntoResponse::into_response),
-        ))
+        Self(BoxCloneSyncService::new(MapIntoResponse::new(svc)))
     }
 
     /// Variant of [`Route::call`] that takes ownership of the route to avoid cloning.
@@ -67,11 +66,7 @@ impl<E> Route<E> {
         <L::Service as Service<Request>>::Future: Send + 'static,
         NewError: 'static,
     {
-        let layer = (
-            MapErrLayer::new(Into::into),
-            MapResponseLayer::new(IntoResponse::into_response),
-            layer,
-        );
+        let layer = (MapErrLayer::new(Into::into), layer);
 
         Route::new(layer.layer(self))
     }