add more test add resreved word caller

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

Author: pollend

askama_derive/src/generator/node.rs

@@ -624,7 +624,11 @@ impl<'a> Generator<'a, '_> {
             (*def, ctx)
         };
 
-        if self.seen_callers.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_callers {
                 if let Some(f) = f {
@@ -1105,7 +1109,23 @@ impl<'a> Generator<'a, '_> {
             ..
         } = &**s
         {
+            fn check_num_args<'a>(
+                s: &'a WithSpan<'a, Expr<'a>>,
+                ctx: &Context<'a>,
+                expected: usize,
+                found: usize,
+            ) -> Result<(), CompileError> {
+                if expected != found {
+                    Err(ctx.generate_error(
+                        format!("expected `{}` argument, found `{}`", expected, found),
+                        s.span(),
+                    ))
+                } else {
+                    Ok(())
+                }
+            }
             if ***path == Expr::Var("super") {
+                check_num_args(s, ctx, 0, expr_args.len())?;
                 return self.write_block(ctx, buf, None, ws, s.span());
             } else if ***path == Expr::Var("caller") {
                 let def = self.active_caller.ok_or_else(|| {
@@ -1118,6 +1138,7 @@ impl<'a> Generator<'a, '_> {
                     buf.write('{');
                     this.prepare_ws(def.ws1);
                     let mut value = Buffer::new();
+                    check_num_args(s, ctx, def.caller_args.len(), expr_args.len())?;
                     for (index, arg) in def.caller_args.iter().enumerate() {
                         match expr_args.get(index) {
                             Some(expr) => {

askama_parser/src/lib.rs

@@ -1265,6 +1265,16 @@ const KWS_PARSER: &[&[[AsciiChar; MAX_RUST_RAW_KEYWORD_LEN]]; MAX_RUST_KEYWORD_L
         result[result.len() - 1] = AsciiStr::new_sized("r#union");
         result
     };
+    const KW6: &[[AsciiChar; MAX_RUST_RAW_KEYWORD_LEN]] = &{
+        let mut result = [AsciiStr::new_sized("r#"); RUST_KEYWORDS[6].len() + 1];
+        let mut i = 0;
+        while i < RUST_KEYWORDS[6].len() {
+            result[i] = RUST_KEYWORDS[6][i];
+            i += 1;
+        }
+        result[result.len() - 1] = AsciiStr::new_sized("r#caller");
+        result
+    };
 
     [
         RUST_KEYWORDS[0],
@@ -1273,7 +1283,7 @@ const KWS_PARSER: &[&[[AsciiChar; MAX_RUST_RAW_KEYWORD_LEN]]; MAX_RUST_KEYWORD_L
         RUST_KEYWORDS[3],
         KW4,
         KW5,
-        RUST_KEYWORDS[6],
+        KW6,
         RUST_KEYWORDS[7],
         RUST_KEYWORDS[8],
     ]
@@ -1493,6 +1503,7 @@ mod test {
 
     #[test]
     fn test_is_rust_keyword() {
+        assert!(is_rust_keyword("caller"));
         assert!(is_rust_keyword("super"));
         assert!(is_rust_keyword("become"));
         assert!(!is_rust_keyword("supeeeer"));

testing/tests/ui/caller_arguments.rs

@@ -15,6 +15,21 @@ use askama::Template;
 struct InvalidNumberArguments {
 }
 
+#[derive(Template)]
+#[template(
+    source = r#"
+    {% macro test() %}
+        {{- caller("a", "b") -}}
+    {%- endmacro -%}
+    {%- call(a) test() -%}
+        {{- a -}}
+    {%- endcall -%}
+    "#,
+    ext = "txt"
+)]
+struct InvalidNumberArguments1 {
+}
+
 #[derive(Template)]
 #[template(
     source = r#"
@@ -66,5 +81,28 @@ struct CallerInCaller {
 struct CallerInCaller1 {
 }
 
+#[derive(Template)]
+#[template(
+    source = r#"{{caller()}}"#,
+    ext = "txt"
+)]
+struct JustCaller{
+}
+
+#[derive(Template)]
+#[template(
+    source = r#"
+    {% macro test() %}
+        {{ caller("a", one = "b") }}
+    {%- endmacro -%}
+    {%- call(two, one) test() -%}
+        {{- two -}} {{- one -}}
+    {%- endcall -%}
+    "#,
+    ext = "txt"
+)]
+struct NamedArguments {
+}
+
 fn main() {}
 

testing/tests/ui/caller_arguments.stderr

@@ -1,4 +1,4 @@
-error: missing `c` argument
+error: expected `3` argument, found `2`
  --> InvalidNumberArguments.txt:3:18
        "(\"a\", \"b\") -}}\n    {%- endmacro -%}\n    {%- call(a,b,c) test() -%}\n        {{- a"...
   --> tests/ui/caller_arguments.rs:5:14
@@ -13,47 +13,85 @@ error: missing `c` argument
 12 | |     "#,
    | |______^
 
+error: expected `1` argument, found `2`
+ --> InvalidNumberArguments1.txt:3:18
+       "(\"a\", \"b\") -}}\n    {%- endmacro -%}\n    {%- call(a) test() -%}\n        {{- a -}}"...
+  --> tests/ui/caller_arguments.rs:21:14
+   |
+21 |       source = r#"
+   |  ______________^
+22 | |     {% macro test() %}
+23 | |         {{- caller("a", "b") -}}
+24 | |     {%- endmacro -%}
+...  |
+27 | |     {%- endcall -%}
+28 | |     "#,
+   | |______^
+
 error: expected `)` to close call argument list
  --> <source attribute>:5:15
        "test() -%}\n        {{- a -}}\n    {%- endcall -%}\n    "
-  --> tests/ui/caller_arguments.rs:20:14
+  --> tests/ui/caller_arguments.rs:36:14
    |
-20 |       source = r#"
+36 |       source = r#"
    |  ______________^
-21 | |     {% macro test() %}
-22 | |         {{- caller("a") -}}
-23 | |     {%- endmacro -%}
+37 | |     {% macro test() %}
+38 | |         {{- caller("a") -}}
+39 | |     {%- endmacro -%}
 ...  |
-26 | |     {%- endcall -%}
-27 | |     "#,
+42 | |     {%- endcall -%}
+43 | |     "#,
    | |______^
 
 error: block is not defined for caller
  --> CallerInCaller.txt:6:18
        "(a) -}}\n    {%- endcall -%}\n    "
-  --> tests/ui/caller_arguments.rs:35:14
+  --> tests/ui/caller_arguments.rs:51:14
    |
-35 |       source = r#"
+51 |       source = r#"
    |  ______________^
-36 | |     {% macro test() %}
-37 | |         {{- caller("a") -}}
-38 | |     {%- endmacro -%}
+52 | |     {% macro test() %}
+53 | |         {{- caller("a") -}}
+54 | |     {%- endmacro -%}
 ...  |
-41 | |     {%- endcall -%}
-42 | |     "#,
+57 | |     {%- endcall -%}
+58 | |     "#,
    | |______^
 
 error: block is not defined for caller
  --> CallerInCaller1.txt:10:21
        "(\"b\") }}\n        {% endcall %}\n        {{- a -}}\n    {%- endcall -%}\n    "
-  --> tests/ui/caller_arguments.rs:50:14
+  --> tests/ui/caller_arguments.rs:66:14
    |
-50 |       source = r#"
+66 |       source = r#"
    |  ______________^
-51 | |     {% macro test2() %}
-52 | |         {{ caller("bb") }}
-53 | |     {% endmacro %}
+67 | |     {% macro test2() %}
+68 | |         {{ caller("bb") }}
+69 | |     {% endmacro %}
 ...  |
-62 | |     {%- endcall -%}
-63 | |     "#,
+78 | |     {%- endcall -%}
+79 | |     "#,
    | |______^
+
+error: block is not defined for caller
+ --> JustCaller.txt:1:8
+       "()}}"
+  --> tests/ui/caller_arguments.rs:87:14
+   |
+87 |     source = r#"{{caller()}}"#,
+   |              ^^^^^^^^^^^^^^^^^
+
+error: failed to parse template source
+ --> <source attribute>:3:27
+       "= \"b\") }}\n    {%- endmacro -%}\n    {%- call(two, one) test() -%}\n        {{- two"...
+   --> tests/ui/caller_arguments.rs:95:14
+    |
+95  |       source = r#"
+    |  ______________^
+96  | |     {% macro test() %}
+97  | |         {{ caller("a", one = "b") }}
+98  | |     {%- endmacro -%}
+...   |
+101 | |     {%- endcall -%}
+102 | |     "#,
+    | |______^

testing/tests/ui/macro-caller.rs

@@ -0,0 +1,8 @@
+use askama::Template;
+
+#[derive(Template)]
+#[template(source = "{%- macro caller() -%}{%- endmacro -%}", ext = "html")]
+struct MacroSuper;
+
+fn main() {
+}

testing/tests/ui/macro-caller.stderr

@@ -0,0 +1,7 @@
+error: 'caller' is not a valid name for a macro
+ --> <source attribute>:1:2
+       "- macro caller() -%}{%- endmacro -%}"
+ --> tests/ui/macro-caller.rs:4:21
+  |
+4 | #[template(source = "{%- macro caller() -%}{%- endmacro -%}", ext = "html")]
+  |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^