Use const fn rather than proc_macro for MAX_LENGTH

Signed-off-by: Nico Burns <nico@nicoburns.com>

Author: nicoburns

macros/lib.rs

@@ -6,38 +6,6 @@ extern crate proc_macro;
 
 use proc_macro::TokenStream;
 
-#[proc_macro]
-pub fn _cssparser_internal_max_len(input: TokenStream) -> TokenStream {
-    struct Input {
-        max_length: usize,
-    }
-
-    impl syn::parse::Parse for Input {
-        fn parse(input: syn::parse::ParseStream) -> syn::parse::Result<Self> {
-            let mut max_length = 0;
-            while !input.is_empty() {
-                if input.peek(syn::Token![_]) {
-                    input.parse::<syn::Token![_]>().unwrap();
-                    continue;
-                }
-                let lit: syn::LitStr = input.parse()?;
-                let value = lit.value();
-                if value.to_ascii_lowercase() != value {
-                    return Err(syn::Error::new(lit.span(), "must be ASCII-lowercase"));
-                }
-                max_length = max_length.max(value.len());
-            }
-            Ok(Input { max_length })
-        }
-    }
-
-    let Input { max_length } = syn::parse_macro_input!(input);
-    quote::quote!(
-        pub(super) const MAX_LENGTH: usize = #max_length;
-    )
-    .into()
-}
-
 fn get_byte_from_lit(lit: &syn::Lit) -> u8 {
     if let syn::Lit::Byte(ref byte) = *lit {
         byte.value()

src/lib.rs

@@ -84,7 +84,6 @@ pub use crate::serializer::{serialize_identifier, serialize_name, serialize_stri
 pub use crate::serializer::{CssStringWriter, ToCss, TokenSerializationType};
 pub use crate::tokenizer::{SourceLocation, SourcePosition, Token};
 pub use crate::unicode_range::UnicodeRange;
-pub use cssparser_macros::_cssparser_internal_max_len;
 
 #[cfg(feature = "fast_match_byte")]
 pub use cssparser_macros::match_byte;

src/macros.rs

@@ -34,29 +34,42 @@ macro_rules! match_ignore_ascii_case {
     ( $input:expr,
         $(
             $( #[$meta: meta] )*
-            $( $pattern: pat )|+ $( if $guard: expr )? => $then: expr
+            $( $pattern:literal )|+ $( if $guard: expr )? => $then: expr
         ),+
+        $(,_ => $fallback:expr)?
         $(,)?
     ) => {
         {
-            // This dummy module works around the feature gate
-            // `error[E0658]: procedural macros cannot be expanded to statements`
-            // by forcing the macro to be in an item context
-            // rather than expression/statement context,
-            // even though the macro only expands to items.
-            mod cssparser_internal {
-                $crate::_cssparser_internal_max_len! {
-                    $( $( $pattern )+ )+
+            #[inline(always)]
+            const fn const_usize_max(a: usize, b: usize) -> usize {
+                if a > b {
+                    a
+                } else {
+                    b
                 }
             }
-            $crate::_cssparser_internal_to_lowercase!($input, cssparser_internal::MAX_LENGTH => lowercase);
+
+            const MAX_LENGTH : usize = {
+                let mut maxlen : usize = 0;
+                $(
+                    $( #[$meta] )*
+                    // {} is necessary to work around "[E0658]: attributes on expressions are experimental"
+                    {
+                        $( maxlen = const_usize_max(maxlen, $pattern.len()); )+
+                    }
+                )+
+                maxlen
+            };
+
+            $crate::_cssparser_internal_to_lowercase!($input, MAX_LENGTH => lowercase);
             // "A" is a short string that we know is different for every string pattern,
             // since we’ve verified that none of them include ASCII upper case letters.
             match lowercase.unwrap_or("A") {
                 $(
                     $( #[$meta] )*
                     $( $pattern )|+ $( if $guard )? => $then,
                 )+
+                $(_ => $fallback,)?
             }
         }
     };
@@ -95,13 +108,24 @@ macro_rules! ascii_case_insensitive_phf_map {
     ($name: ident -> $ValueType: ty = { $( $key: tt => $value: expr, )+ }) => {
         use $crate::_cssparser_internal_phf as phf;
 
-        // See macro above for context.
-        mod cssparser_internal {
-            $crate::_cssparser_internal_max_len! {
-                $( $key )+
+        #[inline(always)]
+        const fn const_usize_max(a: usize, b: usize) -> usize {
+            if a > b {
+                a
+            } else {
+                b
             }
         }
 
+        const MAX_LENGTH : usize = {
+            let mut maxlen : usize = 0;
+            $(
+                // {} is necessary to work around "[E0658]: attributes on expressions are experimental"
+                { maxlen = const_usize_max(maxlen, ($key).len()); }
+            )+
+            maxlen
+        };
+
         static MAP: phf::Map<&'static str, $ValueType> = phf::phf_map! {
             $(
                 $key => $value,
@@ -122,7 +146,7 @@ macro_rules! ascii_case_insensitive_phf_map {
             }
 
             fn get(input: &str) -> Option<&'static $ValueType> {
-                $crate::_cssparser_internal_to_lowercase!(input, cssparser_internal::MAX_LENGTH => lowercase);
+                $crate::_cssparser_internal_to_lowercase!(input, MAX_LENGTH => lowercase);
                 MAP.get(lowercase?)
             }
         }

src/tests.rs

@@ -1333,7 +1333,7 @@ fn utf16_columns() {
 #[test]
 fn servo_define_css_keyword_enum() {
     macro_rules! define_css_keyword_enum {
-        (pub enum $name:ident { $($variant:ident = $css:pat,)+ }) => {
+        (pub enum $name:ident { $($variant:ident = $css:literal,)+ }) => {
             #[derive(PartialEq, Debug)]
             pub enum $name {
                 $($variant),+