Add conditional expressions

Jinja, being based on Python, allows using conditional expressions:
```jinja
{{ "then" if condition else "otherwise" }}
```
will print `"then"` if `condition` is truthy, otherwise `"otherwise"`.

This PR adds the same syntax, with a few restrictions, to Askama:

* The condition must evaluate to a `bool` (or a reference to it), same
  as in `{% if .. %}`.
* The else-case can be absent in Jinja, then behaves like `else None`.
  For Jinja that makes sense. It renders `{{ None }}` like an empty
  string. Askama does not do that: `Option<T>` can not be rendered
  for any `T`; we don't unwrap automatically. So, without automatic
  unwrapping, I don't see a case when you would want to omit the
  else-case.

Author: Kijewski

askama_derive/src/generator.rs

@@ -700,6 +700,19 @@ enum DisplayWrap {
     Unwrapped,
 }
 
+/// `Wrapped & Wrapped == Wrapped`, otherwise `Unwrapped`
+impl std::ops::BitAnd for DisplayWrap {
+    type Output = Self;
+
+    #[inline]
+    fn bitand(self, rhs: Self) -> Self::Output {
+        match self {
+            DisplayWrap::Wrapped => rhs,
+            DisplayWrap::Unwrapped => self,
+        }
+    }
+}
+
 #[derive(Default, Debug)]
 struct WritableBuffer<'a> {
     buf: Vec<Writable<'a>>,

askama_derive/src/generator/expr.rs

@@ -1,5 +1,6 @@
 use std::borrow::Cow;
 
+use parser::expr::Conditional;
 use parser::node::CondTest;
 use parser::{
     AssociatedItem, CharLit, CharPrefix, Expr, PathComponent, Span, StrLit, Target, TyGenerics,
@@ -12,6 +13,7 @@ use super::{
     normalize_identifier,
 };
 use crate::CompileError;
+use crate::generator::node::EvaluatedResult;
 use crate::heritage::Context;
 use crate::integration::Buffer;
 
@@ -95,6 +97,7 @@ impl<'a> Generator<'a, '_> {
             Expr::Concat(ref exprs) => self.visit_concat(ctx, buf, exprs)?,
             Expr::LetCond(ref cond) => self.visit_let_cond(ctx, buf, cond)?,
             Expr::ArgumentPlaceholder => DisplayWrap::Unwrapped,
+            Expr::Conditional(ref cond) => self.visit_conditional_expr(ctx, buf, cond)?,
         })
     }
 
@@ -230,6 +233,35 @@ impl<'a> Generator<'a, '_> {
         }
     }
 
+    fn visit_conditional_expr(
+        &mut self,
+        ctx: &Context<'_>,
+        buf: &mut Buffer,
+        cond: &Conditional<'a>,
+    ) -> Result<DisplayWrap, CompileError> {
+        let expr;
+        let expr = if cond.test.contains_bool_lit_or_is_defined() {
+            let result;
+            (result, expr) = self.evaluate_condition(WithSpan::clone(&cond.test), &mut true);
+            match result {
+                EvaluatedResult::AlwaysTrue => return self.visit_expr(ctx, buf, &cond.then),
+                EvaluatedResult::AlwaysFalse => return self.visit_expr(ctx, buf, &cond.otherwise),
+                EvaluatedResult::Unknown => &expr,
+            }
+        } else {
+            &cond.test
+        };
+
+        buf.write("if ");
+        self.visit_condition(ctx, buf, expr)?;
+        buf.write('{');
+        let then = self.visit_expr(ctx, buf, &cond.then)?;
+        buf.write("} else {");
+        let otherwise = self.visit_expr(ctx, buf, &cond.otherwise)?;
+        buf.write('}');
+        Ok(then & otherwise)
+    }
+
     fn visit_let_cond(
         &mut self,
         ctx: &Context<'_>,

askama_derive/src/generator/node.rs

@@ -180,7 +180,7 @@ impl<'a> Generator<'a, '_> {
         Ok(size_hint)
     }
 
-    fn evaluate_condition(
+    pub(super) fn evaluate_condition(
         &self,
         expr: WithSpan<'a, Expr<'a>>,
         only_contains_is_defined: &mut bool,
@@ -340,6 +340,16 @@ impl<'a> Generator<'a, '_> {
                     )
                 }
             }
+            Expr::Conditional(cond) => {
+                // If we can tell the outcome of the condition, recurse.
+                let (result, expr) = self.evaluate_condition(*cond.test, only_contains_is_defined);
+                let expr = match result {
+                    EvaluatedResult::AlwaysTrue => cond.then,
+                    EvaluatedResult::AlwaysFalse => cond.otherwise,
+                    EvaluatedResult::Unknown => return (EvaluatedResult::Unknown, expr),
+                };
+                self.evaluate_condition(*expr, only_contains_is_defined)
+            }
         }
     }
 
@@ -1370,7 +1380,7 @@ struct Conds<'a> {
 }
 
 #[derive(Clone, Copy, PartialEq, Debug)]
