Add axum-macros crate with #[derive(FromRequest)] (#718)

* initial working impl * support `#[from_request(via(...))]` * support extracting the whole thing at once * rely on type inference * fix footgun * fix typo * generate rejection enums * move tests to trybuild * minor clean up * docs * Support multiple generic extractors with same "via" type * support `Result` as well * Update axum-macros/src/from_request.rs Co-authored-by: Jonas Platte <jplatte@users.noreply.github.com> * Add `#[automatically_derived]` * remove needless `#[derive(Debug)]` on macro types * Fix error messages that different for some reason * Update axum-macros/src/lib.rs Co-authored-by: Jonas Platte <jplatte@users.noreply.github.com> * add more `#[automatically_derived]` * support same types in tuple structs * update docs * prep axum-macros for release * address review feedback * Update axum-macros/src/lib.rs Co-authored-by: Jonas Platte <jplatte@users.noreply.github.com> * Update axum-macros/src/lib.rs Co-authored-by: Jonas Platte <jplatte@users.noreply.github.com> * Update known limitation Co-authored-by: Jonas Platte <jplatte@users.noreply.github.com>
2025-04-03 21:15:55 +02:00 · 2022-01-25 15:05:50 +01:00 · 2022-01-25 15:05:50 +01:00 · e4c389c94d
commit e4c389c94d
parent 9004a14302
23 changed files with 1190 additions and 0 deletions
--- a/Cargo.toml
+++ b/Cargo.toml
@ -4,5 +4,6 @@ members = [
    "axum-core",
    "axum-debug",
    "axum-extra",
+    "axum-macros",
    "examples/*",
 ]
