ty_tag_macros/

lib.rs

//! Proc macro crate for `ty-tag`.

#[cfg(test)]
mod tests;

mod pretty;

mod errors;
mod options;

use std::collections::HashMap;

use core::ops::Not;
use errors::tri;
use options::AttrOptions;
use proc_macro2::{Span, TokenStream};
use quote::{quote, ToTokens};
use syn::{fold::Fold, parse_quote};

#[proc_macro_attribute]
pub fn tag(
    attr: proc_macro::TokenStream,
    item: proc_macro::TokenStream,
) -> proc_macro::TokenStream {
    tag_impl(attr.into(), item.into()).into()
}

fn tag_impl(attr: TokenStream, item: TokenStream) -> TokenStream {
    let options = tri!(syn::parse2::<AttrOptions>(attr));
    let alias = tri!(syn::parse2::<syn::ItemType>(item));

    let options: Options = tri!(options.try_into());

    let attributes = tri!(Attributes::new(&alias.attrs));

    let generics = tri!(Generics::new(&alias.generics.params));

    let struct_def = StructDef::new(&alias, &attributes, &generics);

    let tags_tag_impl = TagsTagImpl::new(&alias, &attributes, &generics);

    let tag_impl = TagImpl::new(&alias, &attributes, &generics);

    let with_lt_impl = WithLtImpl::new(&alias, &attributes, &generics);

    let local_impl = if !options.remote {
        Some(TagsTyImpl::new(&alias, &attributes, &generics, None))
    } else {
        None
    };

    let local_groups = options
        .local_groups
        .iter()
        .map(|group| TagsTyImpl::new(&alias, &attributes, &generics, Some(group)))
        .collect::<Vec<_>>();

    quote! {
        #struct_def

        #local_impl

        #(#local_groups)*

        #tags_tag_impl

        #tag_impl

        #with_lt_impl
    }
}

struct Options {
    remote: bool,
    local_groups: Vec<syn::Type>,
}

impl TryFrom<AttrOptions> for Options {
    type Error = syn::Error;

    fn try_from(value: AttrOptions) -> Result<Self, Self::Error> {
        let mut remote = false;
        let mut local_groups = Vec::new();

        for option in value.options {
            match &*option.name {
                "remote" => {
                    remote = true;
                }
                "group" => {
                    let Some(value) = option.value else {
                        return Err(syn::Error::new(Span::call_site(), "missing type of group"));
                    };

                    local_groups.push(syn::parse2(value)?);
                }
                _ => {
                    return Err(syn::Error::new(
                        Span::call_site(),
                        format!("unknown option `{}`", option.name),
                    ))
                }
            }
        }

        Ok(Self {
            remote,
            local_groups,
        })
    }
}

struct TyTagPath;

impl ToTokens for TyTagPath {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        tokens.extend(quote! { ::ty_tag });
    }
}

const CRATE: TyTagPath = TyTagPath;

struct StructDef<'a> {
    attributes: &'a Attributes<'a>,
    custom_doc: Option<String>,
    vis: &'a syn::Visibility,
    name: &'a syn::Ident,
    generics: &'a Generics<'a>,
}

impl<'a> StructDef<'a> {
    fn new(
        alias: &'a syn::ItemType,
        attributes: &'a Attributes<'a>,
        generics: &'a Generics<'a>,
    ) -> Self {
        let custom_doc = attributes.docs.is_empty().then(|| {
            if let Some(link) = JustTypePath::strip_type(&alias.ty) {
                format!(
                    "Tag for type [`{0}`]({1}).",
                    pretty::unparse_type(&alias.ty),
                    pretty::unparse_type(&link),
                )
            } else {
                format!("Tag for type `{0}`.", pretty::unparse_type(&alias.ty))
            }
        });

        Self {
            attributes,
            custom_doc,
            vis: &alias.vis,
            name: &alias.ident,
            generics,
        }
    }
}

