fix caller logic

Signed-off-by: Michael Pollind <[email protected]>

Author: pollend

askama_derive/src/generator.rs

@@ -85,9 +85,9 @@ struct Generator<'a, 'h> {
     /// Used in blocks to check if we are inside a filter block.
     is_in_filter_block: usize,
     /// Set of called macros we are currently in. Used to prevent (indirect) recursions.
-    seen_macros: Vec<(&'a Macro<'a>, Option<FileInfo<'a>>)>,
-    /// Set of callers to forward into the macro.
-    current_caller: Option<&'a Call<'a>>,
+    seen_callers: Vec<(&'a Call<'a>, &'a Macro<'a>, Option<FileInfo<'a>>)>,
+    /// the active caller within the macro.
+    active_caller: Option<&'a Call<'a>>,
 }
 
 impl<'a, 'h> Generator<'a, 'h> {
@@ -112,8 +112,8 @@ impl<'a, 'h> Generator<'a, 'h> {
                 ..Default::default()
             },
             is_in_filter_block,
-            seen_macros: Vec::new(),
-            current_caller: None,
+            seen_callers: Vec::new(),
+            active_caller: None,
         }
     }
 

askama_derive/src/generator/node.rs

@@ -624,9 +624,9 @@ impl<'a> Generator<'a, '_> {
             (*def, ctx)
         };
 
-        if self.seen_macros.iter().any(|(s, _)| std::ptr::eq(*s, def)) {
+        if self.seen_callers.iter().any(|(_, s, _)| std::ptr::eq(*s, def)) {
             let mut message = "Found recursion in macro calls:".to_owned();
-            for (m, f) in &self.seen_macros {
+            for (_, m, f) in &self.seen_callers {
                 if let Some(f) = f {
                     write!(message, "{f}").unwrap();
                 } else {
@@ -635,9 +635,10 @@ impl<'a> Generator<'a, '_> {
             }
             return Err(ctx.generate_error(message, call.span()));
         } else {
-            self.seen_macros.push((def, ctx.file_info_of(call.span())));
+            self.seen_callers
+                .push((call, def, ctx.file_info_of(call.span())));
         }
-        self.current_caller = Some(call);
+        self.active_caller = self.seen_callers.last().map(|v| v.0);
         self.flush_ws(ws1); // Cannot handle_ws() here: whitespace from macro definition comes first
         let size_hint = self.push_locals(|this| {
             macro_call_ensure_arg_count(call, def, ctx)?;
@@ -760,8 +761,9 @@ impl<'a> Generator<'a, '_> {
             Ok(size_hint)
         })?;
         self.prepare_ws(ws1);
-        self.seen_macros.pop();
-        self.current_caller = None;
+        self.seen_callers.pop();
+        self.seen_callers.pop();
+        self.active_caller = None;
         Ok(size_hint)
     }
 
@@ -1107,11 +1109,11 @@ impl<'a> Generator<'a, '_> {
             if ***path == Expr::Var("super") {
                 return self.write_block(ctx, buf, None, ws, s.span());
             } else if ***path == Expr::Var("caller") {
-                let def = self.current_caller.ok_or_else(|| {
+                let def = self.active_caller.ok_or_else(|| {
                     ctx.generate_error(format_args!("block is not defined for caller"), s.span())
                 })?;
-                self.current_caller = None;
-                self.handle_ws(ws); 
+                self.active_caller = None;
+                self.handle_ws(ws);
                 let size_hint = self.push_locals(|this| {
                     this.write_buf_writable(ctx, buf)?;
                     buf.write('{');
@@ -1171,13 +1173,13 @@ impl<'a> Generator<'a, '_> {
                         }
                     }
                     let mut size_hint = this.handle(ctx, &def.nodes, buf, AstLevel::Nested)?;
-                    
+
                     this.flush_ws(def.ws2);
                     size_hint += this.write_buf_writable(ctx, buf)?;
                     buf.write('}');
                     Ok(size_hint)
                 })?;
-                self.current_caller = Some(def);
+                self.active_caller = self.seen_callers.last().map(|v| v.0);
                 return Ok(size_hint);
             }
         }

testing/tests/calls.rs

@@ -125,7 +125,6 @@ nested
     assert_eq!(x.render().unwrap(), "nested");
 }
 
-
 #[test]
 fn test_caller_struct() {
     struct TestInput<'a> {

testing/tests/macro.rs

@@ -252,7 +252,6 @@ fn test_caller_expr() {
     )]
     struct MacroCallerExpr;
     assert_eq!(MacroCallerExpr.render().unwrap(), "20 1 35\n");
-
 }
 
 #[test]
@@ -261,25 +260,42 @@ fn test_caller_in_caller() {
     #[template(
         source = r#"
         {%- macro test2() -%}
-            {{~ caller("bb") ~}}
+            {{ caller("bb") }}
         {%- endmacro -%}
         {%- macro test() -%}
-            {{~ caller("a") ~}}
+            {{ caller("a") }}
+            {%- call(b) test2() -%}
+                five: {{ b }}
+            {%~ endcall -%}
+        {%- endmacro -%}
+        {%- macro test3() -%}
+            {{ caller("cc") }}
+        {%- endmacro -%}
+        {%- macro test4() -%}
+            {{ caller("dd") }}
         {%- endmacro -%}
         {%- call(a) test() -%}
             {%- call(b) test2() -%}
                 one: {{ b }}
+            {%~ endcall -%}
+            {%- call(b) test3() -%}
+                two: {{ b }}
+                {%~ call(b) test4() -%}
+                    three: {{ b }}
+                {%~ endcall -%}
             {%- endcall -%}
-            two: {{- a -}}
-        {%- endcall -%}
+            four: {{ a }}
+        {%~ endcall -%}
         "#,
         ext = "txt"
     )]
-    struct CallerInCaller; 
-    assert_eq!(CallerInCaller.render().unwrap(), "one: bbtwo:a");
+    struct CallerInCaller;
+    assert_eq!(
+        CallerInCaller.render().unwrap(),
+        "one: bb\ntwo: cc\nthree: dd\nfour: a\nfive: bb\n"
+    );
 }
 
-
 // This test ensures that we can use declared variables as default value for
 // macro arguments.
 #[test]