Move proc-macro trickery to a separate crate.

SimonSapin · SimonSapin · commit 5efba23102b8 · 2017-02-28T00:43:35.000+01:00
It could be useful outside of cssparser.
diff --git a/Cargo.toml b/Cargo.toml
@@ -24,6 +24,7 @@ cssparser-macros = {path = "./macros", version = "0.2"}
 heapsize = {version = "0.3", optional = true}
 matches = "0.1"
 phf = "0.7"
+procedural-masquarade = {path = "./procedural-masquarade", version = "0.1"}
 serde = {version = "0.9", optional = true}
 
 [build-dependencies]
@@ -35,4 +36,4 @@ bench = []
 dummy_match_byte = []
 
 [workspace]
-members = [".", "./macros"]
+members = [".", "./macros", "./procedural-masquarade"]
diff --git a/macros/Cargo.toml b/macros/Cargo.toml
@@ -12,6 +12,7 @@ path = "lib.rs"
 proc-macro = true
 
 [dependencies]
+procedural-masquarade = {path = "../procedural-masquarade", version = "0.1"}
 phf_codegen = "0.7"
-quote = "0.3"
-syn = {version = "0.11", features = ["full"]}
+quote = "0.3.14"
+syn = {version = "0.11.8", features = ["full"]}
diff --git a/macros/lib.rs b/macros/lib.rs
@@ -2,25 +2,25 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+#[macro_use] extern crate procedural_masquarade;
 extern crate phf_codegen;
 extern crate proc_macro;
 #[macro_use] extern crate quote;
 extern crate syn;
 
 use std::ascii::AsciiExt;
 
-/// Panic if any string contains ASCII uppercase letters.
-/// Emit a `MAX_LENGTH` constant with the length of the longest string.
-#[proc_macro_derive(cssparser_internal__assert_ascii_lowercase__max_len)]
-pub fn assert_ascii_lowercase_max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    max_len_common(input, |token_trees| {
-        let tokens = quote!( match x { #( #token_trees )* } );
-        let expr = syn::parse_expr(tokens.as_str()).unwrap();
+define_proc_macros! {
+    /// Panic if any string contains ASCII uppercase letters.
+    /// Emit a `MAX_LENGTH` constant with the length of the longest string.
+    #[allow(non_snake_case)]
+    pub fn cssparser_internal__assert_ascii_lowercase__max_len(input: &str) -> String {
+        let expr = syn::parse_expr(&format!("match x {{ {} }}", input)).unwrap();
         let arms = match expr {
             syn::Expr { node: syn::ExprKind::Match(_, ref arms), .. } => arms,
             _ => panic!("expected a match expression, got {:?}", expr)
         };
-        arms.iter().flat_map(|arm| &arm.pats).filter_map(|pattern| {
+        max_len(arms.iter().flat_map(|arm| &arm.pats).filter_map(|pattern| {
             let expr = match *pattern {
                 syn::Pat::Lit(ref expr) => expr,
                 syn::Pat::Wild |
@@ -42,36 +42,23 @@ pub fn assert_ascii_lowercase_max_len(input: proc_macro::TokenStream) -> proc_ma
                 }
                 _ => panic!("expected string pattern, got {:?}", expr)
             }
-        }).max()
-    })
-}
-
-/// Emit a `MAX_LENGTH` constant with the length of the longest string.
-#[proc_macro_derive(cssparser_internal__max_len)]
-pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    max_len_common(input, |token_trees| {
-        token_trees.iter().map(|tt| string_literal(tt).len()).max()
-    })
-}
+        }))
+    }
 
-fn max_len_common<F>(input: proc_macro::TokenStream, f: F) -> proc_macro::TokenStream
-where F : FnOnce(&[syn::TokenTree]) -> Option<usize> {
-    common(input, |token_trees| {
-        let max_length = f(token_trees).expect("expected at least one string");
-        quote! {
-            const MAX_LENGTH: usize = #max_length;
-        }
-    })
-}
+    /// Emit a `MAX_LENGTH` constant with the length of the longest string.
+    #[allow(non_snake_case)]
+    pub fn cssparser_internal__max_len(input: &str) -> String {
+        max_len(syn::parse_token_trees(input).unwrap().iter().map(|tt| string_literal(tt).len()))
+    }
 
