Improve value and reference passing efficiency (#3406)

Author: theodorebje

Cargo.toml

@@ -29,6 +29,7 @@ exit = "warn"
 filter_map_next = "warn"
 fn_params_excessive_bools = "warn"
 if_let_mutex = "warn"
+implicit_clone = "warn"
 imprecise_flops = "warn"
 inefficient_to_string = "warn"
 linkedlist = "warn"
@@ -41,13 +42,18 @@ mem_forget = "warn"
 must_use_candidate = "warn"
 needless_borrow = "warn"
 needless_continue = "warn"
+needless_pass_by_ref_mut = "warn"
+needless_pass_by_value = "warn"
 option_option = "warn"
+redundant_clone = "warn"
+ref_option = "warn"
 rest_pat_in_fully_bound_structs = "warn"
 return_self_not_must_use = "warn"
 single_match_else = "warn"
 str_to_string = "warn"
 suboptimal_flops = "warn"
 todo = "warn"
+trivially_copy_pass_by_ref = "warn"
 uninlined_format_args = "warn"
 unnested_or_patterns = "warn"
 unused_self = "warn"

axum-extra/src/extract/cookie/mod.rs

@@ -206,7 +206,7 @@ impl IntoResponseParts for CookieJar {
     type Error = Infallible;
 
     fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> {
-        set_cookies(self.jar, res.headers_mut());
+        set_cookies(&self.jar, res.headers_mut());
         Ok(res)
     }
 }
@@ -217,7 +217,7 @@ impl IntoResponse for CookieJar {
     }
 }
 
