Template node structs & whitespace semantics

askama_derive/src/generator.rs

@@ -1,7 +1,7 @@
 use crate::config::{get_template_source, read_config_file, Config, WhitespaceHandling};
 use crate::heritage::{Context, Heritage};
 use crate::input::{Print, Source, TemplateInput};
-use crate::parser::{parse, Cond, CondTest, Expr, Loop, Node, Target, When, Whitespace, Ws};
+use crate::parser::{parse, Call, Cond, CondTest, Expr, Loop, Node, Target, When, Whitespace, Ws};
 use crate::CompileError;
 
 use proc_macro::TokenStream;
@@ -665,7 +665,14 @@ impl<'a> Generator<'a> {
                 Node::Include(ws, path) => {
                     size_hint += self.handle_include(ctx, buf, ws, path)?;
                 }
-                Node::Call(ws, scope, name, ref args) => {
+                Node::Call(
+                    ws,
+                    Call {
+                        scope,
+                        name,
+                        ref args,
+                    },
+                ) => {
                     size_hint += self.write_call(ctx, buf, ws, scope, name, args)?;
                 }
                 Node::Macro(_, ref m) => {

askama_derive/src/parser/mod.rs

@@ -12,7 +12,9 @@ use nom::sequence::{delimited, pair, tuple};
 use nom::{error_position, AsChar, IResult, InputTakeAtPosition};
 
 pub(crate) use self::expr::Expr;
-pub(crate) use self::node::{Cond, CondTest, Loop, Macro, Node, Target, When, Whitespace, Ws};
+pub(crate) use self::node::{
+    Call, Cond, CondTest, Loop, Macro, Node, Target, When, Whitespace, Ws,
+};
 use crate::config::Syntax;
 use crate::CompileError;
 

askama_derive/src/parser/node.rs

@@ -21,7 +21,7 @@ pub(crate) enum Node<'a> {
     Lit(&'a str, &'a str, &'a str),
     Comment(Ws),
     Expr(Ws, Expr<'a>),
-    Call(Ws, Option<&'a str>, &'a str, Vec<Expr<'a>>),
+    Call(Ws, Call<'a>),
     LetDecl(Ws, Target<'a>),
     Let(Ws, Target<'a>, Expr<'a>),
     Cond(Vec<Cond<'a>>, Ws),
@@ -66,6 +66,17 @@ impl From<WhitespaceHandling> for Whitespace {
     }
 }
 
+/// A macro call statement.
+#[derive(Debug, PartialEq)]
+pub(crate) struct Call<'a> {
+    /// If the macro is imported, the scope name.
+    pub(crate) scope: Option<&'a str>,
+    /// The name of the macro to call.
+    pub(crate) name: &'a str,
+    /// The arguments to the macro.
+    pub(crate) args: Vec<Expr<'a>>,
+}
+
 #[derive(Debug, PartialEq)]
 pub(crate) struct Loop<'a> {
     pub(crate) ws1: Ws,
@@ -140,7 +151,7 @@ fn block_call(i: &str) -> IResult<&str, Node<'_>> {
     let (i, (pws, _, (scope, name, args, nws))) = p(i)?;
     let scope = scope.map(|(scope, _)| scope);
     let args = args.unwrap_or_default();
-    Ok((i, Node::Call(Ws(pws, nws), scope, name, args)))
+    Ok((i, Node::Call(Ws(pws, nws), Call { scope, name, args })))
 }
 
 fn cond_if(i: &str) -> IResult<&str, CondTest<'_>> {

askama_derive/src/parser/tests.rs

@@ -669,25 +669,28 @@ fn test_missing_space_after_kw() {
 
 #[test]
 fn test_parse_call_statement() {
+    use super::Call;
     let syntax = Syntax::default();
     assert_eq!(
         super::parse("{% call foo(bar) %}", &syntax).unwrap(),
         vec![Node::Call(
             Ws(None, None),
-            None,
-            "foo",
-            vec![
-                Expr::Var("bar"),
-            ],
+            Call {
+                scope: None,
+                name: "foo",
+                args: vec![Expr::Var("bar"),],
+            }
         )],
     );
     assert_eq!(
         super::parse("{% call foo::bar() %}", &syntax).unwrap(),
         vec![Node::Call(
             Ws(None, None),
-            Some("foo"),
-            "bar",
-            vec![],
+            Call {
+                scope: Some("foo"),
+                name: "bar",
+                args: vec![],
+            }
         )],
     );
 }