-enum EvaluatedResult {
+pub(super) enum EvaluatedResult {
     AlwaysTrue,
     AlwaysFalse,
     Unknown,
@@ -1527,6 +1537,9 @@ fn is_cacheable(expr: &WithSpan<'_, Expr<'_>>) -> bool {
         Expr::As(expr, _) => is_cacheable(expr),
         Expr::Try(expr) => is_cacheable(expr),
         Expr::Concat(args) => args.iter().all(is_cacheable),
+        Expr::Conditional(cond) => {
+            is_cacheable(&cond.test) && is_cacheable(&cond.then) && is_cacheable(&cond.otherwise)
+        }
         // Doesn't make sense in this context.
         Expr::LetCond(_) => false,
         // We have too little information to tell if the expression is pure:

askama_derive/src/tests.rs

@@ -1,7 +1,9 @@
 //! Files containing tests for generated code.
 
-use std::fmt;
+use std::io::Write;
 use std::path::Path;
+use std::process::exit;
+use std::{fmt, io};
 
 use console::style;
 use prettyplease::unparse;
@@ -121,7 +123,8 @@ fn compare_ex(
             }
         }
 
-        panic!(
+        let _: io::Result<()> = writeln!(
+            io::stderr().lock(),
             "\n\
             === Expected ===\n\
             \n\
@@ -140,6 +143,7 @@ fn compare_ex(
             generated = style(&generated).green(),
             diff = Diff(&expected, &generated),
         );
+        exit(1);
     }
 }
 
@@ -1410,3 +1414,117 @@ fn test_bare_cr_doc_comment() -> Result<(), syn::Error> {
 
     Ok(())
 }
+
+#[test]
+fn test_conditional_expr() {
+    compare(
+        r"{{ a if b else c }}",
+        r#"
+        match (
+            &((&&askama::filters::AutoEscaper::new(
+                &(if askama::helpers::as_bool(&(self.b)) { self.a } else { self.c }),
+                askama::filters::Text,
+            ))
+                .askama_auto_escape()?),
+        ) {
+            (expr0,) => {
+                (&&&askama::filters::Writable(expr0))
+                    .askama_write(__askama_writer, __askama_values)?;
+            }
+        }"#,
+        &[("a", "i8"), ("b", "i8"), ("c", "i8")],
+        3,
+    );
+
+    compare(
+        r"{{ a if b is defined else c }}",
+        r#"
+        match (
+            &((&&askama::filters::AutoEscaper::new(&(self.a), askama::filters::Text))
+                .askama_auto_escape()?),
+        ) {
+            (expr0,) => {
+                (&&&askama::filters::Writable(expr0))
+                    .askama_write(__askama_writer, __askama_values)?;
+            }
+        }"#,
+        &[("a", "i8"), ("b", "i8"), ("c", "i8")],
+        3,
+    );
+
+    compare(
+        r"{{ a if b is not defined else c }}",
+        r#"
+        match (
+            &((&&askama::filters::AutoEscaper::new(&(self.c), askama::filters::Text))
+                .askama_auto_escape()?),
+        ) {
+            (expr0,) => {
+                (&&&askama::filters::Writable(expr0))
+                    .askama_write(__askama_writer, __askama_values)?;
+            }
+        }"#,
+        &[("a", "i8"), ("b", "i8"), ("c", "i8")],
+        3,
+    );
+
+    compare(
+        r"{{ a if b if c else d else e }}",
+        r#"
+        match (
+            &((&&askama::filters::AutoEscaper::new(
+                &(if askama::helpers::as_bool(
+                    &(if askama::helpers::as_bool(&(self.c)) { self.b } else { self.d })
+                ) {
+                    self.a
+                } else {
+                    self.e
+                }),
+                askama::filters::Text,
+            ))
+                .askama_auto_escape()?),
+        ) {
+            (expr0,) => {
+                (&&&askama::filters::Writable(expr0))
+                    .askama_write(__askama_writer, __askama_values)?;
+            }
+        }"#,
+        &[
+            ("a", "i8"),
+            ("b", "i8"),
+            ("c", "i8"),
+            ("d", "i8"),
+            ("e", "i8"),
+        ],
+        3,
+    );
+
+    compare(
+        r"{{ a if b else c if d else e }}",
+        r#"
+        match (
+            &((&&askama::filters::AutoEscaper::new(
+                &(if askama::helpers::as_bool(&(self.b)) {
+                    self.a
+                } else {
+                    if askama::helpers::as_bool(&(self.d)) { self.c } else { self.e }
+                }),
+                askama::filters::Text,
+            ))
+                .askama_auto_escape()?),
+        ) {
+            (expr0,) => {
+                (&&&askama::filters::Writable(expr0))
+                    .askama_write(__askama_writer, __askama_values)?;
+            }
+        }"#,
+        &[
+            ("a", "i8"),
+            ("b", "i8"),
+            ("c", "i8"),
+            ("d", "i8"),
+            ("e", "i8"),
+        ],
+        3,
+    );
+}

askama_parser/src/expr.rs

@@ -140,6 +140,11 @@ fn check_expr<'a>(expr: &WithSpan<'a, Expr<'a>>, allowed: Allowed) -> ParseResul
         }
         Expr::LetCond(cond) => check_expr(&cond.expr, Allowed::default()),
         Expr::ArgumentPlaceholder => cut_error!("unreachable", expr.span),
