procedural-masquerade: don’t normalize whitespace in string literals.

Author: SimonSapin

procedural-masquerade/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "procedural-masquerade"
-version = "0.1.0"
+version = "0.1.1"
 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-masquerade/"

procedural-masquerade/lib.rs

@@ -175,7 +175,7 @@ macro_rules! define_proc_macros {
             pub fn $proc_macro_name(derive_input: ::proc_macro::TokenStream)
                                     -> ::proc_macro::TokenStream {
                 let $input = derive_input.to_string();
-                let $input: &str = &$crate::_extract_input(&$input);
+                let $input = $crate::_extract_input(&$input);
                 $body.parse().unwrap()
             }
         )+
@@ -186,21 +186,26 @@ macro_rules! define_proc_macros {
 ///
 /// **This function is not part of the public API. It can change or be removed between any versions.**
 #[doc(hidden)]
-pub fn _extract_input(derive_input: &str) -> String {
-    let mut normalized = String::with_capacity(derive_input.len());
-    for piece in derive_input.split_whitespace() {
-        normalized.push_str(piece);
-        normalized.push(' ');
+pub fn _extract_input(derive_input: &str) -> &str {
+    let mut input = derive_input;
+
+    for expected in &["#[allow(unused)]", "enum", "ProceduralMasqueradeDummyType", "{",
+                     "Input", "=", "(0,", "stringify!", "("] {
+        input = input.trim_left();
+        assert!(input.starts_with(expected),
+                "expected prefix {:?} not found in {:?}", expected, derive_input);
+        input = &input[expected.len()..];
     }
 
-    let prefix = "#[allow(unused)] enum ProceduralMasqueradeDummyType { Input = (0, stringify!(";
-    let suffix = ")).0, } ";
-    assert!(normalized.starts_with(prefix), "expected prefix not found in {:?}", derive_input);
-    assert!(normalized.ends_with(suffix), "expected suffix not found in {:?}", derive_input);
+    for expected in [")", ").0,", "}"].iter().rev() {
+        input = input.trim_right();
+        assert!(input.ends_with(expected),
+                "expected suffix {:?} not found in {:?}", expected, derive_input);
+        let end = input.len() - expected.len();
+        input = &input[..end];
+    }
 
-    let start = prefix.len();
-    let end = normalized.len() - suffix.len();
-    normalized[start..end].to_owned()
+    input
 }
 
 /// This macro expands to the definition of another macro (whose name is given as a parameter).

src/tests.rs

@@ -817,3 +817,29 @@ fn one_component_value_to_json(token: Token, input: &mut Parser) -> Json {
         Token::CloseCurlyBracket => JArray!["error", "}"],
     }
 }
+
+/// A previous version of procedural-masquerade had a bug where it
+/// would normalize consecutive whitespace to a single space,
+/// including in string literals.
+#[test]
+fn procedural_masquerade_whitespace() {
+    ascii_case_insensitive_phf_map! {
+        map -> () = {
+            "  \t\n" => ()
+        }
+    }
+    assert_eq!(map("  \t\n"), Some(&()));
+    assert_eq!(map(" "), None);
+
+    match_ignore_ascii_case! { "  \t\n",
+        " " => panic!("1"),
+        "  \t\n" => {},
+        _ => panic!("2"),
+    }
+
+    match_ignore_ascii_case! { " ",
+        "  \t\n" => panic!("3"),
+        " " => {},
+        _ => panic!("4"),
+    }
+}