-/// ```
-/// static MAP: &'static ::phf::Map<&'static str, $ValueType> = …;
-/// ```
-///
-/// Map keys are ASCII-lowercased.
-#[proc_macro_derive(cssparser_internal__phf_map)]
-pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
-    common(input, |token_trees| {
+    /// ```
+    /// static MAP: &'static ::phf::Map<&'static str, $ValueType> = …;
+    /// ```
+    ///
+    /// Map keys are ASCII-lowercased.
+    #[allow(non_snake_case)]
+    pub fn cssparser_internal__phf_map(input: &str) -> String {
+        let token_trees = syn::parse_token_trees(input).unwrap();
         let value_type = &token_trees[0];
         let pairs: Vec<_> = token_trees[1..].chunks(2).map(|chunk| {
             let key = string_literal(&chunk[0]);
@@ -91,52 +78,13 @@ pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         map.build(&mut initializer_bytes).unwrap();
         tokens.append(::std::str::from_utf8(&initializer_bytes).unwrap());
         tokens.append(";");
-        tokens
-    })
-}
-
-fn common<F>(input: proc_macro::TokenStream, f: F) -> proc_macro::TokenStream
-where F: FnOnce(&[syn::TokenTree]) -> quote::Tokens {
-    let input = syn::parse_macro_input(&input.to_string()).unwrap();
-    let token_trees = find_smuggled_tokens(&input);
-    let tokens = f(token_trees);
-    tokens.as_str().parse().unwrap()
+        tokens.to_string()
+    }
 }
 
-/// Return the `…` part in:
-///
-/// ```rust
-/// enum Somthing {
-///     Input = (0, stringify!(…)).0
-/// }
-/// ```
-fn find_smuggled_tokens(input: &syn::DeriveInput) -> &[syn::TokenTree] {
-    let discriminant = match input.body {
-        syn::Body::Enum(ref variants) if variants.len() == 1 => &variants[0].discriminant,
-        _ => panic!("expected single-variant enum, got {:?}", input.body)
-    };
-    let tuple = match *discriminant {
-        Some(syn::ConstExpr::Other(syn::Expr { node: syn::ExprKind::TupField(ref t, 0), .. })) => t,
-        _ => panic!("expected a discriminant like tuple.0, got {:?}", discriminant)
-    };
-    let expr = match **tuple {
-        syn::Expr { node: syn::ExprKind::Tup(ref values), .. } if values.len() == 2 => &values[1],
-        _ => panic!("expected non-empty tuple, got {:?}", tuple)
-    };
-    let macro_args = match *expr {
-        syn::Expr { node: syn::ExprKind::Mac(
-            syn::Mac { ref tts, path: syn::Path { global: false, ref segments }}
-        ),  .. }
-        if segments.len() == 1
-            && segments[0] == syn::PathSegment::from("stringify")
-            && tts.len() == 1
-        => &tts[0],
-        _ => panic!("expected a stringify!(…) macro, got {:?}", expr)
-    };
-    match *macro_args {
-        syn::TokenTree::Delimited(syn::Delimited { ref tts, delim: syn::DelimToken::Paren }) => tts,
-        _ => panic!("expected (…) parentheses, got {:?}", macro_args)
-    }
+fn max_len<I: Iterator<Item=usize>>(lengths: I) -> String {
+    let max_length = lengths.max().expect("expected at least one string");
+    quote!( const MAX_LENGTH: usize = #max_length; ).to_string()
 }
 
 fn string_literal(token: &syn::TokenTree) -> &str {
diff --git a/procedural-masquarade/Cargo.toml b/procedural-masquarade/Cargo.toml
@@ -0,0 +1,11 @@
+[package]
+name = "procedural-masquarade"
+version = "0.1.0"
+authors = ["Simon Sapin <simon.sapin@exyr.org>"]
+description = "macro_rules for making proc_macro_derive pretending to be proc_macro"
+documentation = "https://docs.rs/procedural-masquarade/"
+repository = "https://github.com/servo/rust-cssparser"
+license = "MIT/Apache-2.0"
+
+[lib]
+path = "lib.rs"
diff --git a/procedural-masquarade/lib.rs b/procedural-masquarade/lib.rs
@@ -0,0 +1,53 @@
+#[macro_export]
+macro_rules! define_proc_macros {
+    (
+        $(
+            $( #[$attr:meta] )*
+            pub fn $func:ident($input:ident: &str) -> String
+            $body:block
+        )+
+    ) => {
+        $(
+            $( #[$attr] )*
+            #[proc_macro_derive($func)]
+            pub fn $func(input: ::proc_macro::TokenStream) -> ::proc_macro::TokenStream {
+                // Use another function to hide this one’s local variables from $block
+                #[inline]
+                fn implementation($input: &str) -> String $body
+
+                let input = input.to_string();
+                let mut normalized = String::with_capacity(input.len());
+                for piece in input.split_whitespace() {
+                    normalized.push_str(piece);
+                    normalized.push(' ');
+                }
+
+                let prefix = "#[allow(unused)] enum Dummy { Input = (0, stringify!(";
+                let suffix = ")).0, } ";
+                assert!(normalized.starts_with(prefix), "Unexpected proc_macro_derive input {:?}", input);
+                assert!(normalized.ends_with(suffix), "Unexpected proc_macro_derive input {:?}", input);
+
+                let start = prefix.len();
+                let end = normalized.len() - suffix.len();
+                let output = implementation(&normalized[start..end]);
+                output.parse().unwrap()
+            }
+        )+
+    }
+}
+
+#[macro_export]
+macro_rules! define_invoke_proc_macro {
+    ($macro_name: ident) => {
+        #[macro_export]
+        macro_rules! $macro_name {
+            ($proc_macro_name: ident ! $paren: tt) => {
+                #[derive($proc_macro_name)]
+                #[allow(unused)]
+                enum Dummy {
+                    Input = (0, stringify! $paren ).0
+                }
+            }
+        }
+    }
+}
diff --git a/src/lib.rs b/src/lib.rs
@@ -70,6 +70,7 @@ fn parse_border_spacing(_context: &ParserContext, input: &mut Parser)
 
 #[macro_use] extern crate cssparser_macros;
 #[macro_use] extern crate matches;
+#[macro_use] extern crate procedural_masquarade;
 extern crate phf;
 #[cfg(test)] extern crate encoding_rs;
 #[cfg(test)] extern crate tempdir;
diff --git a/src/macros.rs b/src/macros.rs
@@ -2,6 +2,7 @@
  * License, v. 2.0. If a copy of the MPL was not distributed with this
  * file, You can obtain one at http://mozilla.org/MPL/2.0/. */
 
+define_invoke_proc_macro!(cssparser_internal__invoke_proc_macro);
 
 /// Expands to an expression equivalent to a `match` with string patterns,
 /// but matching is case-insensitive in the ASCII range.
@@ -37,7 +38,7 @@
 macro_rules! match_ignore_ascii_case {
     ( $input:expr, $( $match_body:tt )* ) => {
         {
-            cssparser_internal__pretend_proc_macro! {
+            cssparser_internal__invoke_proc_macro! {
                 cssparser_internal__assert_ascii_lowercase__max_len!( $( $match_body )* )
             }
 
@@ -86,12 +87,12 @@ macro_rules! match_ignore_ascii_case {
 macro_rules! ascii_case_insensitive_phf_map {
     ($name: ident -> $ValueType: ty = { $( $key: expr => $value: expr, )* }) => {
         fn $name(input: &str) -> Option<&'static $ValueType> {
-            cssparser_internal__pretend_proc_macro! {
+            cssparser_internal__invoke_proc_macro! {
                 cssparser_internal__phf_map!( ($ValueType) $( $key ($value) )+ )
             }
 
             {
-                cssparser_internal__pretend_proc_macro! {
+                cssparser_internal__invoke_proc_macro! {
                     cssparser_internal__max_len!( $( $key )+ )
                 }
                 // MAX_LENGTH is generated by cssparser_internal__max_len
@@ -125,21 +126,6 @@ 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.**
