lib.rs — tailwindcss Source File

Source Code

use proc_macro::TokenStream;
use quote::quote;
use syn::{
    parse_macro_input, punctuated::Punctuated, token::Comma, Attribute, Data, DataEnum,
    DeriveInput, Expr, ExprLit, ExprRange, Ident, Lit, RangeLimits, Result, Variant,
};

/// A custom derive that supports:
///
/// - `#[bytes(…)]` for single byte literals
/// - `#[bytes_range(…)]` for inclusive byte ranges (b'a'..=b'z')
/// - `#[fallback]` for a variant that covers everything else
///
/// Example usage:
///
/// ```rust
/// use classification_macros::ClassifyBytes;
///
/// #[derive(Clone, Copy, ClassifyBytes)]
/// enum Class {
///     #[bytes(b'a', b'b', b'c')]
///     Letters,
///
///     #[bytes_range(b'0'..=b'9')]
///     Digits,
///
///     #[fallback]
///     Other,
/// }
/// ```
/// Then call `b'a'.into()` to get `Example::SomeLetters`.
#[proc_macro_derive(ClassifyBytes, attributes(bytes, bytes_range, fallback))]
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.",
// ... (194 more lines)