Skip caching calls (Resolves #667)

askama_derive/src/generator.rs

@@ -7,7 +7,7 @@ use crate::CompileError;
 use proc_macro::TokenStream;
 use quote::{quote, ToTokens};
 
-use std::collections::HashMap;
+use std::collections::hash_map::{Entry, HashMap};
 use std::path::{Path, PathBuf};
 use std::{cmp, hash, mem, str};
 
@@ -1197,10 +1197,9 @@ impl<'a> Generator<'a> {
                         ),
                     };
 
-                    use std::collections::hash_map::Entry;
                     let id = match expr_cache.entry(expression.clone()) {
-                        Entry::Occupied(e) => *e.get(),
-                        Entry::Vacant(e) => {
+                        Entry::Occupied(e) if s.is_cachable() => *e.get(),
+                        e => {
                             let id = self.named;
                             self.named += 1;
 
@@ -1209,7 +1208,10 @@ impl<'a> Generator<'a> {
                             buf_expr.write(&expression);
                             buf_expr.writeln(",")?;
 
-                            e.insert(id);
+                            if let Entry::Vacant(e) = e {
+                                e.insert(id);
+                            }
+
                             id
                         }
                     };

askama_derive/src/parser.rs

@@ -106,6 +106,39 @@ impl Expr<'_> {
             _ => false,
         }
     }
+
+    /// Returns `true` if the outcome of this expression may be used multiple times in the same
+    /// `write!()` call, without evaluating the expression again, i.e. the expression should be
+    /// side-effect free.
+    pub(crate) fn is_cachable(&self) -> bool {
+        match self {
+            // Literals are the definition of pure:
+            Expr::BoolLit(_) => true,
+            Expr::NumLit(_) => true,
+            Expr::StrLit(_) => true,
+            Expr::CharLit(_) => true,
+            // fmt::Display should have no effects:
+            Expr::Var(_) => true,
+            Expr::Path(_) => true,
+            // Check recursively:
+            Expr::Array(args) => args.iter().all(|arg| arg.is_cachable()),
+            Expr::Attr(lhs, _) => lhs.is_cachable(),
+            Expr::Index(lhs, rhs) => lhs.is_cachable() && rhs.is_cachable(),
+            Expr::Filter(_, args) => args.iter().all(|arg| arg.is_cachable()),
+            Expr::Unary(_, arg) => arg.is_cachable(),
+            Expr::BinOp(_, lhs, rhs) => lhs.is_cachable() && rhs.is_cachable(),
+            Expr::Range(_, lhs, rhs) => {
+                lhs.as_ref().map_or(true, |v| v.is_cachable())
+                    && rhs.as_ref().map_or(true, |v| v.is_cachable())
+            }
+            Expr::Group(arg) => arg.is_cachable(),
+            Expr::Tuple(args) => args.iter().all(|arg| arg.is_cachable()),
+            // We have too little information to tell if the expression is pure:
+            Expr::Call(_, _) => false,
+            Expr::RustMacro(_, _) => false,
+            Expr::Try(_) => false,
+        }
+    }
 }
 
 pub(crate) type When<'a> = (Ws, Target<'a>, Vec<Node<'a>>);