typeshift_derive/

lib.rs

//! Derive macro implementation for `typeshift`.
//!
//! This crate is usually consumed via `typeshift::TypeShift` from the facade
//! crate. It is split out so proc-macro code can live separately.

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    Data, DataEnum, DataStruct, DeriveInput, Expr, Field, Fields, Variant, parse_macro_input,
};

#[proc_macro_derive(TypeShift, attributes(validate, serde, schemars))]
/// Derives serde, validator, and schemars support required by `typeshift`.
///
/// Supported inputs:
/// - structs (named, tuple, unit)
/// - enums (unit and data-carrying variants)
/// - generic types
///
/// Unions are intentionally rejected.
///
/// Generated behavior is equivalent to deriving:
/// - `serde::Serialize`
/// - `serde::Deserialize`
/// - `validator::Validate`
/// - `schemars::JsonSchema`
pub fn derive_typeshift(input: TokenStream) -> TokenStream {
    let input = parse_macro_input!(input as DeriveInput);

    let ident = input.ident;
    let generics = input.generics;
    let (_, ty_generics, _) = generics.split_for_impl();

    let ser_generics =
        generics_with_type_bound(&generics, syn::parse_quote!(::typeshift::serde::Serialize));
    let (ser_impl_generics, _, ser_where_clause) = ser_generics.split_for_impl();

    let mut de_generics = generics_with_type_bound(
        &generics,
        syn::parse_quote!(::typeshift::serde::Deserialize<'__typeshift_de>),
    );
    de_generics
        .params
        .insert(0, syn::parse_quote!('__typeshift_de));
    let (de_impl_generics, _, de_where_clause) = de_generics.split_for_impl();

    let schema_generics = generics_with_type_bound(
        &generics,
        syn::parse_quote!(::typeshift::schemars::JsonSchema),
    );
    let (schema_impl_generics, _, schema_where_clause) = schema_generics.split_for_impl();

    let validate_generics = generics_with_type_bound(
        &generics,
        syn::parse_quote!(::typeshift::validator::Validate),
    );
    let (validate_impl_generics, _, validate_where_clause) = validate_generics.split_for_impl();

    let serde_container_attrs = filter_attrs(&input.attrs, &["serde"]);
    let validate_container_attrs = filter_attrs(&input.attrs, &["validate"]);
    let schema_container_attrs = filter_attrs(&input.attrs, &["serde", "schemars"]);

    let (ser_helper_def, ser_helper_init) = match &input.data {
        Data::Struct(data) => serialize_struct_helpers(data, &generics),
        Data::Enum(data) => serialize_enum_helpers(data, &generics),
        Data::Union(_) => {
            return syn::Error::new_spanned(ident, "TypeShift derive does not support union")
                .to_compile_error()
                .into();
        }
    };

    let (de_helper_def, de_construct) = match &input.data {
        Data::Struct(data) => deserialize_struct_helpers(data, &generics),
        Data::Enum(data) => deserialize_enum_helpers(data, &generics),
        Data::Union(_) => {
            return syn::Error::new_spanned(ident, "TypeShift derive does not support union")
                .to_compile_error()
                .into();
        }
    };

    let schema_helper_def = match &input.data {
        Data::Struct(data) => schema_struct_helper(data, &generics),
        Data::Enum(data) => schema_enum_helper(data, &generics),
        Data::Union(_) => {
            return syn::Error::new_spanned(ident, "TypeShift derive does not support union")
                .to_compile_error()
                .into();
        }
    };

    let ser_ref_lt = match &input.data {
        Data::Struct(data) => (!matches!(data.fields, Fields::Unit)).then_some("'__typeshift_ser"),
        Data::Enum(data) => enum_has_payload(data).then_some("'__typeshift_ser"),
        Data::Union(_) => None,
    };
    let ser_helper_use_generics = helper_use_generics(&generics, ser_ref_lt.map(|_| "'_"));
    let de_helper_use_generics = helper_use_generics(&generics, None);
    let schema_helper_use_generics = helper_use_generics(&generics, None);

    let validate_impl = match &input.data {
        Data::Struct(data) => {
            let (val_helper_def, val_helper_init) = validate_struct_helpers(data, &generics);
            let val_ref_lt = (!matches!(data.fields, Fields::Unit)).then_some("'__typeshift_val");
            let val_helper_use_generics = helper_use_generics(&generics, val_ref_lt.map(|_| "'_"));
            quote! {
                impl #validate_impl_generics ::typeshift::validator::Validate for #ident #ty_generics #validate_where_clause {
                    fn validate(&self) -> ::core::result::Result<(), ::typeshift::validator::ValidationErrors> {
                        #[allow(dead_code)]
                        #[derive(::typeshift::validator::Validate)]
                        #[validate(crate = "typeshift::validator")]
                        #(#validate_container_attrs)*
                        #val_helper_def

                        let helper: __TypeShiftValidateHelper #val_helper_use_generics = #val_helper_init;
                        ::typeshift::validator::Validate::validate(&helper)
                    }
                }
            }
        }
        Data::Enum(_) => {
            quote! {
                impl #validate_impl_generics ::typeshift::validator::Validate for #ident #ty_generics #validate_where_clause {
                    fn validate(&self) -> ::core::result::Result<(), ::typeshift::validator::ValidationErrors> {
                        ::core::result::Result::Ok(())
                    }
                }
            }
        }
        Data::Union(_) => {
            return syn::Error::new_spanned(ident, "TypeShift derive does not support union")
                .to_compile_error()
                .into();
        }
    };

    let expanded = quote! {
        impl #ser_impl_generics ::typeshift::serde::Serialize for #ident #ty_generics #ser_where_clause {
            fn serialize<S>(&self, serializer: S) -> ::core::result::Result<S::Ok, S::Error>
            where
                S: ::typeshift::serde::Serializer,
            {
                #[allow(dead_code)]
                #[derive(::typeshift::serde::Serialize)]
                #[serde(crate = "typeshift::serde")]
                #(#serde_container_attrs)*
                #ser_helper_def

                let helper: __TypeShiftSerializeHelper #ser_helper_use_generics = #ser_helper_init;
                ::typeshift::serde::Serialize::serialize(&helper, serializer)
            }
        }

        impl #de_impl_generics ::typeshift::serde::Deserialize<'__typeshift_de> for #ident #ty_generics #de_where_clause {
            fn deserialize<D>(deserializer: D) -> ::core::result::Result<Self, D::Error>
            where
                D: ::typeshift::serde::Deserializer<'__typeshift_de>,
            {
                #[allow(dead_code)]
                #[derive(::typeshift::serde::Deserialize)]
                #[serde(crate = "typeshift::serde")]
                #(#serde_container_attrs)*
                #de_helper_def

                let helper = <__TypeShiftDeserializeHelper #de_helper_use_generics as ::typeshift::serde::Deserialize>::deserialize(deserializer)?;
                ::core::result::Result::Ok(#de_construct)
            }
        }

        #validate_impl

        impl #schema_impl_generics ::typeshift::schemars::JsonSchema for #ident #ty_generics #schema_where_clause {
            fn schema_name() -> ::std::string::String {
                #[allow(dead_code)]
                #[derive(::typeshift::schemars::JsonSchema)]
                #[schemars(crate = "typeshift::schemars")]
                #(#schema_container_attrs)*
                #schema_helper_def

                <__TypeShiftSchemaHelper #schema_helper_use_generics as ::typeshift::schemars::JsonSchema>::schema_name()
            }

            fn json_schema(
                schema_generator: &mut ::typeshift::schemars::r#gen::SchemaGenerator,
            ) -> ::typeshift::schemars::schema::Schema {
                #[allow(dead_code)]
                #[derive(::typeshift::schemars::JsonSchema)]
                #[schemars(crate = "typeshift::schemars")]
                #(#schema_container_attrs)*
                #schema_helper_def

                <__TypeShiftSchemaHelper #schema_helper_use_generics as ::typeshift::schemars::JsonSchema>::json_schema(schema_generator)
            }

            fn is_referenceable() -> bool {
                #[allow(dead_code)]
                #[derive(::typeshift::schemars::JsonSchema)]
                #[schemars(crate = "typeshift::schemars")]
                #(#schema_container_attrs)*
                #schema_helper_def

                <__TypeShiftSchemaHelper #schema_helper_use_generics as ::typeshift::schemars::JsonSchema>::is_referenceable()
            }
        }
    };

    expanded.into()
}

