Random macro refactoring

Author: SimonSapin

macros/lib.rs

@@ -23,7 +23,7 @@ pub fn assert_ascii_lowercase(input: proc_macro::TokenStream) -> proc_macro::Tok
     "".parse().unwrap()
 }
 
-/// and emit a `MAX_LENGTH` constant with the length of the longest string.
+/// Emit a `MAX_LENGTH` constant with the length of the longest string.
 #[proc_macro_derive(cssparser__max_len)]
 pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse_macro_input(&input.to_string()).unwrap();
@@ -40,16 +40,13 @@ pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 }
 
 /// ```
-/// impl $Name {
-///     fn map() -> &'static ::phf::Map<&'static str, $ValueType> { … }
-/// }
+/// static MAP: &'static ::phf::Map<&'static str, $ValueType> = …;
 /// ```
 ///
 /// Map keys are ASCII-lowercased.
 #[proc_macro_derive(cssparser__phf_map)]
 pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse_macro_input(&input.to_string()).unwrap();
-    let name = &input.ident;
 
     let token_trees = find_smuggled_tokens(&input);
     let value_type = &token_trees[0];
@@ -64,28 +61,21 @@ pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         map.entry(&**key, &**value);
     }
 
-    let mut initializer_bytes = Vec::<u8>::new();
-    let mut initializer_tokens = quote::Tokens::new();
-    map.build(&mut initializer_bytes).unwrap();
-    initializer_tokens.append(::std::str::from_utf8(&initializer_bytes).unwrap());
-
-    let tokens = quote! {
-        impl #name {
-            #[inline]
-            fn map() -> &'static ::phf::Map<&'static str, #value_type> {
-                static MAP: ::phf::Map<&'static str, #value_type> = #initializer_tokens;
-                &MAP
-            }
-        }
+    let mut tokens = quote! {
+        static MAP: ::phf::Map<&'static str, #value_type> =
     };
+    let mut initializer_bytes = Vec::new();
+    map.build(&mut initializer_bytes).unwrap();
+    tokens.append(::std::str::from_utf8(&initializer_bytes).unwrap());
+    tokens.append(";");
 
     tokens.as_str().parse().unwrap()
 }
 
 /// Return the `…` part in:
 ///
 /// ```rust
-/// enum $Name {
+/// enum Somthing {
 ///     Input = (0, stringify!(…)).0
 /// }
 /// ```

src/color.rs

