classify_bytes_derive() — tailwindcss Function Reference

Source Code

crates/classification-macros/src/lib.rs lines 33–119

pub fn classify_bytes_derive(input: TokenStream) -> TokenStream {
    let ast = parse_macro_input!(input as DeriveInput);

    // This derive only works on an enum
    let Data::Enum(DataEnum { variants, .. }) = &ast.data else {
        return syn::Error::new_spanned(
            &ast.ident,
            "ClassifyBytes can only be derived on an enum.",
        )
        .to_compile_error()
        .into();
    };

    let enum_name = &ast.ident;

    let mut byte_map: [Option<Ident>; 256] = [const { None }; 256];
    let mut fallback_variant: Option<Ident> = None;

    // Start parsing the variants
    for variant in variants {
        let variant_ident = &variant.ident;

        // If this variant has #[fallback], record it
        if has_fallback_attr(variant) {
            if fallback_variant.is_some() {
                let err = syn::Error::new_spanned(
                    variant_ident,
                    "Multiple variants have #[fallback]. Only one allowed.",
                );
                return err.to_compile_error().into();
            }
            fallback_variant = Some(variant_ident.clone());
        }

        // Get #[bytes(…)]
        let single_bytes = get_bytes_attrs(&variant.attrs);

        // Get #[bytes_range(…)]
        let range_bytes = get_bytes_range_attrs(&variant.attrs);

        // Combine them
        let all_bytes = single_bytes
            .into_iter()
            .chain(range_bytes)
            .collect::<Vec<_>>();

        // Mark them in the table
        for b in all_bytes {
            byte_map[b as usize] = Some(variant_ident.clone());
        }
    }

    // If no fallback variant is found, default to "Other"
    let fallback_ident = fallback_variant.expect("A variant marked with #[fallback] is missing");

    // For each of the 256 byte values, fill the table
    let fill = byte_map
        .clone()
        .into_iter()
        .map(|variant_opt| match variant_opt {
            Some(ident) => quote!(#enum_name::#ident),
            None => quote!(#enum_name::#fallback_ident),
        });

    // Generate the final expanded code
    let expanded = quote! {
        impl #enum_name {
            pub const TABLE: [#enum_name; 256] = [
                #(#fill),*
            ];
        }

        impl From<u8> for #enum_name {
            fn from(byte: u8) -> Self {
                #enum_name::TABLE[byte as usize]
            }
        }

        impl From<&u8> for #enum_name {
            fn from(byte: &u8) -> Self {
                #enum_name::TABLE[*byte as usize]