fn filter_attrs(attrs: &[syn::Attribute], allowed: &[&str]) -> Vec<syn::Attribute> {
    attrs
        .iter()
        .filter(|attr| {
            attr.path()
                .segments
                .first()
                .map(|seg| allowed.iter().any(|name| seg.ident == name))
                .unwrap_or(false)
        })
        .cloned()
        .collect()
}

fn serialize_struct_helpers(
    data: &DataStruct,
    generics: &syn::Generics,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    let ref_lt = (!matches!(data.fields, Fields::Unit)).then_some("'__typeshift_ser");
    let helper_def_generics = helper_def_generics(generics, ref_lt);
    let helper_where_clause = helper_where_clause(generics);

    let helper_def = match &data.fields {
        Fields::Named(named) => {
            let defs = named.named.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde"]);
                let name = named_field_ident(field);
                let ty = &field.ty;
                quote! { #(#attrs)* #name: &'__typeshift_ser #ty }
            });
            quote! { struct __TypeShiftSerializeHelper #helper_def_generics { #(#defs,)* } #helper_where_clause }
        }
        Fields::Unnamed(unnamed) => {
            let defs = unnamed.unnamed.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde"]);
                let ty = &field.ty;
                quote! { #(#attrs)* &'__typeshift_ser #ty }
            });
            quote! { struct __TypeShiftSerializeHelper #helper_def_generics ( #(#defs,)* ) #helper_where_clause ; }
        }
        Fields::Unit => quote! { struct __TypeShiftSerializeHelper; },
    };

    let helper_init = match &data.fields {
        Fields::Named(named) => {
            let inits = named.named.iter().map(|field| {
                let name = named_field_ident(field);
                quote! { #name: &self.#name }
            });
            quote! { __TypeShiftSerializeHelper { #(#inits,)* } }
        }
        Fields::Unnamed(unnamed) => {
            let inits = unnamed.unnamed.iter().enumerate().map(|(idx, _)| {
                let idx = syn::Index::from(idx);
                quote! { &self.#idx }
            });
            quote! { __TypeShiftSerializeHelper( #(#inits,)* ) }
        }
        Fields::Unit => quote! { __TypeShiftSerializeHelper },
    };

    (helper_def, helper_init)
}

fn deserialize_struct_helpers(
    data: &DataStruct,
    generics: &syn::Generics,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    let helper_def_generics = helper_def_generics(generics, None);
    let helper_where_clause = helper_where_clause(generics);

    let helper_def = match &data.fields {
        Fields::Named(named) => {
            let defs = named.named.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde"]);
                let name = named_field_ident(field);
                let ty = &field.ty;
                quote! { #(#attrs)* #name: #ty }
            });
            quote! { struct __TypeShiftDeserializeHelper #helper_def_generics { #(#defs,)* } #helper_where_clause }
        }
        Fields::Unnamed(unnamed) => {
            let defs = unnamed.unnamed.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde"]);
                let ty = &field.ty;
                quote! { #(#attrs)* #ty }
            });
            quote! { struct __TypeShiftDeserializeHelper #helper_def_generics ( #(#defs,)* ) #helper_where_clause ; }
        }
        Fields::Unit => quote! { struct __TypeShiftDeserializeHelper; },
    };

    let construct = match &data.fields {
        Fields::Named(named) => {
            let builds = named.named.iter().map(|field| {
                let name = named_field_ident(field);
                quote! { #name: helper.#name }
            });
            quote! { Self { #(#builds,)* } }
        }
        Fields::Unnamed(unnamed) => {
            let builds = unnamed.unnamed.iter().enumerate().map(|(idx, _)| {
                let idx = syn::Index::from(idx);
                quote! { helper.#idx }
            });
            quote! { Self( #(#builds,)* ) }
        }
        Fields::Unit => quote! { Self },
    };

    (helper_def, construct)
}

fn validate_struct_helpers(
    data: &DataStruct,
    generics: &syn::Generics,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    let ref_lt = (!matches!(data.fields, Fields::Unit)).then_some("'__typeshift_val");
    let helper_def_generics = helper_def_generics(generics, ref_lt);
    let helper_where_clause = helper_where_clause(generics);

    let helper_def = match &data.fields {
        Fields::Named(named) => {
            let defs = named.named.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["validate"]);
                let name = named_field_ident(field);
                let ty = &field.ty;
                quote! { #(#attrs)* #name: &'__typeshift_val #ty }
            });
            quote! { struct __TypeShiftValidateHelper #helper_def_generics { #(#defs,)* } #helper_where_clause }
        }
        Fields::Unnamed(unnamed) => {
            let defs = unnamed.unnamed.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["validate"]);
                let ty = &field.ty;
                quote! { #(#attrs)* &'__typeshift_val #ty }
            });
            quote! { struct __TypeShiftValidateHelper #helper_def_generics ( #(#defs,)* ) #helper_where_clause ; }
        }
        Fields::Unit => quote! { struct __TypeShiftValidateHelper; },
    };

    let helper_init = match &data.fields {
        Fields::Named(named) => {
            let inits = named.named.iter().map(|field| {
                let name = named_field_ident(field);
                quote! { #name: &self.#name }
            });
            quote! { __TypeShiftValidateHelper { #(#inits,)* } }
        }
        Fields::Unnamed(unnamed) => {
            let inits = unnamed.unnamed.iter().enumerate().map(|(idx, _)| {
                let idx = syn::Index::from(idx);
                quote! { &self.#idx }
            });
            quote! { __TypeShiftValidateHelper( #(#inits,)* ) }
        }
        Fields::Unit => quote! { __TypeShiftValidateHelper },
    };

    (helper_def, helper_init)
}

fn schema_struct_helper(data: &DataStruct, generics: &syn::Generics) -> proc_macro2::TokenStream {
    let helper_def_generics = helper_def_generics(generics, None);
    let helper_where_clause = helper_where_clause(generics);

    match &data.fields {
        Fields::Named(named) => {
            let defs = named.named.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde", "schemars"]);
                let name = named_field_ident(field);
                let ty = &field.ty;
                quote! { #(#attrs)* #name: #ty }
            });
            quote! { struct __TypeShiftSchemaHelper #helper_def_generics { #(#defs,)* } #helper_where_clause }
        }
        Fields::Unnamed(unnamed) => {
            let defs = unnamed.unnamed.iter().map(|field| {
                let attrs = filter_attrs(&field.attrs, &["serde", "schemars"]);
                let ty = &field.ty;
                quote! { #(#attrs)* #ty }
            });
            quote! { struct __TypeShiftSchemaHelper #helper_def_generics ( #(#defs,)* ) #helper_where_clause ; }
        }
        Fields::Unit => quote! { struct __TypeShiftSchemaHelper; },
    }
}

fn serialize_enum_helpers(
    data: &DataEnum,
    generics: &syn::Generics,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    let ref_lt = enum_has_payload(data).then_some("'__typeshift_ser");
    let helper_def_generics = helper_def_generics(generics, ref_lt);
    let helper_where_clause = helper_where_clause(generics);

    let variants = data
        .variants
        .iter()
        .map(|variant| enum_variant_definition(variant, &["serde"], ref_lt, true));

    let helper_def = quote! {
        enum __TypeShiftSerializeHelper #helper_def_generics #helper_where_clause {
            #(#variants,)*
        }
    };

    let arms = data
        .variants
        .iter()
        .map(|variant| enum_match_arm_self_to_helper(variant, "__TypeShiftSerializeHelper"));
    let helper_init = quote! {
        match self {
            #(#arms,)*
        }
    };

    (helper_def, helper_init)
}

fn deserialize_enum_helpers(
    data: &DataEnum,
    generics: &syn::Generics,
) -> (proc_macro2::TokenStream, proc_macro2::TokenStream) {
    let helper_def_generics = helper_def_generics(generics, None);
    let helper_where_clause = helper_where_clause(generics);

    let variants = data
        .variants
        .iter()
        .map(|variant| enum_variant_definition(variant, &["serde"], None, false));

    let helper_def = quote! {
        enum __TypeShiftDeserializeHelper #helper_def_generics #helper_where_clause {
            #(#variants,)*
        }
    };

    let arms = data
        .variants
        .iter()
        .map(|variant| enum_match_arm_helper_to_self(variant, "__TypeShiftDeserializeHelper"));

    let construct = quote! {
        match helper {
            #(#arms,)*
        }
    };

    (helper_def, construct)
}

fn schema_enum_helper(data: &DataEnum, generics: &syn::Generics) -> proc_macro2::TokenStream {
    let helper_def_generics = helper_def_generics(generics, None);
    let helper_where_clause = helper_where_clause(generics);

    let variants = data
        .variants
        .iter()
        .map(|variant| enum_variant_definition(variant, &["serde", "schemars"], None, false));

    quote! {
        enum __TypeShiftSchemaHelper #helper_def_generics #helper_where_clause {
            #(#variants,)*
        }
    }
}

fn enum_variant_definition(
    variant: &Variant,
    attr_allowlist: &[&str],
    ref_lifetime: Option<&str>,
    include_serde_field_attrs_for_refs: bool,
) -> proc_macro2::TokenStream {
    let variant_attrs = filter_attrs(&variant.attrs, attr_allowlist);
    let name = &variant.ident;
    let discriminant = enum_discriminant(&variant.discriminant);

    match &variant.fields {
        Fields::Named(named) => {
            let fields = named.named.iter().map(|field| {
                let mut allowlist = attr_allowlist.to_vec();
                if include_serde_field_attrs_for_refs && !allowlist.contains(&"serde") {
                    allowlist.push("serde");
                }
                let attrs = filter_attrs(&field.attrs, &allowlist);
                let field_name = named_field_ident(field);
                let ty = &field.ty;
                if let Some(lt) = ref_lifetime {
                    let lt_ident = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
                    quote! { #(#attrs)* #field_name: &#lt_ident #ty }
                } else {
                    quote! { #(#attrs)* #field_name: #ty }
                }
            });
            quote! { #(#variant_attrs)* #name { #(#fields,)* } #discriminant }
        }
        Fields::Unnamed(unnamed) => {
            let fields = unnamed.unnamed.iter().map(|field| {
                let mut allowlist = attr_allowlist.to_vec();
                if include_serde_field_attrs_for_refs && !allowlist.contains(&"serde") {
                    allowlist.push("serde");
                }
                let attrs = filter_attrs(&field.attrs, &allowlist);
                let ty = &field.ty;
                if let Some(lt) = ref_lifetime {
                    let lt_ident = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
                    quote! { #(#attrs)* &#lt_ident #ty }
                } else {
                    quote! { #(#attrs)* #ty }
                }
            });
            quote! { #(#variant_attrs)* #name( #(#fields,)* ) #discriminant }
        }
        Fields::Unit => quote! { #(#variant_attrs)* #name #discriminant },
    }
}

fn enum_match_arm_self_to_helper(variant: &Variant, helper_name: &str) -> proc_macro2::TokenStream {
    let helper_ident = syn::Ident::new(helper_name, proc_macro2::Span::call_site());
    let var_ident = &variant.ident;

    match &variant.fields {
        Fields::Named(named) => {
            let names: Vec<_> = named.named.iter().map(named_field_ident).cloned().collect();
            quote! {
                Self::#var_ident { #(#names,)* } => #helper_ident::#var_ident { #(#names,)* }
            }
        }
        Fields::Unnamed(unnamed) => {
            let binds: Vec<_> = unnamed
                .unnamed
                .iter()
                .enumerate()
                .map(|(idx, _)| {
                    syn::Ident::new(&format!("__f{idx}"), proc_macro2::Span::call_site())
                })
                .collect();
            quote! {
                Self::#var_ident( #(#binds,)* ) => #helper_ident::#var_ident( #(#binds,)* )
            }
        }
        Fields::Unit => quote! { Self::#var_ident => #helper_ident::#var_ident },
    }
}

fn enum_match_arm_helper_to_self(variant: &Variant, helper_name: &str) -> proc_macro2::TokenStream {
    let helper_ident = syn::Ident::new(helper_name, proc_macro2::Span::call_site());
    let var_ident = &variant.ident;

    match &variant.fields {
        Fields::Named(named) => {
            let names: Vec<_> = named.named.iter().map(named_field_ident).cloned().collect();
            quote! {
                #helper_ident::#var_ident { #(#names,)* } => Self::#var_ident { #(#names,)* }
            }
        }
        Fields::Unnamed(unnamed) => {
            let binds: Vec<_> = unnamed
                .unnamed
                .iter()
                .enumerate()
                .map(|(idx, _)| {
                    syn::Ident::new(&format!("__f{idx}"), proc_macro2::Span::call_site())
                })
                .collect();
            quote! {
                #helper_ident::#var_ident( #(#binds,)* ) => Self::#var_ident( #(#binds,)* )
            }
        }
        Fields::Unit => quote! { #helper_ident::#var_ident => Self::#var_ident },
    }
}

fn enum_discriminant(discriminant: &Option<(syn::token::Eq, Expr)>) -> proc_macro2::TokenStream {
    match discriminant {
        Some((_, expr)) => quote! { = #expr },
        None => quote! {},
    }
}

fn generics_with_type_bound(generics: &syn::Generics, bound: syn::TypeParamBound) -> syn::Generics {
    let mut output = generics.clone();
    for param in &mut output.params {
        if let syn::GenericParam::Type(type_param) = param {
            type_param.bounds.push(bound.clone());
        }
    }
    output
}

fn helper_def_generics(
    generics: &syn::Generics,
    extra_lifetime: Option<&str>,
) -> proc_macro2::TokenStream {
    let params = &generics.params;
    match (extra_lifetime, params.is_empty()) {
        (Some(lt), true) => {
            let lt = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
            quote! { <#lt> }
        }
        (Some(lt), false) => {
            let lt = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
            quote! { <#lt, #params> }
        }
        (None, true) => quote! {},
        (None, false) => quote! { <#params> },
    }
}

fn helper_use_generics(
    generics: &syn::Generics,
    extra_lifetime: Option<&str>,
) -> proc_macro2::TokenStream {
    let args: Vec<proc_macro2::TokenStream> = generics
        .params
        .iter()
        .map(|param| match param {
            syn::GenericParam::Type(ty) => {
                let ident = &ty.ident;
                quote! { #ident }
            }
            syn::GenericParam::Lifetime(lt) => {
                let lifetime = &lt.lifetime;
                quote! { #lifetime }
            }
            syn::GenericParam::Const(konst) => {
                let ident = &konst.ident;
                quote! { #ident }
            }
        })
        .collect();

    match (extra_lifetime, args.is_empty()) {
        (Some(lt), true) => {
            let lt = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
            quote! { <#lt> }
        }
        (Some(lt), false) => {
            let lt = syn::Lifetime::new(lt, proc_macro2::Span::call_site());
            quote! { <#lt, #(#args,)*> }
        }
        (None, true) => quote! {},
        (None, false) => quote! { <#(#args,)*> },
    }
}

fn helper_where_clause(generics: &syn::Generics) -> proc_macro2::TokenStream {
    match &generics.where_clause {
        Some(where_clause) => quote! { #where_clause },
        None => quote! {},
    }
}

fn enum_has_payload(data: &DataEnum) -> bool {
    data.variants
        .iter()
        .any(|variant| !matches!(variant.fields, Fields::Unit))
}

fn named_field_ident(field: &Field) -> &syn::Ident {
    match &field.ident {
        Some(name) => name,
        None => unreachable!("named field must have ident"),
    }
}