impl ToTokens for StructDef<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            attributes,
            custom_doc,
            vis,
            name,
            generics,
        } = &self;

        // Each generic type needs to be used so we put it in a PhantomData.
        // Its the result of a function pointer to not effect the auto traits.
        // Its also behind a *const because they are ?Sized.
        let generic_type_holder = generics
            .types_is_empty()
            .not()
            .then(|| {
                let type_generics =
                    generics.with_types(|TypeGeneric { ident, .. }| quote! { *const #ident });

                quote! { , ::core::marker::PhantomData<fn() -> (#(#type_generics,)*)> }
            })
            .unwrap_or_default();

        // We only need the type and const generics for the tag.
        // We also include the type alias defaults.
        let generics_def = generics
            .types_and_consts_is_empty()
            .not()
            .then(|| {
                let generics = generics.with_types_and_consts(
                    |TypeGeneric { ident, default, .. }| {
                        let default = default.iter();

                        quote! { #ident: ?Sized #(= #default)* }
                    },
                    |ConstGeneric { ident, ty, default }| {
                        let default = default.iter();

                        quote! { const #ident: #ty #(= #default)* }
                    },
                );

                quote! { <#(#generics),*> }
            })
            .unwrap_or_default();

        let custom_doc = custom_doc.as_ref().map(|doc| {
            quote! { #[doc = #doc] }
        });

        let attrs = &attributes.struct_attrs;
        let docs = &attributes.docs;

        // The tag is a normal struct.
        // The __ type is included to stop a user from constructing the struct.
        tokens.extend(quote! {
            #(#docs)*
            #custom_doc
            #(#attrs)*
            #vis struct #name #generics_def(#CRATE::__ #generic_type_holder);
        });
    }
}

struct TagsTyImpl<'a> {
    attributes: &'a Attributes<'a>,
    tag_type: TagType<'a>,
    ty: &'a syn::Type,
    generics: &'a Generics<'a>,
    group: Option<&'a syn::Type>,
}

impl<'a> TagsTyImpl<'a> {
    fn new(
        alias: &'a syn::ItemType,
        attributes: &'a Attributes<'a>,
        generics: &'a Generics,
        group: Option<&'a syn::Type>,
    ) -> Self {
        Self {
            attributes,
            tag_type: TagType::new(&alias.ident, generics),
            generics,
            ty: &alias.ty,
            group,
        }
    }
}

impl ToTokens for TagsTyImpl<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            attributes,
            tag_type,
            generics,
            ty,
            group,
        } = &self;

        let krate = CRATE;

        let lt_generics = generics.with_lifetimes(|LifetimeGeneric { lifetime, bounds }| {
            if bounds.is_empty() {
                lifetime.into_token_stream()
            } else {
                quote! { #lifetime: #(#bounds)+* }
            }
        });

        let types_and_consts_generics = generics.with_types_and_consts(
            |TypeGeneric {
                 ident,
                 bounds,
                 is_itself,
                 ..
             }| {
                if *is_itself {
                    quote! {
                        #ident: #(#bounds)+*
                    }
                } else {
                    quote! {
                        #ident: #(#bounds + )* ::ty_tag::Tagged<__Group>
                    }
                }
            },
            |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
        );

        let generics_def = if generics.is_empty() {
            if group.is_some() {
                TokenStream::new()
            } else {
                quote! { <__Group: ?Sized> }
            }
        } else if group.is_none() {
            quote! { <#(#lt_generics,)* __Group: ?Sized #(, #types_and_consts_generics)*> }
        } else {
            quote! { <#(#lt_generics,)* #( #types_and_consts_generics),*> }
        };

        let group = if let Some(group) = group {
            group.into_token_stream()
        } else {
            quote! { __Group }
        };

        let mut replacement = GenericTypeReplace {
            replacements: generics
                .with_types(|ty| ty)
                .filter(|ty| !ty.is_itself)
                .map(|TypeGeneric { ident, .. }| {
                    (
                        *ident,
                        parse_quote! {
                            <#ident as #krate::Tagged<#group>>::Tag
                        },
                    )
                })
                .collect(),
        };

        let tag_type_tag = replacement.fold_type(parse_quote! { #tag_type });

        let where_clause = if generics
            .with_types(|ty| !ty.is_itself)
            .filter(|x| *x)
            .count()
            <= 1
        {
            TokenStream::new()
        } else {
            let type_generics = generics.with_types(|ty| ty).flat_map(
                |TypeGeneric {
                     ident, is_itself, ..
                 }| {
                    if *is_itself {
                        None
                    } else {
                        Some(quote! {
                            <
                                <#ident as #krate::Tagged<#group>>::Tag
                            as #krate::Tag>::NeededLifetimes,
                        })
                    }
                },
            );

            quote! {
                where
                    (#(#type_generics)*): ::ty_tag::lifetime_list::ops::Longest<
                        Output: ::ty_tag::lifetime_list::HoleList
                    >
            }
        };

        let attrs = &attributes.impl_attrs;

        tokens.extend(quote! {
            #(#attrs)*
            impl #generics_def #CRATE::Tagged<#group> for #ty
            #where_clause
            {
                type Tag = #tag_type_tag;
            }
        });
    }
}

struct TagsTagImpl<'a> {
    attributes: &'a Attributes<'a>,
    generics: &'a Generics<'a>,
    tag_type: TagType<'a>,
}

impl<'a> TagsTagImpl<'a> {
    fn new(
        alias: &'a syn::ItemType,
        attributes: &'a Attributes<'a>,
        generics: &'a Generics,
    ) -> Self {
        let tag_type = TagType::new(&alias.ident, generics);

        Self {
            tag_type,
            generics,
            attributes,
        }
    }
}

impl ToTokens for TagsTagImpl<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            tag_type,
            generics,
            attributes,
        } = &self;

        let krate = CRATE;

        let generics_def = if generics.types_and_consts_is_empty() {
            quote! { <__Group: ?Sized> }
        } else {
            let generics = generics.with_types_and_consts(
                |TypeGeneric {
                     ident,
                     bounds,
                     is_itself,
                     ..
                 }| {
                    if *is_itself {
                        quote! { #ident: #(#bounds)+* }
                    } else {
                        quote! { #ident: ?Sized + ::ty_tag::Tagged<__Group> }
                    }
                },
                |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
            );

            quote! { <__Group: ?Sized #(, #generics)*> }
        };

        let mut replacement = GenericTypeReplace {
            replacements: generics
                .with_types(|ty| ty)
                .filter(|ty| !ty.is_itself)
                .map(|TypeGeneric { ident, .. }| {
                    (
                        *ident,
                        parse_quote! {
                            <#ident as #krate::Tagged<__Group>>::Tag
                        },
                    )
                })
                .collect(),
        };

        let tag_type_tag = replacement.fold_type(parse_quote! { #tag_type });

        let where_clause = if generics
            .with_types(|ty| !ty.is_itself)
            .filter(|x| *x)
            .count()
            <= 1
        {
            TokenStream::new()
        } else {
            let type_generics = generics.with_types(|ty| ty).flat_map(
                |TypeGeneric {
                     ident, is_itself, ..
                 }| {
                    if *is_itself {
                        None
                    } else {
                        Some(quote! {
                            <
                                <#ident as #krate::Tagged<__Group>>::Tag
                            as #krate::Tag>::NeededLifetimes,
                        })
                    }
                },
            );

            quote! {
                where
                    (#(#type_generics)*): ::ty_tag::lifetime_list::ops::Longest<
                        Output: ::ty_tag::lifetime_list::HoleList
                    >
            }
        };

        let attrs = &attributes.impl_attrs;

        tokens.extend(quote! {
            #(#attrs)*
            impl #generics_def #CRATE::Tagged<__Group> for #tag_type
            #where_clause
            {
                type Tag = #tag_type_tag;
            }
        });
    }
}

struct TagImpl<'a> {
    attributes: &'a Attributes<'a>,
    hole_count: usize,
    generics: &'a Generics<'a>,
    tag_type: TagType<'a>,
}

impl<'a> TagImpl<'a> {
    fn new(
        alias: &'a syn::ItemType,
        attributes: &'a Attributes<'a>,
        generics: &'a Generics,
    ) -> Self {
        let tag_type = TagType::new(&alias.ident, generics);

        Self {
            attributes,
            hole_count: alias.generics.lifetimes().count(),
            generics,
            tag_type,
        }
    }
}

impl ToTokens for TagImpl<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            hole_count,
            generics,
            tag_type,
            attributes,
        } = &self;

        let holes = if *hole_count != 0 {
            let tail = if generics
                .with_types(|ty| !ty.is_itself)
                .filter(|x| *x)
                .count()
                == 1
            {
                let type_generics = generics.with_types(|ty| &ty.ident);

                Some(quote! { <#(#type_generics)* as #CRATE::Tag>::NeededLifetimes })
            } else if generics
                .with_types(|ty| !ty.is_itself)
                .filter(|x| *x)
                .count()
                == 0
            {
                None
            } else {
                let type_generics = generics.with_types(|ty| ty).flat_map(
                    |TypeGeneric {
                         ident, is_itself, ..
                     }| if *is_itself { None } else { Some(ident) },
                );

                Some(quote! {
                    <(#(
                        <#type_generics as ::ty_tag::Tag>::NeededLifetimes,
                    )*) as ::ty_tag::lifetime_list::ops::Longest>::Output
                })
            };

            let holes = HoleList {
                count: *hole_count,
                tail,
            };
            quote! { #holes }
        } else if generics
            .with_types(|ty| !ty.is_itself)
            .filter(|x| *x)
            .count()
            == 0
        {
            let holes = HoleList {
                count: 0,
                tail: None,
            };
            quote! { #holes }
        } else if generics
            .with_types(|ty| !ty.is_itself)
            .filter(|x| *x)
            .count()
            == 1
        {
            let type_generics = generics.with_types(|ty| ty).flat_map(
                |TypeGeneric {
                     ident, is_itself, ..
                 }| if *is_itself { None } else { Some(ident) },
            );

            quote! { <#(#type_generics)* as #CRATE::Tag>::NeededLifetimes }
        } else {
            let type_generics = generics.with_types(|ty| ty).flat_map(
                |TypeGeneric {
                     ident, is_itself, ..
                 }| if *is_itself { None } else { Some(ident) },
            );

            quote! {
                <(#(
                    <#type_generics as ::ty_tag::Tag>::NeededLifetimes,
                )*) as ::ty_tag::lifetime_list::ops::Longest>::Output
            }
        };

        let krate = CRATE;

        let where_clause = if generics
            .with_types(|ty| !ty.is_itself)
            .filter(|x| *x)
            .count()
            <= 1
        {
            TokenStream::new()
        } else {
            let type_generics = generics.with_types(|ty| ty).flat_map(
                |TypeGeneric {
                     ident, is_itself, ..
                 }| {
                    if *is_itself {
                        None
                    } else {
                        Some(quote! {
                            <#ident as #krate::Tag>::NeededLifetimes,
                        })
                    }
                },
            );

            quote! {
                where
                    (#(#type_generics)*): ::ty_tag::lifetime_list::ops::Longest<
                        Output: ::ty_tag::lifetime_list::HoleList
                    >
            }
        };

        let generics_def = if generics.is_empty() {
            TokenStream::new()
        } else {
            let generics = generics.with_types_and_consts(
                |TypeGeneric {
                     ident,
                     bounds,
                     is_itself,
                     ..
                 }| {
                    if *is_itself {
                        quote! {
                            #ident: #(#bounds)+*
                        }
                    } else {
                        quote! {
                            #ident: ?Sized + ::ty_tag::Tag
                        }
                    }
                },
                |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
            );

            quote! { <#(#generics),*> }
        };

        let attrs = &attributes.impl_attrs;

        tokens.extend(quote! {
            #(#attrs)*
            impl #generics_def #CRATE::Tag for #tag_type
            #where_clause
            {
                type NeededLifetimes = #holes;
            }
        });
    }
}

struct WithLtImpl<'a> {
    attributes: &'a Attributes<'a>,
    ty: syn::Type,
    sized_bounds: Vec<syn::Ident>,
    where_bounds: Vec<syn::WherePredicate>,
    tag_type: TagType<'a>,
    generics: &'a Generics<'a>,
}

impl<'a> WithLtImpl<'a> {
    fn new(
        alias: &'a syn::ItemType,
        attributes: &'a Attributes<'a>,
        generics: &'a Generics,
    ) -> Self {
        let mut sized_bounds = HashMap::new();
        let mut where_bounds = Vec::new();

        for generic in generics.with_types(|ty| ty) {
            if generic.is_itself {
                continue
            }

            let bound = syn::WherePredicate::Type(syn::PredicateType {
                lifetimes: None,
                bounded_ty: syn::Type::Path(syn::TypePath {
                    qself: None,
                    path: syn::Path {
                        leading_colon: None,
                        segments: [syn::PathSegment {
                            ident: generic.ident.clone(),
                            arguments: syn::PathArguments::None,
                        }]
                        .into_iter()
                        .collect(),
                    },
                }),
                colon_token: Default::default(),
                bounds: generic.bounds.iter().map(|x| (**x).clone()).collect(),
            });

            let sized = sized_bounds
                .entry(generic.ident.clone())
                .or_insert(FindAndRemoveSized { sized: None });

            let bound = sized.fold_where_predicate(bound);

            where_bounds.push(bound);
        }

        if let Some(clause) = &alias.generics.where_clause {
            for predicate in &clause.predicates {
                match predicate {
                    syn::WherePredicate::Type(predicate_type) => {
                        let bound = match &predicate_type.bounded_ty {
                            syn::Type::Path(type_path) => {
                                if let Some(ident) = type_path.path.get_ident() {
                                    if let Some(sized) = sized_bounds.get_mut(ident) {
                                        sized.fold_where_predicate(predicate.clone())
                                    } else {
                                        predicate.clone()
                                    }
                                } else {
                                    predicate.clone()
                                }
                            }
                            _ => predicate.clone(),
                        };
                        where_bounds.push(bound);
                    }
                    _ => where_bounds.push(predicate.clone()),
                }
            }
        }

        let mut replacement = GenericTypeReplace {
            replacements: generics
                .with_types(|ty| ty)
                .filter(|ty| !ty.is_itself)
                .map(|TypeGeneric { ident, .. }| {
                    (
                        *ident,
                        parse_quote! {
                            <#ident as #CRATE::WithLt<__L>>::Reified
                        },
                    )
                })
                .collect(),
        };

        for bound in &mut where_bounds {
            *bound = replacement.fold_where_predicate(bound.clone());
        }

        if generics
            .with_types(|ty| ty)
            .filter(|ty| !ty.is_itself)
            .count()
            >= 2
        {
            let krate = CRATE;

            let type_generics = generics.with_types(|ty| ty).filter(|ty| !ty.is_itself).map(
                |TypeGeneric { ident, .. }| {
                    quote! {
                        <#ident as #krate::Tag>::NeededLifetimes,
                    }
                },
            );

            where_bounds.push(parse_quote! {
                    (#(#type_generics)*): ::ty_tag::lifetime_list::ops::Longest<
                        Output: ::ty_tag::lifetime_list::HoleList
                    >
            });
        }

        where_bounds.retain(|bound| match bound {
            syn::WherePredicate::Type(predicate_type) => !predicate_type.bounds.is_empty(),
            _ => true,
        });

        let tag_type = TagType::new(&alias.ident, generics);

        let mut sized_bounds = sized_bounds
            .into_iter()
            .flat_map(|(ident, find)| {
                if matches!(find.sized, Some(true) | None) {
                    Some(ident)
                } else {
                    None
                }
            })
            .collect::<Vec<_>>();

        sized_bounds.sort();

        Self {
            ty: (*alias.ty).clone(),
            generics,
            tag_type,
            where_bounds,
            sized_bounds,
            attributes,
        }
    }
}

impl ToTokens for WithLtImpl<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let Self {
            ty,
            generics,
            sized_bounds,
            where_bounds,
            tag_type,
            attributes,
        } = self;

        let krate = CRATE;

        let generics_def = if generics.lifetimes_is_empty() {
            if generics.is_empty() {
                TokenStream::new()
            } else if generics.with_types(|ty| ty).filter(|ty| !ty.is_itself).count() == 0 {
                let generics = generics.with(
                    |LifetimeGeneric { lifetime, bounds }| {
                        if bounds.is_empty() {
                            lifetime.into_token_stream()
                        } else {
                            quote! { #lifetime: #(#bounds)+* }
                        }
                    },
                    |TypeGeneric {
                         ident,
                         bounds,
                         is_itself,
                         ..
                     }| {
                        if *is_itself {
                            quote! {
                                #ident: #(#bounds)+*
                            }
                        } else {
                            quote! {
                                #ident: ?Sized + ::ty_tag::WithLt<__L>
                            }
                        }
                    },
                    |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
                );

                quote! {
                    <#(#generics),*>
                }
            } else {
                let generics = generics.with(
                    |LifetimeGeneric { lifetime, bounds }| {
                        if bounds.is_empty() {
                            lifetime.into_token_stream()
                        } else {
                            quote! { #lifetime: #(#bounds)+* }
                        }
                    },
                    |TypeGeneric {
                         ident,
                         bounds,
                         is_itself,
                         ..
                     }| {
                        if *is_itself {
                            quote! {
                                #ident: #(#bounds)+*
                            }
                        } else {
                            quote! {
                                #ident: ?Sized + ::ty_tag::WithLt<__L>
                            }
                        }
                    },
                    |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
                );

                quote! {
                    <
                        __L: #krate::lifetime_list::LifetimeList,
                        #(#generics),*
                    >
                }
            }
        } else if generics.is_empty() {
            let lt_generics = generics.with_lifetimes(|LifetimeGeneric { lifetime, bounds }| {
                if bounds.is_empty() {
                    lifetime.into_token_stream()
                } else {
                    quote! { #lifetime: #(#bounds)+* }
                }
            });

            quote! { <#(#lt_generics),*> }
        } else if generics.with_types(|ty| ty).filter(|ty| !ty.is_itself).count() == 0 {
            let generics = generics.with(
                |LifetimeGeneric { lifetime, bounds }| {
                    if bounds.is_empty() {
                        lifetime.into_token_stream()
                    } else {
                        quote! { #lifetime: #(#bounds)+* }
                    }
                },
                |TypeGeneric {
                     ident,
                     bounds,
                     is_itself,
                     ..
                 }| {
                    if *is_itself {
                        quote! {
                            #ident: #(#bounds)+*
                        }
                    } else {
                        quote! {
                            #ident: ?Sized + ::ty_tag::WithLt<__L>
                        }
                    }
                },
                |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
            );

            quote! {
                <#(#generics),*>
            }
        } else {
            let lt_generics = generics.with_lifetimes(|LifetimeGeneric { lifetime, bounds }| {
                if bounds.is_empty() {
                    lifetime.into_token_stream()
                } else {
                    quote! { #lifetime: #(#bounds)+* }
                }
            });

            let generics = generics.with_types_and_consts(
                |TypeGeneric {
                     ident,
                     bounds,
                     is_itself,
                     ..
                 }| {
                    if *is_itself {
                        quote! {
                            #ident: #(#bounds)+*
                        }
                    } else {
                        quote! {
                            #ident: ?Sized + ::ty_tag::WithLt<__L>
                        }
                    }
                },
                |ConstGeneric { ident, ty, .. }| quote! { const #ident: #ty },
            );

            quote! {
                <
                    #(#lt_generics,)*
                    __L: #krate::lifetime_list::LifetimeList,
                    #(#generics),*
                >
            }
        };

        let where_clause = match (where_bounds.is_empty(), sized_bounds.is_empty()) {
            (true, true) => TokenStream::new(),
            (true, false) => {
                let sized_bounds = sized_bounds.iter().collect::<Vec<_>>();

                quote! {
                    where
                        #(<#sized_bounds as #krate::WithLt<__L>>::Reified: Sized),*
                }
            }
            (false, true) => {
                quote! {
                    where
                        #(#where_bounds),*
                }
            }
            (false, false) => {
                let sized_bounds = sized_bounds.iter().collect::<Vec<_>>();

                quote! {
                    where
                        #(<#sized_bounds as #krate::WithLt<__L>>::Reified: Sized,)*
                        #(#where_bounds),*
                }
            }
        };

        let l = if generics.with_types(|ty| ty).filter(|ty| !ty.is_itself).count() == 0 {
            let lifetimes = generics
                .with_lifetimes(|l| l.lifetime.clone())
                .collect::<Vec<_>>();

            let l = LifetimeList {
                lifetimes: &lifetimes,
                tail: None,
            };

            quote! { #l }
        } else if generics.lifetimes_is_empty() {
            quote! { __L }
        } else {
            let lifetimes = generics
                .with_lifetimes(|l| l.lifetime.clone())
                .collect::<Vec<_>>();

            let l = LifetimeList {
                lifetimes: &lifetimes,
                tail: Some(quote! { __L }),
            };
            quote! { #l }
        };

        let mut replacement = GenericTypeReplace {
            replacements: generics
                .with_types(|ty| ty)
                .filter(|ty| !ty.is_itself)
                .map(|TypeGeneric { ident, .. }| {
                    (
                        *ident,
                        parse_quote! {
                            <#ident as #CRATE::WithLt<__L>>::Reified
                        },
                    )
                })
                .collect(),
        };

        let reified_ty = replacement.fold_type(ty.clone());

        let attrs = &attributes.impl_attrs;

        tokens.extend(quote! {
            #(#attrs)*
            impl #generics_def #CRATE::WithLt<#l> for #tag_type
            #where_clause
            {
                type Reified = #reified_ty;
            }
        });
    }
}

struct LifetimeList<'a> {
    lifetimes: &'a [syn::Lifetime],
    tail: Option<TokenStream>,
}

impl ToTokens for LifetimeList<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        let mut iter = self.lifetimes.iter();

        if let Some(lt) = iter.next() {
            tokens.extend(
                quote! { #CRATE::lifetime_list::cons::Cons<#CRATE::lifetime_list::Inv<#lt> },
            );
        } else {
            tokens.extend(quote! { #CRATE::lifetime_list::cons::Nil });
            return;
        }

        let mut count = 1;

        for lt in iter {
            count += 1;
            tokens.extend(
                quote! { , #CRATE::lifetime_list::cons::Cons<#CRATE::lifetime_list::Inv<#lt> },
            );
        }

        if let Some(tail) = &self.tail {
            tokens.extend(quote! {, #tail});
        }

        // End the cons list.
        for _ in 0..count {
            tokens.extend(quote! { > });
        }
    }
}

struct HoleList {
    count: usize,
    tail: Option<TokenStream>,
}

impl ToTokens for HoleList {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        if self.count != 0 {
            tokens.extend(quote! { #CRATE::lifetime_list::cons::Cons<#CRATE::lifetime_list::Hole });
        } else {
            tokens.extend(quote! { #CRATE::lifetime_list::cons::Nil });
            return;
        }

        for _ in 0..(self.count - 1) {
            tokens
                .extend(quote! { , #CRATE::lifetime_list::cons::Cons<#CRATE::lifetime_list::Hole });
        }

        if let Some(tail) = &self.tail {
            tokens.extend(quote! {, #tail});
        }

        // End the cons list.
        for _ in 0..self.count {
            tokens.extend(quote! { > });
        }
    }
}

struct GenericTypeReplace<'a> {
    replacements: HashMap<&'a syn::Ident, syn::TypePath>,
}

impl Fold for GenericTypeReplace<'_> {
    fn fold_type_path(&mut self, i: syn::TypePath) -> syn::TypePath {
        if i.qself.is_some() {
            return syn::fold::fold_type_path(self, i);
        }

        let Some(ident) = i.path.get_ident() else {
            return syn::fold::fold_type_path(self, i);
        };

        if let Some(path) = self.replacements.get(ident) {
            parse_quote!(#path)
        } else {
            syn::fold::fold_type_path(self, i)
        }
    }
}

struct FindAndRemoveSized {
    sized: Option<bool>,
}

impl Fold for FindAndRemoveSized {
    fn fold_predicate_type(&mut self, i: syn::PredicateType) -> syn::PredicateType {
        syn::PredicateType {
            lifetimes: i.lifetimes,
            bounded_ty: i.bounded_ty,
            colon_token: i.colon_token,
            bounds: i
                .bounds
                .into_iter()
                .flat_map(|bound| match &bound {
                    syn::TypeParamBound::Trait(trait_bound) => {
                        if trait_bound
                            .path
                            .get_ident()
                            .map(|ident| ident == "Sized")
                            .unwrap_or_default()
                        {
                            if matches!(self.sized, Some(false) | None) {
                                self.sized = Some(matches!(
                                    trait_bound.modifier,
                                    syn::TraitBoundModifier::None
                                ));
                            }

                            None
                        } else {
                            Some(bound)
                        }
                    }
                    _ => Some(bound),
                })
                .collect(),
        }
    }
}

struct TagType<'a> {
    ident: &'a syn::Ident,
    generics: &'a Generics<'a>,
}

impl<'a> TagType<'a> {
    fn new(ident: &'a syn::Ident, generics: &'a Generics) -> Self {
        Self { ident, generics }
    }
}

impl ToTokens for TagType<'_> {
    fn to_tokens(&self, tokens: &mut TokenStream) {
        if self.generics.types_and_consts_is_empty() {
            self.ident.to_tokens(tokens)
        } else {
            let Self { ident, generics } = self;

            let generics = generics.with_types_and_consts(
                |TypeGeneric { ident, .. }| ident,
                |ConstGeneric { ident, .. }| ident,
            );

            tokens.extend(quote! {
                #ident <#(#generics),*>
            });
        }
    }
}

struct JustTypePath;

impl JustTypePath {
    fn strip_type(ty: &syn::Type) -> Option<syn::Type> {
        match ty {
            syn::Type::Path(_) => Some(JustTypePath.fold_type(ty.clone())),
            _ => None,
        }
    }
}

impl Fold for JustTypePath {
    fn fold_path_segment(&mut self, mut segment: syn::PathSegment) -> syn::PathSegment {
        segment.arguments = syn::PathArguments::None;
        segment
    }
}

struct Generics<'a> {
    generics: Vec<Generic<'a>>,
}

enum Generic<'a> {
    Lifetime(LifetimeGeneric<'a>),
    Type(TypeGeneric<'a>),
    Const(ConstGeneric<'a>),
}

struct LifetimeGeneric<'a> {
    lifetime: &'a syn::Lifetime,
    bounds: Vec<&'a syn::Lifetime>,
}

struct TypeGeneric<'a> {
    ident: &'a syn::Ident,
    bounds: Vec<&'a syn::TypeParamBound>,
    default: Option<&'a syn::Type>,
    is_itself: bool,
}

struct ConstGeneric<'a> {
    ident: &'a syn::Ident,
    ty: &'a syn::Type,
    default: Option<&'a syn::Expr>,
}

impl<'a> Generics<'a> {
    fn new<T: IntoIterator<Item = &'a syn::GenericParam>>(generics: T) -> syn::Result<Self> {
        Ok(Self {
            generics: generics
                .into_iter()
                .map(|generic| {
                    Ok(match generic {
                        syn::GenericParam::Lifetime(lifetime_param) => {
                            if let Some(attr) = lifetime_param.attrs.first() {
                                return Err(syn::Error::new_spanned(attr, "unknown attribute"));
                            }

                            Generic::Lifetime(LifetimeGeneric {
                                lifetime: &lifetime_param.lifetime,
                                bounds: lifetime_param.bounds.iter().collect(),
                            })
                        }
                        syn::GenericParam::Type(type_param) => {
                            let mut is_itself = false;

                            for attr in &type_param.attrs {
                                if matches!(attr.style, syn::AttrStyle::Inner(_)) {
                                    return Err(syn::Error::new_spanned(
                                        attr,
                                        "inner attribute not allowed",
                                    ));
                                }

                                match &attr.meta {
                                    syn::Meta::Path(path)
                                        if path
                                            .get_ident()
                                            .map(|ident| ident == "itself")
                                            .unwrap_or_default() =>
                                    {
                                        if is_itself {
                                            return Err(syn::Error::new_spanned(
                                                attr,
                                                "cannot set `itself` more than once",
                                            ));
                                        }

                                        is_itself = true;
                                    }
                                    _ => {
                                        return Err(syn::Error::new_spanned(
                                            attr,
                                            "unknown attribute",
                                        ));
                                    }
                                }
                            }

                            Generic::Type(TypeGeneric {
                                ident: &type_param.ident,
                                bounds: type_param.bounds.iter().collect(),
                                default: type_param.default.as_ref(),
                                is_itself,
                            })
                        }
                        syn::GenericParam::Const(const_param) => {
                            if let Some(attr) = const_param.attrs.first() {
                                return Err(syn::Error::new_spanned(attr, "unknown attribute"));
                            }

                            Generic::Const(ConstGeneric {
                                ident: &const_param.ident,
                                ty: &const_param.ty,
                                default: const_param.default.as_ref(),
                            })
                        }
                    })
                })
                .collect::<syn::Result<_>>()?,
        })
    }

    fn is_empty(&self) -> bool {
        self.generics.is_empty()
    }

    fn types_is_empty(&self) -> bool {
        !self
            .generics
            .iter()
            .any(|generic| matches!(generic, Generic::Type(_)))
    }

    fn lifetimes_is_empty(&self) -> bool {
        !self
            .generics
            .iter()
            .any(|generic| matches!(generic, Generic::Lifetime(_)))
    }

    fn types_and_consts_is_empty(&self) -> bool {
        !self
            .generics
            .iter()
            .any(|generic| matches!(generic, Generic::Type(_) | Generic::Const(_)))
    }

    fn with_types<'b, T, R>(&'b self, mut t: T) -> impl Iterator<Item = R> + use<'b, T, R>
    where
        T: FnMut(&'b TypeGeneric) -> R,
    {
        self.generics.iter().flat_map(move |generic| match generic {
            Generic::Type(ty) => Some(t(ty)),
            _ => None,
        })
    }

    fn with_types_and_consts<'b, T, C, R>(
        &'b self,
        mut t: T,
        mut c: C,
    ) -> impl Iterator<Item = R> + use<'b, T, C, R>
    where
        T: FnMut(&'b TypeGeneric) -> R,
        C: FnMut(&'b ConstGeneric) -> R,
    {
        self.generics.iter().flat_map(move |generic| match generic {
            Generic::Type(ty) => Some(t(ty)),
            Generic::Const(cons) => Some(c(cons)),
            _ => None,
        })
    }

    fn with_lifetimes<'b, L, R>(&'b self, mut l: L) -> impl Iterator<Item = R> + use<'b, L, R>
    where
        L: FnMut(&'b LifetimeGeneric) -> R,
    {
        self.generics.iter().flat_map(move |generic| match generic {
            Generic::Lifetime(lifetime) => Some(l(lifetime)),
            _ => None,
        })
    }

    fn with<'b, L, T, C, R>(
        &'b self,
        mut l: L,
        mut t: T,
        mut c: C,
    ) -> impl Iterator<Item = R> + use<'b, L, T, C, R>
    where
        L: FnMut(&'b LifetimeGeneric) -> R,
        T: FnMut(&'b TypeGeneric) -> R,
        C: FnMut(&'b ConstGeneric) -> R,
    {
        self.generics.iter().map(move |generic| match generic {
            Generic::Lifetime(lifetime) => l(lifetime),
            Generic::Type(ty) => t(ty),
            Generic::Const(cons) => c(cons),
        })
    }
}

struct Attributes<'a> {
    docs: Vec<&'a syn::Attribute>,
    struct_attrs: Vec<&'a syn::Attribute>,
    impl_attrs: Vec<&'a syn::Attribute>,
}

impl<'a> Attributes<'a> {
    fn new<I: IntoIterator<Item = &'a syn::Attribute>>(attrs: I) -> syn::Result<Self> {
        let mut docs = Vec::new();
        let mut struct_attrs = Vec::new();
        let mut impl_attrs = Vec::new();

        for attr in attrs {
            if let Some(ident) = attr.path().get_ident() {
                match &*ident.to_string() {
                    // Only put this on the struct because we can't expect the user to know the
                    // impls exist.
                    "expect" => {
                        struct_attrs.push(attr);
                    }
                    // Apply to all the generated code so the user can set lints for all of it.
                    "allow" | "warn" | "deny" | "forbid" => {
                        struct_attrs.push(attr);
                        impl_attrs.push(attr);
                    }
                    // cfg always happens first, but we shouldn't error on it.
                    // cfg_attr isn't allowed because we don't know where to put it.
                    "cfg" => {}
                    // Deprecated only works on the struct not the impls.
                    "deprecated" => {
                        struct_attrs.push(attr);
                    }
                    // Doc attributes are separate because we generate a doc when they aren't
                    // there.
                    "doc" | "doc_cfg" => {
                        docs.push(attr);
                    }
                    // Everything else we don't allow because we may want to do something specific
                    // in the future.
                    _ => {
                        return Err(syn::Error::new_spanned(attr, "unknown attribute"));
                    }
                }
            } else {
                // We don't allow any non ident attributes #[something::other] because there are
                // none of those we care about currently.
                return Err(syn::Error::new_spanned(attr, "unknown attribute"));
            }
        }

        Ok(Self {
            docs,
            struct_attrs,
            impl_attrs,
        })
    }
}