Add new create tag

Author: GuillaumeGomez

askama_derive/src/generator/expr.rs

@@ -960,7 +960,6 @@ impl<'a> Generator<'a, '_> {
         DisplayWrap::Unwrapped
     }
 
-    // FIXME: This function should have a `Span`, but `cond.target` isn't `WithSpan`.
     pub(super) fn visit_target(
         &mut self,
         ctx: &Context<'_>,

askama_derive/src/generator/node.rs

@@ -7,7 +7,7 @@ use std::str::FromStr;
 
 use parser::expr::BinOp;
 use parser::node::{
-    Call, Comment, Cond, CondTest, FilterBlock, If, Include, Let, Lit, Loop, Match, Whitespace, Ws,
+    Call, Comment, Cond, CondTest, Create, FilterBlock, If, Include, Let, Lit, Loop, Match, Whitespace, Ws,
 };
 use parser::{Expr, Node, Span, Target, WithSpan};
 use proc_macro2::TokenStream;
@@ -103,6 +103,9 @@ impl<'a> Generator<'a, '_> {
                 Node::Let(ref l) => {
                     self.write_let(ctx, buf, l)?;
                 }
+                Node::Create(ref c) => {
+                    self.write_create(ctx, buf, c)?;
+                }
                 Node::If(ref i) => {
                     size_hint += self.write_if(ctx, buf, i)?;
                 }
@@ -913,6 +916,32 @@ impl<'a> Generator<'a, '_> {
         Ok(())
     }
 
+    fn write_create(
+        &mut self,
+        ctx: &Context<'_>,
+        buf: &mut Buffer,
+        c: &'a WithSpan<Create<'_>>,
+    ) -> Result<(), CompileError> {
+        let span = ctx.span_for_node(c.span());
+        if *c.var_name == "_" {
+            return Err(ctx.generate_error(
+                "`_` cannot be used when there is no value assigned, use `let` instead",
+                c.var_name.span(),
+            ));
+        }
+        self.handle_ws(c.ws);
+
+        self.write_buf_writable(ctx, buf)?;
+        buf.write_token(Token![let], span);
+        if c.is_mutable {
+            buf.write_token(Token![mut], span);
+        }
+        self.visit_target(ctx, buf, false, true, &Target::Name(c.var_name), span);
+        buf.write_token(Token![;], span);
+
+        Ok(())
+    }
+
     // If `name` is `Some`, this is a call to a block definition, and we have to find
     // the first block for that name from the ancestry chain. If name is `None`, this
     // is from a `super()` call, and we can get the name from `self.super_block`.

askama_derive/src/input.rs

@@ -310,6 +310,7 @@ impl TemplateInput<'_> {
                         | Node::Expr(_, _)
                         | Node::Extends(_)
                         | Node::Let(_)
+                        | Node::Create(_)
                         | Node::Import(_)
                         | Node::Macro(_)
                         | Node::Raw(_)

askama_parser/src/node.rs