-fn set_cookies(jar: cookie::CookieJar, headers: &mut HeaderMap) {
+fn set_cookies(jar: &cookie::CookieJar, headers: &mut HeaderMap) {
     for cookie in jar.delta() {
         if let Ok(header_value) = cookie.encoded().to_string().parse() {
             headers.append(SET_COOKIE, header_value);

axum-extra/src/extract/cookie/private.rs

@@ -274,7 +274,7 @@ impl<K> IntoResponseParts for PrivateCookieJar<K> {
     type Error = Infallible;
 
     fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> {
-        set_cookies(self.jar, res.headers_mut());
+        set_cookies(&self.jar, res.headers_mut());
         Ok(res)
     }
 }

axum-extra/src/extract/cookie/signed.rs

@@ -292,7 +292,7 @@ impl<K> IntoResponseParts for SignedCookieJar<K> {
     type Error = Infallible;
 
     fn into_response_parts(self, mut res: ResponseParts) -> Result<ResponseParts, Self::Error> {
-        set_cookies(self.jar, res.headers_mut());
+        set_cookies(&self.jar, res.headers_mut());
         Ok(res)
     }
 }

axum-extra/src/protobuf.rs

@@ -172,7 +172,7 @@ mod tests {
 
         let app = Router::new().route(
             "/",
-            post(|input: Protobuf<Input>| async move { input.foo.to_owned() }),
+            post(|Protobuf(input): Protobuf<Input>| async move { input.foo }),
         );
 
         let input = Input {
@@ -228,10 +228,8 @@ mod tests {
         }
 
         #[axum::debug_handler]
-        async fn handler(input: Protobuf<Input>) -> Protobuf<Output> {
-            let output = Output {
-                result: input.foo.to_owned(),
-            };
+        async fn handler(Protobuf(input): Protobuf<Input>) -> Protobuf<Output> {
+            let output = Output { result: input.foo };
 
             Protobuf(output)
         }

axum-macros/src/debug_handler.rs

@@ -8,16 +8,16 @@ use proc_macro2::{Ident, Span, TokenStream};
 use quote::{format_ident, quote, quote_spanned};
 use syn::{parse::Parse, spanned::Spanned, FnArg, ItemFn, ReturnType, Token, Type};
 
-pub(crate) fn expand(attr: Attrs, item_fn: ItemFn, kind: FunctionKind) -> TokenStream {
+pub(crate) fn expand(attr: Attrs, item_fn: &ItemFn, kind: FunctionKind) -> TokenStream {
     let Attrs { state_ty } = attr;
 
     let mut state_ty = state_ty.map(second);
 
-    let check_extractor_count = check_extractor_count(&item_fn, kind);
-    let check_path_extractor = check_path_extractor(&item_fn, kind);
-    let check_output_tuples = check_output_tuples(&item_fn);
+    let check_extractor_count = check_extractor_count(item_fn, kind);
+    let check_path_extractor = check_path_extractor(item_fn, kind);
+    let check_output_tuples = check_output_tuples(item_fn);
     let check_output_impls_into_response = if check_output_tuples.is_empty() {
-        check_output_impls_into_response(&item_fn)
+        check_output_impls_into_response(item_fn)
     } else {
         check_output_tuples
     };
@@ -28,7 +28,7 @@ pub(crate) fn expand(attr: Attrs, item_fn: ItemFn, kind: FunctionKind) -> TokenS
         let mut err = None;
 
         if state_ty.is_none() {
-            let state_types_from_args = state_types_from_args(&item_fn);
+            let state_types_from_args = state_types_from_args(item_fn);
 
             #[allow(clippy::comparison_chain)]
             if state_types_from_args.len() == 1 {
@@ -50,16 +50,16 @@ pub(crate) fn expand(attr: Attrs, item_fn: ItemFn, kind: FunctionKind) -> TokenS
         err.unwrap_or_else(|| {
             let state_ty = state_ty.unwrap_or_else(|| syn::parse_quote!(()));
 
-            let check_future_send = check_future_send(&item_fn, kind);
+            let check_future_send = check_future_send(item_fn, kind);
 
-            if let Some(check_input_order) = check_input_order(&item_fn, kind) {
+            if let Some(check_input_order) = check_input_order(item_fn, kind) {
                 quote! {
                     #check_input_order
                     #check_future_send
                 }
             } else {
                 let check_inputs_impls_from_request =
-                    check_inputs_impls_from_request(&item_fn, state_ty, kind);
+                    check_inputs_impls_from_request(item_fn, &state_ty, kind);
 
                 quote! {
                     #check_inputs_impls_from_request
@@ -76,7 +76,7 @@ pub(crate) fn expand(attr: Attrs, item_fn: ItemFn, kind: FunctionKind) -> TokenS
     };
 
     let middleware_takes_next_as_last_arg =
-        matches!(kind, FunctionKind::Middleware).then(|| next_is_last_input(&item_fn));
+        matches!(kind, FunctionKind::Middleware).then(|| next_is_last_input(item_fn));
 
     quote! {
         #item_fn
@@ -104,7 +104,7 @@ impl fmt::Display for FunctionKind {
 }
 
 impl FunctionKind {
-    fn name_uppercase_plural(&self) -> &'static str {
+    fn name_uppercase_plural(self) -> &'static str {
         match self {
             Self::Handler => "Handlers",
             Self::Middleware => "Middleware",
@@ -222,7 +222,7 @@ fn is_self_pat_type(typed: &syn::PatType) -> bool {
 
 fn check_inputs_impls_from_request(
     item_fn: &ItemFn,
-    state_ty: Type,
+    state_ty: &Type,
     kind: FunctionKind,
 ) -> TokenStream {
     let takes_self = item_fn.sig.inputs.first().is_some_and(|arg| match arg {

axum-macros/src/from_request/mod.rs

@@ -19,7 +19,7 @@ pub(crate) enum Trait {
 }
 
 impl Trait {
-    fn via_marker_type(&self) -> Option<Type> {
+    fn via_marker_type(self) -> Option<Type> {
         match self {
             Self::FromRequest => Some(parse_quote!(M)),
             Self::FromRequestParts => None,
@@ -132,17 +132,17 @@ pub(crate) fn expand(item: syn::Item, tr: Trait) -> syn::Result<TokenStream> {
 
             let trait_impl = match (via.map(second), rejection.map(second)) {
                 (Some(via), rejection) => impl_struct_by_extracting_all_at_once(
-                    ident,
+                    &ident,
                     fields,
-                    via,
-                    rejection,
-                    generic_ident,
+                    &via,
+                    rejection.as_ref(),
+                    generic_ident.as_ref(),
                     &state,
                     tr,
                 )?,
                 (None, rejection) => {
                     error_on_generic_ident(generic_ident, tr)?;
-                    impl_struct_by_extracting_each_field(ident, fields, rejection, &state, tr)?
+                    impl_struct_by_extracting_each_field(&ident, &fields, rejection, &state, tr)?
                 }
             };
 
@@ -206,11 +206,11 @@ pub(crate) fn expand(item: syn::Item, tr: Trait) -> syn::Result<TokenStream> {
 
             match (via.map(second), rejection) {
                 (Some(via), rejection) => impl_enum_by_extracting_all_at_once(
-                    ident,
+                    &ident,
                     variants,
-                    via,
-                    rejection.map(second),
-                    state,
+                    &via,
+                    rejection.map(second).as_ref(),
+                    &state,
                     tr,
                 ),
                 (None, Some((rejection_kw, _))) => Err(syn::Error::new_spanned(
@@ -328,8 +328,8 @@ fn error_on_generic_ident(generic_ident: Option<Ident>, tr: Trait) -> syn::Resul
 }
 
 fn impl_struct_by_extracting_each_field(
-    ident: syn::Ident,
-    fields: syn::Fields,
+    ident: &syn::Ident,
+    fields: &syn::Fields,
     rejection: Option<syn::Path>,
     state: &State,
     tr: Trait,
@@ -339,7 +339,7 @@ fn impl_struct_by_extracting_each_field(
             ::std::unimplemented!()
         }
     } else {
-        let extract_fields = extract_fields(&fields, &rejection, tr)?;
+        let extract_fields = extract_fields(fields, rejection.as_ref(), tr)?;
         quote! {
             ::std::result::Result::Ok(Self {
                 #(#extract_fields)*
@@ -349,7 +349,7 @@ fn impl_struct_by_extracting_each_field(
 
     let rejection_ident = if let Some(rejection) = rejection {
         quote!(#rejection)
-    } else if has_no_fields(&fields) {
+    } else if has_no_fields(fields) {
         quote!(::std::convert::Infallible)
     } else {
         quote!(::axum::response::Response)
@@ -411,7 +411,7 @@ fn has_no_fields(fields: &syn::Fields) -> bool {
 
 fn extract_fields(
     fields: &syn::Fields,
-    rejection: &Option<syn::Path>,
+    rejection: Option<&syn::Path>,
     tr: Trait,
 ) -> syn::Result<Vec<TokenStream>> {
     fn member(field: &syn::Field, index: usize) -> TokenStream {
@@ -426,7 +426,7 @@ fn extract_fields(
         }
     }
 
-    fn into_inner(via: &Option<(attr::kw::via, syn::Path)>, ty_span: Span) -> TokenStream {
+    fn into_inner(via: Option<&(attr::kw::via, syn::Path)>, ty_span: Span) -> TokenStream {
         if let Some((_, path)) = via {
             let span = path.span();
             quote_spanned! {span=>
@@ -440,7 +440,7 @@ fn extract_fields(
     }
 
     fn into_outer(
-        via: &Option<(attr::kw::via, syn::Path)>,
+        via: Option<&(attr::kw::via, syn::Path)>,
         ty_span: Span,
         field_ty: &Type,
     ) -> TokenStream {
@@ -472,10 +472,10 @@ fn extract_fields(
 
             let member = member(field, index);
             let ty_span = field.ty.span();
-            let into_inner = into_inner(&via, ty_span);
+            let into_inner = into_inner(via.as_ref(), ty_span);
 
             if peel_option(&field.ty).is_some() {
-                let field_ty = into_outer(&via, ty_span, peel_option(&field.ty).unwrap());
+                let field_ty = into_outer(via.as_ref(), ty_span, peel_option(&field.ty).unwrap());
                 let tokens = match tr {
                     Trait::FromRequest => {
                         quote_spanned! {ty_span=>
@@ -510,7 +510,7 @@ fn extract_fields(
                 };
                 Ok(tokens)
             } else if peel_result_ok(&field.ty).is_some() {
-                let field_ty = into_outer(&via,ty_span, peel_result_ok(&field.ty).unwrap());
+                let field_ty = into_outer(via.as_ref(), ty_span, peel_result_ok(&field.ty).unwrap());
                 let tokens = match tr {
                     Trait::FromRequest => {
                         quote_spanned! {ty_span=>
@@ -543,7 +543,7 @@ fn extract_fields(
                 };
                 Ok(tokens)
             } else {
-                let field_ty = into_outer(&via,ty_span,&field.ty);
+                let field_ty = into_outer(via.as_ref(), ty_span, &field.ty);
                 let map_err = if let Some(rejection) = rejection {
                     quote! { <#rejection as ::std::convert::From<_>>::from }
                 } else {
@@ -593,10 +593,10 @@ fn extract_fields(
 
         let member = member(field, fields.len() - 1);
         let ty_span = field.ty.span();
-        let into_inner = into_inner(&via, ty_span);
+        let into_inner = into_inner(via.as_ref(), ty_span);
 
         let item = if peel_option(&field.ty).is_some() {
-            let field_ty = into_outer(&via, ty_span, peel_option(&field.ty).unwrap());
+            let field_ty = into_outer(via.as_ref(), ty_span, peel_option(&field.ty).unwrap());
             quote_spanned! {ty_span=>
                 #member: {
                     <#field_ty as ::axum::extract::FromRequest<_, _>>::from_request(req, state)
@@ -606,7 +606,7 @@ fn extract_fields(
                 },
             }
         } else if peel_result_ok(&field.ty).is_some() {
-            let field_ty = into_outer(&via, ty_span, peel_result_ok(&field.ty).unwrap());
+            let field_ty = into_outer(via.as_ref(), ty_span, peel_result_ok(&field.ty).unwrap());
             quote_spanned! {ty_span=>
                 #member: {
                     <#field_ty as ::axum::extract::FromRequest<_, _>>::from_request(req, state)
@@ -615,7 +615,7 @@ fn extract_fields(
                 },
             }
         } else {
-            let field_ty = into_outer(&via, ty_span, &field.ty);
+            let field_ty = into_outer(via.as_ref(), ty_span, &field.ty);
             let map_err = if let Some(rejection) = rejection {
                 quote! { <#rejection as ::std::convert::From<_>>::from }
             } else {
@@ -697,11 +697,11 @@ fn peel_result_ok(ty: &syn::Type) -> Option<&syn::Type> {
 }
 
 fn impl_struct_by_extracting_all_at_once(
-    ident: syn::Ident,
+    ident: &syn::Ident,
     fields: syn::Fields,
-    via_path: syn::Path,
-    rejection: Option<syn::Path>,
-    generic_ident: Option<Ident>,
+    via_path: &syn::Path,
+    rejection: Option<&syn::Path>,
+    generic_ident: Option<&Ident>,
     state: &State,
     tr: Trait,
 ) -> syn::Result<TokenStream> {
@@ -750,7 +750,7 @@ fn impl_struct_by_extracting_all_at_once(
     // - `State`, not other extractors
     //
     // honestly not sure why but the tests all pass
-    let via_marker_type = if path_ident_is_state(&via_path) {
+    let via_marker_type = if path_ident_is_state(via_path) {
         tr.via_marker_type()
     } else {
         None
@@ -868,11 +868,11 @@ fn impl_struct_by_extracting_all_at_once(
 }
 
 fn impl_enum_by_extracting_all_at_once(
-    ident: syn::Ident,
+    ident: &syn::Ident,
     variants: Punctuated<syn::Variant, Token![,]>,
-    path: syn::Path,
-    rejection: Option<syn::Path>,
-    state: State,
+    path: &syn::Path,
+    rejection: Option<&syn::Path>,
+    state: &State,
     tr: Trait,
 ) -> syn::Result<TokenStream> {
     for variant in variants {

axum-macros/src/lib.rs

@@ -579,7 +579,7 @@ pub fn debug_handler(_attr: TokenStream, input: TokenStream) -> TokenStream {
 
     #[cfg(debug_assertions)]
     return expand_attr_with(_attr, input, |attrs, item_fn| {
-        debug_handler::expand(attrs, item_fn, FunctionKind::Handler)
+        debug_handler::expand(attrs, &item_fn, FunctionKind::Handler)
     });
 }
 
@@ -635,7 +635,7 @@ pub fn debug_middleware(_attr: TokenStream, input: TokenStream) -> TokenStream {
 
     #[cfg(debug_assertions)]
     return expand_attr_with(_attr, input, |attrs, item_fn| {
-        debug_handler::expand(attrs, item_fn, FunctionKind::Middleware)
+        debug_handler::expand(attrs, &item_fn, FunctionKind::Middleware)
     });
 }
 
@@ -662,7 +662,7 @@ pub fn __private_axum_test(_attr: TokenStream, input: TokenStream) -> TokenStrea
 /// [`axum_extra::routing::TypedPath`]: https://docs.rs/axum-extra/latest/axum_extra/routing/trait.TypedPath.html
 #[proc_macro_derive(TypedPath, attributes(typed_path))]
 pub fn derive_typed_path(input: TokenStream) -> TokenStream {
-    expand_with(input, typed_path::expand)
+    expand_with(input, |item_struct| typed_path::expand(&item_struct))
 }
 
 /// Derive an implementation of [`FromRef`] for each field in a struct.