reach_proc_macros/

lib.rs

// SPDX-FileCopyrightText: 2023—2025 eaon <eaon@posteo.net>
// SPDX-FileCopyrightText: 2023 Sam Schlinkert <sschlinkert@gmail.com>
// SPDX-License-Identifier: EUPL-1.2

use std::{collections::HashMap, str::FromStr, sync::LazyLock};

use proc_macro2::{Ident, Span, TokenStream, TokenTree};
use quote::{quote, quote_spanned};
use syn::{Data, DeriveInput, GenericArgument, PathArguments, Type, parse_macro_input};

type ConvFn = fn(&Ident, &Ident) -> TokenStream;

static CONV_FNS: LazyLock<HashMap<String, (ConvFn, ConvFn, ConvFn)>> = LazyLock::new(|| {
    let map: Vec<(&str, ConvFn)> = vec![
        ("nop", |_, _| quote! {}),
        ("to_vec", |n, _| quote! { from.#n.to_vec() }),
        ("inner to_vec", |n, _| quote! { from.#n.inner.to_vec() }),
        ("as_bytes", |n, _| quote! { from.#n.as_bytes().to_vec() }),
        ("to_bytes", |n, _| quote! { from.#n.to_bytes().to_vec() }),
        ("move", |n, _| quote! { from.#n }),
        (
            "zeroizing",
            |n, _| quote! { zeroize::Zeroizing::new(from.#n.clone()) },
        ),
        ("zeroizing deref clone", |n, t| {
            quote! { <zeroize::Zeroizing<#t> as std::ops::Deref>::deref(&from.#n).clone() }
        }),
        ("clone", |n, _| quote! { from.#n.clone() }),
        ("as u32", |n, _| quote! { from.#n as u32 }),
        ("direct", |n, t| quote! { #t::try_from(from.#n)? }),
        ("slice", |n, t| quote! { #t::try_from(from.#n.as_slice())? }),
        (
            "try_from slice",
            |n, t| quote! { #t::try_from(from.#n.as_slice())? },
        ),
        (
            "from_bytes",
            |n, t| quote! { #t::from_bytes(from.#n.as_slice().try_into()?) },
        ),
        (
            "from_bytes?",
            |n, t| quote! { #t::from_bytes(from.#n.as_slice())? },
        ),
        (
            "via [u8; 24]",
            |n, t| quote! { #t::from(<[u8; 24]>::try_from(from.#n.as_slice())?) },
        ),
        (
            "via [u8; 32]",
            |n, t| quote! { #t::from(<[u8; 32]>::try_from(from.#n.as_slice())?) },
        ),
        (
            "via &[u8; 64]",
            |n, t| quote! { #t::from_bytes(&<[u8; 64]>::try_from(from.#n.as_slice())?) },
        ),
        ("Option Box try", |n, _| {
            quote! {
                match from.#n {
                    Some(inner) => Some(Box::new(inner.try_into()?)),
                    None => None,
                }
            }
        }),
        (
            "Option Box as_ref",
            |n, t| quote! { from.#n.as_ref().map(|inner| proto::#t::from(inner.deref())) },
        ),
        ("Option try", |n, _| {
            quote! {
                match from.#n {
                    Some(inner) => Some(inner.try_into()?),
                    None => None,
                }
            }
        }),
        (
            "Option as_ref",
            |n, t| quote! { from.#n.as_ref().map(proto::#t::from) },
        ),
        (
            "Option map from",
            |n, t| quote! { from.#n.map(proto::#t::from) },
        ),
        ("Option Result", |n, t| {
            let core_path = core_path(n.span());
            quote! { #t::try_from(from.#n.ok_or(#core_path::error::DecodeError)?)? }
        }),
        (
            "Option Some",
            |n, t| quote! { Some(proto::#t::from(&from.#n)) },
        ),
        (
            "Option Some Owned",
            |n, t| quote! { Some(proto::#t::from(from.#n)) },
        ),
        (
            "into_iter try_from",
            |n, t| quote! { from.#n.into_iter().map(#t::try_from).collect::<Result<_, _>>()? },
        ),
        ("into_iter from_bytes", |n, _| {
            quote! { from.#n.into_iter().map(|item| {
                item.as_slice().try_into()
            }).collect::<Result<_, _>>()? }
        }),
        (
            "iter",
            |n, t| quote! { from.#n.iter().map(proto::#t::from).collect() },
        ),
        (
            "into_iter from",
            |n, t| quote! { from.#n.into_iter().map(proto::#t::from).collect() },
        ),
        (
            "iter to_bytes BlindedPublicKey",
            |n, _| quote! { from.#n.iter().map(|item| item.to_bytes().to_vec()).collect() },
        ),
        (
            "proto decode",
            |n, t| quote! { #t::decode(from.#n.as_slice())? },
        ),
        ("proto encode", |n, _| quote! { from.#n.encode_to_vec() }),
        ("into_iter proto decode", |n, t| {
            quote! {
                from.#n.into_iter().map(#t::decode).collect::<Result<_, _>>()?
            }
        }),
        (
            "iter proto encode",
            |n, _| quote! { from.#n.iter().map(|item| item.encode_to_vec()).collect() },
        ),
    ];

    let map = map.into_iter().collect::<HashMap<&'static str, ConvFn>>();

    [
        ("BlindedPublicKey", "from_bytes", "to_bytes", "nop"),
        ("Ed25519Signature", "via &[u8; 64]", "to_bytes", "to_bytes"),
        ("Ed25519Signing", "slice", "to_bytes", "to_bytes"),
        ("Ed25519Verifying", "slice", "as_bytes", "as_bytes"),
        ("FnDsaVerifying", "slice", "to_vec", "to_vec"),
        ("FnDsaSignature", "slice", "to_vec", "to_vec"),
        ("FnDsaSigning", "slice", "inner to_vec", "inner to_vec"),
        ("EnvelopeIdHints", "from_bytes?", "to_bytes", "to_bytes"),
        ("MlKemCiphertext", "try_from slice", "to_vec", "to_vec"),
        ("MlKemPublic", "from_bytes", "as_bytes", "as_bytes"),
        ("MlKemSecret", "from_bytes", "as_bytes", "as_bytes"),
        ("X25519Public", "via [u8; 32]", "as_bytes", "as_bytes"),
        ("X25519Secret", "via [u8; 32]", "as_bytes", "as_bytes"),
        ("XChaChaKey", "via [u8; 32]", "to_vec", "to_vec"),
        ("XNonce", "via [u8; 24]", "to_vec", "to_vec"),
        ("SixFour", "slice", "to_vec", "to_vec"),
        ("String", "move", "clone", "move"),
        ("ThreeTwo", "slice", "to_vec", "to_vec"),
        ("TwoFour", "slice", "to_vec", "to_vec"),
        ("OneSix", "slice", "to_vec", "to_vec"),
        ("u16", "direct", "as u32", "as u32"),
        ("Vec<u8>", "move", "clone", "move"),
        (
            "Vec<BlindedPublicKey>",
            "into_iter from_bytes",
            "iter to_bytes BlindedPublicKey",
            "nop",
        ),
        ("Vec<_>", "into_iter try_from", "iter", "into_iter from"),
        (
            "Option<MessageMetadata>",
            "Option try",
            "nop",
            "Option map from",
        ),
        (
            "Option<Box<_>>",
            "Option Box try",
            "Option Box as_ref",
            "nop",
        ),
        ("Option<T>", "move", "clone", "move"),
        ("Option<_>", "Option try", "Option as_ref", "Option as_ref"),
        ("_", "Option Result", "Option Some", "Option Some Owned"),
        ("as ProstMessage", "proto decode", "proto encode", "nop"),
        (
            "Vec<as ProstMessage>",
            "into_iter proto decode",
            "iter proto encode",
            "nop",
        ),
        (
            "Zeroizing<_>",
            "zeroizing",
            "zeroizing deref clone",
            "zeroizing",
        ),
    ]
    .into_iter()
    .map(|(key, de, en, eno)| (key.to_string(), (map[de], map[en], map[eno])))
    .collect()
});

#[derive(Debug)]
struct LocalField<'a> {
    field_name: &'a Ident,
    field_type: &'a Ident,
    field_inner_types: Vec<&'a Ident>,
}

impl LocalField<'_> {
    fn conv_material(&self) -> ((ConvFn, ConvFn, ConvFn), &Ident) {
        let field_type = self.field_type.to_string();
        let mut target_field_type = self.field_type;
        let fits = &self.field_inner_types;

        let key = if field_type.starts_with("Wire")
            || field_type.starts_with("Memory")
            || field_type.starts_with("Storage")
        {
            "as ProstMessage".to_string()
        } else if fits.is_empty() {
            field_type
        } else {
            match (field_type.as_str(), fits.first(), fits.get(1)) {
                ("Option", Some(one), Some(two)) => {
                    let inner_type = one.to_string();
                    if inner_type == "Box" {
                        target_field_type = two;
                        "Option<Box<_>>"
                    } else {
                        "Option<T>"
                    }
                    .to_string()
                }
                ("Option", Some(one), _) => {
                    let inner_type = one.to_string();
                    if inner_type == "String" || inner_type == "u32" {
                        "Option<T>"
                    } else if inner_type == "MessageMetadata" {
                        target_field_type = one;
                        "Option<MessageMetadata>"
                    } else {
                        target_field_type = one;
                        "Option<_>"
                    }
                    .to_string()
                }
                ("Vec", Some(one), _) => {
                    let inner_type = one.to_string();
                    if inner_type.starts_with("Wire")
                        || inner_type.starts_with("Memory")
                        || inner_type.starts_with("Storage")
                    {
                        target_field_type = one;
                        "Vec<as ProstMessage>"
                    } else if inner_type == "BlindedPublicKey" {
                        "Vec<BlindedPublicKey>"
                    } else if inner_type == "u8" {
                        "Vec<u8>"
                    } else {
                        target_field_type = one;
                        "Vec<_>"
                    }
                    .to_string()
                }
                ("Zeroizing", Some(one), _) => {
                    target_field_type = one;
                    "Zeroizing<_>".to_string()
                }
                _ => field_type,
            }
        };

        (
            match CONV_FNS.contains_key(&key) {
                true => CONV_FNS[&key],
                false => CONV_FNS["_"],
            },
            target_field_type,
        )
    }

    fn convert(&self, conv: TokenStream) -> TokenStream {
        let field_name = self.field_name;
        quote_spanned! {field_name.span()=> #field_name: #conv, }
    }

    fn decode(&self) -> TokenStream {
        let ((decode, _, _), target_field_type) = self.conv_material();
        self.convert(decode(self.field_name, target_field_type))
    }

    fn encode(&self) -> TokenStream {
        let ((_, encode, _), target_field_type) = self.conv_material();
        self.convert(encode(self.field_name, target_field_type))
    }

    fn encode_owned(&self) -> TokenStream {
        let ((_, _, encode_owned), target_field_type) = self.conv_material();
        self.convert(encode_owned(self.field_name, target_field_type))
    }
}

fn decode(data: &Data) -> Vec<TokenStream> {
    parse_fields(data).iter().map(LocalField::decode).collect()
}

fn encode(data: &Data) -> Vec<TokenStream> {
    parse_fields(data).iter().map(LocalField::encode).collect()
}

fn encode_owned(data: &Data) -> Vec<TokenStream> {
    parse_fields(data)
        .iter()
        .map(LocalField::encode_owned)
        .collect()
}

#[allow(clippy::panic)]
fn prosted_derivations(
    tt: &str,
    input: &DeriveInput,
    mod_base: &TokenTree,
    prost_type_name: &TokenTree,
    type_name: &Ident,
) -> TokenStream {
    let core_path = core_path(type_name.span());

    if tt == "Decode" {
        let decode_fields = decode(&input.data);

        quote! {
            impl TryFrom<#mod_base::#prost_type_name> for #type_name {
                type Error = #core_path::error::DecodeError;

                fn try_from(from: #mod_base::#prost_type_name) -> Result<Self, Self::Error> {
                    Ok(#type_name {
                        #(#decode_fields)*
                    })
                }
            }
        }
    } else if tt == "Encode" {
        let encode_fields = encode(&input.data);

        quote! {
            impl From<&#type_name> for #mod_base::#prost_type_name {
                fn from(from: &#type_name) -> Self {
                    Self {
                        #(#encode_fields)*
                    }
                }
            }
        }
    } else if tt == "EncodeOwned" {
        let encode_owned_fields = encode_owned(&input.data);

        quote! {
            impl From<#type_name> for #mod_base::#prost_type_name {
                fn from(from: #type_name) -> Self {
                    Self {
                        #(#encode_owned_fields)*
                    }
                }
            }
        }
    } else if tt == "ProstTraits" {
        quote! {
            impl #core_path::ProstDecode for #type_name {
                type EncodedType = #mod_base::#prost_type_name;
            }

            impl #core_path::ProstEncode for #type_name {
                type EncodedType = #mod_base::#prost_type_name;
            }
        }
    } else if tt == "ProstTraitsOwned" {
        quote! {
            impl #core_path::ProstDecode for #type_name {
                type EncodedType = #mod_base::#prost_type_name;
            }

            impl #core_path::ProstEncodeOwned for #type_name {
                type EncodedType = #mod_base::#prost_type_name;
            }
        }
    } else {
        panic!("Unsupported prosted derivation.");
    }
}

#[proc_macro_attribute]
pub fn prosted(
    attr: proc_macro::TokenStream,
    item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let structure = TokenStream::from(item.clone());
    let input = parse_macro_input!(item as DeriveInput);
    let type_name = &input.ident;

    let attr = TokenStream::from(attr)
        .into_iter()
        .filter(|t| {
            let tk = t.to_string();
            let tk_s = tk.as_str();
            tk_s != "," && tk_s != ":"
        })
        .collect::<Vec<_>>();

    let mod_base = &attr[0];
    let prost_type_name = &attr[1];

    let impls = attr
        .iter()
        .skip(2)
        .map(|tt| {
            prosted_derivations(
                tt.to_string().as_str(),
                &input,
                mod_base,
                prost_type_name,
                type_name,
            )
        })
        .collect::<Vec<_>>();

    quote! {
        #structure

        #(#impls)*
    }
    .into()
}

#[proc_macro_attribute]
pub fn communicable(
    attr: proc_macro::TokenStream,
    item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let structure = TokenStream::from(item.clone());
    let input = parse_macro_input!(item as DeriveInput);
    let type_name = &input.ident;

    let core_path = core_path(type_name.span());

    let attr = TokenStream::from(attr).into_iter().collect::<Vec<_>>();
    let base_type = &attr[0];
    let variant = &attr[3];
    let kind = attr[&attr.len() - 1].to_string(); // owned, marker

    #[allow(clippy::unwrap_used)]
    let (prost, trait_name) = match kind.as_str() {
        "owned" => (true, "ProstCommunicableOwned"),
        "marker" => (false, "Communicable"),
        _ => (true, "ProstCommunicable"),
    };
    #[allow(clippy::unwrap_used)]
    let trait_name = TokenStream::from_str(trait_name).unwrap();
    if prost {
        quote! {
            #structure

            impl #core_path::communication::#trait_name<#base_type> for #type_name {
                const COMMUNICATION_VARIANT: #base_type = #base_type::#variant;
            }
        }
    } else {
        quote! {
            #structure

            impl #core_path::communication::#trait_name<#base_type> for #type_name {
                fn to_communication(&self) -> #core_path::communication::Communication<#base_type> {
                    #core_path::communication::Communication::from(#base_type::#variant, vec![], None)
                }

                fn try_from_communication(
                    communication: &#core_path::communication::Communication<#base_type>,
                ) -> Result<Self, #core_path::error::DecodeError> {
                    if communication.r#type != #base_type::#variant {
                        return Err(#core_path::error::DecodeError);
                    }

                    Ok(Self {})
                }
            }
        }
    }
    .into()
}

fn parse_fields(data: &Data) -> Vec<LocalField<'_>> {
    let mut fields = Vec::new();

    match data {
        Data::Struct(inner) => {
            for field in &inner.fields {
                let field_name = field.ident.as_ref().expect("Expected field name");
                if let Type::Path(inner) = &field.ty {
                    let field_type = &inner.path.segments[0].ident;
                    let mut field_inner_types = vec![];
                    all_anglebracketed(&inner.path.segments[0].arguments, &mut field_inner_types);

                    fields.push(LocalField {
                        field_name,
                        field_type,
                        field_inner_types,
                    });
                }
            }
        }
        _ => unimplemented!(),
    }

    fields
}

fn all_anglebracketed<'a>(arguments: &'a PathArguments, idents: &mut Vec<&'a Ident>) {
    if let PathArguments::AngleBracketed(inner) = arguments {
        if let GenericArgument::Type(Type::Path(inner)) = &inner.args[0] {
            idents.push(&inner.path.segments[0].ident);
            all_anglebracketed(&inner.path.segments[0].arguments, idents);
        }
    }
}

fn core_path(span: Span) -> Ident {
    Ident::new(
        match std::env::var("CARGO_PKG_NAME")
            .expect("Should use cargo")
            .as_str()
        {
            "reach-core" => "crate",
            _ => "reach_core",
        },
        span,
    )
}

#[proc_macro_derive(ParticipantPublicKeys)]
pub fn derive_participant_public_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;
    let participant_variant = if type_name.to_string().starts_with("Reaching") {
        Ident::new("Reaching", type_name.span())
    } else {
        Ident::new("Reachable", type_name.span())
    };

    let core_path = core_path(type_name.span());

    quote! {
        impl #core_path::ParticipantPublicKeys for #type_name {
            fn ec_public_key(&self) -> &reach_aliases::X25519Public {
                &self.ec_public_key
            }

            fn pq_public_key(&self) -> &reach_aliases::MlKemPublic {
                &self.pq_public_key
            }

            fn participant_type(&self) -> #core_path::ParticipantType {
                #core_path::ParticipantType::#participant_variant
            }
        }
    }
    .into()
}

#[proc_macro_derive(ParticipantSecretKeys)]
pub fn derive_participant_secret_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    quote! {
        impl reach_encryption::ParticipantSecretKeys for #type_name {
            fn ec_secret_key(&self) -> &reach_aliases::X25519Secret {
                &self.ec_secret_key
            }

            fn pq_secret_key(&self) -> &reach_aliases::MlKemSecret {
                &self.pq_secret_key
            }
        }
    }
    .into()
}

#[proc_macro_derive(SecretKeysRandomFromRng)]
pub fn derive_secret_keys_random_from_rng(
    input: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    let core_path = core_path(type_name.span());

    quote! {
        impl #core_path::RandomFromRng for #type_name {
            fn random_from_rng(csprng: &mut impl rand_core::CryptoRngCore) -> Self {
                let (pq_secret_key, pq_public_key) = reach_aliases::MlKem::generate(csprng);

                Self {
                    ec_secret_key: reach_aliases::X25519Secret::random_from_rng(csprng),
                    pq_secret_key,
                    pq_public_key,
                }
            }
        }
    }
    .into()
}

#[proc_macro_derive(UnsignedPublicKeys)]
pub fn derive_unsigned_public_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    let public_keys_type_name = Ident::new(
        format!(
            "Unsigned{}",
            type_name.to_string().replace("SecretKeys", "PublicKeys")
        )
        .as_str(),
        type_name.span(),
    );

    public_keys_tokenstream(type_name, &public_keys_type_name).into()
}

#[proc_macro_derive(PublicKeys)]
pub fn derive_public_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    let public_keys_type_name = Ident::new(
        type_name
            .to_string()
            .as_str()
            .replace("SecretKeys", "PublicKeys")
            .as_str(),
        type_name.span(),
    );

    public_keys_tokenstream(type_name, &public_keys_type_name).into()
}

fn public_keys_tokenstream(type_name: &Ident, public_keys_type_name: &Ident) -> TokenStream {
    quote! {
        impl From<&#type_name> for #public_keys_type_name {
            fn from(from: &#type_name) -> Self {
                Self {
                    ec_public_key: reach_aliases::X25519Public::from(&from.ec_secret_key),
                    pq_public_key: from.pq_public_key.clone(),
                }
            }
        }
    }
}

#[proc_macro_derive(Verifier)]
pub fn derive_verifier(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    quote! {
        impl reach_signatures::Verifier for #type_name {
            fn ec_verifying_key(&self) -> &reach_aliases::Ed25519Verifying {
                &self.ec_verifying_key
            }

            fn pq_verifying_key(&self) -> &reach_aliases::FnDsaVerifying {
                &self.pq_verifying_key
            }
        }
    }
    .into()
}

fn verifying_keys(type_name: &Ident, verifying_type_name: &Ident) -> proc_macro::TokenStream {
    quote! {
        impl From<&#type_name> for #verifying_type_name {
            fn from(from: &#type_name) -> Self {
                Self {
                    ec_verifying_key: from.ec_signing_key.verifying_key(),
                    pq_verifying_key: from.pq_verifying_key,
                }
            }
        }
    }
    .into()
}

#[proc_macro_derive(UnsignedVerifyingKeys)]
pub fn derive_unsigned_verifying_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;
    let verifying_type_name = Ident::new(
        format!(
            "Unsigned{}",
            type_name.to_string().replace("Signing", "Verifying")
        )
        .as_str(),
        type_name.span(),
    );

    verifying_keys(type_name, &verifying_type_name)
}

#[proc_macro_derive(VerifyingKeys)]
pub fn derive_verifying_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;
    let verifying_type_name = Ident::new(
        type_name
            .to_string()
            .replace("Signing", "Verifying")
            .as_str(),
        type_name.span(),
    );

    verifying_keys(type_name, &verifying_type_name)
}

#[proc_macro_derive(SigningKeys)]
pub fn derive_signing_keys(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let input = parse_macro_input!(input as DeriveInput);
    let type_name = &input.ident;

    let core_path = core_path(type_name.span());

    quote! {
        impl #core_path::RandomFromRng for #type_name {
            fn random_from_rng(csprng: &mut impl rand_core::CryptoRngCore) -> Self {
                let mut kg = fn_dsa_kgen::KeyPairGeneratorStandard::default();
                let mut pq_signing_key_inner = reach_signatures::FN_DSA_SIGNING_EMPTY;
                let mut pq_verifying_key = reach_aliases::FN_DSA_VERIFYING_EMPTY;
                kg.keygen(
                    reach_aliases::FN_DSA_DEGREES,
                    csprng,
                    &mut pq_signing_key_inner,
                    &mut pq_verifying_key
                );

                Self {
                    ec_signing_key: reach_aliases::Ed25519Signing::generate(csprng),
                    pq_signing_key: reach_aliases::FnDsaSigning {
                        inner: pq_signing_key_inner,
                    },
                    pq_verifying_key,
                }
            }
        }

        impl reach_signatures::Sign for #type_name {
            fn ec_signing_key(&self) -> &reach_aliases::Ed25519Signing {
                &self.ec_signing_key
            }

            fn pq_signing_key(&self) -> &reach_aliases::FnDsaSigning {
                &self.pq_signing_key
            }
        }
    }
    .into()
}

#[proc_macro]
pub fn request_handler_macro(attr: proc_macro::TokenStream) -> proc_macro::TokenStream {
    let attr = TokenStream::from(attr)
        .into_iter()
        .filter(|t| {
            let tk = t.to_string();
            let tk_s = tk.as_str();
            tk_s != ","
        })
        .collect::<Vec<_>>();

    let macro_name = &attr[0];
    let communication_type = &attr[1];
    let request_wrapper_type = &attr[2];
    let global_context_type = &attr[3];
    let session_context_type = &attr[4];

    quote! {
        macro_rules! #macro_name {
            (
                async fn handle(
                    $request:tt: $request_type:ty,
                    $global_context:tt: _,
                    $session_context:tt: _$(,)?
                ) -> $response_type:ty
                $handler_body:block
            ) => {
                #macro_name!(
                    async fn handle(
                        $request: $request_type,
                        $global_context: #global_context_type,
                        $session_context: #session_context_type,
                    ) -> $response_type $handler_body
                );
            };

            (
                async fn handle(
                    $request:tt: $request_type:ty,
                    $global_context:tt: $global_context_type:ty,
                    $session_context:tt: _$(,)?
                ) -> $response_type:ty
                $handler_body:block
            ) => {
                #macro_name!(
                    async fn handle(
                        $request: $request_type,
                        $global_context: $global_context_type,
                        $session_context: #session_context_type,
                    ) -> $response_type $handler_body
                );
            };

            (
                async fn handle(
                    $request:tt: $request_type:ty,
                    $global_context:tt: _,
                    $session_context:tt: $session_context_type:ty$(,)?
                ) -> $response_type:ty
                $handler_body:block
            ) => {
                #macro_name!(
                    async fn handle(
                        $request: $request_type,
                        $global_context: #global_context_type,
                        $session_context: $session_context_type,
                    ) -> $response_type $handler_body
                );
            };

            (
                async fn handle(
                    $request:tt: $request_type:ty,
                    $global_context:tt: $global_context_type:ty,
                    $session_context:tt: $session_context_type:ty$(,)?
                ) -> $response_type:ty
                $handler_body:block
            ) => {
                impl reach_websocket::RequestHandler<#communication_type>
                    for #request_wrapper_type<$request_type>
                {
                    type GlobalContext = $global_context_type;
                    type SessionContext = $session_context_type;

                    async fn handle(
                        $request: Self,
                        $global_context: std::sync::Arc<Self::GlobalContext>,
                        $session_context: std::sync::Arc<tokio::sync::RwLock<Self::SessionContext>>,
                    ) -> $response_type $handler_body
                }
            };
        }

        pub(crate) use #macro_name;
    }
    .into()
}