Remove the already-lowercase requirement in ascii_case_insensitive_phf_map!

We can do the lower-casing at compile time in a proc-macro.

Note that `match_ignore_ascii_case!` still has that requirement,
since it’s `macro_rules!` that generates a `match` expression.

Author: SimonSapin

macros/lib.rs

@@ -9,21 +9,33 @@ extern crate syn;
 
 use std::ascii::AsciiExt;
 
-/// Find a `#[cssparser__match_ignore_ascii_case__data(string = "…", string = "…")]` attribute,
-/// panic if any string contains ASCII uppercase letters,
-/// emit a `MAX_LENGTH` constant with the length of the longest string.
-#[proc_macro_derive(cssparser__match_ignore_ascii_case__max_len,
-                    attributes(cssparser__match_ignore_ascii_case__data))]
-pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+/// Find a `#[cssparser__assert_ascii_lowercase__data(string = "…", string = "…")]` attribute,
+/// and panic if any string contains ASCII uppercase letters.
+#[proc_macro_derive(cssparser__assert_ascii_lowercase,
+                    attributes(cssparser__assert_ascii_lowercase__data))]
+pub fn assert_ascii_lowercase(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
     let input = syn::parse_macro_input(&input.to_string()).unwrap();
-    let data = list_attr(&input, "cssparser__match_ignore_ascii_case__data");
+    let data = list_attr(&input, "cssparser__assert_ascii_lowercase__data");
 
-    let lengths = data.iter().map(|sub_attr| {
+    for sub_attr in data {
         let string = sub_attr_value(sub_attr, "string");
         assert_eq!(*string, string.to_ascii_lowercase(),
                    "the expected strings must be given in ASCII lowercase");
-        string.len()
-    });
+    }
+
+    "".parse().unwrap()
+}
+
+/// Find a `#[cssparser__max_len__data(string = "…", string = "…")]` attribute,
+/// panic if any string contains ASCII uppercase letters,
+/// emit a `MAX_LENGTH` constant with the length of the longest string.
+#[proc_macro_derive(cssparser__max_len,
+                    attributes(cssparser__max_len__data))]
+pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
+    let input = syn::parse_macro_input(&input.to_string()).unwrap();
+    let data = list_attr(&input, "cssparser__max_len__data");
+
+    let lengths = data.iter().map(|sub_attr| sub_attr_value(sub_attr, "string").len());
     let max_length = lengths.max().expect("expected at least one string");
 
     let tokens = quote! {
@@ -37,6 +49,7 @@ pub fn max_len(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
 /// `fn map() -> &'static ::phf::Map<&'static str, $ValueType>`.
 /// The map’s content is given as:
 /// `#[cssparser__phf_map__kv_pairs(key = "…", value = "…", key = "…", value = "…")]`.
+/// Keys are ASCII-lowercased.
 #[proc_macro_derive(cssparser__phf_map,
                     attributes(cssparser__phf_map__kv_pairs))]
 pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
@@ -49,13 +62,15 @@ pub fn phf_map(input: proc_macro::TokenStream) -> proc_macro::TokenStream {
         _ => panic!("expected tuple struct newtype, got {:?}", input.body)
     };
 
-    let kv_pairs = list_attr(&input, "cssparser__phf_map__kv_pairs");
-
-    let mut map = phf_codegen::Map::new();
-    for chunk in kv_pairs.chunks(2) {
+    let pairs: Vec<_> = list_attr(&input, "cssparser__phf_map__kv_pairs").chunks(2).map(|chunk| {
         let key = sub_attr_value(&chunk[0], "key");
         let value = sub_attr_value(&chunk[1], "value");
-        map.entry(key, value);
+        (key.to_ascii_lowercase(), value)
+    }).collect();
+
+    let mut map = phf_codegen::Map::new();
+    for &(ref key, value) in &pairs {
+        map.entry(&**key, value);
     }
 
     let mut initializer_bytes = Vec::<u8>::new();

src/lib.rs

@@ -134,6 +134,11 @@ macro_rules! match_ignore_ascii_case {
     // finished parsing
     (@inner $value:expr, () -> ($(($string:expr => $result:expr))*) $fallback:expr ) => {
         {
+            #[derive(cssparser__assert_ascii_lowercase)]
+            #[cssparser__assert_ascii_lowercase__data($(string = $string),+)]
+            #[allow(dead_code)]
+            struct Dummy;
+
             _cssparser_internal__max_len!($value => lowercase, $($string),+);
             match lowercase {
                 $(
@@ -160,7 +165,6 @@ macro_rules! match_ignore_ascii_case {
 /// Requirements:
 ///
 /// * The `phf` and `cssparser_macros` crates must also be imported at the crate root
-/// * The keys must not contain ASCII upper case letters. (They must be already be lower-cased.)
 /// * The values must be given a strings that contain Rust syntax for a constant expression.
 ///
 /// ## Example:
@@ -216,10 +220,10 @@ macro_rules! ascii_case_insensitive_phf_map {
 #[doc(hidden)]
 macro_rules! _cssparser_internal__max_len {
     ($input: expr => $output: ident, $($string: expr),+) => {
-        #[derive(cssparser__match_ignore_ascii_case__max_len)]
-        #[cssparser__match_ignore_ascii_case__data($(string = $string),+)]
+        #[derive(cssparser__max_len)]
+        #[cssparser__max_len__data($(string = $string),+)]
         #[allow(dead_code)]
-        struct Dummy;
+        struct Dummy2;
 
         // MAX_LENGTH is generated by cssparser__match_ignore_ascii_case__max_len
         let mut buffer: [u8; MAX_LENGTH] =