derive: escape strings at compile-time when possible

Author: Kijewski

rinja_derive/src/generator.rs

@@ -14,6 +14,7 @@ use quote::quote;
 
 use crate::config::WhitespaceHandling;
 use crate::heritage::{Context, Heritage};
+use crate::html::write_escaped_str;
 use crate::input::{Source, TemplateInput};
 use crate::{CompileError, MsgValidEscapers, CRATE};
 
@@ -1162,8 +1163,76 @@ impl<'a> Generator<'a> {
     }
 
     fn write_expr(&mut self, ws: Ws, s: &'a WithSpan<'a, Expr<'a>>) {
+        // In here, we inspect in the expression if it is a literal, and if it is, whether it
+        // can be escaped at compile time. We use an IIFE to make the code more readable
+        // (immediate returns, try expressions).
+        let writable = (|| -> Option<Writable<'a>> {
+            enum InputKind<'a> {
+                StrLit(&'a str),
+                CharLit(&'a str),
+            }
+            enum OutputKind {
+                Html,
+                Text,
+            }
+
+            // for now, we only escape strings and chars at compile time
+            let lit = match &**s {
+                Expr::StrLit(input) => InputKind::StrLit(input),
+                Expr::CharLit(input) => InputKind::CharLit(input),
+                _ => return None,
+            };
+
+            // we only optimize for known escapers
+            let output = match self.input.escaper.strip_prefix(CRATE)? {
+                "::filters::Html" => OutputKind::Html,
+                "::filters::Text" => OutputKind::Text,
+                _ => return None,
+            };
+
+            // the input could be string escaped if it contains any backslashes
+            let escaped = match lit {
+                InputKind::StrLit(s) => s,
+                InputKind::CharLit(s) => s,
+            };
+            let unescaped = if escaped.find('\\').is_none() {
+                // if the literal does not contain any backslashes, then it does not need unescaping
+                Cow::Borrowed(escaped)
+            } else {
+                // convert the input into a TokenStream and extract the first token
+                Cow::Owned(match lit {
+                    InputKind::StrLit(escaped) => {
+                        let input = format!(r#""{escaped}""#);
+                        let input = input.parse().ok()?;
+                        let input = syn::parse2::<syn::LitStr>(input).ok()?;
+                        input.value()
+                    }
+                    InputKind::CharLit(escaped) => {
+                        let input = format!(r#"'{escaped}'"#);
+                        let input = input.parse().ok()?;
+                        let input = syn::parse2::<syn::LitChar>(input).ok()?;
+                        input.value().to_string()
+                    }
+                })
+            };
+
+            // escape the un-string-escaped input using the selected escaper
+            Some(Writable::Lit(match output {
+                OutputKind::Text => unescaped,
+                OutputKind::Html => {
+                    let mut escaped = String::with_capacity(unescaped.len() + 20);
+                    write_escaped_str(&mut escaped, &unescaped).ok()?;
+                    match escaped == unescaped {
+                        true => unescaped,
+                        false => Cow::Owned(escaped),
+                    }
+                }
+            }))
+        })()
+        .unwrap_or(Writable::Expr(s));
+
         self.handle_ws(ws);
-        self.buf_writable.push(Writable::Expr(s));
+        self.buf_writable.push(writable);
     }
 
     // Write expression buffer and empty

rinja_derive/src/tests.rs

@@ -440,77 +440,24 @@ fn check_escaping_at_compile_time() {
         r#"writer.write_str("The card is")?;
         match &self.suit {
             Suit::Clubs | Suit::Spades => {
-                match (
-                    &((&&::rinja::filters::AutoEscaper::new(&(" black"), ::rinja::filters::Text)).rinja_auto_escape()?),
-                ) {
-                    (expr0,) => {
-                        (&&::rinja::filters::Writable(expr0)).rinja_write(writer)?;
-                    }
-                }
-             }
-             Suit::Diamonds | Suit::Hearts => {
-                match (
-                    &((&&::rinja::filters::AutoEscaper::new(&(" red"), ::rinja::filters::Text)).rinja_auto_escape()?),
-                ) {
-                    (expr0,) => {
-                        (&&::rinja::filters::Writable(expr0)).rinja_write(writer)?;
-                    }
-                }
+                writer.write_str(" black")?;
+            }
+            Suit::Diamonds | Suit::Hearts => {
+                writer.write_str(" red")?;
             }
         }"#,
         &[("suit", "Suit")],
-        14,
+        16,
     );
 
     compare(
         r#"{{ '\x41' }}{{ '\n' }}{{ '\r' }}{{ '\t' }}{{ '\\' }}{{ '\u{2665}' }}{{ '\'' }}{{ '\"' }}{{ '"' }}
 {{ "\x41\n\r\t\\\u{2665}\'\"'" }}"#,
-        r#"
-            match (
-            &((&&::rinja::filters::AutoEscaper::new(&('\x41'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\n'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\r'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\t'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\\'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(
-                &('\u{2665}'),
-                ::rinja::filters::Text,
-            ))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\''), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('\"'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(&('"'), ::rinja::filters::Text))
-                .rinja_auto_escape()?),
-            &((&&::rinja::filters::AutoEscaper::new(
-                &("\x41\n\r\t\\\u{2665}\'\"'"),
-                ::rinja::filters::Text,
-            ))
-                .rinja_auto_escape()?),
-        ) {
-            (expr0, expr1, expr2, expr3, expr4, expr5, expr6, expr7, expr8, expr10) => {
-                (&&::rinja::filters::Writable(expr0)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr1)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr2)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr3)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr4)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr5)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr6)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr7)).rinja_write(writer)?;
-                (&&::rinja::filters::Writable(expr8)).rinja_write(writer)?;
-                writer.write_str("
-")?;
-                (&&::rinja::filters::Writable(expr10)).rinja_write(writer)?;
-            }
-        }
-"#,
+        r#"writer.write_str("A
+\r	\\♥'\"\"
+A
+\r	\\♥'\"'")?;"#,
         &[],
-        31,
+        23,
     );
 }