--- a/axum-macros/CHANGELOG.md
+++ b/axum-macros/CHANGELOG.md
@ -0,0 +1,14 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+# Unreleased
+
+- None.
+
+# 0.1.0 (TODO)
+
+- Initial release.
--- a/axum-macros/Cargo.toml
+++ b/axum-macros/Cargo.toml
@ -0,0 +1,26 @@
+[package]
+categories = ["asynchronous", "network-programming", "web-programming"]
+description = "Macros for axum"
+edition = "2018"
+homepage = "https://github.com/tokio-rs/axum"
+keywords = ["axum"]
+license = "MIT"
+name = "axum-macros"
+readme = "README.md"
+repository = "https://github.com/tokio-rs/axum"
+version = "0.1.0"
+
+[lib]
+proc-macro = true
+
+[dependencies]
+heck = "0.4"
+proc-macro2 = "1.0"
+quote = "1.0"
+syn = { version = "1.0", features = ["full"] }
+
+[dev-dependencies]
+axum = { path = "../axum", version = "0.4", features = ["headers"] }
+rustversion = "1.0"
+serde = { version = "1.0", features = ["derive"] }
+trybuild = "1.0"
--- a/axum-macros/LICENSE
+++ b/axum-macros/LICENSE
@ -0,0 +1,7 @@
+Copyright 2021 Axum Debug Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/axum-macros/README.md
+++ b/axum-macros/README.md
@ -0,0 +1,45 @@
+# axum-macros
+
+[![Build status](https://github.com/tokio-rs/axum/actions/workflows/CI.yml/badge.svg?branch=main)](https://github.com/tokio-rs/axum-macros/actions/workflows/CI.yml)
+[![Crates.io](https://img.shields.io/crates/v/axum-macros)](https://crates.io/crates/axum-macros)
+[![Documentation](https://docs.rs/axum-macros/badge.svg)](https://docs.rs/axum-macros)
+
+Macros for [`axum`].
+
+More information about this crate can be found in the [crate documentation][docs].
+
+## Safety
+
+This crate uses `#![forbid(unsafe_code)]` to ensure everything is implemented in 100% safe Rust.
+
+## Minimum supported Rust version
+
+axum-macros's MSRV is 1.54.
+
+## Getting Help
+
+You're also welcome to ask in the [Discord channel][chat] or open an [issue]
+with your question.
+
+## Contributing
+
+:balloon: Thanks for your help improving the project! We are so happy to have
+you! We have a [contributing guide][contributing] to help you get involved in the
+`axum` project.
+
+## License
+
+This project is licensed under the [MIT license][license].
+
+### Contribution
+
+Unless you explicitly state otherwise, any contribution intentionally submitted
+for inclusion in `axum` by you, shall be licensed as MIT, without any
+additional terms or conditions.
+
+[`axum`]: https://crates.io/crates/axum
+[chat]: https://discord.gg/tokio
+[contributing]: /CONTRIBUTING.md
+[docs]: https://docs.rs/axum-macros
+[license]: /axum-macros/LICENSE
+[issue]: https://github.com/tokio-rs/axum/issues/new
--- a/axum-macros/src/from_request.rs
+++ b/axum-macros/src/from_request.rs
@ -0,0 +1,531 @@
+use heck::ToUpperCamelCase;
+use proc_macro2::TokenStream;
+use quote::{format_ident, quote, quote_spanned};
+use syn::{
+    parse::{Parse, ParseStream},
+    punctuated::Punctuated,
+    spanned::Spanned,
+    Token,
+};
+
+const GENERICS_ERROR: &str = "`#[derive(FromRequest)] doesn't support generics";
+
+pub(crate) fn expand(item: syn::ItemStruct) -> syn::Result<TokenStream> {
+    let syn::ItemStruct {
+        attrs,
+        ident,
+        generics,
+        fields,
+        semi_token: _,
+        vis,
+        struct_token: _,
+    } = item;
+
+    if !generics.params.is_empty() {
+        return Err(syn::Error::new_spanned(generics, GENERICS_ERROR));
+    }
+
+    if let Some(where_clause) = generics.where_clause {
+        return Err(syn::Error::new_spanned(where_clause, GENERICS_ERROR));
+    }
+
+    let FromRequestAttrs { via } = parse_attrs(&attrs)?;
+
+    if let Some((_, path)) = via {
+        impl_by_extracting_all_at_once(ident, fields, path)
+    } else {
+        impl_by_extracting_each_field(ident, fields, vis)
+    }
+}
+
+fn impl_by_extracting_each_field(
+    ident: syn::Ident,
+    fields: syn::Fields,
+    vis: syn::Visibility,
+) -> syn::Result<TokenStream> {
+    let extract_fields = extract_fields(&fields)?;
+
+    let (rejection_ident, rejection) = if let syn::Fields::Unit = &fields {
+        (syn::parse_quote!(::std::convert::Infallible), quote! {})
+    } else {
+        let rejection_ident = rejection_ident(&ident);
+        let rejection = extract_each_field_rejection(&ident, &fields, &vis)?;
+        (rejection_ident, rejection)
+    };
+
+    Ok(quote! {
+        #[::axum::async_trait]
+        #[automatically_derived]
+        impl<B> ::axum::extract::FromRequest<B> for #ident
+        where
+            B: ::axum::body::HttpBody + ::std::marker::Send + 'static,
+            B::Data: ::std::marker::Send,
+            B::Error: ::std::convert::Into<::axum::BoxError>,
+        {
+            type Rejection = #rejection_ident;
+
+            async fn from_request(
+                req: &mut ::axum::extract::RequestParts<B>,
+            ) -> ::std::result::Result<Self, Self::Rejection> {
+                ::std::result::Result::Ok(Self {
+                    #(#extract_fields)*
+                })
+            }
+        }
+
+        #rejection
+    })
+}
+
+fn rejection_ident(ident: &syn::Ident) -> syn::Type {
+    let ident = format_ident!("{}Rejection", ident);
+    syn::parse_quote!(#ident)
+}
+
+fn extract_fields(fields: &syn::Fields) -> syn::Result<Vec<TokenStream>> {
+    fields
+        .iter()
+        .enumerate()
+        .map(|(index, field)| {
+            let FromRequestAttrs { via } = parse_attrs(&field.attrs)?;
+
+            let member = if let Some(ident) = &field.ident {
+                quote! { #ident }
+            } else {
+                let member = syn::Member::Unnamed(syn::Index {
+                    index: index as u32,
+                    span: field.span(),
+                });
+                quote! { #member }
+            };
+
+            let ty_span = field.ty.span();
+
+            let into_inner = if let Some((_, path)) = via {
+                let span = path.span();
+                quote_spanned! {span=>
+                    |#path(inner)| inner
+                }
+            } else {
+                quote_spanned! {ty_span=>
+                    ::std::convert::identity
+                }
+            };
+
+            let rejection_variant_name = rejection_variant_name(field)?;
+
+            if peel_option(&field.ty).is_some() {
+                Ok(quote_spanned! {ty_span=>
+                    #member: {
+                        ::axum::extract::FromRequest::from_request(req)
+                            .await
+                            .ok()
+                            .map(#into_inner)
+                    },
+                })
+            } else if peel_result_ok(&field.ty).is_some() {
+                Ok(quote_spanned! {ty_span=>
+                    #member: {
+                        ::axum::extract::FromRequest::from_request(req)
+                            .await
+                            .map(#into_inner)
+                    },
+                })
+            } else {
+                Ok(quote_spanned! {ty_span=>
+                    #member: {
+                        ::axum::extract::FromRequest::from_request(req)
+                            .await
+                            .map(#into_inner)
+                            .map_err(Self::Rejection::#rejection_variant_name)?
+                    },
+                })
+            }
+        })
+        .collect()
+}
+
+fn peel_option(ty: &syn::Type) -> Option<&syn::Type> {
+    let type_path = if let syn::Type::Path(type_path) = ty {
+        type_path
+    } else {
+        return None;
+    };
+
+    let segment = type_path.path.segments.last()?;
+
+    if segment.ident != "Option" {
+        return None;
+    }
+
+    let args = match &segment.arguments {
+        syn::PathArguments::AngleBracketed(args) => args,
+        syn::PathArguments::Parenthesized(_) | syn::PathArguments::None => return None,
+    };
+
+    let ty = if args.args.len() == 1 {
+        args.args.last().unwrap()
+    } else {
+        return None;
+    };
+
+    if let syn::GenericArgument::Type(ty) = ty {
+        Some(ty)
+    } else {
+        None
+    }
+}
+
+fn peel_result_ok(ty: &syn::Type) -> Option<&syn::Type> {
+    let type_path = if let syn::Type::Path(type_path) = ty {
+        type_path
+    } else {
+        return None;
+    };
+
+    let segment = type_path.path.segments.last()?;
+
+    if segment.ident != "Result" {
+        return None;
+    }
+
+    let args = match &segment.arguments {
+        syn::PathArguments::AngleBracketed(args) => args,
+        syn::PathArguments::Parenthesized(_) | syn::PathArguments::None => return None,
+    };
+
+    let ty = if args.args.len() == 2 {
+        args.args.first().unwrap()
+    } else {
+        return None;
+    };
+
+    if let syn::GenericArgument::Type(ty) = ty {
+        Some(ty)
+    } else {
+        None
+    }
+}
+
+fn extract_each_field_rejection(
+    ident: &syn::Ident,
+    fields: &syn::Fields,
+    vis: &syn::Visibility,
+) -> syn::Result<TokenStream> {
+    let rejection_ident = rejection_ident(ident);
+
+    let variants = fields
+        .iter()
+        .map(|field| {
+            let FromRequestAttrs { via } = parse_attrs(&field.attrs)?;
+
+            let field_ty = &field.ty;
+            let ty_span = field_ty.span();
+
+            let variant_name = rejection_variant_name(field)?;
+
+            let extractor_ty = if let Some((_, path)) = via {
+                if let Some(inner) = peel_option(field_ty) {
+                    quote_spanned! {ty_span=>
+                        ::std::option::Option<#path<#inner>>
+                    }
+                } else if let Some(inner) = peel_result_ok(field_ty) {
+                    quote_spanned! {ty_span=>
+                        ::std::result::Result<#path<#inner>, TypedHeaderRejection>
+                    }
+                } else {
+                    quote_spanned! {ty_span=> #path<#field_ty> }
+                }
+            } else {
+                quote_spanned! {ty_span=> #field_ty }
+            };
+
+            Ok(quote_spanned! {ty_span=>
+                #[allow(non_camel_case_types)]
+                #variant_name(<#extractor_ty as ::axum::extract::FromRequest<::axum::body::Body>>::Rejection),
+            })
+        })
+        .collect::<syn::Result<Vec<_>>>()?;
+
+    let impl_into_response = {
+        let arms = fields
+            .iter()
+            .map(|field| {
+                let variant_name = rejection_variant_name(field)?;
+                Ok(quote! {
+                    Self::#variant_name(inner) => inner.into_response(),
+                })
+            })
+            .collect::<syn::Result<Vec<_>>>()?;
+
+        quote! {
+            #[automatically_derived]
+            impl ::axum::response::IntoResponse for #rejection_ident {
+                fn into_response(self) -> ::axum::response::Response {
+                    match self {
+                        #(#arms)*
+                    }
+                }
+            }
+        }
+    };
+
+    let impl_display = {
+        let arms = fields
+            .iter()
+            .map(|field| {
+                let variant_name = rejection_variant_name(field)?;
+                Ok(quote! {
+                    Self::#variant_name(inner) => inner.fmt(f),
+                })
+            })
+            .collect::<syn::Result<Vec<_>>>()?;
+
+        quote! {
+            #[automatically_derived]
+            impl ::std::fmt::Display for #rejection_ident {
+                fn fmt(&self, f: &mut ::std::fmt::Formatter<'_>) -> ::std::fmt::Result {
+                    match self {
+                        #(#arms)*
+                    }
+                }
+            }
+        }
+    };
+
+    let impl_error = {
+        let arms = fields
+            .iter()
+            .map(|field| {
+                let variant_name = rejection_variant_name(field)?;
+                Ok(quote! {
+                    Self::#variant_name(inner) => Some(inner),
+                })
+            })
+            .collect::<syn::Result<Vec<_>>>()?;
+
+        quote! {
+            #[automatically_derived]
+            impl ::std::error::Error for #rejection_ident {
+                fn source(&self) -> ::std::option::Option<&(dyn ::std::error::Error + 'static)> {
+                    match self {
+                        #(#arms)*
+                    }
+                }
+            }
+        }
+    };
+
+    Ok(quote! {
+        #[derive(Debug)]
+        #vis enum #rejection_ident {
+            #(#variants)*
+        }
+
+        #impl_into_response
+        #impl_display
+        #impl_error
+    })
+}
+
+fn rejection_variant_name(field: &syn::Field) -> syn::Result<syn::Ident> {
+    fn rejection_variant_name_for_type(out: &mut String, ty: &syn::Type) -> syn::Result<()> {
+        if let syn::Type::Path(type_path) = ty {
+            let segment = type_path
+                .path
+                .segments
+                .last()
+                .ok_or_else(|| syn::Error::new_spanned(ty, "Empty type path"))?;
+
+            out.push_str(&segment.ident.to_string());
+
+            match &segment.arguments {
+                syn::PathArguments::AngleBracketed(args) => {
+                    let ty = if args.args.len() == 1 {
+                        args.args.last().unwrap()
+                    } else if args.args.len() == 2 {
+                        if segment.ident == "Result" {
+                            args.args.first().unwrap()
+                        } else {
+                            return Err(syn::Error::new_spanned(
+                                segment,
+                                "Only `Result<T, E>` is supported with two generics type paramters",
+                            ));
+                        }
+                    } else {
+                        return Err(syn::Error::new_spanned(
+                            &args.args,
+                            "Expected exactly one or two type paramters",
+                        ));
+                    };
+
+                    if let syn::GenericArgument::Type(ty) = ty {
+                        rejection_variant_name_for_type(out, ty)
+                    } else {
+                        Err(syn::Error::new_spanned(ty, "Expected type path"))
+                    }
+                }
+                syn::PathArguments::Parenthesized(args) => {
+                    Err(syn::Error::new_spanned(args, "Unsupported"))
+                }
+                syn::PathArguments::None => Ok(()),
+            }
+        } else {
+            Err(syn::Error::new_spanned(ty, "Expected type path"))
+        }
+    }
+
+    if let Some(ident) = &field.ident {
+        Ok(format_ident!("{}", ident.to_string().to_upper_camel_case()))
+    } else {
+        let mut out = String::new();
+        rejection_variant_name_for_type(&mut out, &field.ty)?;
+
+        let FromRequestAttrs { via } = parse_attrs(&field.attrs)?;
+        if let Some((_, path)) = via {
+            let via_ident = &path.segments.last().unwrap().ident;
+            Ok(format_ident!("{}{}", via_ident, out))
+        } else {
+            Ok(format_ident!("{}", out))
+        }
+    }
+}
+
+fn impl_by_extracting_all_at_once(
+    ident: syn::Ident,
+    fields: syn::Fields,
+    path: syn::Path,
+) -> syn::Result<TokenStream> {
+    let fields = match fields {
+        syn::Fields::Named(fields) => fields.named.into_iter(),
+        syn::Fields::Unnamed(fields) => fields.unnamed.into_iter(),
+        syn::Fields::Unit => Punctuated::<_, Token![,]>::new().into_iter(),
+    };
+
+    for field in fields {
+        let FromRequestAttrs { via } = parse_attrs(&field.attrs)?;
+        if let Some((via, _)) = via {
+            return Err(syn::Error::new_spanned(
+                via,
+                "`#[from_request(via(...))]` on a field cannot be used \
+                together with `#[from_request(...)]` on the container",
+            ));
+        }
+    }
+
+    let path_span = path.span();
+
+    Ok(quote_spanned! {path_span=>
+        #[::axum::async_trait]
+        #[automatically_derived]
+        impl<B> ::axum::extract::FromRequest<B> for #ident
+        where
+            B: ::axum::body::HttpBody + ::std::marker::Send + 'static,
+            B::Data: ::std::marker::Send,
+            B::Error: ::std::convert::Into<::axum::BoxError>,
+        {
+            type Rejection = <#path<Self> as ::axum::extract::FromRequest<B>>::Rejection;
+
+            async fn from_request(
+                req: &mut ::axum::extract::RequestParts<B>,
+            ) -> ::std::result::Result<Self, Self::Rejection> {
+                ::axum::extract::FromRequest::<B>::from_request(req)
+                    .await
+                    .map(|#path(inner)| inner)
+            }
+        }
+    })
+}
+
+#[derive(Default)]
+struct FromRequestAttrs {
+    via: Option<(kw::via, syn::Path)>,
+}
+
+mod kw {
+    syn::custom_keyword!(via);
+}
+
+fn parse_attrs(attrs: &[syn::Attribute]) -> syn::Result<FromRequestAttrs> {
+    enum Attr {
+        FromRequest(Punctuated<FromRequestAttr, Token![,]>),
+    }
+
+    enum FromRequestAttr {
+        Via { via: kw::via, path: syn::Path },
+    }
+
+    impl Parse for FromRequestAttr {
+        fn parse(input: ParseStream) -> syn::Result<Self> {
+            let lh = input.lookahead1();
+            if lh.peek(kw::via) {
+                let via = input.parse::<kw::via>()?;
+                let content;
+                syn::parenthesized!(content in input);
+                content.parse().map(|path| Self::Via { via, path })
+            } else {
+                Err(lh.error())
+            }
+        }
+    }
+
+    let attrs = attrs
+        .iter()
+        .filter(|attr| attr.path.is_ident("from_request"))
+        .map(|attr| {
+            attr.parse_args_with(Punctuated::parse_terminated)
+                .map(Attr::FromRequest)
+        })
+        .collect::<syn::Result<Vec<_>>>()?;
+
+    let mut out = FromRequestAttrs::default();
+    for attr in attrs {
+        match attr {
+            Attr::FromRequest(from_request_attrs) => {
+                for from_request_attr in from_request_attrs {
+                    match from_request_attr {
+                        FromRequestAttr::Via { via, path } => {
+                            if out.via.is_some() {
+                                return Err(syn::Error::new_spanned(
+                                    via,
+                                    "`via` specified more than once",
+                                ));
+                            } else {
+                                out.via = Some((via, path));
+                            }
+                        }
+                    }
+                }
+            }
+        }
+    }
+
+    Ok(out)
+}
+
+#[test]
+fn ui() {
+    #[rustversion::stable]
+    fn go() {
+        let t = trybuild::TestCases::new();
+        t.compile_fail("tests/fail/*.rs");
+        t.pass("tests/pass/*.rs");
+    }
+
+    #[rustversion::not(stable)]
+    fn go() {}
+
+    go();
+}
+
+/// For some reason the compiler error for this is different locally and on CI. No idea why... So
+/// we don't use trybuild for this test.
+///
+/// ```compile_fail
+/// #[derive(axum_macros::FromRequest)]
+/// struct Extractor {
+///     thing: bool,
+/// }
+/// ```
+#[allow(dead_code)]
+fn test_field_doesnt_impl_from_request() {}
--- a/axum-macros/src/lib.rs
+++ b/axum-macros/src/lib.rs
@ -0,0 +1,258 @@
+//! Macros for [`axum`].
+//!
+//! [`axum`]: https://crates.io/crates/axum
+
+#![warn(
+    clippy::all,
+    clippy::dbg_macro,
+    clippy::todo,
+    clippy::empty_enum,
+    clippy::enum_glob_use,
+    clippy::mem_forget,
+    clippy::unused_self,
+    clippy::filter_map_next,
+    clippy::needless_continue,
+    clippy::needless_borrow,
+    clippy::match_wildcard_for_single_variants,
+    clippy::if_let_mutex,
+    clippy::mismatched_target_os,
+    clippy::await_holding_lock,
+    clippy::match_on_vec_items,
+    clippy::imprecise_flops,
+    clippy::suboptimal_flops,
+    clippy::lossy_float_literal,
+    clippy::rest_pat_in_fully_bound_structs,
+    clippy::fn_params_excessive_bools,
+    clippy::exit,
+    clippy::inefficient_to_string,
+    clippy::linkedlist,
+    clippy::macro_use_imports,
+    clippy::option_option,
+    clippy::verbose_file_reads,
+    clippy::unnested_or_patterns,
+    clippy::str_to_string,
+    rust_2018_idioms,
+    future_incompatible,
+    nonstandard_style,
+    missing_debug_implementations,
+    missing_docs
+)]
+#![deny(unreachable_pub, private_in_public)]
+#![allow(elided_lifetimes_in_paths, clippy::type_complexity)]
+#![forbid(unsafe_code)]
+#![cfg_attr(docsrs, feature(doc_cfg))]
+#![cfg_attr(test, allow(clippy::float_cmp))]
+
+use quote::{quote, ToTokens};
+use syn::parse::Parse;
+
+mod from_request;
+
+/// Derive an implementation of [`FromRequest`].
+///
+/// Supports generating two kinds of implementations:
+/// 1. One that extracts each field individually.
+/// 2. Another that extracts the whole type at once via another extractor.
+///
+/// # Each field individually
+///
+/// By default `#[derive(FromRequest)]` will call `FromRequest::from_request` for each field:
+///
+/// ```
+/// use axum_macros::FromRequest;
+/// use axum::{
+///     extract::{Extension, TypedHeader},
+///     headers::ContentType,
+///     body::Bytes,
+/// };
+///
+/// #[derive(FromRequest)]
+/// struct MyExtractor {
+///     state: Extension<State>,
+///     content_type: TypedHeader<ContentType>,
+///     request_body: Bytes,
+/// }
+///
+/// #[derive(Clone)]
+/// struct State {
+///     // ...
+/// }
+///
+/// async fn handler(extractor: MyExtractor) {}
+/// ```
+///
+/// This requires that each field is an extractor (i.e. implements [`FromRequest`]).
+///
+/// ## Extracting via another extractor
+///
+/// You can use `#[from_request(via(...))]` to extract a field via another extractor, meaning the
+/// field itself doesn't need to implement `FromRequest`:
+///
+/// ```
+/// use axum_macros::FromRequest;
+/// use axum::{
+///     extract::{Extension, TypedHeader},
+///     headers::ContentType,
+///     body::Bytes,
+/// };
+///
+/// #[derive(FromRequest)]
+/// struct MyExtractor {
+///     // This will extracted via `Extension::<State>::from_request`
+///     #[from_request(via(Extension))]
+///     state: State,
+///     // and this via `TypedHeader::<ContentType>::from_request`
+///     #[from_request(via(TypedHeader))]
+///     content_type: ContentType,
+///     // Can still be combined with other extractors
+///     request_body: Bytes,
+/// }
+///
+/// #[derive(Clone)]
+/// struct State {
+///     // ...
+/// }
+///
+/// async fn handler(extractor: MyExtractor) {}
+/// ```
+///
+/// Note this requires the via extractor to be a generic newtype struct (a tuple struct with
+/// exactly one public field) that implements `FromRequest`:
+///
+/// ```
+/// pub struct ViaExtractor<T>(pub T);
+///
+/// // impl<T, B> FromRequest<B> for ViaExtractor<T> { ... }
+/// ```
+///
+/// More complex via extractors are not supported and require writing a manual implementation.
+///
+/// ## Optional fields
+///
+/// `#[from_request(via(...))]` supports `Option<_>` and `Result<_, _>` to make fields optional:
+///
+/// ```
+/// use axum_macros::FromRequest;
+/// use axum::{
+///     extract::{TypedHeader, rejection::TypedHeaderRejection},
+///     headers::{ContentType, UserAgent},
+/// };
+///
+/// #[derive(FromRequest)]
+/// struct MyExtractor {
+///     // This will extracted via `Option::<TypedHeader<ContentType>>::from_request`
+///     #[from_request(via(TypedHeader))]
+///     content_type: Option<ContentType>,
+///     // This will extracted via
+///     // `Result::<TypedHeader<UserAgent>, TypedHeaderRejection>::from_request`
+///     #[from_request(via(TypedHeader))]
+///     user_agent: Result<UserAgent, TypedHeaderRejection>,
+/// }
+///
+/// async fn handler(extractor: MyExtractor) {}
+/// ```
+///
+/// ## The rejection
+///
+/// A rejection enum is also generated. It has a variant for each field:
+///
+/// ```
+/// use axum_macros::FromRequest;
+/// use axum::{
+///     extract::{Extension, TypedHeader},
+///     headers::ContentType,
+///     body::Bytes,
+/// };
+///
+/// #[derive(FromRequest)]
+/// struct MyExtractor {
+///     #[from_request(via(Extension))]
+///     state: State,
+///     #[from_request(via(TypedHeader))]
+///     content_type: ContentType,
+///     request_body: Bytes,
+/// }
+///
+/// // also generates
+/// //
+/// // #[derive(Debug)]
+/// // enum MyExtractorRejection {
+/// //     State(ExtensionRejection),
+/// //     ContentType(TypedHeaderRejection),
+/// //     RequestBody(BytesRejection),
+/// // }
+/// //
+/// // impl axum::response::IntoResponse for MyExtractor { ... }
+/// //
+/// // impl std::fmt::Display for MyExtractor { ... }
+/// //
+/// // impl std::error::Error for MyExtractor { ... }
+///
+/// #[derive(Clone)]
+/// struct State {
+///     // ...
+/// }
+/// ```
+///
+/// The rejection's `std::error::Error::source` implementation returns the inner rejection. This
+/// can be used to access source errors for example to customize rejection responses. Note this
+/// means the inner rejection types must themselves implement `std::error::Error`. All extractors
+/// in axum does this.
+///
+/// # The whole type at once
+///
+/// By using `#[from_request(via(...))]` on the container you can extract the whole type at once,
+/// instead of each field individually:
+///
+/// ```
+/// use axum_macros::FromRequest;
+/// use axum::extract::Extension;
+///
+/// // This will extracted via `Extension::<State>::from_request`
+/// #[derive(Clone, FromRequest)]
+/// #[from_request(via(Extension))]
+/// struct State {
+///     // ...
+/// }
+///
+/// async fn handler(state: State) {}
+/// ```
+///
+/// The rejection will be the "via extractors"'s rejection. For the previous example that would be
+/// [`axum::extract::rejection::ExtensionRejection`].
+///
+/// # Known limitations
+///
+/// Generics are currently not supported:
+///
+/// ```compile_fail
+/// #[derive(axum_macros::FromRequest)]
+/// struct MyExtractor<T> {
+///     thing: Option<T>,
+/// }
+/// ```
+///
+/// [`FromRequest`]: https://docs.rs/axum/latest/axum/extract/trait.FromRequest.html
+/// [`axum::extract::rejection::ExtensionRejection`]: https://docs.rs/axum/latest/axum/extract/rejection/enum.ExtensionRejection.html
+#[proc_macro_derive(FromRequest, attributes(from_request))]
+pub fn derive_from_request(item: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    expand_with(item, from_request::expand)
+}
+
+fn expand_with<F, T, K>(input: proc_macro::TokenStream, f: F) -> proc_macro::TokenStream
+where
+    F: FnOnce(T) -> syn::Result<K>,
+    T: Parse,
+    K: ToTokens,
+{
+    match syn::parse(input).and_then(f) {
+        Ok(tokens) => {
+            let tokens = (quote! { #tokens }).into();
+            if std::env::var_os("AXUM_MACROS_DEBUG").is_some() {
+                eprintln!("{}", tokens);
+            }
+            tokens
+        }
+        Err(err) => err.into_compile_error().into(),
+    }
+}
--- a/axum-macros/tests/fail/double_via_attr.rs
+++ b/axum-macros/tests/fail/double_via_attr.rs
@ -0,0 +1,10 @@
+use axum_macros::FromRequest;
+use axum::extract::Extension;
+
+#[derive(FromRequest)]
+struct Extractor(#[from_request(via(Extension), via(Extension))] State);
+
+#[derive(Clone)]
+struct State;
+
+fn main() {}
--- a/axum-macros/tests/fail/double_via_attr.stderr
+++ b/axum-macros/tests/fail/double_via_attr.stderr
@ -0,0 +1,13 @@
+error: `via` specified more than once
+ --> tests/fail/double_via_attr.rs:5:49
+  |
+5 | struct Extractor(#[from_request(via(Extension), via(Extension))] State);
+  |                                                 ^^^
+
+warning: unused import: `axum::extract::Extension`
+ --> tests/fail/double_via_attr.rs:2:5
+  |
+2 | use axum::extract::Extension;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `#[warn(unused_imports)]` on by default
--- a/axum-macros/tests/fail/generic.rs
+++ b/axum-macros/tests/fail/generic.rs
@ -0,0 +1,6 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor<T>(Option<T>);
+
+fn main() {}
--- a/axum-macros/tests/fail/generic.stderr
+++ b/axum-macros/tests/fail/generic.stderr
@ -0,0 +1,5 @@
+error: `#[derive(FromRequest)] doesn't support generics
+ --> tests/fail/generic.rs:4:17
+  |
+4 | struct Extractor<T>(Option<T>);
+  |                 ^^^
--- a/axum-macros/tests/fail/unknown_attr.rs
+++ b/axum-macros/tests/fail/unknown_attr.rs
@ -0,0 +1,6 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor(#[from_request(foo)] String);
+
+fn main() {}
--- a/axum-macros/tests/fail/unknown_attr.stderr
+++ b/axum-macros/tests/fail/unknown_attr.stderr
@ -0,0 +1,5 @@
+error: expected `via`
+ --> tests/fail/unknown_attr.rs:4:33
+  |
+4 | struct Extractor(#[from_request(foo)] String);
+  |                                 ^^^
--- a/axum-macros/tests/fail/via_on_container_and_field.rs
+++ b/axum-macros/tests/fail/via_on_container_and_field.rs
@ -0,0 +1,11 @@
+use axum_macros::FromRequest;
+use axum::extract::Extension;
+
+#[derive(FromRequest)]
+#[from_request(via(Extension))]
+struct Extractor(#[from_request(via(Extension))] State);
+
+#[derive(Clone)]
+struct State;
+
+fn main() {}
--- a/axum-macros/tests/fail/via_on_container_and_field.stderr
+++ b/axum-macros/tests/fail/via_on_container_and_field.stderr
@ -0,0 +1,13 @@
+error: `#[from_request(via(...))]` on a field cannot be used together with `#[from_request(...)]` on the container
+ --> tests/fail/via_on_container_and_field.rs:6:33
+  |
+6 | struct Extractor(#[from_request(via(Extension))] State);
+  |                                 ^^^
+
+warning: unused import: `axum::extract::Extension`
+ --> tests/fail/via_on_container_and_field.rs:2:5
+  |
+2 | use axum::extract::Extension;
+  |     ^^^^^^^^^^^^^^^^^^^^^^^^
+  |
+  = note: `#[warn(unused_imports)]` on by default
--- a/axum-macros/tests/pass/container.rs
+++ b/axum-macros/tests/pass/container.rs
@ -0,0 +1,22 @@
+use axum::{
+    body::Body,
+    extract::{rejection::JsonRejection, FromRequest, Json},
+};
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+#[derive(Deserialize, FromRequest)]
+#[from_request(via(Json))]
+struct Extractor {
+    one: i32,
+    two: String,
+    three: bool,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<Body, Rejection = JsonRejection>,
+{
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/named.rs
+++ b/axum-macros/tests/pass/named.rs
@ -0,0 +1,51 @@
+use axum::{
+    body::Body,
+    extract::{FromRequest, TypedHeader, rejection::{TypedHeaderRejection, StringRejection}},
+    headers::{self, UserAgent},
+};
+use axum_macros::FromRequest;
+use std::convert::Infallible;
+
+#[derive(FromRequest)]
+struct Extractor {
+    uri: axum::http::Uri,
+    user_agent: TypedHeader<UserAgent>,
+    content_type: TypedHeader<headers::ContentType>,
+    etag: Option<TypedHeader<headers::ETag>>,
+    host: Result<TypedHeader<headers::Host>, TypedHeaderRejection>,
+    body: String,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<Body, Rejection = ExtractorRejection>,
+{
+}
+
+fn assert_rejection(rejection: ExtractorRejection)
+where
+    ExtractorRejection: std::fmt::Debug + std::fmt::Display + std::error::Error,
+{
+    match rejection {
+        ExtractorRejection::Uri(inner) => {
+            let _: Infallible = inner;
+        }
+        ExtractorRejection::Body(inner) => {
+            let _: StringRejection = inner;
+        }
+        ExtractorRejection::UserAgent(inner) => {
+            let _: TypedHeaderRejection = inner;
+        }
+        ExtractorRejection::ContentType(inner) => {
+            let _: TypedHeaderRejection = inner;
+        }
+        ExtractorRejection::Etag(inner) => {
+            let _: Infallible = inner;
+        }
+        ExtractorRejection::Host(inner) => {
+            let _: Infallible = inner;
+        }
+    }
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/named_via.rs
+++ b/axum-macros/tests/pass/named_via.rs
@ -0,0 +1,58 @@
+use axum::{
+    body::Body,
+    extract::{
+        rejection::{ExtensionRejection, TypedHeaderRejection},
+        Extension, FromRequest, TypedHeader,
+    },
+    headers::{self, UserAgent},
+};
+use axum_macros::FromRequest;
+use std::convert::Infallible;
+
+#[derive(FromRequest)]
+struct Extractor {
+    #[from_request(via(Extension))]
+    state: State,
+    #[from_request(via(TypedHeader))]
+    user_agent: UserAgent,
+    #[from_request(via(TypedHeader))]
+    content_type: headers::ContentType,
+    #[from_request(via(TypedHeader))]
+    etag: Option<headers::ETag>,
+    #[from_request(via(TypedHeader))]
+    host: Result<headers::Host, TypedHeaderRejection>,
+}
+
+fn assert_from_request()
+where
+    Extractor: FromRequest<Body, Rejection = ExtractorRejection>,
+{
+}
+
+fn assert_rejection(rejection: ExtractorRejection)
+where
+    ExtractorRejection: std::fmt::Debug + std::fmt::Display + std::error::Error,
+{
+    match rejection {
+        ExtractorRejection::State(inner) => {
+            let _: ExtensionRejection = inner;
+        }
+        ExtractorRejection::UserAgent(inner) => {
+            let _: TypedHeaderRejection = inner;
+        }
+        ExtractorRejection::ContentType(inner) => {
+            let _: TypedHeaderRejection = inner;
+        }
+        ExtractorRejection::Etag(inner) => {
+            let _: Infallible = inner;
+        }
+        ExtractorRejection::Host(inner) => {
+            let _: Infallible = inner;
+        }
+    }
+}
+
+#[derive(Clone)]
+struct State;
+
+fn main() {}
--- a/axum-macros/tests/pass/tuple.rs
+++ b/axum-macros/tests/pass/tuple.rs
@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor(axum::http::HeaderMap, String);
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<axum::body::Body>,
+{
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/tuple_same_type_twice.rs
+++ b/axum-macros/tests/pass/tuple_same_type_twice.rs
@ -0,0 +1,34 @@
+use axum::extract::{Query, rejection::*};
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+#[derive(FromRequest)]
+struct Extractor(
+    Query<Payload>,
+    axum::extract::Json<Payload>,
+);
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<axum::body::Body>,
+{
+}
+
+fn assert_rejection(rejection: ExtractorRejection)
+where
+    ExtractorRejection: std::fmt::Debug + std::fmt::Display + std::error::Error,
+{
+    match rejection {
+        ExtractorRejection::QueryPayload(inner) => {
+            let _: QueryRejection = inner;
+        }
+        ExtractorRejection::JsonPayload(inner) => {
+            let _: JsonRejection = inner;
+        }
+    }
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/tuple_same_type_twice_via.rs
+++ b/axum-macros/tests/pass/tuple_same_type_twice_via.rs
@ -0,0 +1,34 @@
+use axum::extract::{Query, rejection::*};
+use axum_macros::FromRequest;
+use serde::Deserialize;
+
+#[derive(FromRequest)]
+struct Extractor(
+    #[from_request(via(Query))] Payload,
+    #[from_request(via(axum::extract::Json))] Payload,
+);
+
+fn assert_rejection(rejection: ExtractorRejection)
+where
+    ExtractorRejection: std::fmt::Debug + std::fmt::Display + std::error::Error,
+{
+    match rejection {
+        ExtractorRejection::QueryPayload(inner) => {
+            let _: QueryRejection = inner;
+        }
+        ExtractorRejection::JsonPayload(inner) => {
+            let _: JsonRejection = inner;
+        }
+    }
+}
+
+#[derive(Deserialize)]
+struct Payload {}
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<axum::body::Body>,
+{
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/tuple_via.rs
+++ b/axum-macros/tests/pass/tuple_via.rs
@ -0,0 +1,16 @@
+use axum_macros::FromRequest;
+use axum::extract::Extension;
+
+#[derive(FromRequest)]
+struct Extractor(#[from_request(via(Extension))] State);
+
+#[derive(Clone)]
+struct State;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<axum::body::Body>,
+{
+}
+
+fn main() {}
--- a/axum-macros/tests/pass/unit.rs
+++ b/axum-macros/tests/pass/unit.rs
@ -0,0 +1,12 @@
+use axum_macros::FromRequest;
+
+#[derive(FromRequest)]
+struct Extractor;
+
+fn assert_from_request()
+where
+    Extractor: axum::extract::FromRequest<axum::body::Body>,
+{
+}
+
+fn main() {}