+        Expr::Conditional(cond) => {
+            check_expr(&cond.then, Allowed::default())?;
+            check_expr(&cond.test, Allowed::default())?;
+            check_expr(&cond.otherwise, Allowed::default())
+        }
         Expr::BoolLit(_)
         | Expr::NumLit(_, _)
         | Expr::StrLit(_)
@@ -225,6 +230,14 @@ pub enum Expr<'a> {
     /// This variant should never be used directly.
     /// It is used for the handling of named arguments in the generator, esp. with filters.
     ArgumentPlaceholder,
+    Conditional(Conditional<'a>),
+}
+
+#[derive(Clone, Debug, PartialEq)]
+pub struct Conditional<'a> {
+    pub then: Box<WithSpan<'a, Expr<'a>>>,
+    pub test: Box<WithSpan<'a, Expr<'a>>>,
+    pub otherwise: Box<WithSpan<'a, Expr<'a>>>,
 }
 
 #[derive(Clone, Debug, PartialEq)]
@@ -316,6 +329,84 @@ impl<'a> Expr<'a> {
         allow_underscore: bool,
     ) -> ParseResult<'a, WithSpan<'a, Self>> {
         let _level_guard = level.nest(i)?;
+        Self::if_else(i, level, allow_underscore)
+    }
+
+    /// Like [`Expr::parse()`], but does not parse conditional expressions,
+    /// i.e. the token `if` is not consumed.
+    pub(super) fn parse_no_if_else(
+        i: &mut &'a str,
+        level: Level<'_>,
+        allow_underscore: bool,
+    ) -> ParseResult<'a, WithSpan<'a, Self>> {
+        let _level_guard = level.nest(i)?;
+        Self::range(i, level, allow_underscore)
+    }
+
+    fn if_else(
+        i: &mut &'a str,
+        level: Level<'_>,
+        allow_underscore: bool,
+    ) -> ParseResult<'a, WithSpan<'a, Self>> {
+        #[inline(never)] // very unlikely case
+        fn actually_cond<'a>(
+            i: &mut &'a str,
+            level: Level<'_>,
+            allow_underscore: bool,
+            then: Box<WithSpan<'a, Expr<'a>>>,
+            start: &'a str,
+            if_span: &'a str,
+        ) -> ParseResult<'a, WithSpan<'a, Expr<'a>>> {
+            let Some(test) =
+                opt(|i: &mut _| Expr::parse(i, level, allow_underscore)).parse_next(i)?
+            else {
+                return cut_error!(
+                    "conditional expression (`then if cond else otherwise`) expects an expression \
+                after the keyword `if`",
+                    if_span,
+                );
+            };
+
+            let Some(else_span) = opt(ws(keyword("else")).take()).parse_next(i)? else {
+                return cut_error!(
+                    "conditional expression (`then if cond else otherwise`) expects the keyword \
+                    `else` after its condition",
+                    test.span(),
+                );
+            };
+
+            let Some(otherwise) =
+                opt(|i: &mut _| Expr::if_else(i, level, allow_underscore)).parse_next(i)?
+            else {
+                return cut_error!(
+                    "conditional expression (`then if cond else otherwise`) expects an expression \
+                    after the keyword `else`",
+                    else_span,
+                );
+            };
+
+            let expr = Expr::Conditional(Conditional {
+                test: Box::new(test),
+                then,
+                otherwise: Box::new(otherwise),
+            });
+            Ok(WithSpan::new(expr, start, i))
+        }
+
+        let start = *i;
+        let expr = Self::range(i, level, allow_underscore)?;
+        if let Some(if_span) = opt(ws(keyword("if")).take()).parse_next(i)? {
+            actually_cond(i, level, allow_underscore, expr.into(), start, if_span)
+        } else {
+            Ok(expr)
+        }
+    }
+
+    fn range(
+        i: &mut &'a str,
+        level: Level<'_>,
+        allow_underscore: bool,
+    ) -> ParseResult<'a, WithSpan<'a, Self>> {
         let range_right = move |i: &mut _| {
             (
                 ws(alt(("..=", ".."))),
@@ -634,6 +725,7 @@ impl<'a> Expr<'a> {
             Self::BinOp(v) if matches!(v.op, "&&" | "||") => {
                 v.lhs.contains_bool_lit_or_is_defined() || v.rhs.contains_bool_lit_or_is_defined()
             }
+            Self::Conditional(cond) => cond.test.contains_bool_lit_or_is_defined(),
             Self::NumLit(_, _)
             | Self::StrLit(_)
             | Self::CharLit(_)

askama_parser/src/node.rs

@@ -575,7 +575,7 @@ impl<'a> Loop<'a> {
                     cut_node(
                         Some("for"),
                         (
-                            ws(|i: &mut _| Expr::parse(i, s.level, true)),
+                            ws(|i: &mut _| Expr::parse_no_if_else(i, s.level, true)),
                             opt(if_cond),
                             opt(Whitespace::parse),
                             |i: &mut _| s.tag_block_end(i),