@@ -180,7 +180,7 @@ pub fn parse_color_keyword(ident: &str) -> Result<Color, ()> {
         }
     }
     ascii_case_insensitive_phf_map! {
-        KEYWORDS: Map<Color> = {
+        keyword -> Color = {
             "black" => rgb!(0, 0, 0),
             "silver" => rgb!(192, 192, 192),
             "gray" => rgb!(128, 128, 128),
@@ -335,7 +335,7 @@ pub fn parse_color_keyword(ident: &str) -> Result<Color, ()> {
             "currentcolor" => Color::CurrentColor,
         }
     }
-    KEYWORDS::get(ident).cloned().ok_or(())
+    keyword(ident).cloned().ok_or(())
 }
 
 

src/lib.rs

@@ -134,18 +134,18 @@ macro_rules! match_ignore_ascii_case {
     // finished parsing
     (@inner $value:expr, () -> ($(($string:expr => $result:expr))*) $fallback:expr ) => {
         {
-            #[derive(cssparser__assert_ascii_lowercase)]
-            #[allow(unused)]
-            enum Dummy {
-                Input = (0, stringify!( $( $string )+ )).0
+            _cssparser_internal__pretend_proc_macro! {
+                cssparser__assert_ascii_lowercase!( $( $string )+ )
             }
 
-            _cssparser_internal__to_lowercase!($value => lowercase, $($string),+);
-            match lowercase {
-                $(
-                    Some($string) => $result,
-                )+
-                _ => $fallback
+            {
+                _cssparser_internal__to_lowercase!($value => lowercase, $($string),+);
+                match lowercase {
+                    $(
+                        Some($string) => $result,
+                    )+
+                    _ => $fallback
+                }
             }
         }
     };
@@ -156,11 +156,11 @@ macro_rules! match_ignore_ascii_case {
     };
 }
 
-/// Define a placeholder type `$Name`
-/// with a method `fn get(input: &str) -> Option<&'static $ValueType>`.
+/// Define a function `$name(&str) -> Option<&'static $ValueType>`
 ///
-/// This method uses finds a match for the input string
-/// in a [`phf` map](https://github.com/sfackler/rust-phf).
+/// The function finds a match for the input string
+/// in a [`phf` map](https://github.com/sfackler/rust-phf)
+/// and returns a reference to the corresponding value.
 /// Matching is case-insensitive in the ASCII range.
 ///
 /// The `phf` and `cssparser_macros` crates must also be imported at the crate root
@@ -176,30 +176,25 @@ macro_rules! match_ignore_ascii_case {
 ///
 /// fn color_rgb(input: &str) -> Option<(u8, u8, u8)> {
 ///     ascii_case_insensitive_phf_map! {
-///         KEYWORDS: Map<(u8, u8, u8)> = {
+///         keyword -> (u8, u8, u8) = {
 ///             "red" => (255, 0, 0),
 ///             "green" => (0, 255, 0),
 ///             "blue" => (0, 0, 255),
 ///         }
 ///     }
-///     KEYWORDS::get(input).cloned()
+///     keyword(input).cloned()
 /// }
 #[macro_export]
 macro_rules! ascii_case_insensitive_phf_map {
-    ($Name: ident : Map<$ValueType: ty> = {
-        $( $key: expr => $value: expr, )*
-    }) => {
-        #[derive(cssparser__phf_map)]
-        #[allow(unused)]
-        enum $Name {
-            Input = (0, stringify!( ($ValueType) $( $key ($value) )+ )).0
-        }
+    ($name: ident -> $ValueType: ty = { $( $key: expr => $value: expr, )* }) => {
+        fn $name(input: &str) -> Option<&'static $ValueType> {
+            _cssparser_internal__pretend_proc_macro! {
+                cssparser__phf_map!( ($ValueType) $( $key ($value) )+ )
+            }
 
-        impl $Name {
-            #[inline]
-            fn get(input: &str) -> Option<&'static $ValueType> {
+            {
                 _cssparser_internal__to_lowercase!(input => lowercase, $($key),+);
-                lowercase.and_then(|string| $Name::map().get(string))
+                lowercase.and_then(|s| MAP.get(s))
             }
         }
     }
@@ -216,10 +211,8 @@ macro_rules! ascii_case_insensitive_phf_map {
 #[doc(hidden)]
 macro_rules! _cssparser_internal__to_lowercase {
     ($input: expr => $output: ident, $($string: expr),+) => {
-        #[derive(cssparser__max_len)]
-        #[allow(unused)]
-        enum Dummy2 {
-            Input = (0, stringify!( $( $string )+ )).0
+        _cssparser_internal__pretend_proc_macro! {
+            cssparser__max_len!( $( $string )+ )
         }
 
         // mem::uninitialized() is ok because `buffer` is only used in `_internal__to_lowercase`,
@@ -235,6 +228,21 @@ macro_rules! _cssparser_internal__to_lowercase {
     }
 }
 
+/// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros.
+///
+/// **This macro is not part of the public API. It can change or be removed between any versions.**
+#[macro_export]
+#[doc(hidden)]
+macro_rules! _cssparser_internal__pretend_proc_macro {
+    ($macro_name: ident ! ( $($tt: tt)* )) => {
+        #[derive($macro_name)]
+        #[allow(unused)]
+        enum Dummy {
+            Input = (0, stringify!( $( $tt )* )).0
+        }
+    }
+}
+
 /// Implementation detail of match_ignore_ascii_case! and ascii_case_insensitive_phf_map! macros.
 ///
 /// **This function is not part of the public API. It can change or be removed between any verisons.**