@@ -22,6 +22,7 @@ pub enum Node<'a> {
     Expr(Ws, WithSpan<Box<Expr<'a>>>),
     Call(WithSpan<Call<'a>>),
     Let(WithSpan<Let<'a>>),
+    Create(WithSpan<Create<'a>>),
     If(WithSpan<If<'a>>),
     Match(WithSpan<Match<'a>>),
     Loop(WithSpan<Loop<'a>>),
@@ -93,6 +94,7 @@ impl<'a: 'l, 'l> Node<'a> {
 
         let func = match tag {
             "call" => Call::parse,
+            "create" => Create::parse,
             "let" | "set" => Let::parse,
             "if" => If::parse,
             "for" => Loop::parse,
@@ -190,6 +192,7 @@ impl<'a: 'l, 'l> Node<'a> {
             Self::Expr(_, span) => span.span,
             Self::Call(span) => span.span,
             Self::Let(span) => span.span,
+            Self::Create(span) => span.span,
             Self::If(span) => span.span,
             Self::Match(span) => span.span,
             Self::Loop(span) => span.span,
@@ -1198,6 +1201,35 @@ impl<'a: 'l, 'l> Raw<'a> {
     }
 }
 
+#[derive(Debug, PartialEq)]
+pub struct Create<'a> {
+    pub ws: Ws,
+    pub var_name: WithSpan<&'a str>,
+    pub is_mutable: bool,
+}
+
+impl<'a: 'l, 'l> Create<'a> {
+    fn parse(i: &mut InputStream<'a, 'l>) -> ParseResult<'a, Box<Node<'a>>> {
+        let mut p = (
+            opt(Whitespace::parse),
+            ws(keyword("create").span()),
+            ws(opt(keyword("mut").span())),
+            ws(identifier.with_span()),
+            opt(Whitespace::parse),
+        );
+        let (pws, span, is_mut, (var_name, var_name_span), nws) = p.parse_next(i)?;
+
+        Ok(Box::new(Node::Create(WithSpan::new(
+            Create {
+                ws: Ws(pws, nws),
+                var_name: WithSpan::new(var_name, var_name_span),
+                is_mutable: is_mut.is_some(),
+            },
+            span,
+        ))))
+    }
+}
+
 #[derive(Debug, PartialEq)]
 pub struct Let<'a> {
     pub ws: Ws,

testing/tests/create.rs

@@ -0,0 +1,23 @@
+use askama::Template;
+
+// This test ensures that rust macro calls in `let`/`set` statements are not prepended with `&`.
+#[test]
+fn create() {
+    #[derive(Template)]
+    #[template(
+        source = r#"{%- create x -%}
+{%- if y -%}
+    {%- let x = String::new() %}
+{%- else -%}
+    {%- let x = format!("blob") %}
+{%- endif -%}
+{{ x }}"#,
+        ext = "html"
+    )]
+    struct A {
+        y: bool,
+    }
+
+    assert_eq!(A { y: false }.render().unwrap(), "blob");
+    assert_eq!(A { y: true }.render().unwrap(), "");
+}

testing/tests/let.rs

@@ -18,8 +18,8 @@ fn let_macro() {
         y: bool,
     }
 
-    let template = A { y: false };
-    assert_eq!(template.render().unwrap(), "blob")
+    assert_eq!(A { y: false }.render().unwrap(), "blob");
+    assert_eq!(A { y: true }.render().unwrap(), "");
 }
 
 // Ensures that variables name can start with `_`.

testing/tests/ui/create.rs

@@ -0,0 +1,7 @@
+use askama::Template;
+
+#[derive(Template)]
+#[template(source = "{% create x = 'a' %}", ext = "html")]
+struct Create1;
+
+fn main() {}

testing/tests/ui/create.stderr

@@ -0,0 +1,7 @@
+error: failed to parse template source
+ --> <source attribute>:1:12
+       "= 'a' %}"
+ --> tests/ui/create.rs:4:21
+  |
+4 | #[template(source = "{% create x = 'a' %}", ext = "html")]
+  |                     ^^^^^^^^^^^^^^^^^^^^^^

testing/tests/ui/let.rs renamed to testing/tests/ui/underscore.rs

@@ -16,4 +16,12 @@ struct UnderscoreErr3;
 #[template(source = r#"{% match _ %}{% endmatch %}"#, ext = "html")]
 struct UnderscoreErr4;
 
+#[derive(Template)]
+#[template(source = r#"{% let _ %}"#, ext = "html")]
+struct UnderscoreErr5;
+
+#[derive(Template)]
+#[template(source = r#"{% create _ %}"#, ext = "html")]
+struct UnderscoreErr6;
+
 fn main() {}

testing/tests/ui/let.stderr renamed to testing/tests/ui/underscore.stderr

@@ -1,31 +1,47 @@
 error: reserved keyword `_` cannot be used here
  --> <source attribute>:1:12
        "_] %}"
- --> tests/ui/let.rs:4:21
+ --> tests/ui/underscore.rs:4:21
   |
 4 | #[template(source = r#"{% let x = [_] %}"#, ext = "html")]
   |                     ^^^^^^^^^^^^^^^^^^^^^^
 
 error: reserved keyword `_` cannot be used here
  --> <source attribute>:1:7
        "_ + 12) != 0 %}{% endif %}"
- --> tests/ui/let.rs:8:21
+ --> tests/ui/underscore.rs:8:21
   |
 8 | #[template(source = r#"{% if (_ + 12) != 0 %}{% endif %}"#, ext = "html")]
   |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reserved keyword `_` cannot be used here
  --> <source attribute>:1:12
        "_ %}{% endif %}"
-  --> tests/ui/let.rs:12:21
+  --> tests/ui/underscore.rs:12:21
    |
 12 | #[template(source = r#"{% if 12 == _ %}{% endif %}"#, ext = "html")]
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 error: reserved keyword `_` cannot be used here
  --> <source attribute>:1:9
        "_ %}{% endmatch %}"
-  --> tests/ui/let.rs:16:21
+  --> tests/ui/underscore.rs:16:21
    |
 16 | #[template(source = r#"{% match _ %}{% endmatch %}"#, ext = "html")]
    |                     ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
+
+error: when you forward-define a variable, you cannot use a pattern in place of a variable name
+ --> <source attribute>:1:7
+       "_ %}"
+  --> tests/ui/underscore.rs:20:21
+   |
+20 | #[template(source = r#"{% let _ %}"#, ext = "html")]
+   |                     ^^^^^^^^^^^^^^^^
+
+error: `_` cannot be used when there is no value assigned, use `let` instead
+ --> UnderscoreErr6.html:1:10
+       "_ %}"
+  --> tests/ui/underscore.rs:24:21
+   |
+24 | #[template(source = r#"{% create _ %}"#, ext = "html")]
+   |                     ^^^^^^^^^^^^^^^^^^^